Yo veo más interesante que una función devuelve un valor indicando cuales de las 8 posibles movimientos del caballo son válidas.
Se pasa a la función las cordenadas del caballo y el estado del tablero.
Con estado del tablero, se indica que contiene uno de estos 3 tipos de valores (en cada casilla del array que lo mantiene):
---: =0; Casilla no ocupada.
---: >0; Casillas ocupadas por el contrincante (el valor define que figura es).
---: <0; Casillas ocupadas por tus propias figuras (el valor define que figura es).
Luego, como el caballo tiene 8 posibles movimientos, usaremos un byte como respuesta:
- Cada bit a 1 indica movimiento posible (casilla vacía o figura del enemigo que se puede comer).
- Cada bit a 0, movimiento no posible (esto es, fuera del tablero u ocupada por tus propias figuras)
// Esta funcion devuelve un byte indicando en cada bit si la casilla correspondiente a dicho bit puede o no saltar el caballo a ella.
// Si el movimiento es posible y la casilla está vacía u ocupada por el enemigo, se pone el bit correspondiente a 1.
byte = funcion PosicionesValidas(entero x, entero y, array tablero() )
byte n
' bit 0 y 5 (porque ambos comparten el x-1)
Si (x-1) >= 0) luego
Si (y-2) >= 0) luego // bit 0
Si Tablero(x-1, y-2) >= 0 luego n = 1 //previamente valía 0.
fin si
Si (y+2) >=0) luego //bit 5
Si Tablero(x-1, y+2) >= 0 luego n= (n or 32)
Fin si
Fin si
' bit 1 y 4 (porque ambos comparten el x+1)
Si (x+1) >= 0) luego
Si (y-2) >= 0) luego // bit 1
Si Tablero(x+1, y-2) >= 0 luego n=(n or 2)
fin si
Si (y+2) >=0) luego //bit 4
Si Tablero(x+1, y+2) >= 0 luego n= (n or 16)
Fin si
Fin si
// -----------------------------
' bit 6 y 7 (porque ambos comparten el x-2)
Si (x-2) >= 0) luego
Si (y-1) >= 0) luego // bit 6
Si Tablero(x-2, y-1) >= 0 luego n=(n or 64)
fin si
Si (y+1) >=0) luego //bit 7
Si Tablero(x-2, y+1) >= 0 luego n= (n or 128)
Fin si
Fin si
' bit 2 y 3 (porque ambos comparten el x+2)
Si (x+2) >= 0) luego
Si (y-1) >= 0) luego // bit 2
Si Tablero(x+2, y-1) >= 0 luego n= (n or 4)
fin si
Si (y+1) >=0) luego //bit 3
Si Tablero(x+2, y+1) >= 0 luego n= (n or 8)
Fin si
Fin si
devolver n
fin funcion
- Otra función debiera admitir a qué cordenadas refiere un bit 'n' del byte (que devuelve la función anterior) dada la posición actual del caballo.
- Se añade además a la función otro parámetro; el array del tablero, y así la función retorna un byte, que es indicadtivo de si se mueve a dicha casilla y si además 'se come' una ficha del enemigo, ó si no es posible moverse a ella...
// Una enumeración para la devolución de la función así resulta útil saber que pasó.
// igualmente bastaría un sByte y acordar que este
enumeracion PosibilidadesDeMovimiento
Movimiento_No_Mueve = -1 //No se puede mover a esa posición (están tus figuras o apunta fuera del tablero)
Movimiento_Vacio = 0 //se posiciona en OTRA casilla vacía, no pasa nada más.
// Al comer se podría prescindir de qué figura come (y en todos estos casos devolver simplemente 1) aunque resulta más interesante así...
// Estos valores deberían coincidir con los valores asignados a las figuras (en otra enumeración, para el tablero)
Movimiento_Come1 = 1 // come a un peón
Movimiento_Come2 = 2 //come a una torre
Movimiento_Come3 = 3 //come a un caballo
Movimiento_Come4 = 4 //come a un alfil
Movimiento_Come5 = 5 // Come a la reina.
Movimiento_Come6 = 6 // Mata al rey, fin de partida (el rey no tiene movimientos)
fin enumeracion
Y ahora que queda claramente definida lo que tiene que hace rla función su pseudocódigo resultante:
- Posibles es el byte que se devolvió en la función anterior, y bitposición la elección de movimiento del jugador.
- 'x' e 'y' son las cordenadas actuales y a la devolución contendrán las cordenadas de destino del caballo (solo si fue posible moverse).
PosibilidadesDeMovimiento = funcion PosicionarCaballoSobre(byte x, byte y, byte Posibles, byte BitPosicion, array sByte Tablero() )
sbyte dx, dy
PosibilidadesDeMovimiento n
Si ((2^BitPosicion) and posibles) luego // ¿realmente ese bit está a uno (casilla aceptable donde mover el caballo) ?
Seleccionar BitPosicion
caso 0
dx = x-1
dy = y-2
caso 1
dx = x+1
dy = y-2
caso 2
... // a rellenar por ti...
caso 3
...
caso 4
...
caso 5
...
caso 6
...
caso 7
...
Fin seleccionar
// no hace falta comprobar dx y dy dentro del tablero, ya que eso se comprobó en la función anterior y se garantiza al inicio de esta función...
n = Tablero(dx, dy)
Si (n>0) luego
x = dx
y = dy
devolver n
Osi (n=0)
devolver n
fin si
Fin si
devolver -1
fin funcion
Luego el código de las llamadas sería algo como:
array sByte tablero(0 a 7, 0 a 7) //el array del estado del tablero está definidio a nivel del módulo/clase
Funcion JugarCaballo(byte x, byte y) //x, y son las cordenadas actuales del caballo.
sByte n, p
posibilidadesDeMovimiento j
byte dx, dy
n = PosicionesValidas(x, y, tablero() )
Si (n> 0) luego //hay posiciones válidas para el caballo desde donde está actualmente
dx= x
dy = y
Hacer
mensajeAlJugador ""Elige una de los 8 posibles movimeintos del caballo (un valor en el rango: (0/7)" con imagen adjunta de las psoiciones que son 0-7)
p = JugadorEligePosicion // para el caballo (en el rango 0-7
j = PosicionarCaballoSobre(x, y, n, p, tablero() )
Repetir mientras (j<0)
Si (j>0)
ComerFichaEnemiga(x, y, j) // allí se ve si la ficha comida es el rey en cuyo caso acaba la partida.
Fin si
MoverCaballoA(x, y)
// Actualizar estado del tablero:
tablero(dx, dy) = 0 // casilla libre, caballo retirado de ahí.
tablero(x, y) = -3 // 'nuestro' caballo en dicha posición (hbiera o no una ficha del enemigo en ella).
fin si
fin funcion
Los bits que definen la posición del movimiento serían así:
Autor
En línea
