Ensamblando con R. International

Aprovechando que estaban listas las versiones físicas de Laberinto y que quien redacta este artículo tenía ganas de comenzar de una vez por todas la inmersión en el mundo del ensamblador, lo mejor era acercarse a hacer una visita a su autor y pasar unas jornadas totalmente empapadas en todo lo relacionado al Commodore 64. A preparar la maleta, con todas las ganas del mundo y vamos, vamos que nos vamos!!!!!!!!!

Pasar un fin de semana hablando y compartiendo experiencias sobre todo en el C64 es, aunque quede feo, un orgasmo y mas, mucho mas, cuando se tienen ganas de aprender. Es como ir a una feria, pero solo del C64 y ni quiero imaginar lo que se siente en una de esas partys exclusivas del C64 que se hacen en en norte de Europa.

R. International lo tiene todo preparado. El PC que nos servirá como herramienta de trabajo y dos C64 en cada flanco, para ir probando e ir ambientando el lugar con lo que estemos ejecutando o alguna demo.

Explicar como se ensambla no es fácil y es un tema que hay que ir poco a poco para no saturar la cabeza de datos, comandos, direcciones de memoria y conversiones de decimal a hexadecimal y viceversa. Primero hay que tener preparadas las herramientas de combate y las que R. International nos aconsejaría son estas:

Notepad++ es el bloc de notas donde escribiremos los comandos a ejecutar

SpritePad para crear los sprites

Gang Ed para hacer los bitmaps

Cuneiform para crear nuestro propio charset

64tass, el que lo coge todo y lo convierte en un PRG ejecutable

El símbolo de sistema de toda la vida, con el que ejecutaremos el 64tass

Una calculadora científica que pase de hexadecimal a decimal y viceversa

Y aquí viene lo bueno y creo que es un buen momento para que, quien pueda y mas ahora que está todo tan animado, debería plantearse dar un salto definitivo y sobretodo cualitativo a lo que debería ser una de las metas en nuestra afición. Ahora que tenemos tantos medios, es la hora de ponernos con el ensamblador y quitarnos esa pereza que hace demasiados años que arrastramos. Aprender ensamblador hoy en día, con la cantidad de herramientas que hay, y solo dedicándole un rato, no es una tarea faraónica y fácilmente se pueden aprender y hacer 4 rutinas tontas. Además no es solo aprender ensamblador, es también aprender como funciona la máquina.

Cuando tienes unos conocimientos básicos, lo vas enfocando hacia lo que tu quieres hacer. Esto es, y dicho fríamente, ENTENDER COMO FUNCIONA EL ENSAMBLADOR (nada que ver con saber usarlo) y ENTENDER PARA QUE SIRVE CADA COMANDO. Y no deja a parecerse a un listado en BASIC con muchas subrutinas pero que funcionana a las mil maravillas por que van a toda leche.

Con R. International tuve la suerte de quedar y que me fuera explicando la estructura de un listado. A partir de ahí vas añadiendo rutinas hasta conseguir el resultado deseado, sin dejar cabos sueltos. El programa que nos crea el PRG, el 64Tass, lo convierte todo a un ejecutable a no ser que tenga un error, y si lo hubiese, el mismo nos indicará en que linea está. Solo practicando y practicando nos hará ir cometiendo cada vez menos errores.

En los enlaces de abajo, podéis descargaros 2 listados. Uno y de nuevo gracias R. International está el código de la versión española de Laberinto. El segundo es otro, también del mismo autor, que prepara el C64 para programar un juego. Lo que hace este es borrar la pantalla, preparar los puertos de los joysticks, preparar los Chars (Caracteres) y los Sprites en alta o baja resolución y todo lo necesario para iniciar un proyecto en el que solo debamos intercalar los comandos de lo que iremos creando (Se intercala por que, normalmente, al final del listado van las rutinas que casi no se usan, para optimizar la velocidad del juego y al principio va la configuración del programa)

–R. International nos muestra un ejemplo:

–Imagino que muchos de los lectores del artículo de Bieno o simplemente gente interesada en comenzar o hacer sus primeros pinitos, se preguntará por donde se empieza y como se empieza, y es esta una buena observación que incluso a mi al principio me creaba mucha curiosidad ya que no sabia ni por donde empezar,..y os explico:

Lo primero que debemos de saber es que en Ensamblador no utilizaremos ninguna Herramienta ni Programa para comenzar a hacer el listado, lo haremos desde un Editor de Texto como si escribiéramos una carta, uno preparado para programación.En nuestro caso usamos el Notepad++. Una vez que lo tengáis, lo abrís y ya se puede comenzar a escribir y crear vuestro programa. Os voy a poner un ejemplo sencillo en el que vamos a mostrar un sprite en pantalla...

Tenemos el Editor de Texto abierto, lo primero que hacemos es escribir unas lineas en las que "mandaremos" al sistema a Código Maquina para que el ordenador trabaje en ésta forma con lo siguiente:

*=$0801                    ; INICIA PROGRAMA EN ESA POSICION
.WORD NEXT,10              ; CREA LINEA EN BASIC E INICIA CODIGO MAQUINA 
.NULL $9E,^START           ; "SYS START" (START=INIT M.C.)
NEXT .WORD 0               ; FIN BASIC

Con estas lineas hacemos que nuestro programa arranque en la posición en Hexadecimal $0801 (posición 2048) que esta en el Bank0.

Ahora vamos a escribir a continuación una lineas que harán que nuestro/s sprites se carguen en la posición que nosotros queramos. En este caso serán en la $2000 (8192 en decimal)...

El archivo donde tenemos los sprites se puede llamar Sprites y tendrá que tener extensión .BIN (binario) para que pueda ser mas tarde compilado correctamente, la orden .BINARY antes del archivo sera la que le de la orden de carga. Luego explico como exportar (conformar para poder cargar) un archivo creado con el spritepad (que serán nuestros sprites).

*=$2000                         ; CARGA SPRITES POSICION 49152 BANK0
.BINARY SPRITES.BIN 
FRAMES .BYTE 0                  ; VIDEO FRAMES COUNTER
FRAMES2 .BYTE 0                 ; VIDEO FRAMES COUNTER

Ya tenemos preparada la carga de los sprites pero, para que salgan en pantalla, tenemos que fijar antes unos parámetros como son: Color de Sprites, Multicolor 1 y 2 de Sprite, Coordenadas X e Y y el fijar el Puntero (dirección desde la que leerá donde esté cargada el bloque gráfico que lo forma) y luego simplemente activarlo para que se vea en pantalla. Vamos a escribir lo siguiente para que quede correctamente hecho:

LDA #150                        ; CARGA VALOR
STA $D000                       ; APLICA A X SPRITE 0
LDA #200                        ; CARGA VALOR
STA $D001                       ; APLICA A X SPRITE 0
                                ; MULTICOLOR 1 Y 2
MUCOLSPR0
LDA #$01                        ; BLANCO
STA $D025                       ; MULTICOLOR SPRITE 1
LDA #$06                        ; AZUL
STA $D026                       ; MCOLOR 2
                                ; COLOR SPRITE
LDA #$09                        ; CARGA ORANGE
STA $D027                       ; APLICA A COLOR SPRITE 0
                                ; PUNTERO / GRAFICO
LDA #$80                        ; CARGA GRAFICO COHETE
STA $07F8                       ; APLICA A PUNTERO SPRITE 0
                                ; ACTIVAR SPRITE
LDA #$01                        ; CARGA VALOR 1
STA $07F8                       ; APLICA A ACTIVAR SPRITES, ACTIVA SPRITE 0

Ahora creamos un bucle infinito...

FINAL
JMP FINAL

Y ya está. Guardamos los cambios, le ponemos nombre y ya tenemos nuestro archivo en formato .ASM preparado para compilarlo y verlo funcionando en nuestro Commodore.

Antes de enseñaros como compilarlo algunas pequeñas apreciaciones:

Siempre, siempre a la hora de compilar tienen que estar en la misma carpeta (los que sean necesarios, según vuestro proyecto):

• El programa que compile (en mi caso el 64Tass)
• El archivo con el texto que hemos creado en formato .ASM, (creado con el Notepad++)
• El archivo que hemos creado con el spritepad en formato .BIN (creado con el SpritePad)
• El paquete de fuentes o de Chars también en formato .BIN (creado con el Cuneiform

¿Como se exporta un archivo desde el Spritepad? Tenemos el o los Sprites creados con el Spritepaden pantalla y pulsaremos:

FILE > EXPORT

Se nos abre una ventana pequeña y en ella activaremos la opcion RAW DATA. Pulsaremos OK y se abre otra en la que, ya fijado el formato, nos preguntará donde lo queremos guardar (Recordad que tiene que estar en la misma carpeta donde teníais el texto y el compilador), Ahora le ponéis nombre y lo guardáis, no sin olvidar que ese nombre sera el mismo que tendréis que poner en el programa en su linea correspondiente.

.BINARY SPRITES.BIN

Ya guardado, tenemos nuestros sprites en el formato correcto para ser preparados. Si utilizáramos un paquete de chars o fuentes, también tendríamos que exportarla en formato .BIN para poder cargarlos. Para crearlos uso el cuneiform. La carga de fuentes nos llevara también fijar el modo texto en el principio del programa y lo cargaremos con un .BIN. En el caso de que quisiéramos incluir fuentes, aunque ese es otro tema, lo haríamos de forma similar a los sprites:

*=$4000
CHARS
.BINARY FONTS.BIN           ; BANCO DE CARACTERES

O también modificando las lineas cargarlas al final de nuestro programa y luego ponerlas donde queramos,..pero como os digo ese es otro tema, volvamos donde estábamos...
Solo queda adjuntar esta linea cuando configuras el sprite para que se muestre:

; ACTIVAR MODO MULTICOLOR EN SPRITES
LDA #$FF             ; CARGA VALOR 255
STA $D01C            ; APLICA A ACTIVACION DE SPRITES, ACTIVA TODOS

Ahora ya lo tenemos todo preparado y vamos a compilarlo. En la compilación, el programa que utilizamos, va a convertir todo a código Maquina en Hexadecimal sin darnos cuenta, aunque verdaderamente la maquina lo entenderá como Binario (que es el lenguaje original de la maquina). Para ello necesitamos un programa que compile y para eso utilizo el 64Tass aunque haya otros igual de válidos. Hago otra vez hincapié en la importancia de que este programa esté en la misma carpeta alojado con los demás archivos a compilar.

La ejecucion de la compilación la haremos desde el SIMBOLO DEL SISTEMA que todo ordenador lleva. Lo podremos encontrar utilizando el buscador de Windows. Una vez abierto, iremos a la carpeta donde tenemos todos los ficheros necesarios.

Cuando ya estemos, escribiremos el comando y sus parámetros para que nuestro listado se compile y se convierta en un juego. El compilador juntara todo (incluidos los archivos de Sprites, Chars, SID.etc) y lo convertira a .PRG para que sea reconocible por el Commodore. Escribimos lo siguiente:

64tass.exe -o juego.prg texto.asm

O dicho de otra forma: Ejecuta el 64tass(compilador), coge el fichero texto.asm (creado con el Notepad++) y lo convierte en un PRG ejecutable para el C64 al que llamará juego mediante el comando -o

Ahora ya lo podeis cargar en vuestro Commodore 64!!!

Conclusión:

Esperamos no haberos aburrido mucho y aunque a Josepzin lo tenemos lejos (y nos hubiera encantado estar juntos los tres), R. International y nosotros dos cooperaremos en todo lo posible para hacer lo que se nos vaya pasando por la cabeza. Esperamos repetir pronto, explicar nuestros avances y que vosotros compartáis vuestras experiencias.

Descargas:

• Podéis descargaros la rutina INICIO en ESTE enlace
• Podéis descargaros el listado de Labyrinth en ESTE enlace