コード例 #1
0
        public Movimiento(Juego.Pieza PiezaQueSeVaMover, Juego.Casilla CasillaDondeMover, EstadoDeJuego estadoAnterior)
        {
            this.EstadoAnterior = estadoAnterior;

            this.CasillaDondeMover = CasillaDondeMover;
            this.PiezaQueSeVaMover = PiezaQueSeVaMover;
            DarValorDeMovimiento();
            this.EstadoAnterior = new EstadoDeJuego();



            EstadoDeJuego.PiezaDeEstado piezaAquitar = null;
            if (CasillaDondeMover.pieza != null)
            {
                piezaAquitar = new EstadoDeJuego.PiezaDeEstado(CasillaDondeMover.pieza);
            }

            CrearEstadoFinalDesdeEstadoAnterior(piezaAquitar);
            //ActualizarEstadoFinal ();
            QuitarTodasLasCasillasOcupadas();
            AgregarCasillaOcupada();
            //int id = CasillaDondeMover.id;
            //Debug.Log(id);
            //estadoFinal.CasillasDeEstado[id].EstaOcupada = true;
            //estadoFinal.ActualizarCasillasOcupadas ();
        }
コード例 #2
0
        public void Mover(Casilla Casilla)
        {
            if (this.casilla != Casilla)
            {
                this.CasillaAnterior.Ocupada  = false;
                this.CasillaAnterior.Ocupable = false;
                this.CasillaAnterior.pieza    = null;
                if (Casilla.Ocupada)
                {
                    //Debug.Log ("Se va desactivar " + Casilla.pieza.name);

                    Casilla.pieza.gameObject.SetActive(false);

                    //Debug.Log ("Se desactivo " + Casilla.pieza.name);
                    Casilla.pieza = this;
                    //Debug.Log ("Ahora la casilla tiene a " + Casilla.pieza.name);
                }
                casillaAnterior          = this.casilla;
                this.transform.position  = Casilla.posicion;
                this.SeMovio             = true;
                casillaAnterior.Ocupada  = false;
                casillaAnterior.Ocupable = false;
                casillaAnterior.pieza    = null;
            }
            if (this.casilla == Casilla)
            {
                //this.transform.position = Casilla.posicion;
            }
        }
コード例 #3
0
        public Movimiento(Juego.Pieza Pieza, Juego.Casilla Casilla)
        {
            EstadoDeJuego.PiezaDeEstado pieza = new EstadoDeJuego.PiezaDeEstado(Pieza, Casilla);
            //Debug.Log("Se va crear un movimiento logico para la pieza " + Pieza.name + " de la casilla " + Pieza.casilla.nombre);
            Debug.Log("Se creo un pieza de estado de juego " +
                      pieza.Nombre + " con la casilla " + pieza.Casilla);
            this.PiezaMovida     = Pieza;
            this.CasillaElegida  = Casilla;
            this.CasillaAnterior = this.PiezaMovida.casilla;

            this.PiezaMovida.casilla = Casilla;
            //Juego.Pieza piezaMovida = Pieza;
            EstadoDeJuego.PiezaDeEstado piezaAquitar = null;
            if (Casilla.pieza != null)
            {
                //Debug.Log("se va quitar");

                piezaAquitar = new EstadoDeJuego.PiezaDeEstado(Casilla.pieza);
            }
            //piezaMovida.casilla = Casilla;
            CrearEstadoFinal(piezaAquitar);
            if (Casilla.pieza != null)
            {
                this.Valor = Casilla.pieza.ValorPorColor();
            }
            this.PiezaMovida.casilla = CasillaAnterior;
        }
コード例 #4
0
ファイル: EstadoDeJuego.cs プロジェクト: oscarpavon/ajedrez
 /// <summary>
 /// Crea un pieza con la casilla especificada
 /// </summary>
 /// <param name="pieza"></param>
 /// <param name="Casilla"></param>
 public PiezaDeEstado(Juego.Pieza pieza, Juego.Casilla Casilla)
 {
     this.id      = pieza.id;
     this.Nombre  = pieza.name;
     this.Casilla = Casilla.nombre;
     this.Color   = pieza.ColorPieza.ToString();
 }
コード例 #5
0
        public Movimiento CrearJugadaEnEstado(Casilla casAmover, EstadoDeJuego estado)
        {
            Movimiento MovimientoEnElEstado = new Movimiento(this, casAmover, estado);

            //Movimiento MovimientoEnElEstado = AjedrezSupremo.Movimiento.CrearMovimientoEnEstado();
            return(MovimientoEnElEstado);
        }
コード例 #6
0
        public override void AgregarAmenaza()
        {
            this.marcables = this.PosAmenazadas();
            amenazadas     = this.marcables;
            List <Casilla> casillas = new List <Casilla> ();

            for (int o = 0; o < marcables.Length; o++)
            {
                Casilla cas = marcables[o];
                casillas.Add(cas);
                this.CasillasAmenazadas = casillas;
                if (this.gameObject.activeInHierarchy)
                {
                    if (this.ColorPieza == color.Claro)
                    {
                        cas.AmenazadaPorClaros.Add(this);
                        cas.AmenazadaPorClaros = cas.AmenazadaPorClaros.Distinct().ToList();
                    }
                    if (this.ColorPieza == color.Oscuro)
                    {
                        cas.AmenazadaPorOscuros.Add(this);
                        cas.AmenazadaPorOscuros = cas.AmenazadaPorOscuros.Distinct().ToList();
                    }
                }
            }

            this.marcables = this.Movimientos();
        }
コード例 #7
0
ファイル: IA.cs プロジェクト: oscarpavon/ajedrez
        void Mover(Pieza pieza, Casilla cas)
        {
            piezaAnterior = pieza;
            pieza.MoverA(cas);

            pieza.Seleccionada = false;
            pieza = null;
            Partida.CambiarTurno();
        }
コード例 #8
0
ファイル: EstadoDeJuego.cs プロジェクト: oscarpavon/ajedrez
            public void Crear()
            {
                //AjedrezSupremo.Crear.Ajedrez.CrearPieza(this);
                Juego.Casilla cas = AjedrezSupremo.Crear.Ajedrez.BuscarCasilla(this.Casilla);
                //Debug.Log ("Se va mover " + Nombre + " en la casilla" + cas.nombre);

                Partida.ListaDePiezas[this.id].Mover(cas);
                Partida.ListaDePiezas[this.id].gameObject.SetActive(true);
            }
コード例 #9
0
ファイル: IA.cs プロジェクト: oscarpavon/ajedrez
 static void ActualizarPosicionesDePiezas(EstadoDeJuego estado)
 {
     foreach (EstadoDeJuego.PiezaDeEstado piezaEstadoActual in estado.ListaDePiezasDeEstado)
     {
         Casilla cas = AjedrezSupremo.Crear.Ajedrez.BuscarCasilla(piezaEstadoActual.Casilla);
         Partida.ListaDePiezas[piezaEstadoActual.id].casilla = cas;
         cas.pieza = Partida.ListaDePiezas[piezaEstadoActual.id];
     }
 }
コード例 #10
0
ファイル: EstadoDeJuego.cs プロジェクト: oscarpavon/ajedrez
 public CasillaDeEstado(Juego.Casilla cas)
 {
     this.CasillaDeJuego = cas;
     this.Nombre         = cas.nombre;
     if (cas.Ocupada)
     {
         this.EstaOcupada = true;
         this.pieza       = cas.pieza;
     }
 }
コード例 #11
0
ファイル: IA.cs プロジェクト: oscarpavon/ajedrez
        void Mover()
        {
            Casilla casilla = ElegirCasilla();

            piezaAnterior = piezaSeleccionada;
            piezaSeleccionada.MoverA(casilla);

            piezaSeleccionada.Seleccionada = false;
            piezaSeleccionada = null;
            Partida.CambiarTurno();
        }
コード例 #12
0
ファイル: IA.cs プロジェクト: oscarpavon/ajedrez
        Movimiento ElegirMovimientoAleatorio()
        {
            List <Movimiento> movs = TodosLosMovimientosDeMisPiezas();

            int        m        = Random.Range(0, movs.Count);
            Movimiento mElegido = movs[m];
            Pieza      pieza    = mElegido.PiezaMovida;
            Casilla    cas      = mElegido.CasillaElegida;

            return(mElegido);
        }
コード例 #13
0
ファイル: IA.cs プロジェクト: oscarpavon/ajedrez
        void MiniMax()
        {
            //todos los movimientos

            if (presesntar)
            {
                List <Movimiento> movs = TodosLosMovimientosDeMisPiezas();
                Debug.Log(movs.Count.ToString());
                if (cantidadAnalisis >= movs.Count)
                {
                    analizar = false;
                }
                else
                {
                    analizar = true;
                }
                if (analizar)
                {
                    Movimiento mejorNegras = null;
                    int        mejorValor  = -999;
                    foreach (Movimiento mov in movs)
                    {
                        mov.estadoFinal.MostrarPiezasEnSusPosiciones();
                        cantidadAnalisis++;

                        int valorMovActual = mov.Valor;
                        if (valorMovActual > mejorValor)
                        {
                            mejorValor  = valorMovActual;
                            mejorNegras = mov;
                        }

                        MejorMovBlancas(mov.estadoFinal);
                    }
                    Debug.Log("mejor mov " + mejorNegras.CasillaElegida.nombre);
                    //posicion original antes de calculos
                    foreach (int pieza in idPiezaOscuras)
                    {
                        Casilla cas = Partida.ListaDePiezas[pieza].CasillaAnterior;
                        Partida.ListaDePiezas[pieza].Mover(cas);
                    }
                }

                presesntar = false;
            }

            //guarda estado actual ante de calculos

            //movimiento contrario

            //actualizo el estado del juegp
            //hago el movimiento del contrario
        }
コード例 #14
0
ファイル: ControlJuego.cs プロジェクト: oscarpavon/ajedrez
		void CrearMovimientosPrueba (EstadoDeJuego estado) {
			Juego.Pieza alfil = Partida.ListaDePiezas[0];

			Juego.Casilla h2 = AjedrezSupremo.Crear.Ajedrez.BuscarCasilla ("H2");
			Movimiento movUno = new Movimiento (alfil, h2, estado);
			Juego.Casilla cas = AjedrezSupremo.Crear.Ajedrez.BuscarCasilla ("C2");

			Movimiento mov2 = new Movimiento (alfil, cas, estado);

			CantidadDeCasillasOcupadasEnEstado (estadoOriginal);
			CantidadDeCasillasOcupadasEnEstado (mov2.estadoFinal);
			CantidadDeCasillasOcupadasEnEstado (movUno.estadoFinal);
		}
コード例 #15
0
ファイル: IA.cs プロジェクト: oscarpavon/ajedrez
        //Ya sabe que comer
        void Jugadas3()
        {
            CatalogarPiezas();
            Movimiento mElegido = MejorMovimiento();
            Pieza      pieza    = mElegido.PiezaMovida;
            Casilla    cas      = mElegido.CasillaElegida;

            if (cuadrosAesperar >= 20)
            {
                Mover(pieza, cas);
                cuadrosAesperar = 0;
            }
            cuadrosAesperar += 1;
        }
コード例 #16
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());
        }
コード例 #17
0
ファイル: IA.cs プロジェクト: oscarpavon/ajedrez
        //mueve aleatoriamiente
        void Jugadas2()
        {
            CatalogarPiezas();
            //ElegirPieza ();

            Movimiento mElegido = ElegirMovimientoAleatorio();
            Pieza      pieza    = mElegido.PiezaMovida;
            Casilla    cas      = mElegido.CasillaElegida;

            if (cuadrosAesperar >= 20)
            {
                Mover(pieza, cas);
                cuadrosAesperar = 0;
            }
            cuadrosAesperar += 1;
        }
コード例 #18
0
        public void MoverA(Casilla Casilla)
        {
            Casilla cas = Casilla;

            casillaAnterior = this.casilla;
            if (cas.Ocupada)
            {
                cas.pieza.gameObject.SetActive(false);
            }
            this.transform.position  = cas.posicion;
            this.SeMovio             = true;
            casillaAnterior.Ocupada  = false;
            casillaAnterior.Ocupable = false;
            Movimiento nuevoMov = new Movimiento(this, Casilla);

            AjedrezSupremo.MostarJugadas.jugadaEscrita = false;
            Partida.Movimientos.Add(nuevoMov);
        }
コード例 #19
0
        /// <summary>
        /// Coloca como ocupada la casilla en la que esta la pieza
        /// </summary>
        private void PosPieza()
        {
            Vector3 pos = new Vector3(this.transform.position.x,
                                      this.transform.position.y + .2f, this.transform.position.z);

            if (Physics.Raycast(pos, -Vector3.up, out hit, 0.4f))
            {
                if (hit.collider.gameObject.GetComponent <AjedrezSupremo.Juego.Casilla> () != null)
                {
                    casilla         = hit.collider.gameObject.GetComponent <AjedrezSupremo.Juego.Casilla> ();
                    casillaActual   = casilla.nombre;
                    casilla.Ocupada = true;
                    casilla.pieza   = this;
                }
            }
            if (this.casilla.Ocupable)
            {
                this.Amenazada = true;
            }
            else
            {
                Amenazada = false;
            }
        }
コード例 #20
0
ファイル: ControlJuego.cs プロジェクト: oscarpavon/ajedrez
		Movimiento CrearUnMovimiento (EstadoDeJuego estado) {
			Juego.Pieza pieza = Partida.ListaDePiezas[0];
			Juego.Casilla casilla = Partida.ListaDeCasillas[1];
			Movimiento movimientoUno = new Movimiento (pieza, casilla, estado);
			return movimientoUno;
		}
コード例 #21
0
        /// <summary>
        /// Crear un movimiento para caculos de posiciones
        /// </summary>
        /// <returns></returns>

        public Movimiento CrearJugadaLogica(Casilla casAmover)
        {
            Movimiento movLogico = new Movimiento(this, casAmover);

            return(movLogico);
        }