- screen_1.gif (12.18 KiB) Visto 8225 veces
EL JUEGO
Basado en un juego de mesa, aparentemente inventado en Francia durante el siglo XVII por un noble encarcelado en La Bastille. Hay diferentes variantes respecto a la forma del tablero y el número de casillas.
En esta versión el tablero se compone de 45 casillas, ocupadas todas por una ficha, excepto la central.
Mediante una serie de movimientos se van eliminando las fichas, hasta dejar una única ficha que debe ser la que estaba vacía al principio de la partida.
Los movimientos consisten en hacer saltar una ficha sobre una de las adyacentes siempre que a continuación la casilla esté vacía. En este caso hay que eliminar la ficha sobre la que hemos saltado.
El movimiento se indica introduciendo 4 valores numéricos comprendidos entre el 1 y el 9:
- Fila inicial / Columna inicial / Fila destino / Columna destino
En esta versión no se detecta el final de partida o la imposibilidad de poder realizar más movimientos.
Descargar el juego en formato ".p":
BLOQUES
He dividido el listado en 3 bloques:
- Impresión del tablero.
- Introducir la tirada y comprobar el tipo de movimiento a realizar.
- Comprobar si el movimiento es correcto y actualizar las fichas.
COMO FUNCIONA
A continuación detallo, línea por línea, el funcionamiento del programa.
Se utilizan las siguientes variables:
A$ - Entrada del movimiento.
F – Variable numérica para bucles.
A – Variable numérica coordenada vertical inicial.
B – Variable numérica coordenada horizontal inicial.
C – Variable numérica coordenada vertical destino.
D – Variable numérica coordenada horizontal destino.
Y - Variable numérica de incremento vertical.
X - Variable numérica de incremento horizontal.
8 – Guardamos el valor 2 en la variable “T”. Se usará a lo largo del programa y permite ahorrar memoria.
10 – Muestra el valor de las columnas.
12 – Inicio del bucle que dibuja el tablero.
14 – Guarda en la variable “B” el valor del tipo de la fila del tablero. Hay 3 diferentes.
16 – Imprimir el número de la fila y la fila del tablero.
18 – Final del bucle que dibuja el tablero.
20 – Introducir la tirada del jugador.
21 – Si la longitud de la tirada es distinta de 4 se vuelve a la línea 20.
22 – Guardar en la variable “A” el valor de la coordenada vertical inicial.
24 – Guardar en la variable “B” el valor de la coordenada horizontal inicial.
26 – Guardar en la variable “C” el valor de la coordenada vertical de destino.
28 – Guardar en la variable “D” el valor de la coordenada horizontal de destino.
30 – Guardar en la variable “X” el valor 0.
31 – Guardar en la variable “Y” el valor de “X” (es 0).
32 – Comprobar si el movimiento es horizontal, guardando en “X” la diferencia entre las casillas de inicio y de destino.
34 – Comprobar si el movimiento es vertical, guardando en “Y” la diferencia entre las casillas de inicio y de destino.
36 – Si el movimiento horizontal y vertical es distinto de 2, se vuelve a la línea 20.
38 – Si el valor absoluto de “X” es igual a 2, guardar en X el signo del movimiento. Negativo=Izquierda, Positivo=Derecha.
40 – Si el valor absoluto de “Y” es igual a 2, guardar en Y el signo del movimiento. Negativo=Arriba, Positivo=Abajo.
42 – Inicio del bucle que comprueba que la tirada sea correcta y que actualiza el tablero.
44 – Si el valor del bucle es distinto de 1 y de 4 se salta a la línea 50.
46 – Guardar en la variable “C” el valor de la variable “A”.
48 – Guardar en la variable “D” el valor de la variable “B”.
50 – Situar el cursor en la posición C (vertical) / D (horizontal).
52 – Si “F<3” comprueba si en la pantalla hay la secuencia de caracteres para considerar que el movimiento es correcto, sino pone el valor de “F” a 9 para romper el bucle.
56 – Incrementa el valor de “C” con el valor de “Y”, que puede ser (-1, 0, 1).
58 – Incrementa el valor de “D” con el valor de “X”, que puede ser (-1, 0, 1).
60 – Si el valor del bucle “F” es distinto de 9 imprime el carácter que debe haber en esa posición de la pantalla.
62 – Final del bucle de comprobación.
64 – Saltar a la línea 20 para introducir una nueva tirada.
EL PROGRAMA
- solitario.gif (11.59 KiB) Visto 8225 veces
APUNTES FINALES
El verano es una época que invita a salir por las noches, lo que me deja poco tiempo libre para estar con mis equipos retro.
Revisando mi colección de juegos de ingenio encontré una versión del solitario hecha de madera, perteneciente a una colección de fascículos.
Lo usé un rato y pensé que sería interesante crear una versión para jugar en el ZX-81. En Internet vi que existe una versión de 16K, pero la mía debía caber en 1K. Aparentemente sencillo hasta que ves que es más complicado de lo que parece, y que la poca memoria RAM se consume...
UN SOLITARIO EN 1K
A falta de tiempo libre he usado el emulador “EightyOne” en mis viajes al trabajo en tren, y la verdad es que en poco más de 2 horas el juego estaba completamente finalizado.
Desarrollar este juego ha sido un nuevo reto ya que inicialmente parecía muy simple, pero la cosa se ha complicado cuando has de validar el movimiento y actualizar el tablero, y esto consumía los 600 bytes disponibles, con el consiguiente error 4 de memoria llena.
El programa se divide básicamente en tres partes:
1. Dibujar el tablero
Esta parte ha sido fácil de desarrollar a pesar de que hay 3 tipos de filas distintas en el tablero: 3 bolas, 9 bolas y el de 8 bolas de la fila central. Con 5 líneas de código, tema resuelto, estando la clave en las filas 14 y 16.
La línea 14 nos devuelve un valor 1, 10 ó 19 en función de la cadena que indica el tipo de fila a imprimir, y la línea 16 contiene otra cadena con los tres tipos de fila, en grupos de 9 caracteres. El valor de “B” indica la posición inicial de la cadena a imprimir, más los siguientes 8 caracteres.
2. Validar el movimiento
Esta segunda parte ya ha dado más guerra ya que aquí hay que hacer parte de la validación de la tirada, y detectar el tipo de movimiento: vertical/horizontal y dirección.
Lo primero es introducir la tirada en la línea 20 y validar en la línea 21 que este valor se compone de 4 caracteres, dando por seguro que se han introducido números. A continuación se guarda el valor de cada dígito en una variable (líneas 22 y 28) y se inicializan las variables X e Y que guardan el incremento horizontal y vertical (líneas 30 y 31).
En las líneas 32 y 34 comprueba si las coordenadas verticales y horizontales de inicio y destino son iguales. En caso afirmativo guardamos la distancia entre las otras dos coordenadas. En 36 comprobamos que la distancia absoluta (sin signo) sea igual a 2. Y en 38 y 40 miramos que si el valor absoluto de estas distancias vertical u horizontal es igual a dos, nos guarde el signo del valor en esa variable (-1, 0, 1).
3. Actualizar el tablero
Esta parte es la más complicada ya que primero hay que comprobar que la ficha seleccionada saltará por encima de otra y caerá en una casilla vacía, y a continuación se deben actualizar las fichas del tablero. En un principio este proceso se componía de dos bucles que contaban de 1 a 3, pero como daba errores de memoria lo he conseguido meter en un único bucle que cuenta de 1 a 6.
Si el contador del bucle “F” es distinto de 1 y 4 saltamos a la línea 50, en caso contrario guardamos en las variables “C” y “D” la posición inicial de la ficha a mover, y en la línea 50 ponemos el cursor en la posición de esas dos variables, que “casualmente” coincide con su posición en la pantalla.
Si el contador es menor o igual a 3 comprobamos en la memoria de video si el estado de cada una de las tres posiciones es la correcta, o sea “ficha-ficha-vacía”, y si se detecta un error pone el valor del bucle a 9 para salir en el NEXT de la línea 62. A continuación avanzamos la posición a comprobar con los incrementos de las variables “X” e “Y”.
Para terminar imprimimos en la posición correspondiente el estado correcto. Se ha hecho de esta manera para ahorrar memoria ya que realmente esta condición solo se debería ejecutar a partir del valor del bucle 4, y siempre que “F” sea distinto de 9 (error detectado).
Para terminar
Esta vez he apostado por una mejor legibilidad del programa con lo que he evitado la instrucción CODE y he optado por definir los valores numéricos mediante VAL.
Hay artículos en los que se comentan las estrategias que hay para solucionar el juego en sus múltiples variantes, consistente en agrupar las fichas en zonas con una forma concreta y aplicar unos movimientos determinados para solucionar cada una de las zonas, todo ello en un orden concreto.
Con todo, el programa funciona perfectamente, así que… prueba superada ¡!!
Os invito a probarlo…
- screen_2.gif (3 KiB) Visto 8225 veces
- screen_3.gif (2.82 KiB) Visto 8225 veces
- screen_4.gif (2.65 KiB) Visto 8225 veces
…con el siguiente regalito…
- Solucion.gif (13.68 KiB) Visto 8225 veces
... he estado probando la versión y he visto que no solo es más rápida que la mía sino que encima detecta el final de los movimientos.
