public ComandoMover(Pieza p, Coordenada PosInicial, Coordenada PosFinal, Pieza[,] Tablero, List <Coordenada> ListaBlanco, List <Coordenada> ListaNegros)
{
this.p = p;
this.PosInicial = PosInicial;
this.PosFinal = PosFinal;
this.Tablero = Tablero;
p.CalcularMovimientos(Tablero, PosInicial, ListaBlanco, ListaNegros, p.Color);
ListaMovBlancos = ListaBlanco;
ListaMovNegros = ListaNegros;
}
//El CalcularMovimientos del Rey es diferente porque antes debe verificar que la posicion del rey no este en la lista de movimientos
//del bando contraria asi no cae en jaque
public override void CalcularMovimientos(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
//Dependiendo del color del rey recorre una lista u otra, y compara cada posicion de estas con su posicion
//Si hay coincidencia no te deja poner al rey, caso contraria, todo normal
if (Color == 'B')
{
if (ListaNegra.Count > 0)
{
foreach (Coordenada x in ListaNegra)
{
if (x.X == Coordenadas.X && x.Y == Coordenadas.Y)
{
Console.WriteLine("No se puede poner al Rey en jaque");
Jaque = true;
}
}
if (Jaque == false)
{
UbicarRey(Tablero, Coordenadas, ListaBlanca, ListaNegra, Color);
Tablero[Coordenadas.X, Coordenadas.Y] = this;
}
}
else if (ListaNegra.Count == 0)
{
UbicarRey(Tablero, Coordenadas, ListaBlanca, ListaNegra, Color);
Tablero[Coordenadas.X, Coordenadas.Y] = this;
}
}
else if (Color == 'N')
{
if (ListaBlanca.Count > 0)
{
foreach (Coordenada c in ListaBlanca)
{
if (c.X == Coordenadas.X && c.Y == Coordenadas.Y)
{
Console.WriteLine("No se puede poner al Rey en jaque");
Jaque = true;
}
}
if (Jaque == false)
{
UbicarRey(Tablero, Coordenadas, ListaBlanca, ListaNegra, Color);
Tablero[Coordenadas.X, Coordenadas.Y] = this;
}
}
else if (ListaBlanca.Count == 0)
{
UbicarRey(Tablero, Coordenadas, ListaBlanca, ListaNegra, Color);
Tablero[Coordenadas.X, Coordenadas.Y] = this;
}
}
}
public Tablero()
{
Casilleros = new Pieza[8, 8];
for (int n = 0; n < 8; n++)
{
for (int x = 0; x < 8; x++)
{
Casilleros[n, x] = new Piezas.Vacio();
}
}
MovimientosBlancos = new List <Movimiento>();
MovimientosNegros = new List <Movimiento>();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
texture = this.Content.Load <Texture2D>("terminator");
imgGanador = this.Content.Load <Texture2D>("ganaste");
pieza = new Pieza[nPiezas, nPiezas];
cortes = nPiezas;
ganador = false;
anchoCorte = (int)(texture.Width / cortes);
altoCorte = (int)(texture.Height / cortes);
generarRompecabezas();
mesclarPiezas();
}
/**
* Coloca unas pocas figuras en el tablero para hacer una demostracion
*/
private void SpawnTodasDemo(){
//Crea la matriz de movimientos de colocar piezas
/*Para elegir la posicion de las piezas rojas*/
for (int i = 0; i < 10; i++) {
for (int j = 4; j < 8; j++) {
rRojo [i, j] = true;
}
}
/*Para elegir la posicion de las piezas azules*/
for (int i = 0; i < 10; i++) {
for (int j = 10; j < 14; j++) {
rAzul [i, j] = true;
}
}
figurasActivas = new List<GameObject>();
Piezas = new Pieza[10, 18];
//Spawn rojas
for(int i = 0; i <1; i++){
for(int j = 0; j < 1; j++){
SpawnFiguras (20, j, i);
}
}
//SpawnFiguras (18, 2, 0);
//Spawn azules
for(int i = 17; i < 18; i++){
for(int j = 1; j < 3; j++){
SpawnFiguras (j,j,i );
}
}
//Inicializa y gestiona las imagenes de cada pieza, para poder hacerlas desaparecer despues
GameObject[] arrayAddLista = GameObject.FindGameObjectsWithTag ("Plano Azul");
for(int i = 0; i < arrayAddLista.Length; i++)
planosFigAzules.Add(arrayAddLista[i]);
arrayAddLista = GameObject.FindGameObjectsWithTag ("Plano Rojo");
for(int i = 0; i < arrayAddLista.Length; i++)
planosFigRojos.Add(arrayAddLista[i]);
}
public override void CalcularMovimientos(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
MovAlfil(Tablero, Coordenadas, ListaBlanca, ListaNegra, Color);
MovTorre(Tablero, Coordenadas, ListaBlanca, ListaNegra, Color);
Tablero[Coordenadas.X, Coordenadas.Y].Img = 'r';
Console.Clear();
Console.WriteLine(" 1 2 3 4 5 6 7 8");
int var = 0;
string letras = "ABCDEFGH";
for (int f = 0; f < 8; f++)
{
Console.Write(letras[var].ToString() + " ");
var++;
for (int c = 0; c < 8; c++)
{
if (Tablero[f, c].Img == 'X')
{
Coordenada MovPos = new Coordenada(f, c);
/* MovPos.X = f;
* MovPos.Y = c;
*/
if (Color == 'B')
{
ListaBlanca.Add(MovPos);
}
else if (Color == 'N')
{
ListaNegra.Add(MovPos);
}
}
Console.Write(Tablero[f, c].Img + " ");
}
Console.WriteLine();
}
Tablero[Coordenadas.X, Coordenadas.Y] = this;
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
texture = this.Content.Load<Texture2D>("terminator");
imgGanador = this.Content.Load<Texture2D>("ganaste");
pieza = new Pieza[nPiezas,nPiezas];
cortes = nPiezas;
ganador = false;
anchoCorte = (int) (texture.Width / cortes);
altoCorte = (int) (texture.Height / cortes);
generarRompecabezas ();
mesclarPiezas ();
}
public abstract void CalcularMovimientos(Pieza [,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color);
void UbicarRey(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
//Cada try/catch corresponde a un enroque, basicamente, si tiene una torre al rango, se modifican sus posiciones
//Enroque largo************************************
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y - 3] is Torre && Tablero[Coordenadas.X, Coordenadas.Y - 3].Color == Color)
{
Console.WriteLine("Desea Realizar un enroque? (s)Si / (n)No");
char Opcion = char.Parse(Console.ReadLine());
if (Opcion == 's')
{
Pieza torre = new Torre();
Pieza vacio = new PiezaVacia();
vacio.Img = '*';
Tablero[Coordenadas.X, Coordenadas.Y].Img = '*';
torre = Tablero[Coordenadas.X, Coordenadas.Y - 3];
Tablero[Coordenadas.X, Coordenadas.Y - 3] = vacio;
Tablero[Coordenadas.X, Coordenadas.Y - 1] = torre;
Tablero[Coordenadas.X, Coordenadas.Y - 1].Img = 'T';
Coordenadas.Y -= 2;
}
else
{
}
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y + 3] is Torre && Tablero[Coordenadas.X, Coordenadas.Y + 3].Color == Color)
{
Console.WriteLine("Desea Realizar un enroque? (s)Si / (n)No");
char Opcionb = char.Parse(Console.ReadLine());
if (Opcionb == 's')
{
Pieza torre = new Torre();
Pieza vacio = new PiezaVacia();
vacio.Img = '*';
Tablero[Coordenadas.X, Coordenadas.Y].Img = '*';
torre = Tablero[Coordenadas.X, Coordenadas.Y + 3];
Tablero[Coordenadas.X, Coordenadas.Y + 3] = vacio;
Tablero[Coordenadas.X, Coordenadas.Y + 1] = torre;
Tablero[Coordenadas.X, Coordenadas.Y + 1].Img = 'T';
Coordenadas.Y += 2;
}
else
{
}
}
}
catch (IndexOutOfRangeException) { }
//Enroque corto*******************************
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y - 2] is Torre && Tablero[Coordenadas.X, Coordenadas.Y - 2].Color == Color)
{
Console.WriteLine("Desea Realizar un enroque? (s)Si / (n)No");
char Opcion = char.Parse(Console.ReadLine());
if (Opcion == 's')
{
Pieza torre = new Torre();
Pieza vacio = new PiezaVacia();
vacio.Img = '*';
Tablero[Coordenadas.X, Coordenadas.Y].Img = '*';
torre = Tablero[Coordenadas.X, Coordenadas.Y - 2];
Tablero[Coordenadas.X, Coordenadas.Y - 2] = vacio;
Tablero[Coordenadas.X, Coordenadas.Y - 1] = torre;
Tablero[Coordenadas.X, Coordenadas.Y - 1].Img = 'T';
Coordenadas.Y -= 2;
}
else
{
}
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y + 2] is Torre && Tablero[Coordenadas.X, Coordenadas.Y + 2].Color == Color)
{
Console.WriteLine("Desea Realizar un enroque? (s)Si / (n)No");
char Opcion = char.Parse(Console.ReadLine());
if (Opcion == 's')
{
Pieza torre = new Torre();
Pieza vacio = new PiezaVacia();
vacio.Img = '*';
Tablero[Coordenadas.X, Coordenadas.Y].Img = '*';
torre = Tablero[Coordenadas.X, Coordenadas.Y + 2];
Tablero[Coordenadas.X, Coordenadas.Y + 2] = vacio;
Tablero[Coordenadas.X, Coordenadas.Y + 1] = torre;
Tablero[Coordenadas.X, Coordenadas.Y + 1].Img = 'T';
Coordenadas.Y += 2;
}
else
{
}
}
}
catch (IndexOutOfRangeException) { }
// No enroque
try
{
if (Tablero[Coordenadas.X - 1, Coordenadas.Y - 1].Img == '*' || Tablero[Coordenadas.X - 1, Coordenadas.Y - 1].Color != this.Color)
{
Tablero[Coordenadas.X - 1, Coordenadas.Y - 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X - 1, Coordenadas.Y].Img == '*' || Tablero[Coordenadas.X - 1, Coordenadas.Y].Color != this.Color)
{
Tablero[Coordenadas.X - 1, Coordenadas.Y].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X - 1, Coordenadas.Y + 1].Img == '*' || Tablero[Coordenadas.X - 1, Coordenadas.Y + 1].Color != this.Color)
{
Tablero[Coordenadas.X - 1, Coordenadas.Y + 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y - 1].Img == '*' || Tablero[Coordenadas.X, Coordenadas.Y - 1].Color != this.Color)
{
Tablero[Coordenadas.X, Coordenadas.Y - 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y + 1].Img == '*' || Tablero[Coordenadas.X, Coordenadas.Y + 1].Color != this.Color)
{
Tablero[Coordenadas.X, Coordenadas.Y + 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X + 1, Coordenadas.Y - 1].Img == '*' || Tablero[Coordenadas.X + 1, Coordenadas.Y - 1].Color != this.Color)
{
Tablero[Coordenadas.X + 1, Coordenadas.Y - 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X + 1, Coordenadas.Y].Img == '*' || Tablero[Coordenadas.X + 1, Coordenadas.Y].Color != this.Color)
{
Tablero[Coordenadas.X + 1, Coordenadas.Y].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X + 1, Coordenadas.Y + 1].Img == '*' || Tablero[Coordenadas.X + 1, Coordenadas.Y + 1].Color != this.Color)
{
Tablero[Coordenadas.X + 1, Coordenadas.Y + 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
Tablero[Coordenadas.X, Coordenadas.Y].Img = 'R';
int var = 0;
string letras = "ABCDEFGH";
Console.Clear();
Console.WriteLine(" 1 2 3 4 5 6 7 8");
for (int f = 0; f < 8; f++)
{
Console.Write(letras[var].ToString() + " ");
var++;
for (int c = 0; c < 8; c++)
{
if (Tablero[f, c].Img == 'X')
{
Coordenada MovPos = new Coordenada(f, c);
/* MovPos.X = f;
* MovPos.Y = c;
*/
if (Color == 'B')
{
ListaBlanca.Add(MovPos);
}
else if (Color == 'N')
{
ListaNegra.Add(MovPos);
}
}
Console.Write(Tablero[f, c].Img + " ");
}
Console.WriteLine();
}
}
public override void CalcularMovimientos(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
try
{
if (Tablero[Coordenadas.X - 1, Coordenadas.Y + 2].Color != this.Color || Tablero[Coordenadas.X - 1, Coordenadas.Y + 2].Img == '*')
{
Tablero[Coordenadas.X - 1, Coordenadas.Y + 2].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X - 2, Coordenadas.Y + 1].Color != this.Color || Tablero[Coordenadas.X - 2, Coordenadas.Y + 1].Img == '*')
{
Tablero[Coordenadas.X - 2, Coordenadas.Y + 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X - 1, Coordenadas.Y - 2].Color != this.Color || Tablero[Coordenadas.X - 1, Coordenadas.Y - 2].Img == '*')
{
Tablero[Coordenadas.X - 1, Coordenadas.Y - 2].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X - 2, Coordenadas.Y - 1].Color != this.Color || Tablero[Coordenadas.X - 2, Coordenadas.Y - 1].Img == '*')
{
Tablero[Coordenadas.X - 2, Coordenadas.Y - 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X + 1, Coordenadas.Y + 2].Color != this.Color || Tablero[Coordenadas.X + 1, Coordenadas.Y + 2].Img == '*')
{
Tablero[Coordenadas.X + 1, Coordenadas.Y + 2].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X + 2, Coordenadas.Y + 1].Color != this.Color || Tablero[Coordenadas.X + 2, Coordenadas.Y + 1].Img == '*')
{
Tablero[Coordenadas.X + 2, Coordenadas.Y + 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X + 1, Coordenadas.Y - 2].Color != this.Color || Tablero[Coordenadas.X + 1, Coordenadas.Y - 2].Img == '*')
{
Tablero[Coordenadas.X + 1, Coordenadas.Y - 2].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X + 2, Coordenadas.Y - 1].Color != this.Color || Tablero[Coordenadas.X + 2, Coordenadas.Y - 1].Img == '*')
{
Tablero[Coordenadas.X + 2, Coordenadas.Y - 1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { }
Tablero[Coordenadas.X, Coordenadas.Y].Img = 'C';
Console.Clear();
Console.WriteLine(" 1 2 3 4 5 6 7 8");
int var = 0;
string letras = "ABCDEFGH";
for (int f = 0; f < 8; f++)
{
Console.Write(letras[var].ToString() + " ");
var++;
for (int c = 0; c < 8; c++)
{
if (Tablero[f, c].Img == 'X')
{
Coordenada MovPos = new Coordenada(f, c);
/* MovPos.X = f;
* MovPos.Y = c;
*/
if (Color == 'B')
{
ListaBlanca.Add(MovPos);
}
else if (Color == 'N')
{
ListaNegra.Add(MovPos);
}
}
Console.Write(Tablero[f, c].Img + " ");
}
Console.WriteLine();
}
Tablero[Coordenadas.X, Coordenadas.Y] = this;
}
public override void CalcularMovimientos(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
}
public Tablero()
{
this.tablero = new Pieza[8, 8];
}
public Tablero(int lineas, int columnas)
{
this.lineas = lineas;
this.columnas = columnas;
piezas = new Pieza[lineas, columnas];
}
//Esto recibe al tablero, ambas listas, y el color de la pieza que se esta poniendo, tambien la posicion donde se va a poner a la misma
public override void CalcularMovimientos(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
//Estas varibles son para que el alfil pueda marcar sus diagonales progresivamente
int VarX1 = 1;
int VarX2 = 1;
int VarX3 = 1;
int VarX4 = 1;
int VarY1 = 1;
int VarY2 = 1;
int VarY3 = 1;
int VarY4 = 1;
//Estas 4 variables, cuando se vuelven true, evitan que el alfin siga marcando posibles posiciones en una diagonal
bool BlockUL = false; //Arriba Izquierda
bool BlockDL = false; //Abajo Izquierda
bool BlockUR = false; //Arriba Derecha
bool BlockDR = false; //Abajo Derecha
for (int i = 0; i < 7; i++)
{ //Uso try y catch para marca, asi en caso de que el alfil intente marcar fuera del array no salte un error
//sino que deja de marcar (como si fuera un limitador), cada try/catch corresponde a una diagonal
try
{
if (Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img == '*' && BlockDR == false)
{
Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img = 'X';
}
else if (Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img != '*' && Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Color == this.Color)
{
BlockDR = true;
}
else if (Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img != '*' && Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Color != this.Color)
{
BlockDR = true;
Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
try
{
if (Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img == '*' && BlockUR == false)
{
Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img = 'X';
}
else if (Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img != '*' && Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Color == this.Color)
{
BlockUR = true;
}
else if (Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img != '*' && Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Color != this.Color)
{
BlockUR = true;
Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
try
{
if (Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img == '*' && BlockDL == false)
{
Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img = 'X';
}
else if (Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img != '*' && Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Color == this.Color)
{
BlockDL = true;
}
else if (Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img != '*' && Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Color != this.Color)
{
BlockDL = true;
Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
try
{
if (Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img == '*' && BlockUL == false)
{
Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img = 'X';
}
else if (Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img != '*' && Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Color == this.Color)
{
BlockUL = true;
}
else if (Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img != '*' && Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Color != this.Color)
{
BlockUL = true;
Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
VarX1++;
VarY1++;
VarX2++;
VarY2++;
VarX3++;
VarY3++;
VarX4++;
VarY4++;
}
//Por ultimo muestra el tablero con los posibles movimientos marcados con X
//Al salir de esta funcion, en el main, el tablero borra las X y solo muestra la pieza
Tablero[Coordenadas.X, Coordenadas.Y].Img = 'A';
Console.Clear();
Console.WriteLine(" 1 2 3 4 5 6 7 8");
int var = 0;
string letras = "ABCDEFGH";
for (int f = 0; f < 8; f++)
{
Console.Write(letras[var].ToString() + " ");
var++;
for (int c = 0; c < 8; c++)
{
//Como el alfil marco sus posibles movimientos con X, esto recorre el tablero y si es una X lo agrega
//A la lista de posibles movimientos, obviamente dependiendo del color del alfil va a una lista u otra
if (Tablero[f, c].Img == 'X')
{
Coordenada MovPos = new Coordenada(f, c);
/* MovPos.X = f;
* MovPos.Y = c;
*/
if (Color == 'B')
{
ListaBlanca.Add(MovPos);
}
else if (Color == 'N')
{
ListaNegra.Add(MovPos);
}
}
Console.Write(Tablero[f, c].Img + " ");
}
Console.WriteLine();
}
Tablero[Coordenadas.X, Coordenadas.Y] = this; //Esto es para que en el tablero, cambie la pieza por esta
}
void MovTorre(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
int VarX = 1;
int VarY = 1;
bool BlockD = false; //Abajo
bool BlockU = false; //Arriba
bool BlockL = false; //Izquierda
bool BlockR = false; //Derecha
for (int i = 0; i < 8; i++)
{
try
{
if (Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img == '*' && BlockD == false)
{
Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img = 'X';
}
else if (Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img != '*' && this.Color == Tablero[Coordenadas.X + VarX, Coordenadas.Y].Color)
{
BlockD = true;
}
else if (Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img != '*' && this.Color != Tablero[Coordenadas.X + VarX, Coordenadas.Y].Color)
{
Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img = 'X';
BlockD = true;
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img == '*' && BlockU == false)
{
Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img = 'X';
}
else
if (Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img != '*' && Tablero[Coordenadas.X - VarX, Coordenadas.Y].Color == this.Color)
{
BlockU = true;
}
else if (Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img != '*' && Tablero[Coordenadas.X - VarX, Coordenadas.Y].Color != this.Color)
{
Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img = 'X';
BlockU = true;
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img == '*' && BlockR == false)
{
Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img = 'X';
}
else if (Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y + VarY].Color == this.Color)
{
BlockR = true;
}
else if (Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y + VarY].Color != this.Color)
{
Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img = 'X';
BlockR = true;
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img == '*' && BlockL == false)
{
Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img = 'X';
}
else if (Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y - VarY].Color == this.Color)
{
BlockL = true;
}
else if (Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y - VarY].Color != this.Color)
{
Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img = 'X';
BlockL = true;
}
}
catch (IndexOutOfRangeException) { }
Tablero[Coordenadas.X, Coordenadas.Y].Img = 'T';
VarX++;
VarY++;
}
}
void MovAlfil(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
int VarX1 = 1;
int VarX2 = 1;
int VarX3 = 1;
int VarX4 = 1;
int VarY1 = 1;
int VarY2 = 1;
int VarY3 = 1;
int VarY4 = 1;
bool BlockUL = false; //Arriba Izquierda
bool BlockDL = false; //Abajo Izquierda
bool BlockUR = false; //Arriba Derecha
bool BlockDR = false; //Abajo Derecha
for (int i = 0; i < 7; i++)
{
try
{
if (Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img == '*' && BlockDR == false)
{
Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img = 'X';
}
else if (Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img != '*' && Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Color == this.Color)
{
BlockDR = true;
}
else if (Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img != '*' && Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Color != this.Color)
{
BlockDR = true;
Tablero[Coordenadas.X + VarX1, Coordenadas.Y + VarY1].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
try
{
if (Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img == '*' && BlockUR == false)
{
Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img = 'X';
}
else if (Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img != '*' && Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Color == this.Color)
{
BlockUR = true;
}
else if (Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img != '*' && Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Color != this.Color)
{
BlockUR = true;
Tablero[Coordenadas.X - VarX2, Coordenadas.Y + VarY2].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
try
{
if (Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img == '*' && BlockDL == false)
{
Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img = 'X';
}
else if (Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img != '*' && Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Color == this.Color)
{
BlockDL = true;
}
else if (Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img != '*' && Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Color != this.Color)
{
BlockDL = true;
Tablero[Coordenadas.X + VarX3, Coordenadas.Y - VarY3].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
try
{
if (Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img == '*' && BlockUL == false)
{
Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img = 'X';
}
else if (Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img != '*' && Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Color == this.Color)
{
BlockUL = true;
}
else if (Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img != '*' && Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Color != this.Color)
{
BlockUL = true;
Tablero[Coordenadas.X - VarX4, Coordenadas.Y - VarY4].Img = 'X';
}
}
catch (IndexOutOfRangeException) { };
VarX1++;
VarY1++;
VarX2++;
VarY2++;
VarX3++;
VarY3++;
VarX4++;
VarY4++;
}
}
/**
* Coloca todas las figuras en el tablero
*/
private void SpawnTodas(){
//Crea la matriz de movimientos de colocar piezas
//Para elegir la posicion de las piezas rojas
for (int i = 0; i < 10; i++) {
for (int j = 4; j < 8; j++) {
rRojo [i, j] = true;
}
}
/*Para elegir la posicion de las piezas azules*/
for (int i = 0; i < 10; i++) {
for (int j = 10; j < 14; j++) {
rAzul [i, j] = true;
}
}
figurasActivas = new List<GameObject>();
Piezas = new Pieza[10, 18];
//Spawn rojas
SpawnFiguras (12, 0, 0); //1 bandera
for(int i = 1; i<7; i++) //6 bombas
SpawnFiguras (13, i, 0);
for(int i = 7; i<10; i++) //3 comandantes
SpawnFiguras (15, i, 0);
for(int i = 0; i<8; i++) //8 exploradores
SpawnFiguras (18, i, 1);
SpawnFiguras (16, 8, 1); //2 coroneles
SpawnFiguras (16, 9, 1);
for(int i = 0; i<5; i++) //5 minadores
SpawnFiguras (21, i, 2);
for(int i = 5; i<9; i++) //4 sargentos
SpawnFiguras (22, i, 2);
SpawnFiguras (17, 9, 2); //1 espia
for(int i = 0; i<4; i++) //4 tenientes
SpawnFiguras (23, i, 3);
for(int i = 4; i<8; i++) //4 capitanes
SpawnFiguras (14, i, 3);
SpawnFiguras (19, 8, 3); //1 general
SpawnFiguras (20, 9, 3); //1 mariscal
//Spawn azules
SpawnFiguras (0, 0, 17); //1 bandera
for(int i = 1; i<7; i++) //6 bombas
SpawnFiguras (1, i, 17);
for(int i = 7; i<10; i++) //3 comandantes
SpawnFiguras (3, i, 17);
for(int i = 0; i<8; i++) //8 exploradores
SpawnFiguras (6, i, 16);
SpawnFiguras (4, 8, 16); //2 coroneles
SpawnFiguras (4, 9, 16);
for(int i = 0; i<5; i++) //5 minadores
SpawnFiguras (9, i, 15);
for(int i = 5; i<9; i++) //4 sargentos
SpawnFiguras (10, i, 15);
SpawnFiguras (5, 9, 15); //1 espia
for(int i = 0; i<4; i++) //4 tenientes
SpawnFiguras (11, i, 14);
for(int i = 4; i<8; i++) //4 capitanes
SpawnFiguras (2, i, 14);
SpawnFiguras (7, 8, 14); //1 general
SpawnFiguras (8, 9, 14); //1 mariscal
//Inicializa y gestiona las imagenes de cada pieza, para poder hacerlas desaparecer despues
GameObject[] arrayAddLista = GameObject.FindGameObjectsWithTag ("Plano Azul");
for(int i = 0; i < arrayAddLista.Length; i++)
planosFigAzules.Add(arrayAddLista[i]);
arrayAddLista = GameObject.FindGameObjectsWithTag ("Plano Rojo");
for(int i = 0; i < arrayAddLista.Length; i++)
planosFigRojos.Add(arrayAddLista[i]);
}
public override void CalcularMov(Pieza[,] tablero, Movimiento movimiento, List <Movimiento> listas)
{
MovimientosDePieza = new List <Movimiento>();
int n = 1;
if (movimiento.X + n < 7 && movimiento.Y + n < 7)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y + n] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y + n].color == color)
{
}
else if (tablero[movimiento.X + n, movimiento.Y + n].color != color)
{
tablero[movimiento.X + n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + n;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y + n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
} //listo
if (movimiento.X - n >= 0 && movimiento.Y - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y - n] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y - n].color == color)
{
}
else if (tablero[movimiento.X - n, movimiento.Y - n].color != color)
{
tablero[movimiento.X - n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - n;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y - n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
} //listo
if (movimiento.X - n >= 0 && movimiento.Y + n < 7)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y + n] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y + n].color == color)
{
}
else if (tablero[movimiento.X - n, movimiento.Y + n].color != color)
{
tablero[movimiento.X - n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + n;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y + n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
;
}
}
if (movimiento.X + n < 7 && movimiento.Y - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y - n] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y - n].color == color)
{
}
else if (tablero[movimiento.X + n, movimiento.Y - n].color != color)
{
tablero[movimiento.X + n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - n;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y - n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
} //listo
if (movimiento.X + n < 7)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y].color == color)
{
}
else if (tablero[movimiento.X + n, movimiento.Y].color != color)
{
tablero[movimiento.X + n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (movimiento.X - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y].color == color)
{
}
else if (tablero[movimiento.X - n, movimiento.Y].color != color)
{
tablero[movimiento.X - n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (movimiento.Y + n < 7)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X, movimiento.Y + n] is Vacio)
{
tablero[movimiento.X, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X;
ParaLista.Y = movimiento.Y + n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X, movimiento.Y + n].color == color)
{
}
else if (tablero[movimiento.X, movimiento.Y + n].color != color)
{
tablero[movimiento.X, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X;
ParaLista.Y = movimiento.Y + n;
ParaLista.Peso = tablero[movimiento.X, movimiento.Y + n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (movimiento.Y - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X, movimiento.Y - n] is Vacio)
{
tablero[movimiento.X, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X;
ParaLista.Y = movimiento.Y - n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X, movimiento.Y - n].color == color)
{
}
else if (tablero[movimiento.X, movimiento.Y - n].color != color)
{
tablero[movimiento.X, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X;
ParaLista.Y = movimiento.Y - n;
ParaLista.Peso = tablero[movimiento.X, movimiento.Y - n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (tablero[movimiento.X, movimiento.Y].color == 1)
{
if (movimiento.X == 7 && movimiento.Y == 4)
{
Movimiento ParaLista = new Movimiento();
if (tablero[7, 7] is Torre)
{
tablero[7, 7].Simbolo = this.Simbolo;
ParaLista.X = 7;
ParaLista.Y = 7;
listas.Add(ParaLista);
}
if (tablero[0, 7] is Torre)
{
tablero[0, 7].Simbolo = Simbolo;
ParaLista.X = 0;
ParaLista.Y = 7;
listas.Add(ParaLista);
}
}
} // negro
if (tablero[movimiento.X, movimiento.Y].color == 2)
{
if (movimiento.X == 0 && movimiento.Y == 4)
{
Movimiento ParaLista = new Movimiento();
if (tablero[7, 0] is Torre)
{
tablero[7, 0].Simbolo = this.Simbolo;
ParaLista.X = 7;
ParaLista.Y = 0;
listas.Add(ParaLista);
}
if (tablero[0, 0] is Torre)
{
tablero[0, 0].Simbolo = Simbolo;
ParaLista.X = 0;
ParaLista.Y = 0;
listas.Add(ParaLista);
}
}
} // negro
OrdenarMovs(MovimientosDePieza);
}
public virtual void CalcularMov(Pieza[,] tablero, Movimiento movimiento, List <Movimiento> listas)
{
}
static void ActualizarMovimientos(List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, Pieza[,] Tablero)
{
ListaBlanca.Clear(); //Limpia ambas listas de los movimientos viejos los cuales pudieron haber cambiado
ListaNegra.Clear();
foreach (Pieza p in Tablero)
{
//Recorre el tablero y a cada pieza le dice que calcule sus movimientos devuelta
p.CalcularMovimientos(Tablero, p.Posicion, MovPosiblesBlancos, MovPosiblesNegros, p.Color);
}
}
public override void CalcularMov(Pieza[,] tablero, Movimiento movimiento, List <Movimiento> listas)
{
MovimientosDePieza = new List <Movimiento>();
if (tablero[movimiento.X, movimiento.Y].color == 1)
{
if (movimiento.X == 6)
{
for (int n = 1; n < 4; n++)
{
if (movimiento.X - n >= 0 && movimiento.Y + 1 < 8)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y + 1] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y + 1].color == color)
{
}
else if (tablero[movimiento.X - n, movimiento.Y + 1].color != color)
{
tablero[movimiento.X - n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + 1;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y + 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (movimiento.X - n >= 0 && movimiento.Y - 1 >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y - 1] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y - 1].color == color)
{
}
else if (tablero[movimiento.X - n, movimiento.Y - 1].color != color)
{
tablero[movimiento.X - n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - 1;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y - 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (n < 3)
{
if (movimiento.X - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y].color == color)
{
break;
}
else if (tablero[movimiento.X - n, movimiento.Y].color != color)
{
break;
}
}
}
}
}
else
{
for (int n = 1; n < 3; n++)
{
if (movimiento.X - n >= 0 && movimiento.Y + 1 < 8)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y + 1] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y + 1].color == color)
{
}
else if (tablero[movimiento.X - n, movimiento.Y + 1].color != color)
{
tablero[movimiento.X - n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + 1;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y + 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
;
}
}
if (movimiento.X - n >= 0 && movimiento.Y - 1 >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y - 1] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y - 1].color == color)
{
}
else if (tablero[movimiento.X - n, movimiento.Y - 1].color != color)
{
tablero[movimiento.X - n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - 1;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y - 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (n < 2)
{
if (movimiento.X - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y].color == color)
{
break;
}
else if (tablero[movimiento.X - n, movimiento.Y].color != color)
{
break;
}
}
}
}
}
} // negro
if (tablero[movimiento.X, movimiento.Y].color == 2)
{
if (movimiento.X == 1)
{
for (int n = 1; n < 4; n++)
{
if (movimiento.X + n < 8 && movimiento.Y + 1 < 8)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y + 1] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y + 1].color == color)
{
}
else if (tablero[movimiento.X + n, movimiento.Y + 1].color != color)
{
tablero[movimiento.X + n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + 1;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y + 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (movimiento.X + n < 8 && movimiento.Y - 1 >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y - 1] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y - 1].color == color)
{
}
else if (tablero[movimiento.X + n, movimiento.Y - 1].color != color)
{
tablero[movimiento.X + n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - 1;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y - 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (n < 3)
{
if (movimiento.X + n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y].color == color)
{
break;
}
else if (tablero[movimiento.X + n, movimiento.Y].color != color)
{
break;
}
}
}
}
}
else
{
for (int n = 1; n < 3; n++)
{
if (movimiento.X + n < 8 && movimiento.Y + 1 < 8)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y + 1] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y + 1].color == color)
{
}
else if (tablero[movimiento.X + n, movimiento.Y + 1].color != color)
{
tablero[movimiento.X + n, movimiento.Y + 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + 1;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y + 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (movimiento.X + n < 8 && movimiento.Y - 1 >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y - 1] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - 1;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y - 1].color == color)
{
}
else if (tablero[movimiento.X + n, movimiento.Y - 1].color != color)
{
tablero[movimiento.X + n, movimiento.Y - 1].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - 1;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y - 1].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
}
if (n < 2)
{
if (movimiento.X + n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y].color == color)
{
break;
}
else if (tablero[movimiento.X + n, movimiento.Y].color != color)
{
break;
}
}
}
}
}
}
OrdenarMovs(MovimientosDePieza);
}
public override void CalcularMov(Pieza[,] tablero, Movimiento movimiento, List <Movimiento> listas)
{
MovimientosDePieza = new List <Movimiento>();
for (int n = 1; n < 8; n++)
{
Movimiento ParaLista = new Movimiento();
if (movimiento.X + n < 8 && movimiento.Y + n < 8)
{
if (tablero[movimiento.X + n, movimiento.Y + n] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y + n].color == color)
{
break;
}
else if (tablero[movimiento.X + n, movimiento.Y + n].color != color)
{
tablero[movimiento.X + n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y + n;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y + n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
break;
}
}
} //listo
for (int n = 1; n < 8; n++)
{
if (movimiento.X - n >= 0 && movimiento.Y - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y - n] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y - n].color == color)
{
break;
}
else if (tablero[movimiento.X - n, movimiento.Y - n].color != color)
{
tablero[movimiento.X - n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y - n;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y - n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
break;
}
}
} //listo
for (int n = 1; n < 8; n++)
{
if (movimiento.X - n >= 0 && movimiento.Y + n < 8)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X - n, movimiento.Y + n] is Vacio)
{
tablero[movimiento.X - n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X - n, movimiento.Y + n].color == color)
{
break;
}
else if (tablero[movimiento.X - n, movimiento.Y + n].color != color)
{
tablero[movimiento.X - n, movimiento.Y + n].Simbolo = Simbolo;
ParaLista.X = movimiento.X - n;
ParaLista.Y = movimiento.Y + n;
ParaLista.Peso = tablero[movimiento.X - n, movimiento.Y + n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
break;
}
}
} //listo
for (int n = 1; n < 8; n++)
{
if (movimiento.X + n < 8 && movimiento.Y - n >= 0)
{
Movimiento ParaLista = new Movimiento();
if (tablero[movimiento.X + n, movimiento.Y - n] is Vacio)
{
tablero[movimiento.X + n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - n;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
}
else if (tablero[movimiento.X + n, movimiento.Y - n].color == color)
{
break;
}
else if (tablero[movimiento.X + n, movimiento.Y - n].color != color)
{
tablero[movimiento.X + n, movimiento.Y - n].Simbolo = Simbolo;
ParaLista.X = movimiento.X + n;
ParaLista.Y = movimiento.Y - n;
ParaLista.Peso = tablero[movimiento.X + n, movimiento.Y - n].Valor;
listas.Add(ParaLista);
MovimientosDePieza.Add(ParaLista);
break;
}
}
} //listo
OrdenarMovs(MovimientosDePieza);
}
public override void CalcularMovimientos(Pieza[,] Tablero, Coordenada Coordenadas, List <Coordenada> ListaBlanca, List <Coordenada> ListaNegra, char Color)
{
int VarX = 1;
int VarY = 1;
bool BlockD = false; //Abajo
bool BlockU = false; //Arriba
bool BlockL = false; //Izquierda
bool BlockR = false; //Derecha
for (int i = 0; i < 8; i++)
{
try
{
if (Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img == '*' && BlockD == false)
{
Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img = 'X';
}
else if (Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img != '*' && this.Color == Tablero[Coordenadas.X + VarX, Coordenadas.Y].Color)
{
BlockD = true;
}
else if (Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img != '*' && this.Color != Tablero[Coordenadas.X + VarX, Coordenadas.Y].Color)
{
Tablero[Coordenadas.X + VarX, Coordenadas.Y].Img = 'X';
BlockD = true;
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img == '*' && BlockU == false)
{
Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img = 'X';
}
else
if (Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img != '*' && Tablero[Coordenadas.X - VarX, Coordenadas.Y].Color == this.Color)
{
BlockU = true;
}
else if (Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img != '*' && Tablero[Coordenadas.X - VarX, Coordenadas.Y].Color != this.Color)
{
Tablero[Coordenadas.X - VarX, Coordenadas.Y].Img = 'X';
BlockU = true;
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img == '*' && BlockR == false)
{
Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img = 'X';
}
else if (Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y + VarY].Color == this.Color)
{
BlockR = true;
}
else if (Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y + VarY].Color != this.Color)
{
Tablero[Coordenadas.X, Coordenadas.Y + VarY].Img = 'X';
BlockR = true;
}
}
catch (IndexOutOfRangeException) { }
try
{
if (Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img == '*' && BlockL == false)
{
Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img = 'X';
}
else if (Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y - VarY].Color == this.Color)
{
BlockL = true;
}
else if (Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img != '*' && Tablero[Coordenadas.X, Coordenadas.Y - VarY].Color != this.Color)
{
Tablero[Coordenadas.X, Coordenadas.Y - VarY].Img = 'X';
BlockL = true;
}
}
catch (IndexOutOfRangeException) { }
Tablero[Coordenadas.X, Coordenadas.Y].Img = 'T';
VarX++;
VarY++;
}
Console.Clear();
Console.WriteLine(" 1 2 3 4 5 6 7 8");
int var = 0;
string letras = "ABCDEFGH";
for (int f = 0; f < 8; f++)
{
Console.Write(letras[var].ToString() + " ");
var++;
for (int c = 0; c < 8; c++)
{
if (Tablero[f, c].Img == 'X')
{
Coordenada MovPos = new Coordenada(f, c);
/* MovPos.X = f;
* MovPos.Y = c;
*/
if (Color == 'B')
{
ListaBlanca.Add(MovPos);
}
else if (Color == 'N')
{
ListaNegra.Add(MovPos);
}
}
Console.Write(Tablero[f, c].Img + " ");
}
Console.WriteLine();
}
Tablero[Coordenadas.X, Coordenadas.Y] = this;
}
