¡ZX Retro8ogue actualizado !. Avances

¡Avances de este nuevo ZX Retro8ogue!

Ya tenemos un pequeño motor del juego capaz de: 

• Generar un mapa aleatorio conteniendo de 1 a 4 edificios.
• Rellenar los exteriores con árboles y rocas. 
• Generar las salidas y entradas a otros mapas. 
• Espacio para información de nuestro héroe. 
• Sistema de texto emergente, para la ayuda / información en juego / inventario.
• Depurado del motor hasta el momento.
• Revisión del código para mejor rendimiento del compilador HiBasic a código máquina. 
• Tamaño de código. Actualmente está en 10Kb de BASIC y 14Kb compilado a mcode. 
• Pasados los UDG a decimal (¡espacio!).
• Optimizaciones varias de rendimiento (bucles y re-utilización de variables).

Por el momento, el motor en su estado actual está probado tanto en BASIC como en código máquina.

Podéis descargar del código fuente de este enlace (formato tap) y la cinta con su cargador y su código máquina, en este otro enlace (formato tap).

Una vez ejecutado y cargado, puedes usar "h" para ver el sistema de texto emergente. con "q" salimos del programa. El efecto de vuelta al mapa desde la ventana de texto emergente, es muy chulo :D.

Puedes descargar una grabación hecha en el emulador Fuse desde aquí. Para visualizarla usa el  menú "File/recording/Play".

¡ Seguiré informando de los avances de este nuevo ZX Retro8ogue !.

BASIC, no puedo localizar UDG's con SCREEN$ !!. He aqui una opción buena bonita y barata.

Una de las funciones más útiles que tiene el BASIC de nuestro ZX Spectrum es SCREEN$. 

Gracias a esta función podemos saber que carácter se encuentra presente en la pantalla, dadas las coordenadas X e Y.

En el modo de "texto" tenemos 22 líneas (Y) y 32 columnas (X). Es muy cómodo, utilizar SCREEN$ como mecanismo de detección de colisiones en un juego en el que hallamos usado caracteres (de 8x8) como gráficos. 

Como se puede ver en !Como me gustan los UDG! es muy sencillo usar los 20 caracteres de gráficos de usuario que nos facilita el Spectrum, para hacer nuestros propios sprites de 8x8. 

Los podemos usar en pantalla, y todo bien, hasta que se nos ocurre la brillante idea de usar SCREEN$ para obtenerlos de pantalla. SCREEN$ nos devolverá un vacío, dado que no es capaz de gestionar los UDG. Nuestro gozo en un pozo. 

He aquí unas cuantas líneas de código para tener nuestro propio "SCREEN$" y poder identificar los UDG en pantalla. 

La idea es la misma, le damos unas coordenadas de linea/columna, y el código nos devuelve el código UDG al cual pertenece. Si la variable de control (res) es un cero (0) es que el carácter que se encuentra en las coordenadas proporcionadas, no es un UDG. Si la variable de control res tiene un valor igual o superior a 144, nos está devolviendo el código del UDG que ha encontrado en esas coordenadas. 

  10 REM Localizacion de  UDG por coordenadas x,y
  20 REM igual que el SCREEN$(y,x) pero funciona con UDG
  30 REM vamos a cargar el UDG 149 (f)
  40 FOR i=0 TO 7
  50 POKE USR "f"+i,255
  60 NEXT i
  70 PRINT AT 7,13;CHR$ 149
  80 REM le damos las coordenadas y res nos devuelve el UDG
  90 LET x=13: LET y=7
 100 GO SUB 260
 110 PRINT AT 0,0;"El UDG es el ";res
 120 GO TO 310
 130 LET res=udg
 140 LET vY=y*8
 150 LET vX=x
 160 FOR S=0 TO 7
 170 LET iY=vY+S
 180 LET BLOCK=INT (iY/64)
 190 LET CROW=INT (iY/8)
 200 LET YR=iY-(CROW*8)
 210 LET CROW=CROW-(BLOCK*8)
 220 LET ADD=16384+BLOCK*2048+CROW*32+YR*256
 230 IF (PEEK ((USR (CHR$ udg))+s))<>(PEEK (add+vX)) THEN LET res=0: RETURN
 240 NEXT S
 250 RETURN
 260 FOR i=144 TO 164
 270 LET udg=i
 280 GO SUB 130
 290 IF res>=144 THEN RETURN
 300 NEXT i
 310 STOP

Hay varias cosas que tener en cuenta:

• Las coornedas linea/columa las fijamos igual que en el SCREEN$. Ya se encarga el cógido de las "visicitudes" y "saltos" de las direcciones de memoria en pantalla. 
• Está optimizado para UDG's de 8x8. Con un poco de paciencia y coco, se puede adaptar a 16x16, o 32x32 de forma sencilla. 
• Puedes leer  "Jugando a los Sprites, episodio I" para ampliar la funcionalidad.
• Si res vale cero(0), no es un UDG.
• Si res es 144 o más , es un UDG y res es el código del mismo. 
• Se compara byte a byte el caracter en pantalla, con la(s) definición(es) de(los) UDG.
• Está optimizado para el mejor rendimiento (en caso de diferencia, aborta y al siguiente). 

Ahora ya no tienes excusa para usar los UDG's en esos juegos que puedes hacer y basar tu detección de colisiones de forma muy sencilla desde BASIC.

Que usar para programar el BASIC del Commodore 64 en tu PC.

Me puse como objetivo encontrar un entorno de programación  gráfico al estilo de BasinC para ZX Spectrum. 

La idea es tener una GUI (Graphical User Inerface) con todas las herramientas necesarias para la programación BASIC del Commodore 64 en nuestro PC. No solamente código fuente, sino herramientas gráficas y de sprites, manuales y otro tipo de complementos que nos permitan hacer todo desde un mismo sitio. 

Voy a resaltar CBM .prg Studio de Arthur Jordison. 

Es un entorno completo al estilo de los entornos de programación actuales, como puede ser Visual Studio o Eclipse. 

Traducido de su página web, podemos ver capacidades y funcionalidad: 

Permite realizar desarrollos para : 

• Commodore 64 (and SuperCPU)
• Commodore 128
• Commodore VIC 20
• Commodore 16
• Commodore Plus/4
• Commodore PET BASIC 2 machines, e.g. PET 2001
• Commodore PET BASIC 4 machines, e.g. PET 4000/9000

Un resumen de sus capacidades es: 

• Múltiples tipos de ficheros de código (ensamblador o BASIC) se pueden componer a un solo destino.
• Ensamblador / Desemsamblador y Depurador integrado para 6502/6510/65816
• Importación de programas (.prg, .T64 or .D64/.D71/.D81)
• Exportación de programas (.prg, .p00)
• Editor de Sprites
• Editor de juegos de caracteres
• Diseñador de pantallas 
• Generador de códidos especuales de impresión
• Visor de memoria
• Importación y exportación de binarios
• Herramienta de creación de discos .D64/.D71/.D81
• Constantes en BASIC
• Re-numerado y formateo de código 
• Formateo automático de código ensamblador
• Interfaz de usuario tipo MDI
• Gran cantidad de manuales, ayuda y tutoriales

La verdad que es una herramienta muy completa y funcional. 

Una cosa que no termina de convencerme es que para compilar y ejecutar un proyecto, necesita un emulador externo configurado en la propia herramienta. 

Seguramente con el tiempo y adquiriendo experiencia con el entorno, esta circunstancia se verá justificada. 

En este enlace tenéis más imágenes de la herramienta en acción.