jueves, 10 de noviembre de 2016

ZX Spectrum y C64 Football Manager revive en iOS y Android

Uno de los juegos más adictivos que había para los ordenadores de 8 BITS, era Football Manager de Kevin J.M. Toms

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. 

 Kevin Toms Football * Manager: miniatura de captura de pantalla

  Kevin Toms Football * Manager: captura de pantalla

  Kevin Toms Football * Manager: captura de pantalla


viernes, 22 de julio de 2016

Colección de música en 8-BIT. CHIPTUNES

Os dejo una colección de música en 8-BIT o como le llaman de forma coloquial, ¡chiptunes !.

Hay chiptunes de Spectrum , Commodore 64, MSX, Amiga y otras cosas.

Lo podéis descargar de este enlace.

Abajo, una lista de lo que contiene la colección.

Que lo disfrutéis.
 

martes, 19 de julio de 2016

C64. De dibujo en BASIC con caracteres a Sprite.

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. 



martes, 12 de julio de 2016

Neuromancer para C64. Adaptación de la novela de William Gibson.

Si eres un fan de la ficción de William Gibson, el demoninado "Padre del Cyberpunk", seguramente conoces el libro Neuromancer.

Y si no, deberías leerlo; es una de las "obras maestras" del Cyberpunk.

Uno de los primeros trabajos de la mítica compañía Interplay Productions fue el juego Neuromancer, basado en la obra de William Gibson.

Este juego de aventura y rol, fue revolucionario en muchas formas, y se editó para Commodore 64, Commodore Amiga , PC DOS y Apple II. 

OS dejo unos enlaces, por si os interesa probarlo.

Yo personalmente, estoy disfrutando esta joya en mi C64C. 

* Ejecutar neurocrk.com 






Todo es público y se ha distribuido con permiso de los dueños. 

Fuente en este enlace.









viernes, 1 de julio de 2016

Calibrar el color en un Spectrum 48k placa Ver 1 y 2.

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. 

10 FOR N= 0 TO 7 
20 FOR M = 1 TO 3 
30 PAPER N : PRINT “ “ 
40 NEXT M 
50 NEXT N 
60 GOTO 10

Darle crédito a DataServe Retro Computing donde encuentro siempre información muy útil.

Un pequeño vídeo del programa BASIC para calibrar los colores: 





miércoles, 29 de junio de 2016

Ejemplo de juego en BASIC 3 en Raya.

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.

El código fuente lo podéis bajar de este enlace.

Como siempre, lo he pasado a código máquina, usando el compilador a MC de HiSoft. La ganancia en velocidad de ejecución es asombrosa.

La versión en MC la podéis bajar de este enlace.

Por último, un vídeo de demostración del juego.






martes, 28 de junio de 2016

Colección de Juegos MSX en Flac.

Muy buenas.

Konamito  en el MSXBLOG a publicando una colección de juegos de MSX en formato CD de audio, muy cuidada e indispensable.

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.

Son 14 CDs pasados a pistas en formato Flac.

En cada carpeta encontraréis las portadas de los CDs originales, y las pistas de los mismos por separado.

Que lo disfrutéis mucho. Lo podéis descargar de este enlace.


Nos pasamos a los 16BIT (un momento). Un regalo para el verano. SEGA.

Aprovechando que llega el verano, he puesto orden en un par de colecciones de ROMs Para SEGA Master System y Mega Drive / Genesis de muy alta calidad.

Son un compendio de ROMS "GoodGen 3.21" y "NoIntro".

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.



Nos pasamos a los 16BIT (un momento). Un regalo para el verano. SEGA.

Aprovechando que llega el verano, he puesto orden en un par de colecciones de ROMs Para SEGA Master System y Mega Drive / Genesis de muy alta calidad.

Son un compendio de ROMS "GoodGen 3.21" y "NoIntro".

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.



miércoles, 17 de febrero de 2016

Ejemplo práctico de CBM .prog Studio .Sprites ,diseñador de pantallas y diseñador de juegos de caracteres. PARTE IV

Como quedamos en "Ejemplo práctico de CBM .prog Studio .Sprites ,diseñador de pantallas y diseñador de juegos de caracteres. PARTE III" hoy vamos a cubrir otros dos aspectos básicos de los Sprites. 

Estos aspectos son: 
  • La prioridad de los Sprites. 
  • Gestión de colisiones en BASIC.
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:

IF PEEK(V+30)AND1=1 THEN POKE 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.

Vídeo demostrativo: 



martes, 16 de febrero de 2016

Que usar para programar para MSX/MSX2 en tu PC.

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. 

Esta alternativa es el MSXPad Revived

MSXPad Revived  es : 
  • Un compilador de Pascal para MSX y MSX2.
  • Un pequeño IDE para desarrollar bajo Pascal para MSX y MSX2.
  • Un set de librerías en Pascal que nos permiten usar las capacidades del MSX y MSX2.


Hay que darle las gracias a Slotman por su esfuerzo original. 

Yo he modificado y hackeado la(s) herramienta(s) para poderlas usar en un entorno PC moderno. El MSXPad Revived lo podéis descargar de su página.

Un pequeño vídeo del IDE en acción: 






jueves, 11 de febrero de 2016

Ejemplo práctico de CBM .prog Studio .Sprites ,diseñador de pantallas y diseñador de juegos de caracteres. PARTE III

En la publicación anterior, "Ejemplo práctico de CBM .prog Studio .Sprites ,diseñador de pantallas y diseñador de juegos de caracteres. PARTE II" definimos 3 Sprites y vimos las bases para posicionarlos en pantalla. 

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 anterior publicació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. 

250 PRINT "{113} m para mover los sprites {113}" 
260 PRINT "{113} s para parar el movimeinto {113}"
270 PRINT " {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:












660 REM Movimiento eje X de los Sprites
665 poke v+16,0 : GOSUB 590
670 FOR M=0 TO 347
680 hx=int(M/256):lx=M-256*hx
690 if hx=1 then poke v+16,7 : rem Esto es para hacer que pueda pasar a mas de x = 256
700 poke v+0,lx
720 poke v+2,lx
735 poke v+4,lx
740 NEXT
745 poke v+16,0: GOSUB 590 : rem reseteamos el registro a cero y volvemos a posicionar
750 RETURN
La instrucción poke v+16,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). 
Si vemos los valores por separador serían 
POKE v+16,1 (Sprite 0)
POKE v+16,2 (Sprite 1)
POKE v+16,4 (Sprite 2)
POKE v+16,6 (Sprite 3)
POKE v+16,8 (Sprite 4)
POKE v+16,10 (Sprite 5)
POKE v+16,12 (Sprite 6)
POKE v+16,14 (Sprite 7)

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. 

760 REM Movimiento en el eje Y de 1 Sprite
770 POKE V+0,100 : rem Posicion X
780 POKE V+1,50 : rem Posicion Y 
790 for M=50 to 229
800 POKE V+1,M : rem Posicion Y 
810 next 
815 for M=229 to 50 STEP -1
818 POKE V+1,M : rem Posicion Y 
819 NEXT
820 RETURN 



La tabla completa de las instrucciones POKE para manejar los Sprites, está en este documento técnico o puedes verla aquí

En la próxima publicación veremos como manejar las colisiones de Sprites y las prioridades.

El proyecto CBM .prog Studio de este ejemplo lo puedes descargar de aquí

Este es un vídeo representativo del ejemplo de esta publicación.





miércoles, 10 de febrero de 2016

Ejemplo práctico de CBM .prog Studio .Sprites ,diseñador de pantallas y diseñador de juegos de caracteres. PARTE II


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. 

320 REM Cargamos los Sprites
330 V = 53248 : REM Definimos acceso al chip grafico 
340 M = 832 + ((64*3)-1) : REM vamos a cargalos en mem.
350 REM Necesitamos 63 bytes por 3 Sprites de espacio 
355 RESTORE
360 FOR s=832 to M
370 READ a : REM vamos leyendo los DATA
380 POKE s,a : REM los vamos cargando en memoria
390 NEXT 
395 RETURN
400 REM Asignamos los punteros a partir de la dir. 2040
410 POKE 2040,13 : REM Sprite 1
420 POKE 2041,14 : REM Sprite 2
425 POKE 2042,15 : REM Sprite 3
440 RETURN 
El siguiente paso es activarlos.

Para ello, hay una sola instrucción para los 8 Sprites.

Los vamos a activar :

450 REM Activamos los Sprites
460 POKE V+21,7 : REM Activacion de los Sprites 0,1 y 2
490 RETURN
Y para desactivarlos todos usamos : 

500 REM Desactivamos los Sprites (todos)510 POKE V+21,0520 RETURN
Hay que tener en cuenta la siguiente tabla: 

|ALL ON|SPRT 0|SPRT 1|SPRT 2|SPRT 3|SPRT 4|SPRT 5|SPRT 6|SPRT 7|ALL OFF|
| 255        |1          |          2 |         4 |          8 |       16 |        32 |       64 |       128 |            0 |

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.

530 REM Le ponemos color a los Sprites
540 POKE V+39,13 : REM Sprite 1 a azul550 POKE V+40,7 : REM Sprite 2 a amarillo560 POKE V+41,4 : REM Sprite 3 a violeta570 RETURN

Los códigos de los colores los puedes ver aquí.

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.

580 REM Ponemos los Sprites en pantalla
590 POKE V+0,54 : REM Posicion X del Sprite 1 600 POKE V+1,100 : REM Posicion Y del Sprite 1 610 POKE V+2,54 : REM Posicion X del Sprite 2 620 POKE V+3,150 : REM Posicion Y del Sprite 2630 POKE V+4,54 : REM Posicion X del Sprite 3640 POKE V+5,200 : REM Posicion Y del Sprite 3650 RETURN
Otra cosa interesante, cambiar el color de fondo de la pantalla. 

Se realiza con la(s) siguiente instrucción(es). 

20 POKE 53281,1 : REM Color de fondo a blanco
300 POKE 53281,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.




lunes, 8 de febrero de 2016

Ejemplo práctico de CBM .prog Studio .Sprites ,diseñador de pantallas y diseñador de juegos de caracteres.

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

El CBM .prog Studio lo puedes descargar de este enlace

El emulador VICE lo puedes descargar de este enlace

Un pequeño vídeo de lo que hemos hecho hasta ahora: 





Como hacer un PRINT AT Y,X de Sinclair BASIC en Commodore 64 BASIC

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 print left$(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: 



Como entorno de desarrollo estoy usando CBM .prg Studio  de Arthur Jordison .

Puedes descargar el entorno de aquí y el proyecto de este ejemplo de este otro enlace

He aqui otro ejemplo del modo 2, usando otros registros del sistema: 

10 PRINT CHR$(147) 20 SP = 20: ZE = 3: A$ = "Good Morning!": GOSUB 1000: GOSUB 2000 30 SP = 10: ZE = 3: A$ = "I'm the Commodore 64": GOSUB 1000: GOSUB 2000 40 SP = 12: ZE = 6: A$ = "And what is your name ?": GOSUB 1000 100 END 1000 REM cursor positioning and printing 1010 POKE 211,SP :POKE 214, ZE: SYS 58640 : PRINT A$ 1020 RETURN 2000 REM delay-loop 2010 FOR X=0 TO 3000: NEXT X 2020 RETURN