public override void actualizarAmenazas(Casilla casilla)
{
miCasilla = casilla;
celdasAmenazadas.Clear();
Torre.añadirMovyAme(miCasilla, celdasAmenazadas, false);
Alfil.añadirMovyAme(miCasilla, celdasAmenazadas, false);
}
public Peon(bool color, Casilla casilla)
: base(color, casilla)
{
valor = ValorFicha.PEON;
notacion = NotAlg.Peon;
Casilla vecina, vecina2;
if (color)
{
textura = Texturas.BLANCO_PEON;
vecina = miCasilla.tablero.tablero[miCasilla.posX - 1][miCasilla.posY];
vecina2 = miCasilla.tablero.tablero[miCasilla.posX - 2][miCasilla.posY];
}
else
{
textura = Texturas.NEGRO_PEON;
vecina = miCasilla.tablero.tablero[miCasilla.posX + 1][miCasilla.posY];
vecina2 = miCasilla.tablero.tablero[miCasilla.posX + 2][miCasilla.posY];
}
celdasAmenazadas.Add(vecina.izquierda);
celdasAmenazadas.Add(vecina.derecha);
movimientosPermitidos.Add(vecina);
movimientosPermitidos.Add(vecina2);
alPaso = vecina2;
posNormal = vecina;
}
public override void actualizarMovimientos(Casilla casilla)
{
miCasilla = casilla;
movimientosPermitidos.Clear();
Torre.añadirMovyAme(miCasilla, movimientosPermitidos, true);
Alfil.añadirMovyAme(miCasilla, movimientosPermitidos, true);
}
private string distinguirFicha(Ficha previa, Casilla destino)
{
ArrayList j;
if (previa.color == Ficha.BLANCA)
{
j = fichasBlancas;
}
else
{
j = fichasNegras;
}
foreach (Ficha f in j)
{
if (f != previa && f.valor == previa.valor)
{
if (f.movimientosPermitidos.Contains(destino))
{
if (f.miCasilla.posX != previa.miCasilla.posX)
{
return(NotAlg.fila[previa.miCasilla.posX]);
}
else
{
return(NotAlg.columna[previa.miCasilla.posY]);
}
}
}
}
return("");
}
// Determina si una casilla esta amenazada por el "color"
public bool jaqueCasilla(Casilla c, bool color)
{
ArrayList jugador = new ArrayList();
if (color)
{
jugador = fichasBlancas;
}
else
{
jugador = fichasNegras;
}
Ficha ficha;
for (int i = 0; i < jugador.Count; i++)
{
ficha = (Ficha)jugador[i];
if (ficha.celdasAmenazadas.Contains(c))
{
return(true);
}
}
return(false);
}
public Ficha(bool color, Casilla casilla)
{
celdasAmenazadas = new ArrayList();
movimientosPermitidos = new ArrayList();
capturada = false;
this.miCasilla = casilla;
this.color = color;
}
public Reina(bool color, Casilla casilla)
: base(color, casilla)
{
valor = ValorFicha.REINA;
notacion = NotAlg.Reina;
if (color)
{
textura = Texturas.BLANCO_REINA;
}
else
{
textura = Texturas.NEGRO_REINA;
}
}
public Alfil(bool color, Casilla casilla)
: base(color, casilla)
{
valor = ValorFicha.ALFIL;
notacion = NotAlg.Alfil;
if (color)
{
textura = Texturas.BLANCO_ALFIL;
}
else
{
textura = Texturas.NEGRO_ALFIL;
}
}
public Torre(bool color, Casilla casilla)
: base(color, casilla)
{
valor = ValorFicha.TORRE;
notacion = NotAlg.Torre;
if (color)
{
textura = Texturas.BLANCO_TORRE;
}
else
{
textura = Texturas.NEGRO_TORRE;
}
}
public override void actualizarAmenazas(Casilla casilla)
{
miCasilla = casilla;
celdasAmenazadas.Clear();
Casilla vecina;
for (int i = 0; i < miCasilla.rey.Length; i++)
{
vecina = miCasilla.rey[i];
if (vecina != null)
{
celdasAmenazadas.Add(vecina);
}
}
}
public Caballo(bool color, Casilla casilla)
: base(color, casilla)
{
valor = ValorFicha.CABALLO;
notacion = NotAlg.Caballo;
if (color)
{
textura = Texturas.BLANCO_CABALLO;
}
else
{
textura = Texturas.NEGRO_CABALLO;
}
actualizarMovimientos(miCasilla);
}
static public void añadirMovyAme(Casilla casilla, ArrayList al, bool mov)
{
// Linea horizontal
Casilla vecina;
// Linea horizontal >
for (int i = casilla.posX + 1; i < 8; i++)
{
vecina = casilla.tablero.tablero[i][casilla.posY];
if (Torre.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
}
// Linea horizontal <
for (int i = casilla.posX - 1; i >= 0; i--)
{
vecina = casilla.tablero.tablero[i][casilla.posY];
if (Torre.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
}
// Linea vertical >
for (int i = casilla.posY + 1; i < 8; i++)
{
vecina = casilla.tablero.tablero[casilla.posX][i];
if (Torre.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
}
// Linea vertical <
for (int i = casilla.posY - 1; i >= 0; i--)
{
vecina = casilla.tablero.tablero[casilla.posX][i];
if (Torre.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
}
}
public Ficha click(double x, double y)
{
int i = (int)(y / Casilla.LADO);
int j = (int)(x / Casilla.LADO);
if (i >= 0 && i < 8 && j >= 0 && j < 8)
{
if (selected == tablero[i][j])
{
return(selected.ficha);
}
Ficha previa = null;
Casilla origen = null;
if (selected != null)
{
previa = selected.ficha;
origen = selected;
}
selected = tablero[i][j];
if (selected == null)
{
return(null);
}
if (moverFicha(previa, origen, selected))
{
// Proximo turno
turno = !turno;
nTurno++;
selected = null;
return(null);
}
if (selected != null)
{
return(selected.ficha);
}
}
return(null);
}
public Rey(bool color, Casilla casilla)
: base(color, casilla)
{
valor = ValorFicha.REY;
notacion = NotAlg.Rey;
if (color)
{
textura = Texturas.BLANCO_REY;
}
else
{
textura = Texturas.NEGRO_REY;
}
// Deben haberse posiionado previamente!!
torreC = (Torre)casilla.tablero.tablero[casilla.posX][7].ficha;
torreL = (Torre)casilla.tablero.tablero[casilla.posX][0].ficha;
}
public override void actualizarMovimientos(Casilla casilla)
{
miCasilla = casilla;
movimientosPermitidos.Clear();
Casilla vecina;
for (int i = 0; i < miCasilla.caballo.Length; i++)
{
vecina = miCasilla.caballo[i];
if (vecina != null)
{
if (vecina.ficha == null || vecina.ficha.color != color)
{
movimientosPermitidos.Add(vecina);
}
}
}
}
public override void actualizarAmenazas(Casilla casilla)
{
miCasilla = casilla;
Casilla vecina = null;
int x, y;
celdasAmenazadas.Clear();
x = miCasilla.posX;
y = miCasilla.posY;
if (color)
{
x--;
if (x < 0)
{
return;
}
}
else
{
x++;
if (x > 7)
{
return;
}
}
if (y > 0)
{
vecina = miCasilla.tablero.tablero[x][y - 1];
celdasAmenazadas.Add(vecina);
}
if (y < 7)
{
vecina = miCasilla.tablero.tablero[x][y + 1];
celdasAmenazadas.Add(vecina);
}
}
// Devuelve cuando el bucle debe parar
static private bool comprobarMovAme(Casilla vecina, bool color, ArrayList al, bool mov)
{
if (vecina.ficha == null) // Puede mover y amenaza
{
al.Add(vecina);
return(false);
}
else
{
if (vecina.ficha.color != color) // Puede mover y amenaza
{
al.Add(vecina);
}
else
{
if (!mov) // Solo amenaza pero no puede mover
{
al.Add(vecina);
}
}
return(true);
}
}
public Tablero()
{
// Creamos el tablero
tablero = new Casilla[8][];
for (int i = 0; i < tablero.Length; i++)
{
tablero[i] = new Casilla[8];
for (int j = 0; j < tablero[i].Length; j++)
{
bool color;
color = (i + j) % 2 == 0;
tablero[i][j] = new Casilla(color, this, i, j);
}
}
// Inicializamos vecinos
for (int i = 0; i < tablero.Length; i++)
{
for (int j = 0; j < tablero[i].Length; j++)
{
tablero[i][j].calcularVecinos();
}
}
// Situamos las fichas
// Peones
for (int i = 0; i < tablero[6].Length; i++)
{
tablero[6][i].ficha = new Peon(Ficha.BLANCA, tablero[6][i]);
tablero[1][i].ficha = new Peon(Ficha.NEGRA, tablero[1][i]);
}
// Torres
tablero[0][0].ficha = new Torre(Ficha.NEGRA, tablero[0][0]);
tablero[0][7].ficha = new Torre(Ficha.NEGRA, tablero[0][7]);
tablero[7][0].ficha = new Torre(Ficha.BLANCA, tablero[7][0]);
tablero[7][7].ficha = new Torre(Ficha.BLANCA, tablero[7][7]);
// Caballos
tablero[0][1].ficha = new Caballo(Ficha.NEGRA, tablero[0][1]);
tablero[0][6].ficha = new Caballo(Ficha.NEGRA, tablero[0][6]);
tablero[7][1].ficha = new Caballo(Ficha.BLANCA, tablero[7][1]);
tablero[7][6].ficha = new Caballo(Ficha.BLANCA, tablero[7][6]);
// Alfiles
tablero[0][2].ficha = new Alfil(Ficha.NEGRA, tablero[0][2]);
tablero[0][5].ficha = new Alfil(Ficha.NEGRA, tablero[0][5]);
tablero[7][2].ficha = new Alfil(Ficha.BLANCA, tablero[7][2]);
tablero[7][5].ficha = new Alfil(Ficha.BLANCA, tablero[7][5]);
// Reinas
tablero[0][3].ficha = new Reina(Ficha.NEGRA, tablero[0][3]);
tablero[7][3].ficha = new Reina(Ficha.BLANCA, tablero[7][3]);
// Reyes
tablero[0][4].ficha = new Rey(Ficha.NEGRA, tablero[0][4]);
tablero[7][4].ficha = new Rey(Ficha.BLANCA, tablero[7][4]);
// Añadimos cada ficha a su jugador
for (int i = 0; i < tablero[0].Length; i++)
{
fichasBlancas.Add(tablero[6][i].ficha);
fichasBlancas.Add(tablero[7][i].ficha);
fichasNegras.Add(tablero[1][i].ficha);
fichasNegras.Add(tablero[0][i].ficha);
}
reyBlanco = (Rey)tablero[7][4].ficha;
reyNegro = (Rey)tablero[0][4].ficha;
historial.Add("");
}
public bool moverFicha(Ficha previa, Casilla origen, Casilla destino)
{
bool enroque = false;
if (turno == Ficha.BLANCA)
{
movimiento = ((nTurno / 2) + 1).ToString() + ". ";
}
else
{
movimiento += " ";
}
if (previa != null)
{
if (previa.movimientosPermitidos.Contains(destino))
{
Ficha comida = null;
ArrayList jugador = null;
bool mov = previa.movida;
bool paso = destino.alPaso;
movimiento += previa.ToString();
// Pueden ir alli varias piezas mias???
movimiento += distinguirFicha(previa, destino);
if (destino.ficha != null)
{
destino.ficha.capturada = true;
comida = destino.ficha;
if (fichasBlancas.Contains(destino.ficha))
{
fichasBlancas.Remove(destino.ficha);
jugador = fichasBlancas;
movimiento += "x";
}
else if (fichasNegras.Contains(destino.ficha))
{
fichasNegras.Remove(destino.ficha);
jugador = fichasNegras;
movimiento += "x";
}
// ¿Me comen al paso? Solo peones...
try
{
Peon peon = (Peon)previa;
if (destino.ficha.miCasilla != destino)
{
destino.ficha.miCasilla.ficha = null;
destino.alPaso = false;
}
}
catch (Exception)
{
destino.alPaso = false;
}
// Me comen habiendo dado doble salto?
try
{
Peon peon = (Peon)destino.ficha;
if (peon.alPaso == destino)
{
peon.posNormal.alPaso = false;
peon.posNormal.ficha = null;
}
}
catch (Exception)
{
}
}
movimiento += destino.ToString();
destino.ficha = previa;
origen.ficha = null;
//selected.ficha.actualizarMovimientos(selected);
previa.movida = true;
// Fue un enroque?
Torre torre = null;
Casilla casT = null;
if (previa.enroque == destino)
{
try
{
// Si no es Rey, no fue enroque y saltara la excepcion :)
Rey r = (Rey)previa;
if (destino.derecha == r.torreC.miCasilla)
{
casT = r.torreC.miCasilla;
moverFicha(r.torreC, r.torreC.miCasilla, r.torreC.enroque);
torre = r.torreC;
movimiento = ((nTurno / 2) + 1).ToString() + ". " + NotAlg.ENROQUEC;
}
else
{
casT = r.torreL.miCasilla;
moverFicha(r.torreL, r.torreL.miCasilla, r.torreL.enroque);
torre = r.torreL;
movimiento = ((nTurno / 2) + 1).ToString() + ". " + NotAlg.ENROQUEL;
}
enroque = true;
}
catch (Exception)
{
}
}
// Fue salto doble de peon?
try
{
Peon peon = (Peon)previa;
if (peon.alPaso == destino)
{
peon.posNormal.ficha = peon;
peon.posNormal.alPaso = true;
}
else
{
if (peon.posNormal != null)
{
peon.posNormal.alPaso = false;
}
peon.alPaso = null;
peon.posNormal = null;
}
}
catch (Exception)
{
}
actualizarMovimientos();
// Evitar autojaque
if (esJaque(turno, false))
{
// Por si acaso
destino.ficha = null;
destino.alPaso = paso;
// Deshacemos y nos sigue tocando
if (comida != null && jugador != null)
{
comida.capturada = false;
jugador.Add(comida);
destino.ficha = comida;
}
origen.ficha = previa;
previa.movida = mov;
// Volver a poner variables de "al paso"
try
{
Peon peon = (Peon)previa;
if (peon.alPaso == destino)
{
peon.posNormal.ficha = null;
peon.posNormal.alPaso = false;
peon.mov = -1;
}
}
catch (Exception)
{
}
// Si fue enroque, deshacer tambien a la torre
// Aunque nunca deberia darse, pues se comprueba
// antes que el "camino" no estuviese amenazado
if (enroque && casT != null && torre != null)
{
torre.miCasilla = null;
casT.ficha = torre;
torre.miCasilla = casT;
}
actualizarMovimientos();
// Si movemos, deseleccionamos
destino.selected = false;
return(false);
}
// Finalmente, promocionamos un peon?
try
{
Peon peon = (Peon)previa;
if ((peon.color && peon.miCasilla.posX == 0) ||
(!peon.color && peon.miCasilla.posX == 7))
{
Promocion prom = new Promocion(peon);
prom.ShowDialog();
if (peon.color)
{
fichasBlancas.Remove(peon);
fichasBlancas.Add(prom.seleccionada);
}
else
{
fichasNegras.Remove(peon);
fichasNegras.Add(prom.seleccionada);
}
movimiento += prom.seleccionada.ToString();
}
}
catch (Exception)
{
}
// Si movemos, deseleccionamos
destino.selected = false;
return(true);
}
return(false);
}
return(false);
}
public void calcularVecinos()
{
int i = posX;
int j = posY;
// Calculemos sus vecinos - Por claridad, no agrupamos
if (i > 0)
{
arriba = tablero.tablero[i - 1][j];
}
if (i < 7)
{
abajo = tablero.tablero[i + 1][j];
}
if (j > 0)
{
izquierda = tablero.tablero[i][j - 1];
}
if (j < 7)
{
derecha = tablero.tablero[i][j + 1];
}
if (i > 0 && j > 0)
{
arribaIzquierda = tablero.tablero[i - 1][j - 1];
}
if (i > 0 && j < 7)
{
arribaDerecha = tablero.tablero[i - 1][j + 1];
}
if (i < 7 && j > 0)
{
abajoIzquierda = tablero.tablero[i + 1][j - 1];
}
if (i < 7 && j < 7)
{
abajoDerecha = tablero.tablero[i + 1][j + 1];
}
// Caballos
if (i > 1 && j < 7)
{
caballo1 = tablero.tablero[i - 2][j + 1];
}
if (i > 0 && j < 6)
{
caballo2 = tablero.tablero[i - 1][j + 2];
}
if (i < 7 && j < 6)
{
caballo4 = tablero.tablero[i + 1][j + 2];
}
if (i < 6 && j < 7)
{
caballo5 = tablero.tablero[i + 2][j + 1];
}
if (i < 6 && j > 0)
{
caballo7 = tablero.tablero[i + 2][j - 1];
}
if (i < 7 && j > 1)
{
caballo8 = tablero.tablero[i + 1][j - 2];
}
if (i > 0 && j > 1)
{
caballo10 = tablero.tablero[i - 1][j - 2];
}
if (i > 1 && j > 0)
{
caballo11 = tablero.tablero[i - 2][j - 1];
}
caballo[0] = caballo1;
caballo[1] = caballo2;
caballo[2] = caballo4;
caballo[3] = caballo5;
caballo[4] = caballo7;
caballo[5] = caballo8;
caballo[6] = caballo10;
caballo[7] = caballo11;
rey[0] = arriba;
rey[1] = abajo;
rey[2] = derecha;
rey[3] = izquierda;
rey[4] = arribaIzquierda;
rey[5] = arribaDerecha;
rey[6] = abajoDerecha;
rey[7] = abajoIzquierda;
}
public abstract void actualizarAmenazas(Casilla casilla);
public abstract void actualizarMovimientos(Casilla casilla);
public override void actualizarMovimientos(Casilla casilla)
{
miCasilla = casilla;
ArrayList listaEnemigos;
if (color == BLANCA)
{
listaEnemigos = miCasilla.tablero.fichasNegras;
}
else
{
listaEnemigos = miCasilla.tablero.fichasBlancas;
}
movimientosPermitidos.Clear();
Casilla vecina;
bool amenazada;
for (int i = 0; i < miCasilla.rey.Length; i++)
{
vecina = miCasilla.rey[i];
if (vecina != null)
{
if (vecina.ficha == null || vecina.ficha.color != color)
{
amenazada = false;
for (int j = 0; j < listaEnemigos.Count; j++)
{
if (((Ficha)listaEnemigos[j]).celdasAmenazadas.Contains(vecina))
{
amenazada = true;
break;
}
}
if (!amenazada)
{
movimientosPermitidos.Add(vecina);
}
}
}
}
// Enroque?
enroque = null;
torreC.enroque = null;
torreL.enroque = null;
Casilla vecina2, vecina3;
if (movida == false)
{
if (torreC.movida == false)
{
vecina = miCasilla.derecha;
vecina2 = vecina.derecha;
if (vecina.ficha == null && !miCasilla.tablero.jaqueCasilla(vecina, !color) &&
vecina2.ficha == null && !miCasilla.tablero.jaqueCasilla(vecina2, !color) &&
!miCasilla.tablero.esJaque(color, false))
{
movimientosPermitidos.Add(vecina2);
enroque = vecina2;
torreC.enroque = vecina;
}
}
if (torreL.movida == false)
{
vecina = miCasilla.izquierda;
vecina2 = vecina.izquierda;
vecina3 = vecina2.izquierda;
if (vecina.ficha == null && !miCasilla.tablero.jaqueCasilla(vecina, !color) &&
vecina2.ficha == null && !miCasilla.tablero.jaqueCasilla(vecina2, !color) &&
vecina3.ficha == null && !miCasilla.tablero.jaqueCasilla(vecina3, !color) &&
!miCasilla.tablero.esJaque(color, false))
{
movimientosPermitidos.Add(vecina2);
enroque = vecina2;
torreL.enroque = vecina;
}
}
}
}
static public void añadirMovyAme(Casilla casilla, ArrayList al, bool mov)
{
Casilla vecina;
// Arriba Derecha
int j = casilla.posY + 1;
int i;
for (i = casilla.posX + 1; i < 8 && j < 8; i++)
{
vecina = casilla.tablero.tablero[i][j];
if (Alfil.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
j++;
}
// Arriba Izquierda
j = casilla.posY - 1;
for (i = casilla.posX + 1; i < 8 && j >= 0; i++)
{
vecina = casilla.tablero.tablero[i][j];
if (Alfil.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
j--;
}
// Abajo Izquierda
j = casilla.posY - 1;
for (i = casilla.posX - 1; i >= 0 && j >= 0; i--)
{
vecina = casilla.tablero.tablero[i][j];
if (Alfil.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
j--;
}
// Abajo Derecha
j = casilla.posY + 1;
for (i = casilla.posX - 1; i >= 0 && j < 8; i--)
{
vecina = casilla.tablero.tablero[i][j];
if (Alfil.comprobarMovAme(vecina, casilla.ficha.color, al, mov))
{
break;
}
j++;
}
}
public void setEstado(Estado estado)
{
try
{
turno = estado.turno;
nTurno = estado.nTurno;
fichasBlancas.Clear();
fichasNegras.Clear();
selected = null;
seleccionada = null;
for (int i = 0; i < Estado.LADO; i++)
{
for (int j = 0; j < Estado.LADO; j++)
{
// Referente a la casilla
tablero[i][j].alPaso = estado.alPaso[i][j];
switch (estado.tablero[i][j])
{
case Estado.Vacio:
tablero[i][j].ficha = null;
break;
case Estado.PeonBlanco:
Peon peon = new Peon(Ficha.BLANCA, tablero[i][j]);
tablero[i][j].ficha = peon;
peon.mov = estado.mov[i][j];
if (tablero[i][j].abajo.alPaso)
{
peon.alPaso = tablero[i][j];
peon.posNormal = tablero[i][j].abajo;
peon.posNormal.ficha = peon;
}
break;
case Estado.TorreBlanca:
Torre torre = new Torre(Ficha.BLANCA, tablero[i][j]);
tablero[i][j].ficha = torre;
break;
case Estado.CaballoBlanco:
Caballo caballo = new Caballo(Ficha.BLANCA, tablero[i][j]);
tablero[i][j].ficha = caballo;
break;
case Estado.AlfilBlanco:
Alfil alfil = new Alfil(Ficha.BLANCA, tablero[i][j]);
tablero[i][j].ficha = alfil;
break;
case Estado.ReinaBlanca:
Reina dama = new Reina(Ficha.BLANCA, tablero[i][j]);
tablero[i][j].ficha = dama;
break;
case Estado.ReyBlanco:
reyBlanco = new Rey(Ficha.BLANCA, tablero[i][j]);
tablero[i][j].ficha = reyBlanco;
break;
case Estado.PeonNegro:
Peon peon2 = new Peon(Ficha.NEGRA, tablero[i][j]);
tablero[i][j].ficha = peon2;
peon2.mov = estado.mov[i][j];
if (tablero[i][j].arriba.alPaso)
{
peon2.alPaso = tablero[i][j];
peon2.posNormal = tablero[i][j].arriba;
peon2.posNormal.ficha = peon2;
}
break;
case Estado.TorreNegra:
Torre torre2 = new Torre(Ficha.NEGRA, tablero[i][j]);
tablero[i][j].ficha = torre2;
break;
case Estado.CaballoNegro:
Caballo caballo2 = new Caballo(Ficha.NEGRA, tablero[i][j]);
tablero[i][j].ficha = caballo2;
break;
case Estado.AlfilNegro:
Alfil alfil2 = new Alfil(Ficha.NEGRA, tablero[i][j]);
tablero[i][j].ficha = alfil2;
break;
case Estado.ReinaNegra:
Reina dama2 = new Reina(Ficha.NEGRA, tablero[i][j]);
tablero[i][j].ficha = dama2;
break;
case Estado.ReyNegro:
reyNegro = new Rey(Ficha.NEGRA, tablero[i][j]);
tablero[i][j].ficha = reyNegro;
break;
default:
break;
}
if (tablero[i][j].ficha != null)
{
tablero[i][j].ficha.movida = estado.movida[i][j];
if (tablero[i][j].ficha.color == Ficha.BLANCA)
{
fichasBlancas.Add(tablero[i][j].ficha);
}
else
{
fichasNegras.Add(tablero[i][j].ficha);
}
}
}
} // Bucle externo (i)
// Torres de los reyes
reyBlanco.torreC = ((Torre)tablero[estado.torreCB[0]][estado.torreCB[1]].ficha);
reyBlanco.torreL = ((Torre)tablero[estado.torreLB[0]][estado.torreLB[1]].ficha);
reyNegro.torreC = ((Torre)tablero[estado.torreCN[0]][estado.torreCN[1]].ficha);
reyNegro.torreL = ((Torre)tablero[estado.torreLN[0]][estado.torreLN[1]].ficha);
// Actualizamos resto de cosas
this.actualizarMovimientos();
}
catch (Exception e)
{
MessageBox.Show("Error cargando estado previo: \n\r" + e.Message);
}
}
public override void actualizarMovimientos(Casilla casilla)
{
if (mov == -1 && casilla == alPaso)
{
mov = miCasilla.tablero.nTurno;
}
miCasilla = casilla;
Casilla vecina = null;
int x, y;
movimientosPermitidos.Clear();
// Al siguiente, me borro si no me comen
if (mov != -1 && alPaso != null &&
miCasilla.tablero.nTurno - mov > 0 &&
posNormal != null && !this.capturada)
{
posNormal.ficha = null;
posNormal.alPaso = false;
alPaso = null;
posNormal = null;
}
x = miCasilla.posX;
y = miCasilla.posY;
if (color)
{
x--;
}
else
{
x++;
}
if (x >= 0 && x < 8)
{
vecina = miCasilla.tablero.tablero[x][y];
}
else
{
return;
}
// Movmiento normal
if (vecina != null && vecina.ficha == null)
{
movimientosPermitidos.Add(vecina);
if (!movida)
{
posNormal = vecina;
}
}
// ¿Puede comer?
if (y > 0)
{
vecina = miCasilla.tablero.tablero[x][y - 1];
if (vecina.ficha != null && vecina.ficha.color != color)
{
movimientosPermitidos.Add(vecina);
}
}
if (y < 7)
{
vecina = miCasilla.tablero.tablero[x][y + 1];
if (vecina.ficha != null && vecina.ficha.color != color)
{
movimientosPermitidos.Add(vecina);
}
}
// Salida doble
if (!movida)
{
if (color)
{
x--;
}
else
{
x++;
}
if (x >= 0 && x < 8)
{
vecina = miCasilla.tablero.tablero[x][y];
}
if (vecina != null && vecina.ficha == null)
{
movimientosPermitidos.Add(vecina);
}
}
}