Después de adquirir un par de libros maravillosos y ponerme a devorarlos, he comenzado a desarrollar un pequeño "entorno" de herramientas para facilitar el desarrollo usando Assembler en el Commodore 64.
Este desarrollo lo estoy realizando usando la herramienta CBM .prg Studio. Dicha herramienta es muy completa y me ha facilitado mucho la vida tanto para aprender como para terminar de comprender conceptos básicos del C64.
La idea detrás de "C64DevToolKit" (así lo he bautizado) no es estrictamente tener un set de librerías que facilite la programación, sino aprovechar para aprender implementando los conceptos básicos del Assembler.
Seguro que hay muchas formas de hacer dichas librerías mucho más eficientes, pero como he detallado, la idea principal es aprender en el camino, y , sobre todo, disfrutar de ello.
En esta primera versión, se usan muchos de los conceptos básicos como son:
1) Las posibilidades del propio lenguaje ASM.
2) Uso de subrutinas y macros.
3) Definición de direcciones de memoria y variables de uso común.
4) Uso de alguna que otra facilidad del Kernal del C64.
5) ScreenCodes y caracteres PETSCII.
6) Facilidades de la herramienta CBM Prog Studio.
7) Direccionamiento y uso de memoria 16 Bits usando modo indexado y la Página 0 de memoria.
8) Y alguna otra cosa más.
La funcionalidad de esta primera versión es muy básica, pero he ordenado el proyecto al estilo "moderno", tratando de compactar y reutilizar funcionalidad; como lo haríamos con librerías "modernas".
Seguiré completando el desarrollo, con muchas más cosas, a medida que tenga la posibilidad.
Los próximos pasos serán cosas como suma, multiplicación, el uso del reloj interno, salida de valores numéricos por pantalla y lo que se me valla cruzando, que sea básico, como lo que he desarrollado hasta ahora.
Este libro, aunque tiene una pequeña introducción al Assembly y al C64, va directo al desarrollo de un juego en ASM. Este lo dejo para más adelante, dado que quiero repasar bien lo básico con respecto al C64.
Aquí voy escribiendo mis cositas y es también para referencia rápida.
El plan es ir publicando cosas sueltas, que me parecen interesantes mientras voy construyendo una librería propia en ASM, para mis desarrollos en el C64.
También iré haciendo cositas del ZX Spectrum, en medio, para no perder la costumbre.
Rememorando libros que tengo por ahí de programación en BASIC para Commodore 64 me acordé de un ejemplo que vi en el que se "pinta" un globo.
Usando caracteres en BASIC y luego mediante un algoritmo, se convierte el globo en un Sprite y se pinta en pantalla.
El ejemplo es muy bueno, dado que usa los conceptos básicos del uso de un Sprite y se usa un pequeño algoritmo para pasar ese dibujo en caracteres a pantalla.
En la segunda imagen, se ve que hay tres bucles anidados, para ir leyendo los caracteres contenidos en el DATA e ir calculando el valor para el Sprite.
Es un truco muy chulo, pero sumamente lento. Está muy bien, para aprender pero nada más.
Además, va imprimiendo en pantlla el valor entero (de o a 253) de cada cálculo del Sprite.
Os dejo una imagen de disco D64 para poder cargar el código fuente en un emulador en este enlace.
Solo recordar que hay tres entradas, cubriendo el tema de los Sprites, junto con una herramienta de desarrollo en este mismo blog, por si interesa profundizar en el tema.
La prioridad es muy sencilla de entender. Los Sprites van del 0 al 7 ,así que el 0 es el que mayor prioridad tiene y el 7 el de menos. ¿ En que se traduce esto ?. Pues bien, si los solapamos, el cero siempre estará completamente visible, por debajo el 1 y así hasta el 7.
En la imagen siguiente lo vemos. Al moverse los 3 y solaparse, el fantasma quede arriba del todo (Sprite 0), el Pac - Man en medio (Sprite 1), pero tapando la cruz (Sprite 2).
La gestión de colisiones, es el conjunto de instrucciones BASIC que nos permiten detectar cuando nuestros Sprites se tocan entre ellos. Esto es una parte básica de cualquier juego, y es muy de agradecer que esté soportado tanto por hardware como por el BASIC (no como otros, si te miro a ti, Spectrum).
Básicamente existen dos instrucciones para detectar las colisiones, que usaremos en algún bucle donde tengamos la lógica de movimiento.
Para detectar la colisión de un Sprite con otro Sprite:
IF PEEK(V+30)AND X = [1,2,4,8,16,32,64 o 128] THEN [acción]
Sprite 0 1 2 3 4 5 6 7
Los valores de son 1,2,4,8,16,32,64 y 128 para cada uno de los Sprites del 0 al 7. Tenemos que usar el mismo valor en ambos lados.
Es decir, si queremos controlar las colisiones del primer Sprite en nuestro ejemplo (el fantasma), debemos usar la siguiente instrucción:
IFPEEK(V+30)AND1=1THENPOKE V+1,PEEK(V+1)-1
Lo que conseguimos con esto, es parar el movimiento del primer Sprite.
Hay que tener en cuenta que el registro de colisiones queda "sucio" siempre después de usado. Si no queremos sorpresas raras, lo debemos "limpiar" antes de usarlo.
Esto se hace con la instrucción: POKE V+30,0
Puedes descargar el ejemplo para CBM .prog Studio de este enlace.
En esta publicación vamos a cubrir los aspectos básicos de los movimientos de los Sprites en pantalla. Nos basaremos en el ejemplo de la anteriorpublicación y en el proyecto de la misma.
Añadimos una pequeña ayuda en el diseño de pantalla (directamente sobre el código) y movemos las posiciones iniciales de los Sprites un poco para acoplarlos a estas nuevas líneas de texto.
250PRINT"{113} m para mover los sprites {113}"
260PRINT"{113} s para parar el movimeinto {113}"
270PRINT" {113} q para salir {113}"
Ya que tenemos la pantalla montada, ahora vamos a implementar el movimiento de los 3 Sprites.
Los límites de coordenadas de la pantalla, para el uso de los Sprites y que sean completamente visibles son:
Esquina superior izquierda :
Coordenada X : 24
Coordenada Y : 50
Esquina inferior derecha :
Coordenada X : 343
Coordenada Y : 208
Esquina inferior izquierda :
Coordenada X : 24
Coordenada Y : 229
Esquina superior derecha :
Coordenada X : 343
Coordenada Y : 50
Estas son las coordenadas máximas de las esquinas, donde el Sprite es completamente visible. Es decir, podemos usar valores inferiores o superiores, pero entonces el Sprite no será completamente visible en pantalla.
Si no hemos usado toda la cuadríacula del Sprite (los 63 bytes) no importa, la cuenta aplica. Es decir que tenemos que tener en cuenta el tamaño completo del Sprite aunque no lo hallamos usado el lienzo completamente.
Lo primero será mover los 3 Sprites de izquierda a derecha.
Una cosa que tenemos que tener en cuenta, es que, si queremos mover hacia la derecha un valor superior a 255, tenemos que hacer un pequeño truco.
Para mover los Sprites, usamos POKE tal y como se indica en esta tabla:
660REM Movimiento eje X de los Sprites
665poke v+16,0 : GOSUB590
670FOR M=0TO347
680 hx=int(M/256):lx=M-256*hx
690if hx=1thenpoke v+16,7 : rem Esto es para hacer que pueda pasar a mas de x = 256
700poke v+0,lx
720poke v+2,lx
735poke v+4,lx
740NEXT
745poke v+16,0: GOSUB590 : rem reseteamos el registro a cero y volvemos a posicionar
750RETURN
La instrucción poke v+16,7 activa los 3 Sprites para que puedan pasar a la "derecha" del valor 256. Si no lo hacemos, se moverán hasta un determinado punto (255) y volverán desde la izquierda (24).
Es por esto que sumamos y usamos 7, para activarlo sobre los 3 a la vez.
Este lío no lo tenemos para el movimiento vertical.
Las posiciones donde el Sprite es completamente visible van de la 50 a la 229.
760REM Movimiento en el eje Y de 1 Sprite
770POKE V+0,100 : remPosicion X
780POKE V+1,50 : remPosicion Y
790for M=50to229
800POKE V+1,M : remPosicion Y
810next
815for M=229to50STEP -1
818POKE V+1,M : remPosicion Y
819NEXT
820RETURN
La tabla completa de las instrucciones POKE para manejar los Sprites, está en este documentotécnico o puedes verla aquí.
En la próxima publicación veremos como manejar las colisiones de Sprites y las prioridades.
Fue un primer paso muy básico, para ponerlo en marcha en lo que respecta a un proyecto BASIC para Commodore 64.
También usamos muy por encima el diseñador de pantallas, que nos permite, dado un set de caracteres "pintar" la pantalla y luego exportarla a nuestro código BASIC.
En esta publicación cubriremos el diseño de Sprites (por encima) usando el CBM .prog Studio y los conceptos básicos de uso de los Sprites desde el BASIC.
La herramienta de diseños de Sprites del BCM .prog Studio es muy completa y facilita mucho la tarea. A medida que avancemos en las subsiguientes publicaciones iremos usando algo más de su funcionalidad.
Usaremos como base el proyecto ya comenzado en la anterior publicación que se puede descargar de este enlace.
Una vez abierto el proyecto, hacemos doble click en la hoja de Sprites bajo el arbol "Spride Data". Esto abrirá el editor de Sprites.
Vamos a dibujar 3 Sprites distintos, para luego usarlos en nuestro programa BASIC.
En el editor, podemos usar color, color de fondo, multicolor y otras posibilidades como ver como quedaría una animación.
Hay que tener en cuenta, que lo que se exporta al listado BASIC es solo la definición de datos de los Sprites, por lo que lo que hagamos con las propiedades de color y demás cosas, lo tendremos que hacer luego por código.
Estos son los 3 Sprites que hemos pintado:
En la segunda solapa, "Scatch Pad" podemos posicionarlos en una pantalla artificial para ver que tal quedarían.
En resumen, el diseñador de Sprites tiene un montón de posibilidades para el diseño gráfico.
Hay un menú de exportar , donde pasaremos la definición de los Sprites al listado BASIC:
Una vez que tenemos el código en nuestro listado, empecemos con la parte esencial del uso de Sprites.
La idea es dejar los tecnicismos aparte e ir a lo que realmente nos va a ayudar a comenzar a conseguir cosas en pantalla.
Si te interesa la parte muy técnica, en este enlace puedes descargar la guía del programador en inglés.
Cosas que tenemos que saber:
El Commodore 64 tiene soporte por hardware para Sprites, en su afamado chip gráfico VIC-II.
Este chip se controla mediante registros en memoria (POKE) a partir de una determinada dirección. Esta dirección es 53248.
Lo primero que hacemos es definir una variable (V) con valor 53248. Esto nos simplifica la vida ( V = 53248). A partir de ahí, usamos esta variable más otros valores para acceder al control del chip de vídeo y por ende, hacer cosas en pantalla con los Sprites.
Dicho esto, el primer paso es cargar en memoria los datos de definición de los Sprites.
Cada Sprite son 63 bytes. Necesitamos un puntero para decirle a la máquina de donde coger los Sprites y luego inicializarlos en su posición. Las posiciones comienzan en el valor 2040 hasta el 2047. Es decir, tenemos 8 definiciones de Sprites.
Solo 8 no es problema, porque, como veremos en las siguientes publicaciones , podemos cambiar el contenido de la definición dentro de cada uno de los 8 , a nuestra conveniencia.
En nuestro proyecto de ejemplo, cargamos los 3 Sprites con la siguiente rutina.
320REM Cargamos los Sprites
330 V = 53248 : REMDefinimos acceso al chip grafico
340 M = 832 + ((64*3)-1) : REM vamos a cargalos en mem.
350REM Necesitamos 63 bytes por3 Sprites de espacio
355RESTORE
360FOR s=832to M
370READ a : REM vamos leyendo los DATA
380POKE s,a : REM los vamos cargando en memoria
390NEXT
395RETURN
400REM Asignamos los punteros a partir de la dir. 2040
410POKE2040,13 : REM Sprite 1
420POKE2041,14 : REM Sprite 2
425POKE2042,15 : REM Sprite 3
440RETURN
El siguiente paso es activarlos.
Para ello, hay una sola instrucción para los 8 Sprites.
Los vamos a activar :
450REM Activamos los Sprites
460POKE V+21,7 : REM Activacion de los Sprites 0,1 y 2
490RETURN
Y para desactivarlos todos usamos :
500REM Desactivamos los Sprites (todos)510POKE V+21,0520RETURN
Estos valores son los que se usan para manejar la activación / desactivación de los Sprites.
Es decir que usamos siempre POKE V+21, y el valor o suma de valores que necesitamos.
Para activar los 3 Sprites usamos:
POKE V+21,(1+2+4)
En resumen : POKE V+21,7.
Esto activaría los Sprites 0, 1 y 2.
Ahora asignamos los colores a cada Sprite.
530REM Le ponemos color a los Sprites 540POKE V+39,13 : REM Sprite 1 a azul550POKE V+40,7 : REM Sprite 2 a amarillo560POKE V+41,4 : REM Sprite 3 a violeta570RETURN
Del V+39 al V+46, se asignan los colores para cada uno de los 8 Sprites.
Por último en esta publicación , los posicionaremos en pantalla, para que se vean.
580REM Ponemos los Sprites en pantalla 590POKE V+0,54 : REMPosicion X del Sprite 1600POKE V+1,100 : REMPosicion Y del Sprite 1610POKE V+2,54 : REMPosicion X del Sprite 2620POKE V+3,150 : REMPosicion Y del Sprite 2630POKE V+4,54 : REMPosicion X del Sprite 3640POKE V+5,200 : REMPosicion Y del Sprite 3650RETURN
Otra cosa interesante, cambiar el color de fondo de la pantalla.
Se realiza con la(s) siguiente instrucción(es).
20POKE53281,1 : REM Color de fondo a blanco
300POKE53281,0 : REM Color de fondo a negro
Puedes descargar el proyecto para CBM .prog Studio, de este enlace.
Un pequeño vídeo de como va quedando nuestro tutorial.
Hace un tiempo recomendé el entorno de desarrollo para Commodore 64, el CBM .prog Studio.
Aunque tiene carencias básicas con respecto a lo que estoy acostumbrado para el ZX Spectrum (BasinC), como por ejemplo, la imposibilidad de depurar código BASIC, es un entorno bastante completo y que tiene una organización estructural muy buena para el desarrollo de proyectos para el Commodore 64.
Voy a aprovechar que quiero refrescar los conceptos básicos del manejo de Sprites desde el BASIC del Commodore 64, para darle visibilidad a esta herramienta de desarrollo.
Si lo que queremos es desarrollar en ensamblador, la situación es distinta. Para código ensamblador el entorno sí que permite depuración y está mucho más avanzado.
Aprovecharé entonces, el repaso que vamos a hacer de los Sprites en BASIC, para utilizar determinada funcionalidad del entorno CBM .prog Studio y así darlo a conocer.
Lo primero que tenemos que hacer es descargarlo e instalarlo.
Además, si no tenemos el emulador VICE funcionando, nos haremos con él y lo instalaremos también.
Con ambas cosas ya instaladas, lo primero es configurar el CBM .prog Studio para decirle en que directorio por defecto nos creará los proyectos y donde reside el emulador VICE.
En el menú "Tools, Options" podemos definir el valor del directorio por defecto para nuestros proyectos.
Luego nos vamos a "Emulator Control" y le damos el directorio donde tenemos instalado el emulador VICE.
No hace falta tener un proyecto ya abierto para hacer esta configuración, la podemos hacer sin ninguno abierto.
Ahora, procedemos a crear un nuevo proyecto.
El entorno tiene plantillas de proyecto para proyectos tipo BASIC y tipo ensamblador.
Nos vamos a "File" y a "New basic Project".
Nos mostrará una ventana emergente, donde podemos personalizar.
Esta es la pinta que tendrá nuestro entorno:
Ya estamos listos para comenzar con nuestro código.
Una cosa MUY importante que tenemos que hacer, si no queremos recibir petardazos continuamente, es modificar las propiedades del proyecto para decirle cual es el programa principal.
Por defecto lo trata de "adivinar", dado que puede haber código BASIC y ensamblador mezclado, pero esto está dando problemas, si sólo tenemos BASIC.
Así que a "Project", Properties y le decimos que solo compile nuestro programa principal.
Vamos a usar "El Editor de Pantallas" para crearnos una pantalla chula como comienzo del programa.
Botón de la derecha en "Screen Designs" y añadimos uno nuevo.
Luego con doble click abrimos el editor.
Este editor nos deja trabajar tanto con los dos set de caracteres por defecto como con los que hallamos creado nosotros.
Yo me he hecho una pantalla tal que así:
Las posibilidades las podéis explorar, yo he usado lo más básico para hacer un marco con un título.
En el menú "File" podemos exportar a código BASIC, lo que nos abrirá la ventana de "Preview". De ahí podemos copiar y pegar en nuestro código.
Luego de pegado, lo apañamos lo re - numeramos y lo que nos parezca.
En el siguiente capítulo editaremos un sprite y lo cargaremos en pantalla, para lo cual refrescaremos los conceptos básicos para manejar Sprites desde C64 BASIC.
El proyecto completo lo puedes descargar de este enlace.
Una de las cosas que más me llamó la atención cuando me pasé de Sinclair BASIC a Commodore 64 BASIC a cacharrear, es que no hay ¡ PRINT AT !.
¿Como se les puede haber pasado el implementar esta funcionalidad en el comando PRINT del BASIC ?. ¡En qué estaban pensando!.
Bueno, he aquí un par de posibilidades para simular el comando PRINT AT.
Una de ellas, la primera, se basa en "engañar" al comando PRINT del BASIC, con alguna instrucción que otra, para que se posicione donde queremos imprimir en pantalla.
La segunda, fija directamente el cursor en la posición de la pantalla donde queremos imprimir, usando POKEs.
La primera quedaría tal que así:
10 REM Buscando una altgernativa al PRINT AT
20 REM de Sinclair BASIC para el C64 BASIC
30 REM Posibilidad 1. Usando caracteres especiales
40 REM del C64 BASIC y el comando BASIC
50 REM ********* Modo 1 **************************
55 print "{clear}"
60 X$="{home}{right*39}"
70 Y$="{down*24}"
80 x=1:y=1
90 print left$(x$,x)right$(y$,y)" AAAAAAAAAAAAAAAAAAAAAA";
100 x=2:y=2 110
110 print left$(x$,x)right$(y$,y)"hola";
120 x=2:y=10 130
130 print left$(x$,x)right$(y$,y)"mundo";
140 x=10:y=10 150
150 print left$(x$,x)right$(y$,y)"hola mundo!";
152 x=1:y=12:print left$(x$,x)right$(y$,y)"";
155 rem *************************************
Si ejecutamos el programa, vemos el resultado :
Usamos X e Y para fijar donde queremos imprimir, y luego imprimimos el texto en pantalla usando printleft$(x$,x)right$(y$,y)+ el texto que queremos.
Hay una segunda opción, que es la que más me gusta, que es directamente posicionar el cursor en pantalla, donde queremos imprimir, y luego simplemente usar PRINT.
En C64 BASIC esto se consigue con la siguiente rutina, que puedes usar en tus programas:
999 REM Rutina que posiciona el cursor en un determinado sitio
1000 poke 780,0:REM fijamos cero para resetear
1010 poke 781,row:REM a memoria la fila(X)
1020 poke 782,col:REM a memoria la columna(Y)
1030 sys 65520 : REM fijamos el cursor en X,Y
1040 return
Los POKE 781 y 782 son los registros .X y .Y en la máquina, y la istrucción sys 65520 posiciona el cursor en pantalla en las coordenadas que están en 781 y 782.
SAREG 030C 780 Storage for 6502 .A Register SXREG 030D 781 Storage for 5502 .X Register SYREG 030E 782 Storage for 6502 .Y Register PLOT $FFF0 65520 Read/set X,Y cursor position
Usar la rutina se convierte simplemente en esto:
200 row = 5:col = 10:gosub 1000
210 print "hola"
Este método es mucho mejor y más limpio que el primero, en mi opinión, aunque ambos nos permiten saber donde hemos dejado el cursor después de haber impreso en pantalla.
Un pequeño vídeo del programa de demostración en cuestión:
