Los objetivos no son muy ambiciosos, pero son ampliables. Contado así deprisa, lo que pretendo es hacer un programa que sea capaz de mostrar partidas para analizarlas y aprender de ellas. Para ello tiene que:

• Mostrar un tablero por pantalla, con las reglas del ajedrez imbuidas en él.
• Comprender los formatos más habituales de notación de partidas.
• Posibilidad de hacer búsquedas de partidas.
• Análisis de partidas.
• Posibilidad de programar ejercicios de aprendizaje.

Como objetivo secundario y más a largo plazo hacer un pequeño motor de juego para poder jugar contra la máquina o que sirva de asistente para el análisis de las partidas de la base de datos. Sin embargo, existiendo varios motores de juego ya plenamente probados, como gnuchess u otros.

Es complicado anotar las posiciones o movimientos del ajedrez y a lo largo del tiempo se han ido proponiendo diferentes formas de hacerlo, cada uno a su manera. Algunas de estas maneras conviven en la actualidad y pueden presentarse en diferentes bases de datos. Además contamos con las diferentes variantes idiomáticas para el nombre de las piezas y su notación.

En muchas bases de datos, especialmente las que utilizan el formato PGN (Portable Game Notation) utilizan los nombres en inglés. Las notaciones pueden ser:

• Notación algebraica: Es la más extendida y está estandarizada por la FIDE, especialmente con su notación inglesa, sin embargo, no es unitaria y hay varios modos de hacer la anotación:
  • Notación algebraica estándar.
  • Notación algebraica larga.
  • Notación algebraica corta.
  • Notación algebraica mínima.
  • Notación algebraica de figuras.
  • Notación algebraica reversible.
  • Notación algebraica concisa de figuras.
• Notación descriptiva: Más tradicional, está en desuso, pero se sigue encontrando en libros antiguos y la siguen utilizando algunos jugadores, especialmente los de más edad.
• Notación numérica de la ICCF: La necesidad de notación fue especialmente importante para las partidas a través del correo y la Federación Internacional de Ajedrez por Corresponencia elaboró y estandarizó una notación numérica que es la oficial en sus competiciones.
• Notación de Smith: es una notación sencilla diseñada para ser reversible que anota la casilla de origen y destino de cada movimiento y la pieza capturada si es necesario.
• Notación de coordenadas: Es similar a la notación algebraica pero no utiliza código para la pieza movida y en lugar de utilizar letras para las columnas utiliza también números.

Por todo esto, podemos encontrar que las mismas jugadas se pueden expresar de muy diferentes maneras. Según un ejemplo sacado de la wikipedia podríamos utilizar las siguientes maneras:

Como se puede observar, hay muchas maneras de indicar los movimientos, siendo algunos más comprensibles que otros a ojos humanos. Los símbolos que se suelen utilizar son varios:

• +: indica jaque.
• ++, #, ≠, ‡: indica jaque mate.
• O-O, O-O-O: enroque corto y largo, respectivamente.
• 1-0: ganan blancas.
• 0-1: ganan negras.
• ½-½: tablas.
• !: jugada excepcionalmente buena. Se pueden utilizar varios !! para dar aún más énfasis.
• ?: jugada excepcionalmente mala. Se pueden utilizar varios ?? para dar aún más énfasis.

Dado que el tablero de ajedrez está dividido en casillas colocadas en filas y en columnas, se han utilizado varios sistemas de coordenadas para referirse a ellas. Por ejemplo, en la notación descriptiva las columnas se denominan como:

• TR: columna de la torre de rey.
• CR: columna del caballo de rey.
• AR: columna del alfil de rey.
• R: columna del rey.
• D: columna de la dama.
• AD: columna del alfil de dama.
• CD: columna del caballo de dama.
• TD: columna de la torre de dama.

En este mismo sistema, las filas se numeran desde el punto de vista de cada jugador, es decir, la fila 1 del jugador de blancas es la fila 8 del jugador de negras y viceversa.

En la esquina superior derecha está el sistema de coordenadas más utilizado por los distintos sistemas de notación. Abajo a la izquierda está el sistema de coordenadas del sistema descriptivo. Como se puede apreciar, este sistema tiene en cuenta la perspectiva del jugador para la anotación haciendo que las casillas tengan dos coordenadas distintas dependiendo del jugador. El tercer sistema, abajo a la derecha, es el sistema de coordenadas utilizado por la ICCF en partidas por correspondencia.

En las partidas por correspondencia además se anota el día de recepción de la respuesta del contrincante y el día de respuesta.

¿Por dónde empezar? En principio, se podría pensar que no hace falta que el tablero sepa las reglas del ajedrez para implementar uno que sea capaz de cargar esas partidas y estudiarlas o incluso que sirva para jugar alguna partida. Sería como jugar con un tablero físico con sus fichas, la madera pintada no tiene consciencia de regla o norma alguna más allá de quedarse donde la mano la suelte. Sin embargo, al encontrarse algo como "Ng8" debe saber que es un caballo, pero además debe saber cuál de los dos que puede tener el jugador puede mover a la coordenada g8. Por tanto, se hace necesario que el programa conozca toda la reglamentación del ajedrez.

De momento, el proyecto se llama ŝako, ajedrez en Esperanto, aunque lo escribo shako por si alguna herramienta (no lo he comprobado) tiene algún problema con caracteres unicode que estén más allá del ASCII.

La forma más sencilla de implementar un tablero es utilizar un array de 64 caracteres:

type
  Tablero* = ref object
    tablero: array[64, char]

Podemos convertir de manera sencilla una cadena de dos caracteres alfanuméricos en una posición en ese array. Se podría implementar un diccionario que buscará la cadena y devolviera un entero con la posición de la casilla buscada en el array. En mi caso me he decantado por tener un array con las coordenadas:

 const
  coordenadas = [
    "a8", "b8", "c8", "d8", "e8", "f8", "g8", "h8",
    "a7", "b7", "c7", "d7", "e7", "f7", "g7", "h7",
    "a6", "b6", "c6", "d6", "e6", "f6", "g6", "h6",
    "a5", "b5", "c5", "d5", "e5", "f5", "g5", "h5",
    "a4", "b4", "c4", "d4", "e4", "f4", "g4", "h4",
    "a3", "b3", "c3", "d3", "e3", "f3", "g3", "h3",
    "a2", "b2", "c2", "d2", "e2", "f2", "g2", "h2",
    "a1", "b1", "c1", "d1", "e1", "f1", "g1", "h1"]

proc posicion*(t: Tablero, pos: string): char =
  var casilla: uint8 = coordenadas.find(pos).uint8()
  return t.tablero[casilla]

Así, con poco esfuerzo podemos mostrar el tablero por pantalla escribiendo el array hacia adelante:

const
  tableroInicial = [
    't', 'c', 'a', 'd', 'r', 'a', 'c', 't',
    'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p',
    '.', '.', '.', '.', '.', '.', '.', '.',
    '.', '.', '.', '.', '.', '.', '.', '.',
    '.', '.', '.', '.', '.', '.', '.', '.',
    '.', '.', '.', '.', '.', '.', '.', '.',
    'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P',
    'T', 'C', 'A', 'D', 'R', 'A', 'C', 'T']

proc mostrarTablero*(t: Tablero): string =
  for i in 0 .. 63:
    if (i mod 8) == 0:
      result.add('\n')
    result.add(t.tablero[i])
    result.add(' ')
  return result

El procedimiento mostrarTablero lo que hace es recorrer el array que representa el tablero, carácter a carácter y lo va añadiendo a una cadena dejando un espacio en blanco entre los caracteres y añadiendo un salto de línea cuando la posición del array sea múltiplo de 8.

Para mostrar el tablero desde la posición del jugador de negras se invierte el proceso:

proc mostrarTableroNegras*(t: Tablero): string =
  for i in countdown(63, 0):
    if (i mod 8) == 0:
      result.add(t.tablero[i])
      result.add('\n')
    else:
      result.add(t.tablero[i])
      result.add(' ')
  return result

Hasta ahora no es mucho, lo que llevo hecho, apenas un par de tests y cuatro funciones básicas para limpiar el tablero, iniciar uno con el procedimiento partidaNueva, la posibilidad de obtener la ficha de una determinada casilla, bien de manera numérica o por coordenada y algunos tests para comprobar que todo va funcionando. De momento no enseño mucho el código. Por ejemplo, me he hecho un script en bash para manejar nimble de manera más sencilla:

#!/bin/bash

function crear_docs () {
    nimble doc -o:doc/shako.html src/shako.nim
    nimble doc -o:doc/tablero.html src/tablero.nim
}

if [ $1 = 'run' ] ; then
    nimble c -r -o:bin/shako src/shako.nim
fi
if [ $1 = 'doc' ] ; then
    crear_docs
fi
if [ $1 = 'all' ] ; then
    nimble test
    nimble c -r -o:bin/shako src/shako.nim
    crear_docs
fi
if [ $1 = 'tests' ] ; then
   nimble test
fi
if [ $1 = 'clean' ] ; then
   rm -rf ./bin
   rm -rf ./doc
fi

La salida de todo el proceso, de momento queda así:

> ./make.sh all
  Verifying dependencies for shako@0.0.1
  Compiling /home/notxor/proyectos/shako/tests/test_tablero (from package shako) using c backend

[Suite] Prueba del módulo «tablero»
  [OK] Un tablero vacío
  [OK] Iniciar tablero a partida nueva
  [OK] Posiciones por cadena de coordenada
   Success: Execution finished
   Success: All tests passed
  Verifying dependencies for shako@0.0.1
  Compiling src/shako (from package shako) using c backend
Tablero en memoria:

t c a d r a c t 
p p p p p p p p 
. . . . . . . . 
. . . . . . . . 
. . . . . . . . 
. . . . . . . . 
P P P P P P P P 
T C A D R A C T 
Tablero desde negras:
T C A R D A C T
P P P P P P P P
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
p p p p p p p p
t c a r d a c t

   Success: Execution finished
  Verifying dependencies for shako@0.0.1
 Generating documentation for src/shako (from package shako) using doc backend
   Success: Execution finished
  Verifying dependencies for shako@0.0.1
 Generating documentation for src/tablero (from package shako) using doc backend
   Success: Execution finished

De momento, el programa está en mantillas. Si alguien espera poder analizar partidas con él tendrá que esperar mucho tiempo, por lo que es recomendable que espere sentado o en posiciones aún más cómodas y que no olvide hidratarse y alimentarse para poder sobrellevar mucho mejor la espera. Pero si no puedes esperar, te recomiendo SCID. Que es más o menos similar a lo que pretendo hacer.

Como me he puesto con este proyecto, amenazo con una serie de artículos sobre su implementación. Avisados estáis. Lo siguiente será la posibilidad de que entienda mínimamente la notación FEN para poder iniciar el tablero de una manera más o menos directa. Sería el primer modo de pasarle partidas e implementar algunas de las reglas básicas como la de los 50 movimientos que dice que la partida se acaba si se alcanzan 50 movimientos sin que se mueva un peón o sin que una pieza capture otra, o también las que gobiernan los enroques.