Teoría de Autómatas y Lenguajes Formales

Segundo curso. Segundo cuatrimestre.

Ingeniería Técnica en Informática de Sistemas.
Escuela Politécnica Superior.
Universidad de Córdoba.
Curso académico: 2008-2009

Práctica de LEX
ChessLex

Nombre de Autores:
● Ángel Jesús Martínez Bernal
● Rafael Jesús Sánchez Santos
 INDICE
1.Objetivo de la practica.

2.Partes del fichero que definirá el juego.

2.1.Tablero.

2.1.1.Tablero_Aleatorio(num_piezas,tipo_situación);
2.1.2.Tablero_Aleatorio(num_piezasB,ratioBN,tipo_situación);
2.1.3.Agregar_Pieza(tipo,color,ubicación);
2.1.4.Situar_Pieza(origen,destino);
2.1.5.Eliminar_Pieza(ubicación);
2.1.6.Eliminar_Pieza(tipo,color);

2.2.Juego.

2.2.1.Movimiento_Jugador_B(origen,destino);
2.2.2.Movimiento_Jugador_N(origen,destino);
2.2.3.Estado(fich);
2.2.4.Lista_Movimientos();

3.Consideraciones Generales.

3.1.Jaque
3.2.Jaque Mate
3.3.Ahogado
3.4.Cambio de pieza

4.Explicación del Código en C

4.1.Archivos.h
4.1.1 Juego.h
4.1.2 Tablero.h
4.1.2.1 Enumeraciones
4.1.2.2 Estructuras
4.1.2.3 Cabeceras de las funciones
4.2. Archivos.c
4.2.1.Juego.c
4.2.2.Tablero.c
4.2.3.Main.c

5.Explicación del Código en Lex

5.1 Definiciones Regulares

5.2 Zona de Reglas
5.3 Consideraciones
1.Objetivos de la practica
● Se desea crear un analizador léxico para controlar un juego de ajedrez basándonos en
las siguientes directrices fundamentales:

● Partimos de un tablero 8x8 de casillas cuadradas que constituirá nuestro campo de

batalla. La casilla de la esquina inferior izquierda será la (1,1) y la de la esquina superior
derecha la (8,8). Sobre dicho tablero se dispondrán las piezas correspondientes a ambos
jugadores: un máximo de 16 piezas blancas y un máximo de 16 piezas negras.

● El desarrollo del juego de ajedrez tendrá dos partes fundamentales: la que define la
disposición inicial de las piezas y aquella que permite el juego propiamente dicho.

● La orientación del tablero supondrá una ubicación original de las piezas blancas en
las filas (1,c) y (2,c), y una ubicación original de las piezas negras en las filas (7,c) y (8,c)
siendo c una columna cualquiera. La casilla (1,1) será de color negro.

● Inicialmente, el tablero está vacío.

2.Partes del fichero que definirá el juego

El fichero que definirá el juego tendrá dos tipos de regiones fundamentales, que
pueden intercalarse entre sí: tablero y juego. La primera de ellas permitirá definir la
disposición inicial de las piezas en el tablero. La segunda de ellas permitirá desarrollar
el movimiento de las piezas y verificar el estado de la partida.

2.1.Tablero

● Tablero: delimitada por las palabras inicio_tablero y fin_tablero, ambas en el

principio de una línea. Las órdenes posibles a ubicar en esta región serán las siguientes.

2.1.1.Tablero_Aleatorio(num_piezas,tipo_situación);

Crea una disposición inicial en el tablero con num_piezas piezas para cada jugador. La
disposición será la original del ajedrez si tipo_situación toma el valor original o aleatoria si
tipo_situación toma el valor aleatoria. El máximo número de piezas permitido para cada jugador es
de 16: 8 peones, 2 torres, 2 alfiles (1 por color), 2 caballos, 1 rey y 1 reina. El rey es imprescindible.
No se admiten peones blancos en la fila (8,c) ni peones negros en la fila (1,c), siendo c cualquier
columna. El rey no podrá estar en jaque, en cuyo caso se moverá a la casilla más próxima posible
que no viole este supuesto.

2.1.2.Tablero_Aleatorio(num_piezasB,ratioBN,tipo_situacion);

Crea una disposición inicial en el tablero con num_piezasB piezas blancas. Para conocer el
número de piezas negras a disponer se proporciona el ratio ratioBN aproximado entre el número de
piezas blancas y el número de piezas negras. La disposición será la original del ajedrez si
tipo_situacion toma el valor original o aleatoria si tipo_situacion toma el valor aleatoria. El máximo
número de piezas permitido para cada jugador es de 16: 8 peones, 2 torres, 2 alfiles (1 por color), 2
caballos, 1 rey y 1 reina. El rey es imprescindible. No se admiten peones blancos en la fila (8,c) ni
peones negros en la fila (1,c), siendo c cualquier columna. El rey no podrá estar en jaque, en cuyo
caso se moverá a la casilla más próxima posible que no viole este supuesto.
2.1.3.Agregar_Pieza(tipo,color,ubicacion);

Agrega, si es posible, la pieza de tipo tipo y color color en la ubicación ubicacion. La

ubicación no podrá estar ocupada. El máximo número de piezas permitido para cada jugador es de
16: 8 peones, 2 torres, 2 alfiles (1 por color), 2 caballos, 1 rey y 1 reina. No se admiten peones
blancos en la fila (8,c) ni peones negros en la fila (1,c), siendo c cualquier columna. El rey no
podrá estar en jaque, en cuyo caso se moverá tal rey a la casilla más próxima posible que no viole
este supuesto.

2.1.4.Situar_Pieza(origen,destino);

Cambia, si es posible, la pieza ubicada en la casilla origen a la casilla destino. Para el

cambio no se tienen que seguir las reglas de movimientos del ajedrez. El máximo número de piezas
permitido para cada jugador es de 16: 8 peones, 2 torres, 2 alfiles (1 por color), 2 caballos, 1 rey y 1
reina. No se admiten peones blancos en la fila (8,c) ni peones negros en la fila (1,c), siendo c
cualquier columna.

2.1.5.Eliminar_Pieza(ubicacion);

Elimina la pieza ubicada en la casilla ubicación. El rey es imprescindible. El rey no podrá

estar en jaque, en cuyo caso se moverá tal rey a la casilla más próxima posible que no viole este
supuesto

2.1.6.Eliminar_Pieza(tipo,color);

Elimina una pieza de tipo tipo y color color. El rey es imprescindible. El rey no podrá estar
en jaque, en cuyo caso se moverá tal rey a la casilla más próxima posible que no viole este
supuesto.

2.2.Juego.

• Juego: delimitada por las palabras inicio_juego y fin_juego, ambas en el

principio de una línea. Las órdenes posibles a ubicar en esta región serán las siguientes.

2.2.1.Movimiento_Jugador_B(origen,destino);

Mueve, si es posible, la pieza blanca ubicada en la casilla origen a la casilla destino. Si en la

casilla destino hay una pieza negra distinta al rey, tal pieza es capturada. Si la pieza movida es el
rey y es válido el enroque (piezas en su ubicación original, sin haberse movido, ni hay jaque
actualmente o alguna de las casillas por la que pasa el rey está en jaque) se produce enroque. Si el
movimiento supone jaque o jaque-mate para las negras muestra el estado de la partida por pantalla.
Si tras el movimiento el rey blanco se encuentra en jaque, el movimiento sería ilegal.

2.2.2.Movimiento_Jugador_N(origen,destino);

Mueve, si es posible, la pieza negra ubicada en la casilla origen a la casilla destino. Si en la

casilla destino hay una pieza blanca distinta al rey, tal pieza es capturada. Si la pieza movida es el
rey y es válido el enroque (piezas en su ubicación original, sin haberse movido, ni hay jaque
actualmente o alguna de las casillas por la que pasa el rey está en jaque) se produce enroque. Si el
movimiento supone jaque o jaque-mate para las blancas muestra el estado de la partida por pantalla.
Si tras el movimiento el rey negro se encuentra en jaque, el movimiento sería ilegal.
2.2.3.Estado(fich);

Generará un informe de la partida en el fichero de nombre fich.chs (el nombre fich podrá
comenzar por subrayado o letra y puede estar seguido de cualquier número de caracteres
alfanuméricos o subrayados) que contendrá la disposición actual en el tablero de los distintas piezas
y el estado actual de la partida (piezas capturadas por cada oponente y situación de amenaza: jaque,
jaque-mate o ahogado). Si fich es stdout el informe se generará por pantalla.

2.2.4.Lista_Movimientos();

Presenta un informe por pantalla de la lista de movimientos realizados por ambos jugadores
para el último tablero definido.

3.Consideraciones Generales

3.1.Jaque

Se dice que un rey se encuentra en jaque cuando, tras mover el jugador contrario, se ve
amenazado por una pieza contraria. Cuando un rey se encuentra en jaque es necesario evitarlo, si es
posible, en el siguiente movimiento:
a) Moviendo el rey.
b) Capturando la pieza que supone la amenaza.
c) Disponiendo una pieza propia que evite el jaque.

3.2.Jaque Mate

Se dice que un rey se encuentra en jaque-mate cuando, tras mover el jugador

contrario, no le es posible evitar una amenaza previa:
a) No es posible mover el rey a una casilla no amenazada.
b) No es posible capturar la pieza que supone la amenaza.
c) No es posible interponer una pieza propia para evitar la amenaza.

3.3.Ahogado

Se dice que un rey está ahogado cuando, tras mover el jugador contrario, en su
casilla actual no se siente amenazado pero sí en sus posibles movimientos, y las
demás piezas no pueden mover tampoco.

3.4.Cambio de pieza

Si un peón llega a la casilla final: (8,c) para las blancas y (1,c) para las negras,
se cambia por otra pieza cualquiera distinta a sí mismo.
4.Explicación del código en C

4.1.Archivos .h

4.1.1. Juego.h

En este archivo “Juego.h” se incluyen las cabeceras de las funciones utilizadas

en el archivo “Juego.c” que son:

#ifndef JUEGO_H
#define JUEGO_H

int moverBlancas(TABLERO* tablero, int ofila, int oclumna, int dfila, int dcolumna);
int moverNegras(TABLERO* tablero, int ofila, int oclumna, int dfila, int dcolumna);
void estado(TABLERO* tablero,char * fichero);
void imprimirMovimientos(TABLERO *tablero);

int moverPieza(TABLERO* tablero, int ofila, int ocolumna, int dfila, int dcolumna);

int moverPeon(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);

int moverTorre(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverCaballo(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverAlfil(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverDama(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverRey(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int enroque(TABLERO* tablero,int ofila, int ocolumna,int dfila,int dcolumna);
int comerPaso(TABLERO* tablero,int ofila,int ocolumna,int dfila, int dcolumna);
int ahogado(TABLERO *tablero,COLOR color);

void imprimirMovimientos(TABLERO *tablero);

void insertarMovimiento(TABLERO* tablero, int ofila,int ocolumna,int dfila,int dcolumna,int
comido);
LISTA *nuevoElemento();
void borrarLista(TABLERO *tablero);
int jaque(TABLERO* tablero,COLOR color);
int jaqueMate(TABLERO* tablero,COLOR color);

#endif

4.1.2. Tablero.h

En este archivo “Tablero.h” se incluyen junto a las cabeceras de las funciones que se han
utilizado en el archivo “Tablero.c”, la declaración de enumeraciones utilizadas para el COLOR y
TIPO_PIEZA de la ajedrez y tres estructuras que son FICHA y TABLERO y LISTA. Ahora
pasaremos a explicar cada una de estas declaraciones:

4.1.2.1. Enumeraciones

Estos campos han sido creados para definir el COLOR y el TIPO_PIEZA de ajedrez.
 El color se utiliza para distinguir entre piezas blancas y negras y diferenciar en el tablero de
ajedrez las casillas blancas,negras y vacías.

El tipo de pieza se utiliza para distinguir entre los tipos de piezas que existen en el juego de
ajedrez, como son peón,torre,caballo,dama,alfil y rey.
Las enumeraciones son:

typedef enum
{
VACIO=0,BLANCAS, NEGRAS
}COLOR;

typedef enum
{
LIBRE=0,PEON,TORRE,CABALLO,ALFIL,DAMA,REY
}TIPO_PIEZA;

4.1.2.2. Estructuras

Las estructuras que se han empleado son FICHA, TABLERO y LISTA. La estructura
FICHA contiene dos campos que son las dos enumeraciones que creamos anteriormente, ya que así
definimos el tipo de ficha y qué color es.
Por otro lado, la estructura TABLERO posee como campo una matriz de ocho por ocho de
tipo FICHA ( estructura anterior ) que será el tablero de ajedrez, también tiene dos vectores de
fichas de 15 elementos cada uno, donde se almacenarán las piezas comidas blancas o negras, según
el nombre del vector.
La estructura LISTA es creada para la creación de la lista de movimientos.
Las estructuras son:

typedef struct ficha

{
TIPO_PIEZA tipo;
COLOR color;
}FICHA;

typedef struct lista

{
int origen[2];//almacenara la posición original
int destino[2];//almacenara la posición de destino
int comido;
COLOR color;//almacenara el color de quien realiza el movimiento
struct lista *sig;
}LISTA;

typedef struct tablero

{
FICHA t[8][8]; //acceso a posición, t[-(i-8))][j-1];
FICHA blancas[15];//almacenara las fichas blancas muertas, son 15 ya que el rey no se puede
comer
FICHA negras[15];//almacenara las fichas negras muertas
LISTA *movimientos;//almacenara los movimientos de la partida
}TABLERO;
4.1.2.3. Cabeceras de funciones

En el fichero “tablero.c” hemos utilizado una serie de funciones, de las cuales aquí se
encuentran sus cabeceras:

//si disposicion es 0 es el tablero original, si vale 1 ó más se pondrá de forma aleatoria

int tableroAleatorio(TABLERO* tablero,int nPiezas, int disposicion);
int tableroAleatorio2(TABLERO* tablero, int nPiezasB,float ratioBN, int disposicion);
int agregarPieza(TABLERO* tablero, TIPO_PIEZA tipo,COLOR color,int fila,int columna);
int agregarPieza2(TABLERO* tablero, TIPO_PIEZA tipo,COLOR color,int fila,int columna);
int situarPieza(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna); //parametros:
origen fila y columna y destino fila y columna
int eliminarPieza(TABLERO* tablero,int fila,int columna);
int eliminarPieza2(TABLERO* tablero,TIPO_PIEZA tipo,COLOR color);
//funciones auxiliares
void imprimirTablero(TABLERO* tablero);
void imprimirTableroN(TABLERO* tablero);

4.2 Archivos.c
4.2.1. Juego.c

En este archivo encontramos los cuerpos de las cabeceras de las funciones que hemos
comentado en el archivo “juego.h”. En esta parte, encontramos funciones de movimiento de pieza
como son:

int moverPieza(TABLERO* tablero, int ofila, int ocolumna, int dfila, int dcolumna);
int moverPeon(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverTorre(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverCaballo(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverAlfil(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverDama(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverRey(TABLERO* tablero,int ofila,int ocolumna,int dfila,int dcolumna);
int moverBlancas(TABLERO* tablero, int ofila, int oclumna, int dfila, int dcolumna);
int moverNegras(TABLERO* tablero, int ofila, int oclumna, int dfila, int dcolumna);

A estas funciones se les pasan los siguientes parámetros, que son:

● TABLERO: matriz 8x8 de la cual hablamos anteriormente.

● Ofila: la fila en la que se encuentra la pieza que deseamos mover.
● Ocolumna: la columna en la que se encuentra la pieza que deseamos mover
● Dfila: la fila de la casilla de destino a la que deseamos mover la pieza.
● Dcolumna: la columna de la casilla de destino a la que deseamos mover la pieza.

También cabe destacar la existencia de las funciones:

int enroque(TABLERO* tablero,int ofila, int ocolumna,int dfila,int dcolumna);

int comerPaso(TABLERO* tablero,int ofila,int ocolumna,int dfila, int dcolumna);
int ahogado(TABLERO *tablero,COLOR color);
int jaque(TABLERO* tablero,COLOR color);
int jaqueMate(TABLERO* tablero,COLOR color);
 Estas funciones tienen los movimientos especiales, como enroque, comer al paso, y algunas
consideraciones como si se da jaque al color pasado, si está ahogado o si se da jaque mate.

También encontramos las funciones siguientes, que son funciones dedicadas al estado de la
partida y la lista de movimientos, es decir, toda la información que se pueda dar de la partida a los
jugadores.

void estado(TABLERO* tablero,char * fichero);

void imprimirMovimientos(TABLERO *tablero);
void insertarMovimiento(TABLERO* tablero, int ofila,int ocolumna,int dfila,int dcolumna,int
comido);
LISTA *nuevoElemento();
void borrarLista(TABLERO *tablero);

Ahora pasaremos ha comentar profundamente cada una de las funciones:

4.2.1.1 moverPeon

Como su propio nombre indica, tiene la misión de realizar el movimiento de un Peón. Si la

función consigue realizar su cometido, devolverá un 1 y en caso contrario devuelve un 0.
A su vez, la función no sólo debe cumplir la misión de movimiento de peón, debe mirar que no
exista una pieza entre su movimiento, puesto que si existe debe comerla. También debe mirar que si
el peón no se ha movido ninguna vez, puede realizar un movimiento de dos casillas hacia adelante.
Otra cosa que debe realizar, es que si el peón llega a la última fila del tablero, éste puede
“coronarse”, es decir, puede transformarse en otra pieza distinta del rey. Por último, si un peón
contrario avanza dos pasos (a la salida de su posición de origen) y se pone al lado de otro peón de
color contrario, puede comer al paso, con su movimiento de comer normal, por la casilla que
debiera haber pasado el peón movido, esto solo puede hacerse cuando es el movimiento instantáneo
al de mover dos casillas.

4.2.1.2. moverTorre

Esta función es más simple que la de moverPeon, puesto que en esta sólo se debe realizar el
movimiento de la Torre, que es en horizontal o vertical. Esta función a su vez debe realizar la
comida de piezas que se encuentren en su camino,comprobar que no hay piezas en su
camino,puesto que no las puede saltar.

4.2.1.3 moverCaballo

Esta función realiza el movimiento del caballo, en el cual tiene de especial que no importa
que existan piezas en su trayectoria puesto que podrá saltarlas y llegar a la casilla de destino. Se ha
implementado haciendo que se pueda mover una fila y dos columnas o viceversa.

4.2.1.4. moverAlfil

Esta función realiza el movimiento de la pieza ALFIL, la cual se mueve aumentando o

disminuyendo filas y columnas a la vez, es decir la casilla destino sera la casilla origen mas una fila
y una columna o menos una fila y una columna. Esta pieza no podrá saltar a otras piezas que se
encuentre en su camino.
4.2.1.5. moverDama

Esta función tiene como misión mover la pieza DAMA al lugar donde el usuario elija,
siempre comprobando que ese movimiento esta permitido, que no haya otra pieza en el lugar en el
que se desea mover..etc. El movimiento de la dama es como si uniéramos el movimiento de la pieza
TORRE y ALFIL, es decir, horizontal, vertical y en diagonal.

4.2.1.6. moverRey

La función moverRey realiza el movimiento de la ficha REY de una casilla a otra. Esta
función es de las mas simples, puesto que solo se realiza el movimiento de la pieza, y cuándo no se
ha movido se puede enrocar y mover dos posiciones.

4.2.1.7. moverPieza

Esta función la utilizamos para generalizar el movimiento, es decir, que cuando el usuario
elija una casilla donde halla una pieza para mover, esta función detecte esa pieza, llame a su función
correspondiente ( Ejem: si es un Peón llame a moverPeon ) y realice el movimiento. También tiene
como misión detectar que no mueve a una casilla donde exista una pieza de su mismo color y que
no se selecciona para mover una casilla en la que no existe una pieza, y que al mover dicha pieza el
rey propio no quede en jaque.

4.2.1.8. Enroque

El enroque consiste en mover simultáneamente el rey y la torre del mismo bando. Para ellos
creamos un tablero auxiliar y trabajamos sobre él para realizar sobre el las diferentes
comprobaciones.
TABLERO aux=*tablero;
Comprueba si se ha movido el rey y/o las torres con las que se va a enrocar y si se cumplen las
condiciones para enrocarse se enroca el rey.

4.2.1.9. Comer Paso

Esta función come al paso a otro peón, su comprobación si se puede comer al paso o no se
hace en la función moverPeon.

4.2.1.10. Ahogado

En la función ahogado lo que comprobamos es que no podemos mover ninguna pieza, ya

que si podemos mover alguna el rey ya no está ahogado. Para ello, buscamos los diferentes tipos de
piezas y llamamos a la función moverPieza en un tablero auxiliar, la cual tiene como misión realizar
el movimiento de la pieza. Si esta función se lleva a cabo, quiere decir que el color no se encuentra
ahogado, mientras que si la función no se lleva a cabo en ningún tipo de pieza se dice que está
“ahogado”..

4.2.1.11. Jaque

La función jaque devolverá el número de piezas que lo hacen estar en jaque. Para ello
vamos comprobando alrededor de la casilla de donde esta situado el rey si hay alguna pieza de color
contrario que pueda comer al rey. Comprobamos en horizontal y vertical, en las cuales las únicas
piezas que ponen en peligro al rey serían las damas y las torres. Comprobamos en diagonal, en las
cuales las únicas piezas que lo ponen en peligro son los peones, alfiles y damas. Comprobamos los
caballos respecto a la posición del rey para ver si existe un caballo de color contrario al rey que
pueda comer al rey. En cada comprobación, si se cumple que ponen en jaque al rey, se va
incrementando la variable “jaque” la cual se devolverá dando el número de piezas que dan jaque.

4.2.1.12. Jaque Mate

Esta función es muy parecida a la anterior, solamente que en esta comprobamos que el rey
esta en jaque y no se puede librar de el. Para comprobar que no se puede librar de el, hay que mirar
que no existe ninguna pieza que se pueda comer a la pieza que le da jaque al rey, ni que el rey se
pueda desplazar para librarse del jaque, ni que se pueda interponer una pieza entre el movimiento de
la pieza que da jaque al rey.

4.2.1.13. Estado

Esta función realiza una copia a un fichero de como se encuentra la partida en ese momento.
En el fichero informara de lo siguiente:
● Piezas Blancas y Negras comidas.
● Si se produce en el momento actual jaque a algún rey.
● Si se produce en el momento actual jaque-mate a algún color.
● Si se produce en el momento actual ahogamiento a algún color.

4.2.1.14. Imprimir Movimientos

Esta función sólo realiza la muestra por pantalla de los movimientos que realizan las piezas
blancas y negras, muestran la casilla de origen y la casilla destino.

4.2.1.15. Insertar Movimiento

Esta función tiene como misión el insertar un movimiento en la lista de movimientos creada
anteriormente.

4.2.1.16. Borrar Lista

La función de BorrarLista comprueba que la lista no esta vacía, y si es así la borra.

4.2.2. Tablero.c

En este archivo encontramos los cuerpos de las funciones cuyas cabeceras colocamos en
“tablero.h”.
4.2.2.1 Imprimir Tablero

El acceso a tablero en dos bucles, t[-(i-8)][j-1]; solo para cuando i y j son introducidas por el
usuario, sino se recorrerá como una matriz normal de C .
Para imprimir el tablero se recorre “tablero” con ds bucles for y se va comprobando que
cuando haya una pieza, por ejemplo peón se imprima una P. Para distinguir las piezas blancas de las
negras se imprimirá la letra con dos asteriscos, ejemplo * P *.
4.2.2.2 Imprimir TableroN

Esta función hace exactamente lo mismo que la anterior solo que le da la vuelta al tablero
para que el jugador de piezas negras pueda visualizar mejor el tablero.

4.2.2. 3 Tablero Aleatorio

Crea una disposición inicial en el tablero con num_piezas piezas para cada jugador. La
disposición será la original del ajedrez si tipo_situacion toma el valor original o aleatoria si
tipo_situacion toma el valor aleatoria. El máximo número de piezas permitido para cada jugador es
de 16: 8 peones, 2 torres, 2 alfiles (1 por color), 2 caballos, 1 rey y 1 reina. El rey es imprescindible.
No se admiten peones en las fila (8,c) ni en (1,c), siendo c cualquier columna. Las piezas se
introducirán sin dar jaque a los reyes.

4.2.2.4 Tablero Aleatorio2

Crea una disposición inicial en el tablero con num_piezasB piezas blancas. Para conocer el
número de piezas negras a disponer se proporciona el ratio ratioBN aproximado entre el número de
piezas blancas y el número de piezas negras. La disposición será la original del ajedrez si
tipo_situación toma el cero o aleatoria si tipo_situación toma otro valor. El máximo número de
piezas permitido para cada jugador es de 16: 8 peones, 2 torres, 2 alfiles (1 por color), 2 caballos, 1
rey y 1 reina. El rey es imprescindible. No se admiten en las filas (8,c) y (1,c), siendo c cualquier
columna. Las piezas se introducirán sin dar jaque a los reyes.

4.2.2.5 Agregar Pieza

Esta función tiene como misión agregar un tipo de pieza al tablero donde el usuario elija. El
usuario decide el tipo de pieza, el color y la casilla en la que desea insertar la pieza. Para ello le
pasamos a la función el tablero, el tipo de pieza, el color, la fila de la casilla a insertar y la columna.
Esta función antes de insertar la pieza, comprueba que se puede introducir, mirando que no va a
rebasar el máximo de piezas sobre el tablero, que no puede haber mas de un rey del mismo
color...etc.
Cabe destacar de esta función, que si al agregar la pieza el rey queda en jaque la agrega, ya
que luego la usaremos para moverPieza, donde se puede dar jaque a los reyes y/o comer piezas.

4.2.2.6 Agregar Pieza2

Esta función es exactamente igual que la anterior, solamente que no importa que el rey
quede en jaque al introducir la pieza.

4.2.2.7 Situar Pieza

Esta función realiza el movimiento de las piezas sin seguir las reglas del ajedrez, es decir, podemos
mover las piezas como deseemos que no tendremos ninguna restricción. Es una función similar a
moverPieza solo que moverPieza sigue las reglas del ajedrez.
4.2.2.8 Eliminar Pieza

Esta función consiste en eliminar una determinada pieza elegida por el usuario del tablero. En la
función, trabajamos en un tablero auxiliar para comprobar que al eliminar la pieza el rey no quede
en jaque.

5.Explicación del código en Lex

Antes de nada cabe destacar que para pasar un carácter numérico en ASCII a un número
real/entero, hemos restado 48, que es la diferencia que hay entre el valor real del número y su
correspondiente carácter ASCII.

5.1. Definiciones Regulares

Las definiciones regulares siguientes significan que los nombres de la izquierda pueden tomar los
valores de la derecha:

espacio [ \t\n]
Tabulador y salto de linea
espacios {espacio}+
Sucesión de espacios
fila [1-8]
El valor fila puede tomar desde 1 a 8 ambos incluidos
columna [1-8]
El valor columna puede tomar desde 1 a 8 ambos incluidos
dígito [0-9]
El valor dígito toma desde 0 a 9 ambos incluidos
letra [a-zA-Z]
Letra toma valor de la 'a' a la 'z' incluido en mayúsculas
carácter ["_""-""!""#""%""¡""+""*"]
Carácter puede tomar los siguientes caracteres (-_!#%¡+*)
alfanumérico {letra}|{dígito}|{carácter}|\_
Alfanumérico puede tomar el valor de letra,dígito o carácter.
Ratio [01]+\.[0-9]*
Valores comprendidos entre 0 y 1.99, solo se usaran dos decimales
numeroPiezas 1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16
numeroPiezas puede ser 1 o 2 o 3...o 16.
casilla {espacios}*\[{espacios}*{fila}{espacios}*\,
{espacios}*{columna}{espacios}*\]{espacios}*
color BLANCAS|NEGRAS
El color puede ser blancas o negras
disposicion original|aleatoria|ORIGINAL|ALEATORIA|aleatorio|ALEATORIO
La disposición puede tomar los valores que hay a derecha, “original”, “aleatoria”,
“ORIGINAL”, “ALEATORIA”, “aleatorio” y “ALEATORIO”.
tipo PEON|TORRE|CABALLO|ALFIL|DAMA|REY
Tipo define el tipo de ficha y pueden ser PEON, TORRE, CABALLO...
fichero (\_|{letra})({alfanumerico}*)
El fichero puede comenzar por subrayado o letra y luego cualquier número de
caracteres alfanuméricos.

5.2. Zona de Reglas

TABLERO_ALEATORIO"("{numeroPiezas}","{disposición}")"

La regla tablero_aleatorio se llevara a cabo cuando se encuentre la siguiente

cadena TABLERO_ALEATORIO(numeroPiezas,disposición) donde numeroPiezas y
disposición son definiciones regulares que solo pueden tomar los valores que
anteriormente definidos.

TABLERO_ALEATORIO"("{numeroPiezas}","{ratio}","{disposición}")"

La regla tablero_aleatorio se llevara a cabo cuando se encuentre la siguiente

cadena TABLERO_ALEATORIO(numeroPiezas,ratio,disposición) donde
numeroPiezas, ratio y disposición son definiciones regulares que solo pueden tomar
los valores que anteriormente definidos.

AGREGAR_PIEZA"("{tipo}","{color}","{casilla}")"

La regla agregar_pieza se llevara a cabo cuando se encuentre la siguiente

cadena AGREGAR_PIEZA(tipo,color,casilla) donde tipo, color y casilla son
definiciones regulares que solo pueden tomar los valores anteriormente comentados.

SITUAR_PIEZA"("{casilla}","{casilla}")"

La regla SITUAR_PIEZA se llevara a cabo cuando se encuentre la siguiente

cadena SITUAR_PIEZA(casilla,casilla) donde casilla es una definición regular que
tomara valores definidos anteriormente.

ELIMINAR_PIEZA"("{casilla}")"

La regla eliminar_pieza se llevara a cabo cuando se encuentre la siguiente

cadena ELIMINAR_PIEZA(casilla) donde casilla es una definición regular que
tomara los valores definidos anteriormente para eliminar la pieza.

ELIMINAR_PIEZA"("{tipo}","{color}")"

La regla eliminar_pieza se llevara a cabo cuando se encuentre la siguiente

cadena ELIMINAR_PIEZA(tipo,color) donde tipo y color son definiciones regulares
que tomaran valores definidos anteriormente para eliminar la pieza por tipo y color.
MOVIMIENTO_JUGADOR_B"("{casilla}","{casilla}")"

La regla movimiento_jugador_B se llevara a cabo cuando se encuentre la

siguiente cadena MOVIMIENTO_JUGADOR_B(casilla,casilla) donde casilla es una
definición regular que tomara un valor definido anteriormente para realizar el
movimiento del jugador. La primera es la casilla origen, y la segunda el destino.

MOVIMIENTO_JUGADOR_N"("{casilla}","{casilla}")"

La regla movimiento_jugador_N se llevara a cabo cuando se encuentre la

siguiente cadena MOVIMIENTO_JUGADOR_N(casilla,casilla) donde casilla es una
definición regular que tomara un valor definido anteriormente para realizar el
movimiento del jugador. La primera es la casilla origen, y la segunda el destino.

ESTADO"("{fichero}")"

La regla estado se llevara a cabo cuando se encuentre la siguiente cadena

ESTADO(fichero) donde fichero es una definición regular que tomara el valor
definido anteriormente.

LISTA_MOVIMIENTOS"("")"

La regla lista_movimientos se llevará a cabo cuando se encuentre la siguiente

cadena LISTA_MOVIMIENTOS(), y generará una lista con movimientos realizados.

^ver_tableroB

El ^ indica que va al comienzo de línea, y al poner ver_tableroB al comienzo

de línea, se imprimirá el tablero visto desde la parte de las blancas.

^ver_tableroN

El ^ indica que va al comienzo de línea, y al poner ver_tableroN al comienzo

de línea, se imprimirá el tablero visto desde la parte de las negras.

^inicio_tablero

Indica que se pueden usar las funciones que dependen del tablero.
^fin_tablero

Indica que se dejan de poder usar las funciones que dependen del
tablero.
^inicio_juego

Indica que se pueden usar las funciones del juego.

^fin_juego

Indica que se dejan de poder usar las funciones que dependen del
tablero.

5.3 Consideraciones

● Las casillas se introducirán entre corchetes, por ejemplo: la casilla cuya fila es
2 y columna 3, se pondrá de la siguiente manera: [2,3].
● Las reglas se podrán poner tanto en mayúsculas como en minúsculas ya que se
compila con la opción -i.
● Las definiciones regulares siempre tienen que conservar su nomenclatura de
mayúsculas y minúsculas.
● No se pueden poner espacios en las reglas, ya que no las cumplirían.