Muestro aquí los objetos que intervienen en la partida para no hablar en vacío, pero tampoco voy a hacer una disertación detallada de todos los detalles:

type Tablero* = ref array[64, char]

type
  Movimiento* = object
    san*: string
    fen*: string

type
  Partida* = ref object
    tablero*: Tablero
    movimientos*: seq[Movimiento]
    turno*: string
    enroqueCortoBlancas*: bool
    enroqueLargoBlancas*: bool
    enroqueCortoNegras*: bool
    enroqueLargoNegras*: bool
    posAlPaso*: string
    contador*: int
    numJugada*: int

El Tablero es un array de 64 caracteres, cada uno de los cuales representa el contenido de una casilla. La Partida cuenta con un tablero que es el que utilizan las interfaces para mostrarlo por pantalla. Además, la Partida cuenta con una lista de movimientos. Cada Movimiento consta de una cadena SAN⁴ y el FEN que muestra el estado de la partida tras ese movimiento. El movimiento 0 es el estado inicial del tablero al comenzar la partida. De momento, sólo es posible el inicio estándar, pero esperamos poder iniciar las partidas de otros modos, como el ajedrez 960⁵, o cuando ambos jugadores pactan una ventaja, por ejemplo iniciando el juego uno de ellos con una figura menos.

El meollo de la partida la controla muevePieza. Dicha función controla que al realizar un movimiento se siguen las normas del ajedrez llamando a la función esMovimientoLegal, y si, efectivamente el movimiento es legal, realiza el movimiento, genera la cadena SAN y la cadena FEN, las guarda y pone la Partida en el estado correspondiente. Aunque aún faltan un par de detalles para dar por finalizada la implementación de Partida. El código, de momento, tiene esta forma:

##[
La función `muevePieza` cambia la posición de una pieza desde una
casilla de origen `co` a una casilla final `cf`, en el tablero `p`
dado.

Devuelve `true` si se efectúa el movimiento de pieza y `false` en
caso contrario. Cuando se realiza el movimiento de pieza también
cambia el turno en la partida.
]##
# TODO: Falta por implementar:
#       1. la promoción de los peones: de momento sólo promocionan a reina
#       2. detección del Mate
proc muevePieza*(p: Partida, co, cf: string): bool =
  var
    san: string
    [...]
  if p.esMovimientoLegal(t, co, cf):

    [...]

    # hace el movimiento
    t.ponValorCasilla(cf, figura)
    t.ponValorCasilla(co, VACIA)
    if san == "":  # Si ha habido enroque ya llega aquí relleno
      # si no, junta las partes de la notación del movimiento
      san = fig & origen & captura & cf & jaque & ep
    # Cambia el jugador de turno
    p.cambiaTurno()
    # Guarda el registro del movimiento
    p.movimientos.add(Movimiento(san: san, fen: p.fen()))
    return true
  else:
    return false

Algunas cosas merecen un poco más de atención, como los detalles sobre movimientos de peones, reyes y torres. Estas tres piezas producen cambios en el estado de Partida por reglas especiales que les afectan, como la captura al paso⁶ de los peones, la regla de los cincuenta movimientos⁷, de los que Partida lleva un contador, o de las reglas de enroque⁸, que también debe vigilar Partida y que se ven afectadas por movimientos de reyes y torres. Además, en el enroque se debe mover también la torre y no sólo el rey y, por último, debe registrar los datos para generar la cadena san que es la notación algebraica del movimiento.

Sin embargo, el mayor peso de proceso y comprobaciones recae sobre la función esMovimientoLegal:

##[
Para que un movimiento sea legal, en una partida `p` la pieza situada
en la casilla de origen `co` debe estar en su turno, no puede mover al
mismo sitio donde está y la casilla de destino `cf` debe ser
alcanzable según las normas del ajedrez.
]##
proc esMovimientoLegal(p: Partida, t: Tablero, co, cf: string): bool =
  var
    figura: char = t.contenidoCasilla(co)
    tablero: Tablero

  if figura != VACIA and estaEnTurno(p, figura) and co != cf and p.esDestinoLegal(t, co, cf):
    # Si el movimiento parece legal, realizamos el movimiento en un tablero aparte
    tablero = t.copiarTablero()
    tablero.ponValorCasilla(co, VACIA)
    tablero.ponValorCasilla(cf, figura)
    # Y comprobamos que no queda el rey propio en jaque
    if tablero.estaEnJaque(p, figura.colorPieza()):
      echo("Deja el rey propio en jaque.")
      return false
    return true
  else:
    return false

Las comprobaciones que hace esta función son las siguientes:

1. Que para la casilla de origen no se ha seleccionado una casilla vacía.
2. Que la figura de la casilla de origen está en su turno.
3. Que la casilla de origen y destino son distintas.
4. Que la figura de la casilla de origen puede mover a la casilla final. La función esDestinoLegal comprueba las normas de movimiento de cada pieza y determina si puede alcanzar la casilla final.
5. Que al realizar el movimiento no quedaría el rey propio en jaque. Para hacerlo, copia el tablero de la partida en otro, poniéndolo en la situación de que el movimiento se ha realizado y comprueba que el rey de su color no quede en jaque.

Falta por implementar un par de detalles que aún no tengo claro cómo se pueden afrontar, aunque sí alguna idea:

• Promoción del peón: Cuando un peón alcanza la fila más alejada de su posición de inicio puede promocionar a cualquier figura, excepto a rey. Puede convertirse en reina, torre, alfil o caballo a elección del jugador. Lo habitual es que todos elijamos la reina por ser la pieza más potente, pero puede elegirse otra, por ejemplo, para evitar ahogar al rey contrario y acabar en tablas o porque estratégicamente le guste más al jugador. En la notación por coordenadas se anota la pieza deseada después del movimiento, por ejemplo: e7e8N coronaría el peón y lo convertiría en un caballo. En modo gráfico podría ser mostrar un diálogo para que elija el jugador y en modo texto, añadir la pieza deseada a las coordenadas al introducir el movimiento para coronar el peón... pero aún hay que hacerlo.
• Detección del mate: Actualmente Partida no sabe si ha acabado el juego porque no se pueda evitar la captura de un rey. Mirando por Internet he visto un algoritmo que tiene dos casos, a partir de un jaque inicial:
  1. El jaque inicial se da por dos piezas a la vez:
     1. Comprobar si algún movimiento de rey evita el jaque.
  2. El jaque inicial lo da una sola pieza:
     1. Comprobar si la pieza que da el jaque puede ser capturada.
     2. Comprobar si se puede interponer una pieza propia entre el rey y la pieza atacante.
     3. Comprobar si algún movimiento del rey evita el jaque.

Poder analizar partidas implica navegarlas, poder avanzar y retroceder tantas veces como sea necesario. Para colocar la partida en una posición cualquiera, la aproximación por fuerza bruta de iniciarla e ir haciendo todos los movimientos anteriores. Sin embargo, creo que esta forma es un poco primitiva y que la mejor manera sería utilizar la notación FEN. Por esto, tras cada movimiento se registra no sólo la notación estándar, sino también el estado de la partida con FEN.

La forma de comunicar al motor de juego la situación actual de la partida es con la notación FEN. Ya lo expliqué en el artículo anterior: consta de seis campos:

• Cadena representando las 8 filas del tablero:
  • El tablero se lee de izquierda a derecha comenzando por la casilla a8 y de arriba hacia abajo hasta h1.
  • Cada fila se separa de la siguiente con el signo /.
  • Se utiliza la notación de piezas con la inicial inglesa, en mayúscula para blancas y en minúscula para negras.
  • Las casillas vacías se muestran agrupándolas con un número.
• Indicador de color activo, o a quién le toca mover, w (white) y b (black).
• Indicador de posibilidad de enroques: QKqk (de Queen y King) que actuarían como flags de que blancas (en mayúscula) y negras (en minúscula) tienen capacidad de enrocar aún por alguno de los lados o un - si ningún jugador tiene ya posibilidad de enroque.
• Casilla de destino para la captura al paso. Si no hay casilla de destino aparecerá un -. La casilla destino aparecerá después de un doble avance de salida de un peón. Un peón contrario que se encuentre en la fila 3 (para negras) o en la fila 6 (para blancas) puede ejercer la acción de captura al paso, situándose en la casilla donde hubiera terminado si el movimiento del peón que avanza hubiera sido de una sola casilla.
• Reloj de medios movimientos: Este número es el recuento de medios movimientos desde el avance de peones o movimientos de captura y se utiliza para la regla de conteo de 50 movimientos. Esta regla establece tablas o empate, si se producen 50 movimientos seguidos sin que se mueva un peón o se realice alguna captura.
• Número de jugadas completas: Comienza puesto a 1 y se incrementa tras cada movimiento de las negras.

Todos los campos llegan en una sola cadena separados por espacios.

En base a los campos anteriores se establece el estado de la Partida con la función:

##[
Esta función `fen` recibe una cadena codificada con la notación FEN y
la utiliza para situar la partida `p` en el estado descrito por la
misma, decodificando los campos que esta notación proporciona.
]##

proc fen*(p: Partida, fen: string) =
  let campos = split(fen)
  p.limpiarTablero()
  p.ponPiezasFen(campos[0])
  p.turno = campos[1]
  p.ponEnroquesFen(campos[2])
  p.posAlPaso = campos[3]
  p.contador = parseInt(campos[4])
  p.numJugada = parseInt(campos[5])

También hay una función que realiza el proceso inverso y devuelve una cadena codificada como FEN a partir del estado de una partida:

proc fen*(p: Partida): string

No quiero cansinar mucho con el proyecto, aún está en pañales aunque promete maneras. De momento tenemos un objeto que nos permite mantener una partida de ajedrez dentro de las normas de juego, con alguna carencia, que sin duda para cuando se publique este artículo ya estará solucionada o en vías de solución. Además se puede conectar con un motor de juego. De momento sólo se ha probado con Stockfish mediante el protocolo UCI, aunque está pensado admitir otros motores como GNU chess o Crafty. Quizá también soportar algún protocolo más, como XBoard.

Lo que estoy ahora mirando es poder configurar el motor para jugar desde la interface. También introducir otros parámetros del programa, que me permitan o bien jugar o bien analizar una partida desde el primer movimiento al último realizado.

El siguiente paso es poder cargar archivos PGN, con múltiples partidas, que permita analizar su contenido, desarrollar las partidas y hacer variaciones sobre ellas utilizando el motor de juego, etc.

También el asunto del reloj y el tiempo de juego está en pendientes, pero no creo que sea el momento aún para afinar tanto. Primero hay que terminar con la representación del tablero, asegurarnos de seguir las normas del ajedrez y de que permite un análisis pausado de la partida.