Repaso de C: control de flujo

En C las instrucciones o proposiciones se terminan con ; . Las instrucciones se pueden agrupar con { … } para dar lugar a proposiciones compuestas o bloques.

Las instrucciones de control de flujo son las que permiten tomar decisiones y controlar por dónde fluye la ejecución del programa. En el caso de C son:

  • if – else if – else.
  • switch.
  • while.
  • for.
  • do – while.
  • break y continue.
  • goto y etiquetas.

Lo más simple es ver un ejemplo de cada tipo:

if – else if – else:

La instrucción if evalúa una condición y, si se cumple, ejecuta el bloque que sigue. Este bloque puede ser simple, en cuyo caso no hacen falta llaves, o compuesto:

En caso de que no se cumpla la condición, tenemos la rama else opcional, que también puede tener un bloque simple o compuesto:

Y si se quieren evaluar varias condiciones seguidas, tenemos else if:

switch:

La instrucción switch es similar al if – else if – else, es decir, también vale para decisiones múltiples. La principal diferencia es que, en vez de evaluar una expresión arbitraria y decidir si es cierta (!= 0) o falsa (== 0), como el if, compara la expresión, normalmente una variable, con un conjunto limitado de valores constantes.

Por ejemplo, la instrucción switch:

es básicamente equivalente a if (a == 0) {…} else if (a == 1) {…} else if (a == 2) {…} else {…}.

Sí hay un matiz importante, y es que en un if – else if – else sólo se ejecuta una de las ramas. Sin embargo, en un switch se evalúan y ejecutan todas las ramas case a partir de la coincidencia, salvo que de forma explícita se decida salir del switch con un break. La instrucción break también se utiliza para salir de bucles while, for y do – while.

while:

La instrucción while sirve para hacer bucles. La condición de terminación del bucle se evalúa primero, y el bucle se ejecuta hasta que deja de cumplirse:

Cuando el cuerpo del while es una proposición simple también se pueden obviar las llaves. Esto es una norma general de todas las instrucciones de control de flujo.

for:

La instrucción for también vale para implementar bucles. Es un poco más compleja que while, porque tiene una inicialización, una condición de terminación del bucle, y una expresión que se ejecuta al final de cada iteración, y que típicamente se utiliza para incrementar o decrementar un contador.

Lo bueno del for es que todo lo que controla el bucle, la inicialización, la condición de terminación / continuación, y el cambio de una iteración a la siguiente, están claros y en el mismo sitio.

do – while:

El do – while es el tercer tipo de bucle en C. A diferencia del while, primero se ejecuta el cuerpo el mismo, y luego se comprueba la condición. Por tanto, un do – while tiene sentido cuando el bucle tiene que ejecutarse al menos una vez:

Hay bucles, sin embargo, que tienen que ejecutarse 0 o más veces, en función del valor de una variable. Para estos es mejor un while.

break y continue:

En todos los tipos de bucles cabe la opción de salir del mismo. Esto se hace con la instrucción break, que ya se presentó con el switch.

Igualmente, también cabe la opción de saltar a la siguiente iteración, lo cual se hace con la instrucción continue. Esto no tiene sentido en un switch:

goto y etiquetas:

Por último, C soporta etiquetas y goto. Las etiquetas son como las etiquetas de ensamblador: sirven para marcar posiciones en el código. Se nombran como las variables (letras, números y algunos símbolos), pero tienen que terminar con : .

Por su parte, el goto es una instrucción que hace saltar la ejecución a una etiqueta. El goto y la etiqueta tienen que estar en la misma función:

En general, el goto está desaconsejado, porque todo lo que se puede escribir con goto se puede también escribir sin él, resultando más fácil de entender y mantener.


Código de ejemplo: control_flujo

Repaso de C: operadores y expresiones

Operadores y operandos:

Como en el caso de las variables, todo programador tiene una idea intuitiva de qué es un operador: es un signo u operación que relaciona unos operandos (variables o constantes) para devolver un valor.

En C, como en otros lenguajes, hay muchos tipos de operadores:

  • Operadores aritméticos: Sirven para realizar operaciones aritméticas. Son +, -, *, / y % (resto de la división entera). No hay exponenciación.
  • Operadores de relación: Sirven para comparar. Son >, >=, <, <=, == y !=. No se debe confundir la igualdad (==) con la asignación (=).
  • Operadores lógicos: Sirven para realizar operaciones lógicas o booleanas, es decir, && (AND), || (OR) y ! (NOT). En C no existe el tipo boolean, así que se toma 1 como true (realmente distinto de 0) y 0 como false.
  • Operadores de incremento y decremento: Son ++ y –, y sirven para incrementar o decrementar una variable. Lo curioso es que pueden usarse como prefijo o sufijo, hablándose de preincremento, postincremento, etc. En la versión prefijo primero se incrementa o decrementa y luego se devuelve el valor; en la versión sufijo primero se devuelve el valor y luego se incrementa o decrementa.
  • Operadores de manejo de bits: Son & (AND), | (OR), ^ (OR exclusivo), << (desplazamiento a la izquierda), >> (desplazamiento a la derecha) y ~ (complemento a uno o negación). Como se puede ver, C es de alto nivel, pero no tanto, porque se puede operar directamente con bits.
  • Operadores de asignación: El operador de asignación por excelencia es el =, que asigna un valor a una variable. Pero hay más, porque la mayoría de operadores binarios (+, -, *, /, %, …) tienen también un operador de asignación asociado (+=, -=, *=, /=, %=, …). Por ejemplo, la asignación i = i +2 también puede ponerse como i += 2.

Hay más operadores, como los que tienen que ver con estructuras (. y ->), con arrays ([]), con direcciones y punteros (* y &), con funciones (paréntesis), con conversión de tipos o “casting”, sizeof para obtener el tamaño de una variable, etc. Todos estos operadores se verán más adelante.

Lo que sí es bastante complejo son las reglas de precedencia y asociación de los operadores de C (extracto del libro de Kernighan & Ritchie):

Expresiones:

Las expresiones son un tipo especial de instrucción que devuelven un valor. Por ejemplo, todas las operaciones vistas anteriormente (aritméticas, de relación, booleanas, de manejo de bits, etc.) conforman expresiones, porque devuelven un valor.

En particular, las asignaciones no sólo almacenan un valor en una variable; además, devuelven ese valor para hacer más cosas con él, si se quiere. Por este motivo se pueden hacer cosas como i = j = 0. Esto no sólo asigna 0 a la variable j, sino que además devuelve el valor 0, que se asigna a la variable i. Es decir, la asignación j = 0 es, además, una expresión.

Hay un tipo especial de expresión que es la expresión condicional. Ésta verifica una condición y, en función del resultado, devuelve un valor u otro. Se expresa con el operador ternario ? : . Por ejemplo, (a > b) ? a : b devuelve a si a > b y b en caso contrario.


Código de ejemplo: operadores

Repaso de C: variables, tipos, constantes y declaraciones

Variables:

Todo programador tiene una idea intuitiva de qué es una variable: un trocito de memoria que guarda un valor. Las variables tienen:

  • Una dirección de memoria.
  • Un nombre.
  • Un valor, que puede cambiar, por eso se llama variable.
  • Un tipo.

En C, los nombres de las variables tienen que empezar por una letra, y pueden contener letras, algunos símbolos y números. Por supuesto, el nombre no puede ser una palabra reservada del lenguaje. Las mayúsculas y las minúsculas se consideran diferentes. Las variables se suelen nombrar con minúsculas y las constantes simbólicas con mayúsculas.

Tipos de datos:

Las variables tienen un tipo, que define el conjunto de valores que pueden tomar. Los tipos de datos pueden ser básicos o estructurados.

Los tipos básicos son los más sencillos, los que aporta el lenguaje de forma directa. En el caso de C son:

  • char.
  • int.
  • float (no soportado en cc65).
  • double (no soportado en cc65).

Estos tipos básicos se pueden modificar con los calificadores:

  • short y long.
  • signed y unsigned.

El primero hace referencia al tamaño en bytes, y el segundo al carácter con signo / sin signo.

Una curiosidad de C es que no fija el tamaño en bytes de sus tipos básicos o primitivos. Sólo fija que un short tiene que ser menor que un int, que tiene que ser menor que un long. Esto ha dificultado su portabilidad entre máquinas.

Constantes y constantes simbólicas:

Las constantes –o valores constantes– son valores fijos que se utilizan en inicializaciones, expresiones, llamadas a funciones, etc. Las constantes también tienen un tipo, que puede ser el natural a partir de su sintaxis o se puede forzar mediante sufijos. Lo mejor es ver ejemplos:

  • 1234 es una constante de tipo int.
  • 123456789L es una constante de tipo long.
  • 123.4 es una constante de tipo double.
  • ‘A’ es una constante de tipo char.
  • “programa” es una constante de tipo array de char (cadena).
  • Etc.

Las constantes de tipo int se pueden expresar en decimal, en octal empezando por 0, o en hexadecimal empezando por 0x.

Los caracteres especiales se pueden representar mediante secuencias de escape. Por ejemplo, la nueva línea se puede representar con \n, la barra invertida con \\, etc. También se puede usar \xHH, donde HH es el valor ASCII en hexadecimal.

Con la instrucción del preprocesador #define es posible definir constantes simbólicas, es decir, nombres que equivalen a un valor fijo. Por ejemplo, #define SPRITES_NUM 8 hace que el nombre SPRITES_NUM equivalga a 8.

También es posible definir enumeraciones, por ejemplo:

enum meses {ENE=1, FEB, MAR, ABR, MAY, JUN, JUL, AGO, SEP, OCT, NOV, DIC}

lo cual equivale a definir ENE = 1, FEB = 2, MAR = 3, etc.

Declaraciones:

Para poder usar una variable, antes hay que declararla. Al declararla se indica:

  • Su tipo.
  • Su nombre.
  • Y una inicialización opcional.

Por ejemplo:

  • int contador = 0;
  • char car = ‘a’;

En función de donde se declaren, las variables pueden ser locales a una función o globales al programa (en C se llaman variables “externas”).

Las variables locales, si no se inicializan, contienen basura. Y si están inicializadas, se inicializan en cada ejecución de la función (salvo que se declaren static).

Las variables globales se inicializan sólo una vez antes de iniciarse la ejecución del programa. Se inicializan a 0 salvo que tengan una inicialización explícita.

En una declaración se puede usar el calificador const para indicar que una variable no cambia su valor. Sería una variable constante, si vale la paradoja. También se puede usar const en los parámetros de las funciones.


Código de ejemplo: variables

Repaso rápido del lenguaje de programación C

Llegados a este punto, y de cara a desarrollar un posible proyecto en C para el C64, lo suyo sería repasar de forma breve, aunque sistemática, el lenguaje de programación C.

Y la biblia de C ya sabéis cual es, el libro escrito hace décadas por los diseñadores del lenguaje (Brian Kernighan y Dennis Ritchie). Este libro ha tenido varias ediciones según ha ido evolucionando el lenguaje y, en particular, por su proceso de estandarización en ANSI:

Siguiendo un poco la estructura de este libro, los aspectos principales a revisar serían:

  • Variables.
  • Tipos de datos.
  • Constantes.
  • Declaraciones.
  • Operadores.
  • Expresiones.
  • Control de flujo.
  • Funciones.
  • Estructura de un programa C.
  • Preprocesador.
  • Punteros.
  • Arrays.
  • Estructuras.
  • Uniones.
  • Typedef.
  • Librerías estándar.

Por supuesto, el lenguaje C tiene muchos más aspectos, pero lo anterior es lo fundamental. Sólo eso ya dará para varias entradas.

Un libro interesante de programación retro en C

A lo largo de este blog ya hemos mencionado, al menos en un par de ocasiones, la página web https://8bitworkshop.com/, relativa a la programación retro de diferentes máquinas de 8 bits. Pues bien, vinculados a esa página web hay varios libros que se puede ver en la dirección:

https://8bitworkshop.com/docs/books/index.html

De todos ellos, el que me parece más interesante es el titulado “Making 8-bit arcade games in C”, de Steven Hugg:

Como indica su título, está dedicado a la programación en C de juegos para máquinas de 8 bits.

Es importante destacar que el libro no trata específicamente el C64. Sí trata otras plataformas de los 80 como Midway 8080, VIC Dual, Galaxian / Scramble, Atari y Williams. Se trata de plataformas hardware específicas para juegos de tipo arcade.

De hecho, el libro toca un poco de todo:

  • Conceptos básicos de microprocesadores.
  • Conceptos y ejemplos de programación en C.
  • Plataformas de hardware como las mencionadas.
  • Y la programación de diferentes proyectos o juegos.

El libro va saltando de una temática a otra a lo largo de sus 31 capítulos y 220 páginas, pero yo diría que el hilo conductor principal son las diferentes plataformas y cómo fueron evolucionando con el paso del tiempo.

En definitiva, un libro interesante y que guarda relación con lo que venimos tratando aquí últimamente.

Desarrollo de una librería de sonido en C

Igual que hemos hecho con los sprites, se podrían desarrollar librerías en C para trabajar en modo bitmap, modo bitmap multicolor, definir y activar juegos de caracteres personalizados, hacer scroll, etc. Algunas de estas librerías ya estarían parcialmente cubiertas por otras propias de cc65, como TGI; otras no.

Sea como fuere, la otra gran librería que podemos hacer es una librería de sonido en C, y a esto es a lo que vamos a dedicar esta entrada.

Nuevamente, si nos inspiramos en la librería en ensamblador del Volumen II:

https://programacionretroc64.files.wordpress.com/2019/11/lib-v2.zip

y, más concretamente, en el fichero “LibSonido.asm”, vemos que tiene rutinas para:

  • Inicializar una imagen del SID.
  • Transferir la imagen del SID (al SID, claro).
  • Fijar el volumen.
  • Fijar la frecuencia de una voz.
  • Fijar la forma de onda de una voz.
  • Fijar el ADSR de una voz (attack – decay – sustain – release).
  • Fijar el ancho de pulso de una voz, en caso de que la forma de onda sea cuadrada.
  • Configurar un filtro sobre una voz.
  • Activar una voz.
  • Desactivar una voz.
  • Pasar de octava y nota a frecuencia.
  • Introducir un retardo.

Pues bien, todo esto perfectamente puede hacerse en C. Es más, es mucho más cómodo usarlo mediante una librería (pareja de ficheros sonido.h y sonido.c) que conociendo y manejando las estructuras de datos que cc65 define en _sid.h:

Vamos a ello:

Fichero de cabecera sonido.h:

El fichero de cabecera tiene una primera parte de definición de constantes que es así:

Es decir, aparte de controlar si el fichero ya está incluido con __SONIDO_H, define constantes para el tamaño del SID (25 registros de sólo escritura; 29 en total), para las tres voces (que ahora vamos a numerar 0, 1 y 2), para las formas de onda y para los tipos de filtro. También define el tipo byte.

A partir de ahí, incluye prototipos para las funciones de interés:

No vamos a repetir aquí las funciones, porque en el fondo son las mismas que las rutinas que ya se han enumerado para la librería en ensamblador.

Sí interesa recordar que, al ser el SID en su mayoría registros de sólo escritura, salvo los cuatro últimos ($d419 – $d41c), que son de sólo lectura, aplicaremos la técnica de trabajar sobre una imagen del SID (un array de 25 posiciones, uno por cada registro de sólo escritura) y copiar o transferir esa imagen al SID cuando se quiera configurar éste. De este modo será posible conocer y modificar el estado del SID a partir de su imagen.

Fichero de implementación sonido.c:

El fichero que implementa la librería empieza con esta apariencia:

Es decir, primero incluye el header file sonido.h (con “…” para que no se busque en cc65\include, sino en el mismo directorio que sonido.c) y algunas librerías estándar. Después recoge tres tablas de interés:

  • La tabla sonido_imagen_sid[] es la imagen del SID. Esta es la tabla que vamos a configurar con las diferentes funciones y, llegado el momento, vamos a transferir o copiar al SID.
  • La tabla sonido_offset_voces[] nos da el offset de los registros de cada voz ($00, $07 y $0e respectivamente) dentro del mapa de memoria del SID.
  • La tabla sonido_frecuencias_oct7[] nos da las frecuencias correspondientes a las 12 notas de la octava 7, y que nos permite calcular las frecuencias de esas mismas notas en otras octavas (0…6).

A partir de ahí, vienen las implementaciones de las diferentes funciones. E, igual que en el caso de la librería de sprites, no vamos a revisarlas todas, sino alguna seleccionada:

Por ejemplo, para la función sonido_fija_volumen():

  • Recibe el volumen en un byte, aunque sólo ocupa un nibble.
  • Se queda con el nibble bajo mediante un AND (volumen & 0x0F).
  • Toma la posición 0x18 = 24 de la imagen del SID, le hace un OR con el volumen (sonido_imagen_sid[0x18] | volumen), y lo vuelve a guardar en la posición 0x18.

Esto último, es decir, el tomar la posición y hacerle un OR, lo podemos hacer porque estamos trabajando con una imagen del SID. Directamente contra el SID no sería posible hacerlo, porque esos registros son de sólo escritura.

Ya sólo nos quedaría transferir la imagen al SID para que el cambio de volumen fuera efectivo.

Por otro lado, la función sonido_fija_frecuencia() hace cosas parecidas, por ejemplo un AND (frecuencia & 0x00FF) para quedarse con el byte low o menos significativo de la frecuencia, y un desplazamiento de 8 bits a la derecha (frecuencia >> 8) para quedarse con el byte high o más significativo.

Todo esto demuestra que C es un lenguaje de “alto nivel”, pero no mucho, ya que tiene operadores como &, |, >> y muchos otros que permiten operar con bits de forma similar al ensamblador.

Programa de ejemplo:

Para el programa de ejemplo nuevamente nos vamos a basar en uno ya conocido, concretamente el programa 53 del Volumen I:

Este programa, tanto la versión en ensamblador como la versión en C, tiene una tabla de cuatro entradas, siendo cada entrada:

  • La octava y la nota de la voz 0.
  • La octava y la nota de la voz 1.
  • La octava y la nota de la voz 2.
  • La duración y el volumen, que son comunes a las tres voces.

Y para que la tabla con la melodía ocupe lo menos posible, octavas y notas se codifican en el mismo byte, a razón de un nibble cada una, al igual que la duración y el volumen.

Por tanto, lo que tiene que hacer el programa es inicializar las voces con su forma de onda y ADSR y, luego, reproducir la melodía. Para esto último:

  • Lee un byte de la tabla, separa octava y nota, calcula la frecuencia, y configura la voz 0 con esa frecuencia.
  • Idem para la voz 1.
  • Idem para la voz 2.
  • Lee un byte de la tabla, separa duración y volumen, y configura el volumen para las tres voces.
  • Activa las tres voces y transfiere la imagen al SID. Hasta este punto el SID no ha cambiado.
  • Espera la duración de la nota.
  • Y repite todo lo anterior hasta que termine la melodía, lo cual se señaliza con el byte $ff, que no es un byte válido pues el C64 no soporta ni $0f = 15 octavas ni 15 notas por octava.
  • Para terminar, desactiva las tres voces y vuelve a transferir la imagen al SID. Esto último –desactivar las voces– se puede hacer en cada iteración del bucle, es decir, de una nota a la siguiente, pero si se hace sólo al final del mismo la reproducción queda como más fluida.

Y como el programa es largo, aunque esencialmente es un bucle, sólo vamos a ver en detalle algunas de sus funciones más representativas. Por ejemplo, la función configura_frecuencia() es así:

Es decir, recibe como parámetros la pareja (octava, nota) y la voz, que salen de la tabla con la melodía, y separa el nibble alto (octava) del nibble bajo (nota), imprime ambos con printf(), obtiene la frecuencia asociada con sonido_obten_frecuencia(), también la imprime, y fija esa frecuencia para la voz en cuestión.

Por su parte, configura_volumen() es parecida:

Es decir, recibe la pareja (duración, volumen), separa el nibble alto (duración) del nibble bajo (volumen), imprime ambos con printf(), y fija el volumen con sonido_fija_volumen(). Aquí no interviene la voz porque el volumen es común para todas.

Si compilamos y ejecutamos el programa el resultado es así, aparte de escuchar una bonita canción:

Los datos que se muestran en cada fila son la voz, la octava, la nota y la frecuencia. Esto para las tres voces (numeradas ahora como 0, 1 y 2), y luego la duración y el volumen.


Código de ejemplo: sonido

Desarrollo de una librería de sprites en C

En la entrada anterior hemos visto que el manejo de sprites (y del VIC en general) con cc65 es sencillo. Llega con conocer las estructuras de datos de _vic2.h. y hacer asignaciones de valores a los registros.

Ahora bien, se puede hacer todavía más sencillo. Si recordamos, cc65 aporta header files, es decir, constantes, funciones y otras cosas para el manejo de joystick, ratón, consola, disco, gráficos, etc. ¿Por qué no hacer lo mismo con los sprites? ¿Por qué limitarnos a las estructuras de datos de _vic2.h y similares?

Y esto es precisamente lo que me planteo en esta entrada. Inspirándonos en la librería en ensamblador para manejar sprites del Volumen II, hacer una librería equivalente en C. Y la implementación de esa librería se apoyaría en _vic2.h.

Vamos a ello. Partimos del fichero lib-v2.zip disponible aquí:

https://programacionretroc64.files.wordpress.com/2019/11/lib-v2.zip

El contenido de ese ZIP es así (hay muchas librerías para diferentes propósitos):

Y si analizamos el fichero “LibSprites.asm” veremos que contiene estas rutinas:

  • Una rutina para copiar los datos de un sprite de un origen a un destino.
  • Una rutina para configurar los colores multicolor.
  • Una rutina para hacer la configuración básica de un sprite, es decir, para configurar su bloque, su color y activarlo.
  • Una rutina para posicionar un sprite.
  • Una rutina para hacer la configuración avanzada de un sprite, es decir, para configurar el multicolor, la expansión horizontal y/o vertical, y la prioridad sobre el fondo.
  • Una rutina para decidir si dos sprites están o no en colisión.

Todo esto lo vamos a convertir en dos ficheros en C:

  • sprites.h, que será el header file con los prototipos, constantes y demás.
  • Y sprites.c, que será la implementación de las funciones.

Por claridad, los nombres de las funciones serán similares a los de las rutinas, y lo de los parámetros también, salvando las diferencias lógicas por las nomenclaturas de nombrado en ensamblador y en C.

Fichero de cabecera sprites.h:

El fichero sprites.h quedaría así. Tendría una primera parte con constantes:

Una primera constante (__SPRITES_H) serviría para controlar si el header file ya está incluido en un programa y, en tal caso, no volver a incluirlo. A partir de ahí, habría constantes para el tamaño de los sprites (64 bytes), el número de sprites (8), controlar el multicolor, la expansión X e Y, la prioridad del fondo y las colisiones.

También aprovechamos para definir el tipo byte, que equivale a un unsigned char de C. Este tipo es muy útil para programar el C64, ya que es un ordenador de 8 bits.

Y la segunda parte sería así:

Es decir, primero define una estructura (el tipo de dato) para tener acceso a los punteros de los sprites, y luego define SPRITES_PUNTEROS como un puntero a ese tipo de estructura y lo vincula la posición $07f8, que es donde empiezan los punteros de los sprites ($07f8 – $07ff).

Por último, define los prototipos de las funciones que permiten copiar los datos de un sprite, configurar los multicolores, hacer la configuración básica de un sprite (puntero / bloque, color y activación), posicionar un sprite, hacer la configuración avanzada (multicolor, expansión y prioridad del fondo) y, por último, la función que permite detectar si dos sprites han colisionado.

Por supuesto, se pueden definir más funciones con otros propósitos, por ejemplo, para animar sprites, pero lo anterior es lo básico.

Fichero de implementación sprites.c:

La implementación de la librería de sprites es el fichero sprites.c. Este fichero incluye el sprites.h (#include <sprites.h>) y, a partir de ahí, aporta implementaciones para sus funciones. Estas implementaciones lógicamente se apoyan en las estructuras de datos de _vic2.h.

A modo de ejemplo, la implementación de la función sprites_conf_basica() sería así:

Es decir:

  • Recibe tres parámetros, el número de sprite, el bloque donde está almacenada la definición y el color deseado.
  • Guarda el bloque recibido en el puntero del sprite.
  • Guarda el color deseado en el registro del VIC encargado del color.
  • Y, mediante un OR, es decir, mediante el operador | de C, activa el bit correspondiente al sprite en el registro encargado de habilitar los sprites.

Las otras funciones tienen implementaciones similares. Su revisión queda como ejercicio para el lector interesado.

Programa de ejemplo:

Lo último sería hacer un programa de ejemplo que, usando la nueva librería, maneje sprites. Para ello nos inspiramos en el ejemplo de la entrada:

La versión en C sería así:

Es decir:

  • Limpia la pantalla con la función clrscr() de conio.
  • Instala el driver de los joysticks.
  • Configura los sprites.
  • Y, a partir de ahí, entra en un bucle que mueve un sprite, analiza las posibles colisiones y espera un tiempo. Y lo mismo con el otro sprite.

Las funciones para configurar los sprites, moverlos y analizar las colisiones se apoyan en la nueva librería.

Para configurar los sprites, la función conf_sprites() hace así:

A saber, configura los multicolores, que son compartidos entre todos los sprites, copia la definición del sprite 0 en el bloque 0 (254), hace su configuración básica (pone el puntero apuntando al bloque 254, configura el color verde y activa el sprite), hace su configuración avanzada (activa el multicolor, desactiva las expansiones y da prioridad al fondo), y termina con su posición. Y algo análogo con el sprite 1.

Por otro lado, para mover los sprites las funciones mueve_sprite_0() y mueve_sprite_1() hacen así:

Es decir, leen el joystick 1 y 2 respectivamente, y, en función del movimiento leído incrementan o decrementan la coordenada X o la Y. Finalmente, vuelven a posicionar el sprite.

Por último, para detectar las colisiones la función analiza_colision():

Es decir, se apoya directamente en la función sprites_colision() de la nueva librería. Y, en caso de detectar la colisión, termina la ejecución con exit().

El resultado es un viejo conocido:

En conclusión, que no hay por qué limitarse al uso de las estructuras de datos de _vic2.h. Sobre éstas es posible programar librerías que simplifiquen todavía más la programación con sprites o del VIC en general.


Código de ejemplo: sprites

Un ejemplo de sprites en C

Como hemos comentado varias veces, cc65, a través de su header file c64.h, tiene estructuras de datos que permiten manejar fácilmente el VIC, el SID, la RAM de color y las CIAs. Por ejemplo:

Y en el caso particular del VIC (ver header file cc65\include\_vic2.h):

Esto quiere decir que mediante una sintaxis de C tan sencilla como ésta (asignaciones):

VIC.spr0_x = 100

VIC.spr0_y = 100

es posible modificar la posición del sprite 0, por poner un ejemplo.

Veamos entonces cómo podemos hacer un ejemplo sencillo en C para manejar sprites. Si recordamos de alguna entrada antigua de este blog, para definir un sprite necesitamos:

  • Diseñar el aspecto gráfico del sprite y guardar los 64 bytes que lo definen (en realidad 63) en alguna zona de memoria.
  • Copiar esos 64 bytes a uno de los 256 “bloques” a los que tiene acceso el VIC.
  • Poner el puntero del sprite (posiciones $07f8 –$07ff, según el número de sprite) apuntando al bloque elegido.
  • Habilitar el sprite.
  • Elegir el color del sprite.
  • Posicionar el sprite.

Pues bien, veamos cada uno de estos pasos:

Diseñar el aspecto gráfico del sprite:

En este caso vamos a reutilizar algún sprite ya diseñado. Se trata de nuestra vieja amiga la pulga:

Guardar la definición del sprite en una zona de memoria:

Como sabemos, ese diseño de 24 x 21 pixels se traduce en (yendo de izquierda a derecha y de arriba abajo):

  • 3 bytes por fila (24 pixels).
  • 21 filas (21 pixels).
  • En total, 63 bytes.

En ocasiones, en vez de 63 bytes se manejan 64, aprovechando el byte 64 para guardar la información del color (o colores, en el caso multicolor). También puede ser mero relleno o, simplemente, manejar 63 bytes.

En nuestro ejemplo en C esos 64 bytes se traducen en este array de 64 bytes (o char, en C vienen a ser lo mismo):

Usamos notación hexadecimal (0x…) porque resulta lo más directo en este caso.

Copiar la definición del sprite a uno de los 256 bloques:

Se podría intentar que al cargar el programa PRG en el C64, esos 64 bytes se cargaran ya directamente en el bloque en el que tienen que estar. Sin embargo, no es lo más práctico.

Por ello, lo que vamos a hacer es copiar esos 64 bytes desde la posición que les haya tocado “en suerte” al compilar, hasta el bloque en que queremos que se almacenen. Esto lo hacemos con la función copia_def_sprite(), de la que lógicamente necesitamos prototipo e implementación.

La implementación es así:

Como se puede ver, el código es sencillo:

  • A partir del número de bloque determinamos la dirección destino multiplicando por 64.
  • Utilizamos la función estándar memcpy() para copiar los 64 bytes del sprite desde el origen (el array de bytes) hasta el destino (el bloque elegido).

Ya tenemos la definición del sprite en su sitio.

Configurar el puntero del sprite:

Para configurar el puntero del sprite tenemos que guardar el número de bloque elegido en la posición correspondiente al sprite, que es la $07f8 en el caso del sprite 0 y así sucesivamente hasta la $07ff en el caso del sprite 7 (en total, 8 sprites).

Esto lo hacemos con la función conf_ptr_sprite() que, en una primera aproximación, tiene una implementación muy similar a la de copia_def_sprite(), es decir, basada en memcpy():

Posteriormente, veremos otras implementaciones mejores y más claras.

Habilitar el sprite:

Lo siguiente es habilitar el sprite, para lo que ni siquiera necesitamos una función, ya que se trata de asignar el valor 1 (o el valor previo OR 1) a la posición SPENA = $d015, que está accesible mediante VIC.spr_ena.

Esto es tan sencillo que no merece un pantallazo propio, así que aprovechamos para presentar el programa principal en su conjunto. Véase la línea 29 en particular:

Como se puede ver en las primeras líneas del programa principal main(), estamos usando el sprite 0 y el bloque 254. Pero cambiar esto se ha hecho fácilmente configurable mediante variables (sprite y bloque).

Elegir el color y posicionar del sprite:

Con estas dos últimas operaciones ocurre lo mismo que con la habilitación del sprite, son tan sencillas que no requieren de funciones propias. En el caso del color se trata de dar valor a la variable VIC.spr0_color y en el caso de la posición a las variables VIC.spr0_x y VIC.spr0_y.

Una cosa chula del header file _vic2.h es que hay dos formas de usar los registros, bien mediante un nombre específico para cada sprite, o bien mediante un array con un índice que indica el número de sprite. Por ejemplo, en el caso de las posiciones (ídem colores, etc.):

Es decir, la posición del sprite 0 se puede cambiar:

  • Bien con VIC.spr0_x = X y VIC.spr0_y = Y.
  • O con VIC.spr_pos[0].x = X y VIC.spr_pos[0].y = Y.

La segunda forma me parece mejor, ya que permite trabajar con una variable “sprite” o “num_sprite” que en ocasiones valdrá 0, en otras 1, en otras 2, … Es más general.

Resultado:

Bueno, pues el resultado de compilar y ejecutar el programa es el que cabría esperar:

En realidad, el resultado no es tan espectacular. El tema sprites lo tenemos controlado desde hace tiempo. Lo que me resulta más espectacular es lo sencillo y directo que resulta hacerlo en C.

Y más sencillo que se puede hacer, lo que me dará pie a futuras entradas…

Mejoras:

En el ZIP adjunto encontraréis la versión original de este programa (sprite1.c), así como varias mejoras:

  • sprite2.c: En vez de usar el sprite 0 de forma fija usamos el sprite indicado por la variable “sprite”. Es decir, usamos las variables de _vic2.h en su variante por índice.
  • sprite3.c: Definimos un header file (sprite3.h) con variables para tener acceso de forma fácil a los punteros de los sprites (posiciones $07f8 – $07ff), de forma que no tengamos que usar memcpy() para algo tan sencillo como darles valor.
  • sprite4.c: Mejoramos el header file (ahora sprite4.h) para poder usar los punteros de los sprites mediante un índice, no con nombres fijos.

Mediante el uso de uniones de C se puede hacer un nuevo header file (sprite5.h) que permita tanto nombres fijos (SPR_PTR.spr0_ptr, SPR_PTR.spr1_ptr, …) como nombres con índice (SPR_PTR.spr_ptr[sprite]). Esto se deja como ejercicio para el lector.


Código de ejemplo: sprites

Entorno de ejecución de cc65 para el C64

Como ya comentamos algunas entradas más atrás, el resultado de compilar y enlazar un programa en C para el C64 con cc65 es un programa en código máquina con un cachito de BASIC que llama al código máquina con un comando SYS. Por tanto, los programas preparados con cc65 se cargan y ejecutan como si fueran programas en BASIC, pero su grueso es código máquina. Esta es la configuración por defecto, aunque se puede cambiar.

Respecto al mapa de memoria de los programas, estos empiezan en $0801, puesto que tienen ese trocito de BASIC, y pueden llegar hasta $cfff. Esto es así porque cc65 desactiva el intérprete de BASIC ($a000 – $bfff), pero mantiene los chips de entrada / salida (VIC, SID, RAM de color y CIAs) y el kernal.

La RAM de pantalla, salvo que se utilice el driver de Conio para 80 columnas, sigue en su sitio habitual: $0400 – $07e7. La pila de C empieza en $cfff y crece hacia abajo; no hay que confundir esta pila con la pila del C64 (página 1; $0100 – $01ff). Por último, el “heap”, que es de donde C saca la memoria para las estructuras de datos dinámicas que pudiera usar el programa (ej. listas enlazadas, árboles, etc.), se ubica al final del programa y crece hacia la pila (la pila de C).

Por tanto, el mapa de memoria sería algo así:

Ya comentamos anteriormente que cc65 tiene header files específicos para el C64 (cbm.h y c64.h), así como estructuras (structs) vinculadas a las direcciones de memoria del VIC, SID, RAM de color y CIAs, lo que permite manipular cómodamente desde C los registros de estos chips, básicamente haciendo asignaciones de valores a los campos de esas estructuras.

cc65 también tiene drivers para que el C64 pueda manejar gráficos TGI, la consola con Conio, el ratón, el joystick, etc., como hemos ido comentando en entradas anteriores.

También es interesante comentar que, para que el programa en C pueda recibir parámetros del entorno, se puede usar esta sintaxis al ejecutar el programa desde BASIC:

RUN : REM ARG1 “ARG 2” ARG3 “ARG 4” …

Igualmente, el programa en C puede devolver un valor de retorno al BASIC en la posición de memoria STATUS = $90 = 144.

Por último, es interesante comentar que es posible programar en C sacando provecho de las interrupciones del C64, si bien para ello las rutinas de interrupción tienen que estar en ensamblador.

Todo esto y mucho más se puede ver en detalle en la página:

https://cc65.github.io/doc/c64.html


Código de ejemplo: argumentos

Manejo de GEOS con geos.h

Es increíble, pero el C64 tuvo un sistema operativo con interfaz de usuario gráfica (GUI) ya en el año 1986. Se llamaba GEOS y podéis ver una descripción aquí:

https://es.wikipedia.org/wiki/GEOS

El GEOS se distribuyó sobre todo con el modelo C64C, y como mi modelo era la “panera” original, he de reconocer que en los 80 no caté mucho GEOS. Pero sí lo vi en funcionamiento en alguna ocasión.

Algunos aspectos increíbles de GEOS son:

  • Residía en disco. Había que cargarlo desde ahí.
  • Tenía interfaz de usuario gráfica.
  • Permitía el uso de ratón.
  • Incluía aplicaciones de edición de textos, hojas de cálculo, para pintar, etc. También había aplicaciones hechas por terceros.
  • Tenía un cargador turbo para disco.
  • Permitía el uso de múltiples impresoras.
  • Etc.

Un sitio interesante para aprender mucho sobre GEOS y descargarlo es éste:

https://cbmfiles.com/geos/

Concretamente, la descarga de GEOS para C64 en formato D64 se puede realizar desde aquí:

https://cbmfiles.com/geos/geosfiles/GEOS64.ZIP

En realidad, lo que te descargas es un fichero ZIP de unos 380 KB con varios discos en formato D64:

El disco / fichero que más nos interesa es el “GEOS64.D64”. Si lo arrastras a VICE…

Ahora sólo queda configurar un ratón o un joystick en VICE (puerto de control 1) y empezar a jugar con GEOS. ¿No es increíble?

En particular, con el menú de VICE File > Attach disk image > Drive 8 se puede conectar cualquiera de los otros discos, por ejemplo, el “APPS64.D64”, y explorar su contenido:

En cualquier caso, aquí estamos para hablar de cc65. Y ocurre que cc65 también soporta la programación en C para un C64 con GEOS mediante el header file geos.h. De hecho, si nos vamos a cc65\include veremos que no sólo tenemos el fichero geos.h, sino toda una carpeta geos con este contenido:

Es decir, que la programación en C para GEOS tiene su miga, hasta el punto de que no hay un único header file, sino 13, cada uno de ellos especializado en funciones concretas de este sistema operativo (constantes, disco, memoria, procesos, sprites, etc.).

La programación para GEOS, incluso en C que será más fácil que en ensamblador, queda fuera del objetivo de este blog, al menos de momento. Pero el que tenga interés puede profundizar en esta página de cc65:

https://cc65.github.io/doc/geos.html