El propio autor, que tiene cuenta propia en Twitter, ha desarrollado una revisión moderna del mismo juego, llamada Kevin Toms Football * Manager y que está disponible en iOS y Android.
Tiene un precio de unos 4 Euros.
Para los que recordamos con cariño este juego y sus versiones posteriores, tiene un valor añadido el tener esta nueva versión en nuestros teléfonos smartphone.
La nueva versión no tiene gráficos, pero en todo lo demás respeta al original.
Es un juego sencillo, pero adictivo que viene muy bien para esos tiempos muertos.
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.
En las dos primeras versiones del ZX Spectrum, las "Issue 1" e "Issue 2" el sincronismo del color y el balance de los colores dependen de unos pequeños reguladores.
Ya me ha pasado más de una vez, que, al no usar el Spectrum en un largo período de tiempo, al encenderlo se ve mal.
Pues bueno, no queda más remedio que abrirlo y "jugar" con estos pequeños reguladores, hasta que tengamos una imagen y color buena.
Hay que tener cuidado porque hay que hacerlo con el Spectrum encendido y los movimientos tienen que ser mínimos. Si no hacemos los movimientos muy pequeños, nos podemos tirar horas sin dar con ello.
El primer regulador "Clock Trimmer" regula la caída del punto en pantalla. Normalmente no hay que tocarlo.
El segundo regulador o "Colour sync trimmer" solo lo tocamos si no tenemos color en absoluto.
Y ahora los más puñeteros.
El tercero o "Red-yellow trimmer" y el cuarto o "Blue-yellow trimmer" regulan el balance de color y los debemos mover al tiempo para encontrar un buen color y un blanco lo mas "neutral" (es decir lo más blanco posible). Es aquí donde vamos a invertir más tiempo y debemos movernos lo más lento y suave posible.
La mejor manera de regular los colores, es mientras ejecutamos este programa BASIC , que nos ayuda a ver como va quedando todo.
Uno de los juegos más manidos, en los ratos muertos en el cole, el 3 en raya.
Implementar este juego en BASIC para el ZX Spectrum, nos da la posibilidad de practicar una de las cosas más importantes que hay en la programación, que es la inteligencia artificial (IA o en inglés AI).
Hay muchos algoritmos aplicables a este juego, que se pueden desarrollar en BASIC con más o menos esfuerzo, e incluso hacer que el juego sea "invencible".
La verdad que un juego en el que no podamos ganar, no tiene gracia y además, la IA debería parecerse a nosotros, los humanos, cometiendo errores y tomando decisiones inadecuadas.
Las premisas básicas para implementar la inteligencia del Spectrum a la hora de jugar contra nosotros han sido:
1) Se decide quien juega primero, humano o ordenador de forma aleatoria.
2) Si sale el Spectrum, posiciona su jugada de forma aleatoria.
3) Se comprueba siempre que nadie a ganado, o si hay un empate.
4) Se comprueba si el jugador humano tiene una jugada para ganar, y se tapa por parte del Spectrum.
5) Si no hay una jugada por parte del jugador humano en la que pueda ganar, el Spectrum hace su siguiente jugada de forma aleatoria, en las casillas que hay libres.
Parece demasiado simple, ¿ verdad ?. Pues bueno, si que es sencillo de programar en el Spectrum y además, el juego es divertido.
Habrá veces que nos gane otras que empatemos o que gane el Speccy. La aleatoriedad de la un valor añadido al juego, lo hace divertido, pero a la vez (como sabe comprobar si vamos a ganar y nos trata de parar) es lo suficientemente listo como para que el juego tenga dificultad.
Para aquellos que como yo, cargan los juegos en su MSX usando el IPod, su portátil o un dispositivo de audio, he convertido la colección de CDs de Audio con juegos de MSX a formato Flac y lo he ordenado.
Estas ROMS son las que se recomienda usar para jugar en nuestra consola SEGA original con el cartucho EverDrive. Por supuesto, que también sirven para nuestro emulador favorito.
En este enlace podéis ver la lista de ROMs contenidas.
En este otro enlace podéis descargar el archivo que contiene todas las ROMs.
Abajo, la lista de las ROMs que contiene la distribución.
Estas ROMS son las que se recomienda usar para jugar en nuestra consola SEGA original con el cartucho EverDrive. Por supuesto, que también sirven para nuestro emulador favorito.
En este enlace podéis ver la lista de ROMs contenidas.
En este otro enlace podéis descargar el archivo que contiene todas las ROMs.
Abajo, la lista de las ROMs que contiene la distribución.
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.
De las muchas opciones que hay para programar para MSX y MSX2 os destaco una que pasa por usar el lenguaje de programación Pascal.
Hace tiempo gracias a Slotman, teníamos el IDE MSXPad el cual compila código Pascal para nuestros MSX. Esto, combinado con las librerías incluidas nos permitía acceder a todas las funcionalidades del MSX desde Pascal.
Esta idea es muy buena, pero lamentablemente, MSXPad no funciona correctamente en los PC modernos.
Os presento una alternativa que he desarrollado, usando como base el trabajo realizado por Slotman.
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.
