public void ValidarPosicaoDeDestino(Posicao origem, Posicao destino)
{
if (!Tabuleiro.GetPeca(origem).MovimentoPossivel(destino))
{
throw new TabuleiroException("Posição de destino inválida!");
}
}
public static void drawTabuleiro(Tabuleiro tabuleiro, SpriteBatch sp,
Texture2D textura, SpriteFont fonte)
{
Peca fakePeca = new Peca(corPeca.Branca);
if (tabuleiro != null)
{
for (int lin = 0; lin < tabuleiro.Altura; lin++)
{
for (int col = 0; col < tabuleiro.Largura; col++)
{
Peca peca = tabuleiro.GetPeca(lin, col);
if (peca != null)
{
DrawObjeto.drawPeca(peca, sp, textura);
}
else
{
fakePeca.Linha = lin;
fakePeca.Coluna = col;
DrawObjeto.drawPeca(fakePeca, sp, textura);
}
}
}
String texto = " 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |";
sp.DrawString(fonte, texto, new Vector2(0, 8 * Peca.Tamanho), Color.Yellow);
}
}
public static void ImprimirTabuleiro(Tabuleiro tab, bool[,] matriz)
{
ConsoleColor originalBg = Console.BackgroundColor;
ConsoleColor alternativeBg = ConsoleColor.Cyan;
for (int i = 0; i < tab.Linhas; i++)
{
Console.Write(8 - i + " ");
for (int j = 0; j < tab.Colunas; j++)
{
if (matriz[i, j])
{
Console.BackgroundColor = alternativeBg;
}
else
{
Console.BackgroundColor = originalBg;
}
ImprimirPeca(tab.GetPeca(i, j));
Console.BackgroundColor = originalBg;
}
Console.WriteLine();
}
Console.WriteLine(" A B C D E F G H");
}
public static void imprimirTabuleiro(Tabuleiro tab, bool[,] posicoesPossiveis)
{
ConsoleColor fundoOriginal = Console.BackgroundColor;
ConsoleColor fundoAlterado = ConsoleColor.DarkGray;
Console.WriteLine();
for (int i = 0; i < tab.Linhas; i++)
{
Console.Write(8 - i + " ");
for (int j = 0; j < tab.Colunas; j++)
{
if (posicoesPossiveis[i, j] == true)
{
Console.BackgroundColor = fundoAlterado;
}
else
{
Console.BackgroundColor = fundoOriginal;
}
imprimirPeca(tab.GetPeca(i, j));
Console.BackgroundColor = fundoOriginal;
}
Console.WriteLine();
}
Console.WriteLine(" a b c d e f g h");
Console.BackgroundColor = fundoOriginal;
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicaoAux = new Posicao();
#region Movimentos para esquerda
posicaoAux.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
if (Tabuleiro.GetPeca(posicaoAux) != null && Tabuleiro.GetPeca(posicaoAux).Cor != Cor)
{
break;
}
posicaoAux.Coluna -= 1;
}
#endregion
#region Movimentos para direita
posicaoAux.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
if (Tabuleiro.GetPeca(posicaoAux) != null && Tabuleiro.GetPeca(posicaoAux).Cor != Cor)
{
break;
}
posicaoAux.Coluna += 1;
}
#endregion
#region Movimentos para cima
posicaoAux.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
if (Tabuleiro.GetPeca(posicaoAux) != null && Tabuleiro.GetPeca(posicaoAux).Cor != Cor)
{
break;
}
posicaoAux.Linha -= 1;
}
#endregion
#region Movimentos para baixo
posicaoAux.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
if (Tabuleiro.GetPeca(posicaoAux) != null && Tabuleiro.GetPeca(posicaoAux).Cor != Cor)
{
break;
}
posicaoAux.Linha += 1;
}
#endregion
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
var movimentosPossiveis = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
var posicao = new Posicao(0, 0);
posicao.AlterarPosicao(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != Cor)
{
break;
}
posicao.AlterarPosicao(posicao.Linha - 1, posicao.Coluna - 1);
}
posicao.AlterarPosicao(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != Cor)
{
break;
}
posicao.AlterarPosicao(posicao.Linha - 1, posicao.Coluna + 1);
}
posicao.AlterarPosicao(Posicao.Linha + 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != Cor)
{
break;
}
posicao.AlterarPosicao(posicao.Linha + 1, posicao.Coluna - 1);
}
posicao.AlterarPosicao(Posicao.Linha + 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != Cor)
{
break;
}
posicao.AlterarPosicao(posicao.Linha + 1, posicao.Coluna + 1);
}
return(movimentosPossiveis);
}
public static void imprimeTabuleiro(Tabuleiro tab)
{
for (int i = 0; i < tab.linhas; i++)
{
Console.Write(((tab.linhas) - i) + " ");
for (int j = 0; j < tab.colunas; j++)
{
if (tab.GetPeca(i, j) == null)
{ //Imprime o traço caso não existam peças na posição
Console.Write("- ");
}
else
{
//Imprime a Peça de Acordo Se É Branca ou Preta
Peca aux = tab.GetPeca(i, j);
if (aux.cor == Cor.Branca)
{
Console.Write(aux + " ");
}
else
{
ConsoleColor auxcolor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(aux + " ");
Console.ForegroundColor = auxcolor;
}
}
}
//Parte para a proxíma linha quando todas as colunas da linha forem percorridas
Console.WriteLine();
}
for (int j = 0; j < tab.colunas; j++)
{
if (j == 0)
{
Console.Write(" ");
}
Console.Write(" " + (char)('A' + j));
}
Console.WriteLine();
}
public static void ImprimirTabuleiro(Tabuleiro tab)
{
for (int i = 0; i < tab.Linha; i++)
{
for (int j = 0; j < tab.Coluna; j++)
{
if (tab.GetPeca(i, j) == null)
{
Console.Write("- ");
}
else
{
Console.Write(tab.GetPeca(i, j) + " ");
}
}
Console.WriteLine();
}
}
public override bool[,] MovimentosPossiveis()
{
bool[,] MatrizMovimentosPossiveis = new bool[this.Tabuleiro.Linhas, this.Tabuleiro.Colunas];
Posicao posicao = new Posicao(0, 0);
// acima
posicao.DefinirValores(this.Posicao.Linha - 1, this.Posicao.Coluna);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
MatrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.MoverPosicaoAcima();
}
// abaixo
posicao.DefinirValores(this.Posicao.Linha + 1, this.Posicao.Coluna);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
MatrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.MoverPosicaoAbaixo();
}
// direita
posicao.DefinirValores(this.Posicao.Linha, this.Posicao.Coluna + 1);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
MatrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.MoverPosicaoDireita();
}
// esquerda
posicao.DefinirValores(this.Posicao.Linha, this.Posicao.Coluna - 1);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
MatrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.MoverPosicaoEsquerda();
}
return(MatrizMovimentosPossiveis);
}
public static void ImprimirTabuleiro(Tabuleiro tab)
{
for (int i = 0; i < tab.Linhas; i++)
{
Console.Write((8 - i) + " ");
for (int j = 0; j < tab.Colunas; j++)
{
if (tab.GetPeca(i, j) == null)
{
Console.Write("-" + " ");
}
else
{
ImprimePeca(tab.GetPeca(i, j));
}
}
Console.WriteLine();
}
Console.WriteLine(" a b c d e f g h");
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.NumLinhas, Tabuleiro.NumColunas];
Posicao pos = new Posicao(0, 0);
// NO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.GetPeca(pos) != null && Tabuleiro.GetPeca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha - 1, pos.Coluna - 1);
}
// NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.GetPeca(pos) != null && Tabuleiro.GetPeca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha - 1, pos.Coluna + 1);
}
// SE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.GetPeca(pos) != null && Tabuleiro.GetPeca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha + 1, pos.Coluna + 1);
}
// SO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.GetPeca(pos) != null && Tabuleiro.GetPeca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha + 1, pos.Coluna - 1);
}
return(matriz);
}
public static void ImprimirTabuleiro(Tabuleiro tab)
{
for (int i = 0; i < tab.Linhas; i++)
{
Console.Write(8 - i + " ");
for (int j = 0; j < tab.Colunas; j++)
{
ImprimirPeca(tab.GetPeca(i, j));
}
Console.WriteLine();
}
Console.WriteLine(" a b c d e f g h");
}
public void ValidarPosicaoDeOrigem(Posicao pos)
{
if (Tabuleiro.GetPeca(pos) == null)
{
throw new TabuleiroException("Não existe peça na posição de origem escolhida!");
}
if (JogadorAtual != Tabuleiro.GetPeca(pos).Cor)
{
throw new TabuleiroException("A peça de origem escolhida não é sua!");
}
if (!Tabuleiro.GetPeca(pos).ExisteMovimentosPossiveis())
{
throw new TabuleiroException("Não há movimentos possíveis para a peça de origem escolhida!");
}
}
public static void ImprimirTabuleiro(Tabuleiro tabuleiro, bool[,] posicoesPossiveis)
{
Console.WriteLine();
for (int l = 0; l < tabuleiro.Linhas; l++)
{
Console.Write(" " + (8 - l) + " ");
for (int c = 0; c < tabuleiro.Colunas; c++)
{
ImprimirPeca(tabuleiro.GetPeca(new Posicao(l, c)), posicoesPossiveis[l, c]);
}
Console.WriteLine();
}
Console.WriteLine(" A B C D E F G H\n");
}
public static void ImprimirTabuleiro(Tabuleiro tabuleiro, bool[,] m = null)
{
for (int i = 0; i < tabuleiro.Linhas; i++)
{
ImprimirPosicaoXadrez($"{8 - i} ", false);
for (int j = 0; j < tabuleiro.Colunas; j++)
{
ConsoleColor corDeFundo = (m != null && m[i, j]) ? ConsoleColor.DarkGray : ConsoleColor.Black;
ImprimirPeca(tabuleiro.GetPeca(i, j), corDeFundo);
}
Console.WriteLine();
}
ImprimirPosicaoXadrez(" a b c d e f g h ", true);
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (EstaEmXeque(JogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = Tabuleiro.GetPeca(destino);
// Promoção do peão
if (p is Peao)
{
if ((p.Cor == Cor.Branca && destino.Linha == 0) || (p.Cor == Cor.Preta && destino.Linha == 7))
{
p = Tabuleiro.RetirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(Tabuleiro, p.Cor);
Tabuleiro.ColocarPeca(dama, destino);
pecas.Add(dama);
}
}
Xeque = (EstaEmXeque(Adversaria(JogadorAtual))) ? true : false;
if (TesteXequeMate(Adversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
// En passant
VulneravelEnPassant = (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2)) ? p : null;
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (EstaEmXeque(JogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em Xeque!");
}
Peca peca = Tabuleiro.GetPeca(destino);
// Jogada especial
// Promoção
if (peca is Peao)
{
if ((peca.Cor == Cor.Branco && destino.Linha == 0) ||
(peca.Cor == Cor.Preto && destino.Linha == 7))
{
peca = Tabuleiro.RetirarPeca(destino);
_pecas.Remove(peca);
Peca rainha = new Rainha(Tabuleiro, peca.Cor);
Tabuleiro.ColocarPeca(rainha, destino);
}
}
Xeque = EstaEmXeque(Adversário(JogadorAtual));
if (XequeMate(Adversário(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
AlternaJogador();
}
}
public void RealizarJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (ReiEstaEmXeque(JogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca peca = Tabuleiro.GetPeca(destino);
if (peca is Peao)
{
PromocaoDoPeao(peca, destino);
}
Xeque = ReiEstaEmXeque(GetAdversario(JogadorAtual));
if (TesteXequeMate(GetAdversario(JogadorAtual)))
{
Terminada = true;
}
else
{
PassaTurno();
MudaJogador();
}
if (peca is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravelEnPassant = peca;
}
else
{
VulneravelEnPassant = null;
}
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.NumLinhas, Tabuleiro.NumColunas];
Posicao pos = new Posicao(0, 0);
if (Cor == Cor.Branca)
{
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoEValida(pos) && livre(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
if (Tabuleiro.PosicaoEValida(pos) && livre(pos) && QtdeMovimentos == 0 && !existeInimigo(new Posicao(Posicao.Linha - 1, Posicao.Coluna)))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoEValida(pos) && existeInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoEValida(pos) && existeInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// En passant
if (Posicao.Linha == 3)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoEValida(esquerda) && existeInimigo(esquerda) && Tabuleiro.GetPeca(esquerda) == partida.VulneravelEnPassant)
{
matriz[esquerda.Linha - 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoEValida(direita) && existeInimigo(direita) && Tabuleiro.GetPeca(direita) == partida.VulneravelEnPassant)
{
matriz[direita.Linha - 1, direita.Coluna] = true;
}
}
}
else
{
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoEValida(pos) && livre(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
if (Tabuleiro.PosicaoEValida(pos) && livre(pos) && QtdeMovimentos == 0 && !existeInimigo(new Posicao(Posicao.Linha + 1, Posicao.Coluna)))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoEValida(pos) && existeInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoEValida(pos) && existeInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// En passant
if (Posicao.Linha == 4)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoEValida(esquerda) && existeInimigo(esquerda) && Tabuleiro.GetPeca(esquerda) == partida.VulneravelEnPassant)
{
matriz[esquerda.Linha + 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoEValida(direita) && existeInimigo(direita) && Tabuleiro.GetPeca(direita) == partida.VulneravelEnPassant)
{
matriz[direita.Linha + 1, direita.Coluna] = true;
}
}
}
return(matriz);
}
private bool livre(Posicao pos)
{
return(Tabuleiro.GetPeca(pos) == null);
}
private bool existeInimigo(Posicao pos)
{
Peca p = Tabuleiro.GetPeca(pos);
return(p != null && p.Cor != Cor);
}
private bool Livre(Posicao posicao) => Tabuleiro.GetPeca(posicao) == null;
public static void imprimeTabuleiro(Tabuleiro tab, bool[,] movimentosPossiveis)
{
ConsoleColor fundOrginal = Console.BackgroundColor;
ConsoleColor fundoMarcado = ConsoleColor.DarkGray;
for (int i = 0; i < tab.linhas; i++)
{
Console.Write(((tab.linhas) - i) + " ");
for (int j = 0; j < tab.colunas; j++)
{
if (movimentosPossiveis[i, j] == true)
{
Console.BackgroundColor = fundoMarcado;
}
else
{
Console.BackgroundColor = fundOrginal;
}
if (tab.GetPeca(i, j) == null)
{ //Imprime o traço caso não existam peças na posição
Console.Write("- ");
}
else
{
//Imprime a Peça de Acordo Se É Branca ou Preta
Peca aux = tab.GetPeca(i, j);
if (aux.cor == Cor.Branca)
{
Console.Write(aux + " ");
}
else
{
ConsoleColor auxcolor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(aux + " ");
Console.ForegroundColor = auxcolor;
}
}
Console.BackgroundColor = fundOrginal;
}
//Parte para a proxíma linha quando todas as colunas da linha forem percorridas
Console.WriteLine();
}
Console.BackgroundColor = fundOrginal;
for (int j = 0; j < tab.colunas; j++)
{
if (j == 0)
{
Console.Write(" ");
}
Console.Write(" " + (char)('A' + j));
}
Console.WriteLine();
Console.BackgroundColor = fundOrginal;
}
private bool PodeMover(Posicao posicao)
{
Peca peca = Tabuleiro.GetPeca(posicao);
return(peca == null || peca.Cor != Cor);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.NumLinhas, Tabuleiro.NumColunas];
Posicao pos = new Posicao(0, 0);
// N
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// E
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// SE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// S
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// SO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// O
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// NO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoEValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Roque
if (QtdeMovimentos == 0 && !partida.Xeque)
{
// Roque pequeno
Posicao PosT1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (testeTorreParaRoque(PosT1))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tabuleiro.GetPeca(p1) == null && Tabuleiro.GetPeca(p2) == null)
{
matriz[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
// Roque grande
Posicao PosT2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (testeTorreParaRoque(PosT2))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna - 2);
Posicao p3 = new Posicao(Posicao.Linha, Posicao.Coluna - 3);
if (Tabuleiro.GetPeca(p1) == null && Tabuleiro.GetPeca(p2) == null && Tabuleiro.GetPeca(p2) == null)
{
matriz[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(matriz);
}
private bool testeTorreParaRoque(Posicao pos)
{
Peca p = Tabuleiro.GetPeca(pos);
return(p != null && p is Torre && p.Cor == Cor && p.QtdeMovimentos == 0);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicaoAux = new Posicao();
#region Movimentos uma linha acima
posicaoAux.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
posicaoAux.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
posicaoAux.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
#endregion
#region Movimentos na mesma linha
posicaoAux.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
posicaoAux.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
#endregion
#region Movimentos uma linha abaixo
posicaoAux.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
posicaoAux.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
posicaoAux.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
}
#endregion
#region Roque
if (QtdeMovimentos == 0 && !_partidaDeXadrez.Xeque)
{
//roque pequeno
Posicao posicaoTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (TesteTorreParaRoque(posicaoTorre1))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tabuleiro.GetPeca(p1) == null && Tabuleiro.GetPeca(p2) == null)
{
matriz[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
//roque grande
Posicao posicaoTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (TesteTorreParaRoque(posicaoTorre2))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna - 2);
Posicao p3 = new Posicao(Posicao.Linha, Posicao.Coluna - 3);
if (Tabuleiro.GetPeca(p1) == null && Tabuleiro.GetPeca(p2) == null && Tabuleiro.GetPeca(p3) == null)
{
matriz[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
#endregion
return(matriz);
}
private bool ExisteInimigo(Posicao posicao)
{
Peca peca = Tabuleiro.GetPeca(posicao);
return(peca != null && peca.Cor != Cor);
}
private bool TesteTorreParaRoque(Posicao posicao)
{
Peca peca = Tabuleiro.GetPeca(posicao);
return(peca != null && peca is Torre && peca.Cor == Cor && peca.QtdeMovimentos == 0);
}
public override bool[,] MovimentosPossiveis()
{
var movimentosPossiveis = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
var posicao = new Posicao(0, 0);
posicao.AlterarPosicao(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
posicao.AlterarPosicao(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
posicao.AlterarPosicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
posicao.AlterarPosicao(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
posicao.AlterarPosicao(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
posicao.AlterarPosicao(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
posicao.AlterarPosicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
posicao.AlterarPosicao(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// Jogada especial
// Roque
if (QtdDeMovimentos == 0 && !Partida.Xeque)
{
// Roque pequeno
var posicaoTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (PossibilidadeDeRoque(posicaoTorre1))
{
var posicao1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
var posicao2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tabuleiro.GetPeca(posicao1) == null && Tabuleiro.GetPeca(posicao2) == null)
{
movimentosPossiveis[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
// Roque grande
var posicaoTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (PossibilidadeDeRoque(posicaoTorre2))
{
var posicao1 = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
var posicao2 = new Posicao(Posicao.Linha, Posicao.Coluna - 2);
var posicao3 = new Posicao(Posicao.Linha, Posicao.Coluna - 3);
if (Tabuleiro.GetPeca(posicao1) == null && Tabuleiro.GetPeca(posicao2) == null &&
Tabuleiro.GetPeca(posicao3) == null)
{
movimentosPossiveis[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(movimentosPossiveis);
}
