buleano = funcion EsPrimo(entero Valor)
     entero unidades, max, k

    unidades = (valor modulo 10)

    Si ((unidades and 1) = 1) luego  // primer filtro  (eliminamos los acabados en 0,2,4,6 y 8, es decir aceptamos solo los impares
        Si (unidades = 5) luego   // y ahora descartamos el impar 5
            Si (valor=5) luego
                Devolver TRUE
            Sino
                Devolver FALSE  // cualquier otro múltiplo de 5 no es primo.
            Fin si
        Sino
            max = RaizCuadrada(valor) +1  // segundo filtro, 
            bucle para k desde 7 hasta max en incrementos de 2
                  Si ((valor modulo k) = 0) Devolver FALSE
            Fin bucle

            Devolver TRUE 
        Fin si
    Sino  // todavía podría ser 2 que es el único par que es primo (divisible sólo: por sí mismo y la unidad)
        Si (valor = 2) luego
            Devolver TRUE 
        Sino
            Devolver FALSE
        Fin si
    Fin si
Fin funcion

// 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

// 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

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

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