RYG: árbol de juego – generar tableros hijo

Ya sabemos generar las jugadas válidas del ratón y los gatos. También sabemos dónde y cómo vamos a almacenar el árbol de juego. Por tanto, el siguiente paso es empezar a construirlo.

Supongamos que acaba de jugar el humano. El humano ha seleccionado una jugada del ratón y ésta se ha aplicado al tablero actual dando lugar a un tablero actual modificado.

Ahora le toca mover al C64 y, para decidir su jugada, hay que conformar y evaluar el árbol de juego. El árbol va a tener varios niveles de profundidad, pero no vamos a abordar todos los niveles de golpe. Vamos paso a paso; empecemos por el primero.

Para generar el primer nivel del árbol de juego, los hijos de la raíz, hay que:

  • Copiar el tablero actual a la raíz del árbol de juego.
  • Recorrer los cuatros gatos, desde el 0 hasta el 3.
  • Para cada gato, localizarlo sobre la raíz (rutina “dameGato”) y generar sus movimientos válidos (rutina “generaJugadasValidasGato”).
  • Y, en vez de pintar las jugadas de los gatos, como en una entrada anterior, aplicar (*) cada jugada o movimiento al tablero raíz.

Pero cuidado con una cosa (*). Ahora no se trata de “aplicar la jugada” en el sentido de modificar la raíz del árbol o el tablero actual. Eso lo haremos más adelante, cuando el C64 haya decidido qué jugada le interesa más. Ahora estamos en un momento previo, construyendo el árbol que le permita tomar esa decisión.

Por tanto, ahora no queremos modificar la raíz del árbol, sino que queremos generar un tablero hijo por cada jugada posible. Por ello, vamos a desarrollar una nueva rutina “aplicaJugadaGatoHijo” que será similar a la rutina “aplicaJugadaGato” pero que, en vez de modificar el tablero de entrada, lo que hace es todo lo que sigue:

  • Saca una copia del tablero de entrada (ahora la raíz del árbol) en un nuevo tablero que será el hijo. Para esto hace falta una nueva rutina de apoyo “copiaTablero” en el fichero “Tableros.asm”.
  • Actualiza el puntero a la memoria libre (libreLo – libreHi), puesto que hemos creado un nuevo tablero en el árbol.
  • Sobre el tablero hijo, aplica el movimiento.
  • Más adelante, enlazará el tablero padre con el tablero hijo, y viceversa, aunque en esta fase del proyecto esto todavía no está implementado.
  • A modo de depuración, y de forma temporal, imprime el tablero hijo.

Los parámetros de la rutina son así (el tablero padre, el tablero hijo, la posición actual del gato y su nueva posición):

Rutina aplicaJugadaGatoHijo - params

La copia de la raíz al tablero hijo es así (se apoya en la nueva rutina de apoyo “copiaTablero”):

Rutina aplicaJugadaGatoHijo - copia

La actualización del puntero a memoria libre es así (básicamente suma 85 bytes):

Rutina aplicaJugadaGatoHijo - puntero

La aplicación del movimiento es así (se apoya en “aplicaJugadaGato”, pero actuando sobre el tablero hijo):

Rutina aplicaJugadaGatoHijo - aplicar

Las previsiones pendientes de implementar son así:

Rutina aplicaJugadaGatoHijo - previsiones

Y, por último, la impresión del tablero hijo (para depurar) es así:

Rutina aplicaJugadaGatoHijo - pintar

Con esta nueva rutina “aplicaJugadaGatoHijo” ya deberíamos ser capaces de generar el primer nivel del árbol, es decir, esta parte (ver rojo):

Arbol de juego - primer nivel

Para ello, lógicamente, habrá que invocar esta nueva rutina desde algún sitio del programa principal (fichero “RYG.asm”). Pero como esta entrada ya ha sido demasiado larga, lo dejamos para la siguiente.


Código del proyecto: RYG07

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