Ejemplo n.º 1
0
 public override void actualizarAmenazas(Casilla casilla)
 {
     miCasilla = casilla;
     celdasAmenazadas.Clear();
     Torre.añadirMovyAme(miCasilla, celdasAmenazadas, false);
     Alfil.añadirMovyAme(miCasilla, celdasAmenazadas, false);
 }
Ejemplo n.º 2
0
        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;
        }
Ejemplo n.º 3
0
 public override void actualizarMovimientos(Casilla casilla)
 {
     miCasilla = casilla;
     movimientosPermitidos.Clear();
     Torre.añadirMovyAme(miCasilla, movimientosPermitidos, true);
     Alfil.añadirMovyAme(miCasilla, movimientosPermitidos, true);
 }
Ejemplo n.º 4
0
        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("");
        }
Ejemplo n.º 5
0
        // 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);
        }
Ejemplo n.º 6
0
 public Ficha(bool color, Casilla casilla)
 {
     celdasAmenazadas      = new ArrayList();
     movimientosPermitidos = new ArrayList();
     capturada             = false;
     this.miCasilla        = casilla;
     this.color            = color;
 }
Ejemplo n.º 7
0
        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;
            }
        }
Ejemplo n.º 8
0
        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;
            }
        }
Ejemplo n.º 9
0
        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;
            }
        }
Ejemplo n.º 10
0
        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);
                }
            }
        }
Ejemplo n.º 11
0
        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);
        }
Ejemplo n.º 12
0
        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;
                }
            }
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 14
0
        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;
        }
Ejemplo n.º 15
0
        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);
                    }
                }
            }
        }
Ejemplo n.º 16
0
        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);
            }
        }
Ejemplo n.º 17
0
        // 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);
            }
        }
Ejemplo n.º 18
0
        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("");
        }
Ejemplo n.º 19
0
        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);
        }
Ejemplo n.º 20
0
        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;
        }
Ejemplo n.º 21
0
 public abstract void actualizarAmenazas(Casilla casilla);
Ejemplo n.º 22
0
 public abstract void actualizarMovimientos(Casilla casilla);
Ejemplo n.º 23
0
        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;
                    }
                }
            }
        }
Ejemplo n.º 24
0
        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++;
            }
        }
Ejemplo n.º 25
0
        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);
            }
        }
Ejemplo n.º 26
0
        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);
                }
            }
        }