73. Inteligencia Artificial (2). Analizando el motor del juego de Ajedrez
- En este capítulo del curso de programación en c# con visual studio 2017 vamos a continuar con nuestra serie de entradas relacionadas con un tema de moda: la inteligencia artificial. En este capítulo del curso empezamos a analizar el motor del juego. Desgranaremos el funcionamiento de algunas de las clases que controlan los movimientos de nuestro ajedrez.
- En concreto en esta entrada vemos el funcionamiento de las clases: Cuadrado.cs, Movimiento.cs ,Pieza.cs y MovimientoPieza.cs. Antes de dejaros con el video en el que vemos el funcionamiento de estas clases, es importante tener claro la manera en que representamos el tablero de forma interna. El tablero no será otra cosa que una matriz de 8x8:
En el video podemos ver brevemente el funcionamiento de las clase anteriormente nombradas:
Como acostumbro os dejo el código de cada una de las clases mencionadas en el vídeo:
- Cuadrado.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AjedrezIA.Motor
{
class Cuadrado
{
internal Pieza pieza;
#region Constructors
internal Cuadrado(){ }
internal Cuadrado(Pieza pieza)
{
this.pieza = new Pieza(pieza);
}
#endregion
}
}
- Movimiento.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AjedrezIA.Motor
{
public struct MovimientoPieza
{
public byte posicionDestino;
public bool movio;
public ColorPieza colorPieza;
public TipoPiezaAjedrez tipoPieza;
public byte posicionOrigen;
public MovimientoPieza(ColorPieza colorpieza, TipoPiezaAjedrez tippopieza, bool Movio, byte posOrigen, byte posDestino)
{
colorPieza = colorpieza;
tipoPieza = tippopieza;
posicionOrigen = posOrigen;
posicionDestino = posDestino;
movio = Movio;
}
public MovimientoPieza(MovimientoPieza movPieza)
{
colorPieza = movPieza.colorPieza;
tipoPieza = movPieza.tipoPieza;
posicionOrigen = movPieza.posicionOrigen;
posicionDestino = movPieza.posicionDestino;
movio = movPieza.movio;
}
public MovimientoPieza(TipoPiezaAjedrez tipoPieza)
{
this.tipoPieza = tipoPieza;
colorPieza = ColorPieza.Blanco;
posicionOrigen = 0;
posicionDestino = 0;
movio = false;
}
}
public struct PiezaComida
{
public bool movio;
public ColorPieza colorPieza;
public TipoPiezaAjedrez tipoPieza;
public byte posicion;
public PiezaComida(ColorPieza colorpieza, TipoPiezaAjedrez tipopieza, bool Movio,byte pos)
{
colorPieza = colorpieza;
tipoPieza = tipopieza;
posicion = pos;
movio = Movio;
}
public PiezaComida(TipoPiezaAjedrez tipopieza)
{
colorPieza = ColorPieza.Blanco;
tipoPieza = tipopieza;
posicion = 0;
movio = false;
}
}
public sealed class Movimiento
{
public bool capturaAlPasoOcurrio;
public MovimientoPieza moviendoPiezaPrincipal;
public MovimientoPieza moviendoPiezaSecundaria;
public bool peonPromocionado;
public PiezaComida piezaComida;
public Movimiento()
{
moviendoPiezaPrincipal = new MovimientoPieza(TipoPiezaAjedrez.Ninguna);
moviendoPiezaSecundaria = new MovimientoPieza(TipoPiezaAjedrez.Ninguna);
piezaComida = new PiezaComida(TipoPiezaAjedrez.Ninguna);
}
public Movimiento(Movimiento movimiento)
{
moviendoPiezaPrincipal = new MovimientoPieza(movimiento.moviendoPiezaPrincipal);
moviendoPiezaSecundaria = new MovimientoPieza(movimiento.moviendoPiezaSecundaria);
piezaComida = new PiezaComida(movimiento.piezaComida.colorPieza,movimiento.piezaComida.tipoPieza,movimiento.piezaComida.movio,movimiento.piezaComida.posicion);
capturaAlPasoOcurrio = movimiento.capturaAlPasoOcurrio;
peonPromocionado = movimiento.peonPromocionado;
}
public Movimiento(string movimiento) : this()
{
int columnaOrigen = -1;
bool comentario = false;
bool origenEncontrado = false;
if (movimiento.Contains("=Q"))
peonPromocionado = true;
foreach (char c in movimiento)
{
if (c == '{')
{
comentario = true;
continue;
}
if (c == '}')
{
comentario = false;
continue;
}
if (comentario)
continue;
if (moviendoPiezaPrincipal.tipoPieza == TipoPiezaAjedrez.Ninguna)
{
//Dame tipo pieza
moviendoPiezaPrincipal.tipoPieza = dameTipoPieza(c);
if (moviendoPiezaPrincipal.tipoPieza == TipoPiezaAjedrez.Ninguna)
{
moviendoPiezaPrincipal.tipoPieza = TipoPiezaAjedrez.Peon;
columnaOrigen = dameNumeroColumna(c);
}
continue;
}
if (columnaOrigen < 0)
{
columnaOrigen = dameNumeroColumna(c);
continue;
}
if (columnaOrigen >= 0)
{
int filaOrigen = int.Parse(c.ToString());
if (!origenEncontrado)
{
moviendoPiezaPrincipal.posicionOrigen = damePosicionTablero(columnaOrigen, 8 - filaOrigen);
origenEncontrado = true;
}
else
{
moviendoPiezaPrincipal.posicionDestino = damePosicionTablero(columnaOrigen, 8 - filaOrigen);
}
columnaOrigen = -1;
continue;
}
}
}
public new string ToString()
{
string valor = "";
var colOrigen = (byte)(moviendoPiezaPrincipal.posicionOrigen % 8);
var filaOrigen = (byte)(8 - (moviendoPiezaPrincipal.posicionOrigen / 8));
var colDestino = (byte)(moviendoPiezaPrincipal.posicionDestino % 8);
var filaDestino = (byte)(8 - (moviendoPiezaPrincipal.posicionDestino / 8));
if (moviendoPiezaSecundaria.tipoPieza == TipoPiezaAjedrez.Torre)
{
if (moviendoPiezaSecundaria.colorPieza == ColorPieza.Negro)
{
if (moviendoPiezaSecundaria.posicionOrigen == 7)
{
valor += "O-O";
}
else if (moviendoPiezaSecundaria.posicionOrigen == 0)
{
valor += "O-O-O";
}
}
else if (moviendoPiezaSecundaria.colorPieza == ColorPieza.Blanco)
{
if (moviendoPiezaSecundaria.posicionOrigen == 63)
{
valor += "O-O";
}
else if (moviendoPiezaSecundaria.posicionOrigen == 56)
{
valor += "O-O-O";
}
}
}
else
{
valor += damePiezaSemueve(moviendoPiezaPrincipal.tipoPieza);
switch (moviendoPiezaPrincipal.tipoPieza)
{
case TipoPiezaAjedrez.Caballo:
valor += dameLetraColumna(colOrigen);
valor += filaOrigen;
break;
case TipoPiezaAjedrez.Torre:
valor += dameLetraColumna(colOrigen);
valor += filaOrigen;
break;
case TipoPiezaAjedrez.Peon:
if (colOrigen != colDestino)
{
valor += dameLetraColumna(colOrigen);
}
break;
}
if (piezaComida.tipoPieza != TipoPiezaAjedrez.Ninguna)
{
valor += "x";
}
valor += dameLetraColumna(colDestino);
valor += filaDestino;
if (peonPromocionado)
{
valor += "=Q";
}
}
return valor;
}
private static byte damePosicionTablero(int columna, int fila)
{
return (byte)(columna + (fila * 8));
}
private static string dameLetraColumna(int columna)
{
switch (columna)
{
case 0:
return "a";
case 1:
return "b";
case 2:
return "c";
case 3:
return "d";
case 4:
return "e";
case 5:
return "f";
case 6:
return "g";
case 7:
return "h";
default:
return "Desconocida";
}
}
private static int dameNumeroColumna(char columna)
{
switch (columna)
{
case 'a':
return 0;
case 'b':
return 1;
case 'c':
return 2;
case 'd':
return 3;
case 'e':
return 4;
case 'f':
return 5;
case 'g':
return 6;
case 'h':
return 7;
default:
return -1;
}
}
private static TipoPiezaAjedrez dameTipoPieza(char c)
{
switch (c)
{
case 'B':
return TipoPiezaAjedrez.Alfil;
case 'K':
return TipoPiezaAjedrez.Rey;
case 'N':
return TipoPiezaAjedrez.Caballo;
case 'Q':
return TipoPiezaAjedrez.Reina;
case 'R':
return TipoPiezaAjedrez.Torre;
default:
return TipoPiezaAjedrez.Ninguna;
}
}
private static string damePiezaSemueve(TipoPiezaAjedrez tipoPieza)
{
switch (tipoPieza)
{
case TipoPiezaAjedrez.Alfil:
return "B";
case TipoPiezaAjedrez.Rey:
return "K";
case TipoPiezaAjedrez.Caballo:
return "N";
case TipoPiezaAjedrez.Reina:
return "Q";
case TipoPiezaAjedrez.Torre:
return "R";
default:
return "";
}
}
}
}
- Pieza.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AjedrezIA.Motor
{
#region Enumerados
#region colorPiezas enum
public enum ColorPieza
{
Blanco,
Negro
}
#endregion
#region tipoPieza enum
public enum TipoPiezaAjedrez
{
Rey,
Reina,
Torre,
Alfil,
Caballo,
Peon,
Ninguna
}
#endregion
#endregion
internal sealed class Pieza
{
#region InternalMembers
internal ColorPieza colorPieza;
internal TipoPiezaAjedrez tipoPieza;
internal short valorPieza;
internal short valorAccionPieza;
internal short valorAtaque;
internal short valorDefensa;
internal int ultimoMovimiento;
internal bool Movida;
internal bool Seleccionada;
internal Stack<byte> movimientosValidos;
#endregion
#region Constructors
internal Pieza(Pieza pieza)
{
colorPieza = pieza.colorPieza;
tipoPieza = pieza.tipoPieza;
Movida = pieza.Movida;
valorPieza = pieza.valorPieza;
valorAccionPieza = pieza.valorAccionPieza;
if (pieza.movimientosValidos != null)
ultimoMovimiento = pieza.movimientosValidos.Count;
}
internal Pieza(TipoPiezaAjedrez tipoPieza, ColorPieza colorPieza)
{
this.tipoPieza = tipoPieza;
this.colorPieza = colorPieza;
if (this.tipoPieza == TipoPiezaAjedrez.Peon || this.tipoPieza == TipoPiezaAjedrez.Caballo)
{
ultimoMovimiento = 2;
}
else
{
ultimoMovimiento = 0;
}
movimientosValidos = new Stack<byte>(ultimoMovimiento);
valorPieza = calcularValorPieza(this.tipoPieza);
valorAccionPieza = calcularValorAccionPieza(this.tipoPieza);
}
#endregion
#region internal
internal static string dameLetraPieza(TipoPiezaAjedrez tipoPieza)
{
switch (tipoPieza)
{
case TipoPiezaAjedrez.Peon:
return "P";
case TipoPiezaAjedrez.Caballo:
return "N";
case TipoPiezaAjedrez.Alfil:
return "B";
case TipoPiezaAjedrez.Torre:
return "R";
case TipoPiezaAjedrez.Reina:
return "Q";
case TipoPiezaAjedrez.Rey:
return "K";
default:
return "P";
}
}
#endregion
#region Metodos Privados
private static short calcularValorPieza(TipoPiezaAjedrez tipoPieza)
{
switch (tipoPieza)
{
case TipoPiezaAjedrez.Peon:
return 100;
case TipoPiezaAjedrez.Caballo:
return 320;
case TipoPiezaAjedrez.Alfil:
return 325;
case TipoPiezaAjedrez.Torre:
return 500;
case TipoPiezaAjedrez.Reina:
return 975;
case TipoPiezaAjedrez.Rey:
return 32767;
default:
return 0;
}
}
private static short calcularValorAccionPieza(TipoPiezaAjedrez tipoPieza)
{
switch (tipoPieza)
{
case TipoPiezaAjedrez.Peon:
return 6;
case TipoPiezaAjedrez.Caballo:
return 3;
case TipoPiezaAjedrez.Alfil:
return 3;
case TipoPiezaAjedrez.Torre:
return 2;
case TipoPiezaAjedrez.Reina:
return 1;
case TipoPiezaAjedrez.Rey:
return 1;
default:
return 0;
}
}
#endregion
}
}
- MovimientoPieza.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AjedrezIA.Motor
{
internal struct AsignarMovimientoPieza
{
internal readonly List<byte> Movimientos;
internal AsignarMovimientoPieza(List<byte> movimientos)
{
Movimientos = movimientos;
}
}
internal struct MovimientoArrays
{
internal static AsignarMovimientoPieza[] AlfilMovimientos1;
internal static byte[] AlfilTotalMovimientos1;
internal static AsignarMovimientoPieza[] AlfilMovimientos2;
internal static byte[] AlfilTotalMovimientos2;
internal static AsignarMovimientoPieza[] AlfilMovimientos3;
internal static byte[] AlfilTotalMovimientos3;
internal static AsignarMovimientoPieza[] AlfilMovimientos4;
internal static byte[] AlfilTotalMovimientos4;
internal static AsignarMovimientoPieza[] peonNegroMovimientos;
internal static byte[] peonNegroTotalMovimientos;
internal static AsignarMovimientoPieza[] peonBlancoMovimientos;
internal static byte[] peonBlancoTotalMovimientos;
internal static AsignarMovimientoPieza[] caballoMovimientos;
internal static byte[] caballoTotalMovimientos;
internal static AsignarMovimientoPieza[] ReinaMovimientos1;
internal static byte[] ReinaTotalMovimientos1;
internal static AsignarMovimientoPieza[] ReinaMovimientos2;
internal static byte[] ReinaTotalMovimientos2;
internal static AsignarMovimientoPieza[] ReinaMovimientos3;
internal static byte[] ReinaTotalMovimientos3;
internal static AsignarMovimientoPieza[] ReinaMovimientos4;
internal static byte[] ReinaTotalMovimientos4;
internal static AsignarMovimientoPieza[] ReinaMovimientos5;
internal static byte[] ReinaTotalMovimientos5;
internal static AsignarMovimientoPieza[] ReinaMovimientos6;
internal static byte[] ReinaTotalMovimientos6;
internal static AsignarMovimientoPieza[] ReinaMovimientos7;
internal static byte[] ReinaTotalMovimientos7;
internal static AsignarMovimientoPieza[] ReinaMovimientos8;
internal static byte[] ReinaTotalMovimientos8;
internal static AsignarMovimientoPieza[] TorreMovimientos1;
internal static byte[] TorreTotalMovimientos1;
internal static AsignarMovimientoPieza[] TorreMovimientos2;
internal static byte[] TorreTotalMovimientos2;
internal static AsignarMovimientoPieza[] TorreMovimientos3;
internal static byte[] TorreTotalMovimientos3;
internal static AsignarMovimientoPieza[] TorreMovimientos4;
internal static byte[] TorreTotalMovimientos4;
internal static AsignarMovimientoPieza[] ReyMovimientos;
internal static byte[] ReytotalMovimientos;
}
internal static class MovimientoPiezas
{
private static byte Posicion(byte columna, byte fila)
{
return (byte)(columna + (fila * 8));
}
#region Iniciliazar Metodos Movimientos
internal static void IniciarMovimientoPieza()
{
MovimientoArrays.peonBlancoMovimientos = new AsignarMovimientoPieza[64];
MovimientoArrays.peonBlancoTotalMovimientos = new byte[64];
MovimientoArrays.peonNegroMovimientos = new AsignarMovimientoPieza[64];
MovimientoArrays.peonNegroTotalMovimientos = new byte[64];
MovimientoArrays.caballoMovimientos = new AsignarMovimientoPieza[64];
MovimientoArrays.caballoTotalMovimientos = new byte[64];
MovimientoArrays.AlfilMovimientos1 = new AsignarMovimientoPieza[64];
MovimientoArrays.AlfilTotalMovimientos1 = new byte[64];
MovimientoArrays.AlfilMovimientos2 = new AsignarMovimientoPieza[64];
MovimientoArrays.AlfilTotalMovimientos2 = new byte[64];
MovimientoArrays.AlfilMovimientos3 = new AsignarMovimientoPieza[64];
MovimientoArrays.AlfilTotalMovimientos3 = new byte[64];
MovimientoArrays.AlfilMovimientos4 = new AsignarMovimientoPieza[64];
MovimientoArrays.AlfilTotalMovimientos4 = new byte[64];
MovimientoArrays.TorreMovimientos1 = new AsignarMovimientoPieza[64];
MovimientoArrays.TorreTotalMovimientos1 = new byte[64];
MovimientoArrays.TorreMovimientos2 = new AsignarMovimientoPieza[64];
MovimientoArrays.TorreTotalMovimientos2 = new byte[64];
MovimientoArrays.TorreMovimientos3 = new AsignarMovimientoPieza[64];
MovimientoArrays.TorreTotalMovimientos3 = new byte[64];
MovimientoArrays.TorreMovimientos4 = new AsignarMovimientoPieza[64];
MovimientoArrays.TorreTotalMovimientos4 = new byte[64];
MovimientoArrays.ReinaMovimientos1 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos1 = new byte[64];
MovimientoArrays.ReinaMovimientos2 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos2 = new byte[64];
MovimientoArrays.ReinaMovimientos3 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos3 = new byte[64];
MovimientoArrays.ReinaMovimientos4 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos4 = new byte[64];
MovimientoArrays.ReinaMovimientos5 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos5 = new byte[64];
MovimientoArrays.ReinaMovimientos6 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos6 = new byte[64];
MovimientoArrays.ReinaMovimientos7 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos7 = new byte[64];
MovimientoArrays.ReinaMovimientos8 = new AsignarMovimientoPieza[64];
MovimientoArrays.ReinaTotalMovimientos8 = new byte[64];
MovimientoArrays.ReyMovimientos = new AsignarMovimientoPieza[64];
MovimientoArrays.ReytotalMovimientos = new byte[64];
asignarMovimientoPeonBlanco();
asignarMovimientoPeonNegro();
asignarMovimientoCaballo();
asignarMovimientoAlfil();
asignarMovimientosTorre();
asginarMovimientosReina();
asignarMovimientoRey();
}
private static void asignarMovimientoPeonNegro()
{
for (byte posicion = 8; posicion <= 55; posicion++)
{
var asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
byte x = (byte)(posicion % 8);
byte y = (byte)((posicion / 8));
//Matar en diagonal
if (y < 7 && x < 7)
{
asignarMovimiento.Movimientos.Add((byte)(posicion + 8 + 1));
MovimientoArrays.peonNegroTotalMovimientos[posicion]++;
}
if (x > 0 && y < 7)
{
asignarMovimiento.Movimientos.Add((byte)(posicion + 8 - 1));
MovimientoArrays.peonNegroTotalMovimientos[posicion]++;
}
//uno hacia delante
asignarMovimiento.Movimientos.Add((byte)(posicion + 8));
MovimientoArrays.peonNegroTotalMovimientos[posicion]++;
//Desde posicion inicial movemos dos
if (y == 1)
{
asignarMovimiento.Movimientos.Add((byte)(posicion + 16));
MovimientoArrays.peonNegroTotalMovimientos[posicion]++;
}
MovimientoArrays.peonNegroMovimientos[posicion] = asignarMovimiento;
}
}
private static void asignarMovimientoPeonBlanco()
{
for (byte posicion = 8; posicion <= 55; posicion++)
{
byte x = (byte)(posicion % 8);
byte y = (byte)((posicion / 8));
var asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
//Matar en diagonal
if (x < 7 && y > 0)
{
asignarMovimiento.Movimientos.Add((byte)(posicion - 8 + 1));
MovimientoArrays.peonBlancoTotalMovimientos[posicion]++;
}
if (x > 0 && y > 0)
{
asignarMovimiento.Movimientos.Add((byte)(posicion - 8 - 1));
MovimientoArrays.peonBlancoTotalMovimientos[posicion]++;
}
//uno hacia delante
asignarMovimiento.Movimientos.Add((byte)(posicion - 8));
MovimientoArrays.peonBlancoTotalMovimientos[posicion]++;
//Desde posicion inicial movemos dos
if (y == 6)
{
asignarMovimiento.Movimientos.Add((byte)(posicion - 16));
MovimientoArrays.peonBlancoTotalMovimientos[posicion]++;
}
MovimientoArrays.peonBlancoMovimientos[posicion] = asignarMovimiento;
}
}
private static void asignarMovimientoCaballo()
{
for (byte y = 0; y < 8; y++)
{
for (byte x = 0; x < 8; x++)
{
byte posicion = (byte)(y + (x * 8));
var asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
byte movimiento;
if (y < 6 && x > 0)
{
movimiento = Posicion((byte)(y + 2), (byte)(x - 1));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
if (y > 1 && x < 7)
{
movimiento = Posicion((byte)(y - 2), (byte)(x + 1));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
if (y > 1 && x > 0)
{
movimiento = Posicion((byte)(y - 2), (byte)(x - 1));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
if (y < 6 && x < 7)
{
movimiento = Posicion((byte)(y + 2), (byte)(x + 1));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
if (y > 0 && x < 6)
{
movimiento = Posicion((byte)(y - 1), (byte)(x + 2));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
if (y < 7 && x > 1)
{
movimiento = Posicion((byte)(y + 1), (byte)(x - 2));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
if (y > 0 && x > 1)
{
movimiento = Posicion((byte)(y - 1), (byte)(x - 2));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
if (y < 7 && x < 6)
{
movimiento = Posicion((byte)(y + 1), (byte)(x + 2));
if (movimiento < 64)
{
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.caballoTotalMovimientos[posicion]++;
}
}
MovimientoArrays.caballoMovimientos[posicion] = asignarMovimiento;
}
}
}
private static void asignarMovimientoAlfil()
{
for (byte y = 0; y < 8; y++)
{
for (byte x = 0; x < 8; x++)
{
byte posicion = (byte)(y + (x * 8));
var asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
byte movimiento;
byte fila = x;
byte columna = y;
while (fila < 7 && columna < 7)
{
fila++;
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.AlfilTotalMovimientos1[posicion]++;
}
MovimientoArrays.AlfilMovimientos1[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila < 7 && columna > 0)
{
fila++;
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.AlfilTotalMovimientos2[posicion]++;
}
MovimientoArrays.AlfilMovimientos2[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila > 0 && columna < 7)
{
fila--;
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.AlfilTotalMovimientos3[posicion]++;
}
MovimientoArrays.AlfilMovimientos3[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila > 0 && columna > 0)
{
fila--;
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.AlfilTotalMovimientos4[posicion]++;
}
MovimientoArrays.AlfilMovimientos4[posicion] = asignarMovimiento;
}
}
}
private static void asignarMovimientosTorre()
{
for (byte y = 0; y < 8; y++)
{
for (byte x = 0; x < 8; x++)
{
byte posicion = (byte)(y + (x * 8));
var asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
byte movimiento;
byte fila = x;
byte columna = y;
while (fila < 7)
{
fila++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.TorreTotalMovimientos1[posicion]++;
}
MovimientoArrays.TorreMovimientos1[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila > 0)
{
fila--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.TorreTotalMovimientos2[posicion]++;
}
MovimientoArrays.TorreMovimientos2[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (columna > 0)
{
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.TorreTotalMovimientos3[posicion]++;
}
MovimientoArrays.TorreMovimientos3[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (columna < 7)
{
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.TorreTotalMovimientos4[posicion]++;
}
MovimientoArrays.TorreMovimientos4[posicion] = asignarMovimiento;
}
}
}
private static void asginarMovimientosReina()
{
for (byte y = 0; y < 8; y++)
{
for (byte x = 0; x < 8; x++)
{
byte posicion = (byte)(y + (x * 8));
var asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
byte movimiento;
byte fila = x;
byte columna = y;
while (fila < 7)
{
fila++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos1[posicion]++;
}
MovimientoArrays.ReinaMovimientos1[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila > 0)
{
fila--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos2[posicion]++;
}
MovimientoArrays.ReinaMovimientos2[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (columna > 0)
{
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos3[posicion]++;
}
MovimientoArrays.ReinaMovimientos3[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (columna < 7)
{
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos4[posicion]++;
}
MovimientoArrays.ReinaMovimientos4[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila < 7 && columna < 7)
{
fila++;
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos5[posicion]++;
}
MovimientoArrays.ReinaMovimientos5[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila < 7 && columna > 0)
{
fila++;
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos6[posicion]++;
}
MovimientoArrays.ReinaMovimientos6[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila > 0 && columna < 7)
{
fila--;
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos7[posicion]++;
}
MovimientoArrays.ReinaMovimientos7[posicion] = asignarMovimiento;
asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
fila = x;
columna = y;
while (fila > 0 && columna > 0)
{
fila--;
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReinaTotalMovimientos8[posicion]++;
}
MovimientoArrays.ReinaMovimientos8[posicion] = asignarMovimiento;
}
}
}
private static void asignarMovimientoRey()
{
for (byte y = 0; y < 8; y++)
{
for (byte x = 0; x < 8; x++)
{
byte posicion = (byte)(y + (x * 8));
var asignarMovimiento = new AsignarMovimientoPieza(new List<byte>());
byte movimiento;
byte fila = x;
byte columna = y;
if (fila < 7)
{
fila++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
fila = x;
columna = y;
if (fila > 0)
{
fila--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
fila = x;
columna = y;
if (columna > 0)
{
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
fila = x;
columna = y;
if (columna < 7)
{
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
fila = x;
columna = y;
if (fila < 7 && columna < 7)
{
fila++;
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
fila = x;
columna = y;
if (fila < 7 && columna > 0)
{
fila++;
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
fila = x;
columna = y;
if (fila > 0 && columna < 7)
{
fila--;
columna++;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
fila = x;
columna = y;
if (fila > 0 && columna > 0)
{
fila--;
columna--;
movimiento = Posicion(columna, fila);
asignarMovimiento.Movimientos.Add(movimiento);
MovimientoArrays.ReytotalMovimientos[posicion]++;
}
MovimientoArrays.ReyMovimientos[posicion] = asignarMovimiento;
}
}
}
#endregion
}
}
No hay comentarios:
Publicar un comentario