RYG: jugadas de los gatos – rutinas básicas

Los principios básicos que rigen la generación de jugadas para los gatos son los mismos que para el ratón:

  • Los movimientos posibles se gestionan mediante una tabla doble que recoge los cambios posibles en filas y columnas.
  • Los movimientos posibles hay que validarlos. Para que sean válidos, además de realizarse conforme a las reglas del juego (punto anterior), la posición de destino debe estar vacía y caer dentro del tablero.

Por otro lado, las principales diferencias entre gatos y ratón son:

  • Ratón sólo hay uno, mientras que gatos hay cuatro. Esto complica un poco las rutinas, porque hay que indicarles sobre qué gato se trabaja. Y también complica los programas que usan esas rutinas, porque tendrán que hacer bucles desde 0 hasta 3 para trabajar con todos los gatos.
  • Con el ratón juega el humano, y lo que él decida y comunique a través del teclado se aplicará al tablero actual. Sin embargo, con los gatos juega el C64 y, para que éste pueda decidir sus jugadas, hace falta conformar y evaluar un árbol de juego. Este árbol de juego tendrá varios niveles de profundidad (cuantos más tenga más potente será el juego), y para conformarlo habrá que alternar movimientos de gatos y ratón.

Por tanto, la diferencia fundamental entre ratón y gatos es que para los gatos hay que conformar y evaluar un árbol de juego. No es tarea fácil, pero vamos paso a paso. De momento vamos a empezar por generar, validar y aplicar los movimientos de los gatos:

Separación de “GenJugadasRaton.asm” y “GenJugadasGatos.asm”:

Aunque en la introducción teórica a los juegos de tablero hablamos genéricamente de un “generador de jugadas”, lo cierto es que por claridad y simplicidad es mejor separar el generador de jugadas en dos ficheros:

  • “GenJugadasRaton.asm”, dedicado al ratón. Es lo que en versiones anteriores del proyecto llamábamos “GenJugadas.asm”.
  • “GenJugadasGatos.asm”, dedicado a los gatos. Es nuevo.

Por tanto, en esta entrada nos centramos en el nuevo fichero “GenJugadasGatos.asm”.

Nueva rutina “generaJugadaGato”:

Esta rutina es totalmente análoga a la ya conocida “generaJugadaRaton”. La principal diferencia es que los gatos sólo se mueven hacia adelante, hacia abajo con la orientación del tablero que tenemos, por lo que la tabla doble que rige el movimiento es más sencilla:

Movimientos gatos

Es decir, los gatos pueden moverse así (siempre avanzando la fila):

  • Índice 0 => (+1, -1).
  • Índice 1 => (+1, +1).

Por lo demás, las rutinas “generaJugadaGato” y “generaJugadaRaton” son un calco, por lo que no merece la pena comentar más la primera.

Nueva rutina “generaJugadasValidasGato”:

Para que un movimiento de un gato sea válido, además de estar generado conforme a las reglas del juego (punto anterior), el destino tiene que estar vacío y caer dentro de los márgenes del tablero.

Estas reglas de validación son las mismas que para el ratón, por lo que no hace falta disponer de dos rutinas de validación diferentes. Se puede reutilizar la ya conocida “validaJugada” de “GenJugadasRaton.asm”.

Lo que si hará falta será una rutina “generaJugadasValidasGato” que permita generar todas las jugadas válidas de un gato (y sólo las válidas), igual que en su momento desarrollamos la rutina “generaJugadasValidasRaton”.

Ambas rutinas, “generaJugadasValidasGato” y “generaJugadasValidasRaton” son totalmente análogas, y básicamente consisten en generar las jugadas con “generaJugadaGato” o “generaJugadaRaton”, y luego validarlas con “validaJugada”. Por tanto, no abundaremos más en ellas aquí.

Nueva rutina “aplicaJugadaGato”:

Por último, igual que es necesario aplicar una jugada del ratón a un tablero, también será necesario aplicar una jugada de un gato. Por ello, desarrollamos la rutina “aplicaJugadaGato”, que es totalmente análoga a la ya conocida “aplicaJugadaRaton”.

En este punto, la principal diferencia entre ratón y gatos es que, con el primero, es el usuario quien decide la jugada. Y una vez decidida se aplica al tablero actual.

Con los gatos el tema es bastante más complejo porque, como ya hemos comentado, para que el C64 decida su jugada, hay que conformar y evaluar un árbol de juego. Para crear este árbol también habrá que generar jugadas (de gatos y ratón, por cierto) y aplicarlas a tableros. Pero ya no se aplicarán modificando un tablero concreto (la raíz del árbol), sino generando nuevos tableros hijo, nuevos tableros nieto, etc.:

Arbol de juego

Cuando todo este proceso de generación y evaluación del árbol haya terminado, y el C64 haya tomado una decisión sobre su jugada, entonces sí, la jugada elegida por el C64 habrá que aplicarla sobre el tablero actual, dando lugar a un nuevo tablero actual.


Código de proyecto: RYG06

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google photo

Estás comentando usando tu cuenta de Google. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s