PDF de programación - curso z88dk básico

Introducción


Hay tres razones por las que he decidido escribir este curso: La primera de ellas es tratar de acercar
la programación de videojuegos para ZX Spectrum al mayor número de personas posible. La segunda
que la mayoría de los tutoriales son demasiado complicados para mi gusto. La tercera es poder leer
mi propio tutorial cuando se me haya olvidados más de una cosa. XD

De rebote, sin quererlo ni beberlo, este curso también servirá para hacer juegos de Amstrad CPC
cambiando cuatro cosas. En primer lugar se explicará la forma de hacerlo para ZX Spectrum y a
continuación la de Amstrad CPC y sus cambios.

Tras esto voy a ser totalmente sincero: este tutorial no va a mostrarte todo lo que se puede hacer en
Z88DK, pero si te va a abrir las puertas para coger luego otro tutorial mejor y quedarte todo más
claro que la ropa recién lavada con Ariel Blanco Nuclear. Cuando te hayas leído esto podrás pasar a
uno de esos tutoriales machotes llenos de palabras que ahora mismo te suenan a chino.

Es decir, sólo voy a explicar lo básico para que puedas arrancar y defenderte. Pero creo que mejor lo
vemos con la práctica.

Radastan





Preparando nuestro entorno de trabajo


Para poder empezar a trabajar es imprescindible tener lo más importante... Z88DK. De nada sirve
que hagamos ejemplos y aprendas nada si no puedes ponerlo en práctica.

Voy a presuponer que tienes Windows, si tienes Linux tendrás que ingeniártelas (cosa que ya sabrás
hacer si usas ese sistema operativo). Así que desde ahora todo irá explicado para Windows.

Para empezar descárgate el Z88DK de este enlace, que es la versión que vamos a usar:

http://www.bytemaniacos.com/ficheros/zxspectrum/z88dk10.zip

Se trata de una versión de Z88DK "portable", es decir, no hace falta instalar nada. Sólo descomprime
el fichero tal cual en el directorio raíz C: de tu ordenador. Ojo, descomprimir allí, no en una
subcarpeta. Debería crearse una nueva carpeta llamada z88dk10, y dentro todo el follón de cosas
que trae este compilador.

Se trata de la versión que se usa en la "Churrera" de los Mojon Twins, por lo que de paso ya tenéis
excusa para mirar su curso de paso si veis que esto es muy complicado. Ellos ya han hecho un motor
basado en Z88DK y no hace falta programar nada, sólo dedicarse a hacer gráficos, mapa, y configurar
un ficherito con la forma que queremos que actúe nuestro juego. Más info en:

http://www.elmundodelspectrum.com/taller.php

Bien, ahora el segundo paso. Créate donde te de la real y santísima gana una carpeta para trabajar.
Da igual como se llame (Curso, Megamotor, Eljuegodelaño, CastlevaniaZX, etc), dentro vamos a crear
nuestros ficheros para hacernos un entorno amigable.

Cómo editor puedes usar lo que te dé la gana: Notepad, Wordpad, Crimson Editor, etc. Yo te
recomiendo el Crimson Editor porque es sencillo, te va a poner los comandos de distinto color, te
mostrará los números de línea, y es gratis:

http://www.crimsoneditor.com/

Bien, y ahora como colofón vamos a descargar un esqueleto básico de Z88DK en:

http://www.bytemaniacos.com/ficheros/zxspectrum/cursoz88dk.zip

El contenido del ZIP lo metes dentro de la carpeta que has creado donde has querido (Curso,
Megamotor, Pedazojuego, MetalGearZX, CPCpowa, etc).

Y ahora pasamos a lo bueno...





Familiarizándonos con el lenguaje C


Vete a la carpeta de trabajo y abre el fichero juegozx.c. Deberías ver algo como esto:

// juegozx.c
// Esqueleto de juegos de Radastan para ZX Spectrum
// version 0.1 beta

#include <config.h>
#include <spriteszx.h>
#include <lib\motorzx.h>

#pragma output STACKPTR=65000

void main (void)
{

}

Vamos a explicar de forma muy sencillita lo que es cada cosa:





Los comentarios van siempre precedidos de //. En lenguaje C se hace así y hace que toda esa
línea sea ignorada por el compilador (no, los comentarios no están en el fichero compilado).
Si quieres poner como comentario varias líneas seguidas o anular parte de tu código (muy
útil) puedes hacer lo mismo empezando con /* y terminando con */.

Los #include es el copy&paste de los programadores. Para no apelotonar todo en un mismo
fichero (que es posible) usamos #include para que el compilador meta todo lo que haya en el
fichero que le mencionamos dentro de la compilación. Es decir, en este caso es como si en
juego.c estuviera donde hay cada #include el contenido de dichos ficheros.

 El #pragma lo olvidas, tú lo usas como está y ya está. Básicamente dice dónde va a estar la
pila del Z80, una zona de memoria donde se guardan cositas que si no sabes de ensamblador
de poco o nada te va a sonar. Con 65000 tenemos 538 bytes reservados para ello y si no
haces cosas muy raras sobrará.

 Al principio también se pueden poner #define, pero no recomiendo que los pongas en el
fichero principal. Sirve para definir variables. Sí, es posible crear variables globales para todo
el programa. Las nuestras las vamos a meter en config.h, y nos servirán para especificar los
valores que vayamos a necesitar. Es más abre config.h y verás que te he dejado una variable
imprescindible lista para usar.

La chicha de “juegozx.c” empieza en void main (void) y lo que hay entre sus corchetes.







Definiendo funciones en C


En lenguaje C se trabaja con funciones. Las funciones son partes de código, y podemos crear tantas
funciones como nos venga en gana. Lo normal es que hagamos funciones de cosas que repitamos de
forma cíclica, así no tendremos que volver a escribir el mismo código en distintos sitios. También nos
sirven para organizar mejor nuestro código.

La función principal es "main", y es la que primero se va a ejecutar cuando ejecutemos el código.
Desde ella vamos a llamar a las distintas partes que conforman nuestro programa, y es conveniente
que no pongamos en ella código en si mismo, sino llamadas a otras funciones.

Cuando termine "main" de ejecutarse el programa también lo hará, así que tenemos que evitar que
esto suceda a menos que lo deseemos expresamente.

Toda función tiene una entrada y una salida, sino queremos tener alguna de las dos (o las dos)
usaremos void para indicarlo. La entrada va entre paréntesis, al final de la declaración, y la salida al
principio de la misma.

Si quisiéramos crear una función que sumara dos valores, por ejemplo, y nos diera el resultado sería
algo como esto:

int suma (int valor1, int valor2)
{
int total;
total=valor1+valor2;
return (total);
}

Ignorad los int de momento, lo importante ahora es ver que hemos definido una función llamada
"suma" con valores de entrada y un valor de salida, el valor lo devolvemos mediante el comando
return.

De todas formas este ejemplo nos sirve para enseñar un par de cosas más:

 Todos los comandos en C deben acabar con punto y coma (salvo las funciones que

definamos.



Las funciones engloban su contenido mediante corchetes.

¿Cómo usaremos esta función que hemos creado? llamándola desde otra función pasando los
parámetros que necesita y recogiendo el valor que proporciona. Un ejemplo desde main sería:







void main (void)
{
int valor1;
int valor 2;
int resultado;
valor 1 = 10;
valor 2 = 35;
resultado = suma (valor1, valor2);
}

Definiendo variables y constantes


Las variables son el alma de todo programa, con ellas pasamos datos de un lugar a otro y podemos
realizar operaciones. Las variables pueden ser globales o locales:





Las variables globales se usan en todas las funciones, son las que hemos definido al principio
del código con #define.

Las variables locales sólo se usan dentro de cada función, no son vistas por el resto de
funciones, dichas variables no pueden llamarse como ninguna variable global.

Un ejemplo de variable local es la que hemos definido en config.h:

#define NUMERO_DE_VIDAS 0

A la hora de definir la variable podemos indicar también un valor inicial, en nuestro caso hemos
puesto el valor cero. No hace falta indicar el tipo de variable que es, sólo el nombre y su valor.
Tampoco hay que terminar con punto y coma.

En las variables internas la cosa cambia:

int total;

Una variable local termina su declaración con punto y coma, y además se debe crear indicando el
tipo de variable que es. Los tipos de variables básicos (hay más) que podemos manejar en C con
Z88DK son:

char, 8 bits, se usa para definir caracteres
signed char, 8 bits con signo (-127 a +127)
unsigned char, 8 bits sin signo (0 a 255)

int, 16 bits con signo (-32767 a 32767)
signed int, igual que el anterior (es lo mismo)
unsigned int, 16 bits sin signo (0 a 65535)





long, 32 bits con signo
signed long, igual que el anterior (es lo mismo)
unsigned long, 32 bits sin signo

float, 32 bits coma flotante con precisión simple (para definir valores reales)

double, 64 bits coma flotante con precisión doble (para definir valores reales)

No os recomiendo el uso de más de 16 bits a menos que sea absolutamente imprescindible, ya que
todas las operaciones que hagamos serán seriamente penalizadas (el Z80 está pensado para
operaciones con 8 y 16 bits). A todos los efectos con char e Int tenemos de sobra.

Unos ejemplillos:

unsigned char valor_x; // Define una variable llamada valor_x, que puede valer desde 0 a 255

unsigned int memoria_pantalla; // Define una variable de 16 bits sin signo (de 0 a 65535)

unsigned char valor1, valor2; // También es posible definir dos variables a la vez (o más)

Os quedará más claro cuál usar en cada caso cuando os llegue el momento.





El ZX Spectrum por dentro


Para poder programar