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 ();
}
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;
}
}
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;
}
/// <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();
}
public Movimiento CrearJugadaEnEstado(Casilla casAmover, EstadoDeJuego estado)
{
Movimiento MovimientoEnElEstado = new Movimiento(this, casAmover, estado);
//Movimiento MovimientoEnElEstado = AjedrezSupremo.Movimiento.CrearMovimientoEnEstado();
return(MovimientoEnElEstado);
}
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();
}
void Mover(Pieza pieza, Casilla cas)
{
piezaAnterior = pieza;
pieza.MoverA(cas);
pieza.Seleccionada = false;
pieza = null;
Partida.CambiarTurno();
}
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);
}
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];
}
}
public CasillaDeEstado(Juego.Casilla cas)
{
this.CasillaDeJuego = cas;
this.Nombre = cas.nombre;
if (cas.Ocupada)
{
this.EstaOcupada = true;
this.pieza = cas.pieza;
}
}
void Mover()
{
Casilla casilla = ElegirCasilla();
piezaAnterior = piezaSeleccionada;
piezaSeleccionada.MoverA(casilla);
piezaSeleccionada.Seleccionada = false;
piezaSeleccionada = null;
Partida.CambiarTurno();
}
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);
}
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
}
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);
}
//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;
}
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());
}
//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;
}
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);
}
/// <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;
}
}
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;
}
/// <summary>
/// Crear un movimiento para caculos de posiciones
/// </summary>
/// <returns></returns>
public Movimiento CrearJugadaLogica(Casilla casAmover)
{
Movimiento movLogico = new Movimiento(this, casAmover);
return(movLogico);
}
