Example #1
0
        /// <summary>
        /// Calculas las cacillas a marcar(posibles movimientos)
        /// </summary>
        /// <param name="calcAmenazas">Si es true, calcula las cacillas a amenzar</param>
        /// <returns></returns>
        Casilla[] Casillas(bool calcAmenazas)
        {
            string casillaAct = this.casillaActual;

            string[] frente = Repetir(8, casillaAct, "Frente");
            string[] atras  = Repetir(8, casillaAct, "Atras");
            string[] izq    = Repetir(8, casillaAct, "Izquierda");
            string[] der    = Repetir(8, casillaAct, "Derecha");

            frente = Ajedrez.ValidadCasillas(frente);
            atras  = Ajedrez.ValidadCasillas(atras);
            izq    = Ajedrez.ValidadCasillas(izq);
            der    = Ajedrez.ValidadCasillas(der);

            frente = Ajedrez.CasillasHasta(this, frente, calcAmenazas);
            atras  = Ajedrez.CasillasHasta(this, atras, calcAmenazas);
            izq    = Ajedrez.CasillasHasta(this, izq, calcAmenazas);
            der    = Ajedrez.CasillasHasta(this, der, calcAmenazas);

            List <string> pos = new List <string> ();

            pos.AddRange(frente);
            pos.AddRange(atras);
            pos.AddRange(izq);
            pos.AddRange(der);
            string[] posicionesposibles = pos.ToArray();

            Casilla[] cass = Ajedrez.BuscarCasillas(posicionesposibles);
            return(cass);
        }
Example #2
0
        public Casilla[] Marcables()
        {
            string casillaAct = this.casillaActual;

            string[] frente = Repetir(8, casillaAct, "Diagonal Derecha");
            string[] atras  = Repetir(8, casillaAct, "Diagonal Izquierda");
            string[] izq    = Repetir(8, casillaAct, "Diagonal Izquierda Abajo");
            string[] der    = Repetir(8, casillaAct, "Diagonal Derecha Abajo");

            frente = Ajedrez.ValidadCasillas(frente);
            atras  = Ajedrez.ValidadCasillas(atras);
            izq    = Ajedrez.ValidadCasillas(izq);
            der    = Ajedrez.ValidadCasillas(der);

            frente = Ajedrez.CasillasHasta(this, frente);
            atras  = Ajedrez.CasillasHasta(this, atras);
            izq    = Ajedrez.CasillasHasta(this, izq);
            der    = Ajedrez.CasillasHasta(this, der);

            List <string> pos = new List <string> ();

            pos.AddRange(frente);
            pos.AddRange(atras);
            pos.AddRange(izq);
            pos.AddRange(der);
            string[]  posicionesposibles = pos.ToArray();
            Casilla[] cass = Ajedrez.BuscarCasillas(posicionesposibles);
            return(cass);
        }
Example #3
0
        Juego.Casilla[] PosAmenazadas()
        {
            string[] CasillasPosibles = new string[1];
            string   mov1             = null;
            string   mov2             = null;

            if (this.ColorPieza == color.Claro)
            {
                mov1 = Movimiento(this.casillaActual, 1, 1);
                mov2 = Movimiento(this.casillaActual, 1, -1);
            }
            else               //Oscuro
            {
                mov1 = Movimiento(this.casillaActual, -1, -1);
                mov2 = Movimiento(this.casillaActual, -1, 1);
            }

            List <string> posiciones = new List <string> ();

            posiciones.Add(mov1);
            posiciones.Add(mov2);
            string[] posicionesposibles = posiciones.ToArray();
            posicionesposibles = Ajedrez.ValidadCasillas(posicionesposibles);
            Casilla[] casMenazadas = Ajedrez.BuscarCasillas(posicionesposibles);

            return(casMenazadas);
        }
Example #4
0
        string[] PosicionesComibles()
        {
            string mov1 = null;
            string mov2 = null;

            if (this.ColorPieza == color.Claro)
            {
                mov1 = Movimiento(this.casillaActual, 1, 1);
                mov2 = Movimiento(this.casillaActual, 1, -1);
            }
            else               //Oscuro
            {
                mov1 = Movimiento(this.casillaActual, -1, -1);
                mov2 = Movimiento(this.casillaActual, -1, 1);
            }
            List <string> posComi = new List <string> ();
            Casilla       cas1    = null;
            Casilla       cas2    = null;

            if (Ajedrez.ValidarCasilla(mov1))
            {
                cas1 = Ajedrez.BuscarCasilla(mov1);
                if (cas1.Ocupada)
                {
                    if (cas1.pieza.ColorPieza != this.ColorPieza)
                    {
                        posComi.Add(cas1.nombre);
                    }
                }
            }
            if (Ajedrez.ValidarCasilla(mov2))
            {
                cas2 = Ajedrez.BuscarCasilla(mov2);
                if (cas2.Ocupada)
                {
                    if (cas2.pieza.ColorPieza != this.ColorPieza)
                    {
                        posComi.Add(cas2.nombre);
                    }
                }
            }

            //string[] val = null;
            if (posComi != null)
            {
                //val = Ajedrez.ValidadCasillas(posComi.ToArray());
                CasComi = true;
            }
            return(posComi.ToArray());
        }
Example #5
0
        public override Casilla[] MovimientosDesdeEstado(EstadoDeJuego estado)
        {
            string casillaAct = null;

            foreach (EstadoDeJuego.PiezaDeEstado pieza in estado.ListaDePiezasDeEstado)
            {
                if (pieza.id == this.id)
                {
                    casillaAct = pieza.Casilla;
                }
            }
            //Debug.Log("Casilla desde donde se va calcular " + casillaAct);
            string[] frente = Repetir(8, casillaAct, "Frente");
            string[] atras  = Repetir(8, casillaAct, "Atras");
            string[] izq    = Repetir(8, casillaAct, "Izquierda");
            string[] der    = Repetir(8, casillaAct, "Derecha");

            frente = Ajedrez.ValidadCasillas(frente);
            atras  = Ajedrez.ValidadCasillas(atras);
            izq    = Ajedrez.ValidadCasillas(izq);
            der    = Ajedrez.ValidadCasillas(der);



            bool calcAmenazas = false;

            frente = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, frente, calcAmenazas);
            atras  = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, atras, calcAmenazas);
            izq    = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, izq, calcAmenazas);
            der    = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, der, calcAmenazas);

            //Debug.Log("Cantidad frente " + frente.Length);


            List <string> pos = new List <string> ();

            pos.AddRange(frente);
            pos.AddRange(atras);
            pos.AddRange(izq);
            pos.AddRange(der);
            string[] posicionesposibles = pos.ToArray();

            Casilla[] cass = Ajedrez.BuscarCasillas(posicionesposibles);

            return(cass);
        }
Example #6
0
        public override Casilla[] MovimientosDesdeEstado(EstadoDeJuego estado)
        {
            string casillaAct = null;

            foreach (EstadoDeJuego.PiezaDeEstado pieza in estado.ListaDePiezasDeEstado)
            {
                if (pieza.id == this.id)
                {
                    casillaAct = pieza.Casilla;
                }
            }

            //Debug.Log (this.name + " " + "color "+ this.ColorPieza.ToString()+" "+"Casilla actual " + casillaAct);

            string[] frente = Repetir(8, casillaAct, "Diagonal Derecha");
            string[] atras  = Repetir(8, casillaAct, "Diagonal Izquierda");
            string[] izq    = Repetir(8, casillaAct, "Diagonal Izquierda Abajo");
            string[] der    = Repetir(8, casillaAct, "Diagonal Derecha Abajo");

            frente = Ajedrez.ValidadCasillas(frente);
            atras  = Ajedrez.ValidadCasillas(atras);
            izq    = Ajedrez.ValidadCasillas(izq);
            der    = Ajedrez.ValidadCasillas(der);

            bool calcAmenazas = false;

            frente = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, frente, calcAmenazas);
            atras  = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, atras, calcAmenazas);
            izq    = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, izq, calcAmenazas);
            der    = Ajedrez.CasillasHastaQueEsteOcupadaEnEstado(estado, this, der, calcAmenazas);

            List <string> pos = new List <string> ();

            pos.AddRange(frente);
            pos.AddRange(atras);
            pos.AddRange(izq);
            pos.AddRange(der);
            string[] posicionesposibles = pos.ToArray();

            Casilla[] cass = Ajedrez.BuscarCasillas(posicionesposibles);

            return(cass);
        }
Example #7
0
        //Devuelve las posiciones posibles del rey validadas y si no estan ocupadas
        Casilla[] Posiciones()
        {
            string casillaAct = this.casillaActual;

            string[] pos = new string[8];
            pos[0] = Movimiento(casillaAct, 1, 1);
            pos[1] = Movimiento(casillaAct, 1, 0);
            pos[2] = Movimiento(casillaAct, 0, 1);
            pos[3] = Movimiento(casillaAct, -1, -1);
            pos[4] = Movimiento(casillaAct, -1, 0);
            pos[5] = Movimiento(casillaAct, 0, -1);
            pos[6] = Movimiento(casillaAct, 1, -1);
            pos[7] = Movimiento(casillaAct, -1, 1);

            pos = Ajedrez.ValidadCasillas(pos);
            Casilla[] cass = Ajedrez.BuscarCasillas(pos);
            cass = Ajedrez.CacillaOcupada(this, cass);

            return(cass);
        }
Example #8
0
        public Casilla[] Posibles()
        {
            string[] CasillasAmenazadas = new string[8];

            string casillaAcual = this.casillaActual;

            string[] frente = Repetir(2, casillaAcual, "Frente");
            CasillasAmenazadas[0] = Repetir(1, frente[1], "Derecha") [0];
            CasillasAmenazadas[1] = Repetir(1, frente[1], "Izquierda") [0];

            string[] atras = Repetir(2, casillaAcual, "Atras");
            CasillasAmenazadas[2] = Repetir(1, atras[1], "Izquierda") [0];
            CasillasAmenazadas[3] = Repetir(1, atras[1], "Derecha") [0];

            string[] izq = Repetir(2, casillaAcual, "Izquierda");
            CasillasAmenazadas[4] = Repetir(1, izq[1], "Frente") [0];
            CasillasAmenazadas[5] = Repetir(1, izq[1], "Atras") [0];

            string[] der = Repetir(2, casillaAcual, "Derecha");
            CasillasAmenazadas[6] = Repetir(1, der[1], "Frente") [0];
            CasillasAmenazadas[7] = Repetir(1, der[1], "Atras") [0];

            List <string> posiciones = new List <string> ();

            for (int i = 0; i < CasillasAmenazadas.Length; i++)
            {
                if (Ajedrez.ValidarCasilla(CasillasAmenazadas[i]))
                {
                    posiciones.Add(CasillasAmenazadas[i]);
                }
            }
            string[]  posicionesposibles = posiciones.ToArray();
            Casilla[] cass = Ajedrez.BuscarCasillas(posicionesposibles);

            cass = Ajedrez.CacillaOcupada(this, cass);
            return(cass);
        }
Example #9
0
        Juego.Casilla[] Posiciones()
        {
            string[] CasillasPosibles  = new string[1];
            string[] CasillaAmenazada1 = new string[1];
            string[] CasillaAmenazada2 = new string[1];
            string   casillaAcual      = this.casillaActual;

            //Movimientos Marcables Normales
            if (this.ColorPieza == color.Claro)
            {
                if (this.casilla == posInicial)
                {
                    //Posibles movimientos
                    //Dos pasos
                    CasillasPosibles = Repetir(2, casillaAcual, "Frente");
                    CasillasPosibles = Ajedrez.CasillasHasta(this, CasillasPosibles);
                }
                else
                {
                    CasillasPosibles = Repetir(1, casillaAcual, "Frente");
                    Casilla[] cas = Ajedrez.BuscarCasillas(CasillasPosibles);
                    cas[0].marcar = false;
                    casNoMarcables.Add(cas[0]);
                }
            }
            else
            {
                if (this.casilla == posInicial)
                {
                    //Posibles movimientos
                    //Dos pasos
                    CasillasPosibles = Repetir(2, casillaAcual, "Atras");
                    CasillasPosibles = Ajedrez.CasillasHasta(this, CasillasPosibles);
                }
                else
                {
                    CasillasPosibles = Repetir(1, casillaAcual, "Atras");
                    Casilla[] cas = Ajedrez.BuscarCasillas(CasillasPosibles);
                    cas[0].marcar = false;
                    casNoMarcables.Add(cas[0]);
                }
            }

            string[]      comibles   = PosicionesComibles();
            List <string> posiciones = new List <string> ();

            if (CasComi && comibles != null)
            {
                posiciones.AddRange(CasillasPosibles);
                posiciones.AddRange(comibles);
            }
            else
            {
                posiciones.AddRange(CasillasPosibles);
            }

            //posiciones.AddRange (CasillaAmenazada1);
            //posiciones.AddRange (CasillaAmenazada2);

            string[] posicionesposibles = posiciones.ToArray();
            posicionesposibles = Ajedrez.ValidadCasillas(posicionesposibles);
            Casilla[] cass = Ajedrez.BuscarCasillas(posicionesposibles);
            cass = Ajedrez.CacillaOcupada(this, cass);

            return(cass);
        }