public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicaoAux = new Posicao(0, 0);
for (int i = -1; i <= 1; i += 2)
{
posicaoAux.DefinirValores(Posicao.Linha + i, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
if (Tabuleiro.PecaPosition(posicaoAux) != null && Tabuleiro.PecaPosition(posicaoAux).Cor != Cor)
{
break;
}
posicaoAux.Linha += i;
}
posicaoAux.DefinirValores(Posicao.Linha, Posicao.Coluna + i);
while (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
{
matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
if (Tabuleiro.PecaPosition(posicaoAux) != null && Tabuleiro.PecaPosition(posicaoAux).Cor != Cor)
{
break;
}
posicaoAux.Coluna += i;
}
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
return(mat);
}
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);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//ACIMA ESQUERDA
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ACIMA DIREITA
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//DIREITA CIMA
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//DIREITA BAIXO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ESQUERDA CIMA
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ESQUERDA BAIXO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ABAIXO DIREITA
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ABAIXO ESQUERDA
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao pos = new Posicao(0, 0);
//Norte
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(pos) && _podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.Peca(pos) != null && Tabuleiro.Peca(pos).CorPeca != CorPeca)
{
break;
}
pos.Linha = pos.Linha - 1;
}
//Sul
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(pos) && _podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.Peca(pos) != null && Tabuleiro.Peca(pos).CorPeca != CorPeca)
{
break;
}
pos.Linha = pos.Linha + 1;
}
//Leste
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(pos) && _podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.Peca(pos) != null && Tabuleiro.Peca(pos).CorPeca != CorPeca)
{
break;
}
pos.Coluna = pos.Coluna + 1;
}
//oeste
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(pos) && _podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tabuleiro.Peca(pos) != null && Tabuleiro.Peca(pos).CorPeca != CorPeca)
{
break;
}
pos.Coluna = pos.Coluna - 1;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//Anda para cima
if (Cor == Cor.Branca)
{
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
Posicao p2 = new Posicao(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(p2) && Livre(p2) && Tab.PosicaoValida(pos) && Livre(pos) && QteMovimentos == 0)
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
#region EnPassant
// Para as peças brancas só acontece na linha 3 da matriz
if (Posicao.Linha == 3)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tab.Peca(esquerda) == Partida.VulneravelEnPassant)
{
matriz[esquerda.Linha - 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(direita) && ExisteInimigo(direita) && Tab.Peca(direita) == Partida.VulneravelEnPassant)
{
matriz[direita.Linha - 1, direita.Coluna] = true;
}
}
#endregion
}
//Anda para baixo
else
{
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
Posicao p2 = new Posicao(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(p2) && Livre(p2) && Tab.PosicaoValida(pos) && Livre(pos) && QteMovimentos == 0)
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
#region EnPassant
// Para as peças pretas só acontece na linha 4 da matriz
if (Posicao.Linha == 4)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tab.Peca(esquerda) == Partida.VulneravelEnPassant)
{
matriz[esquerda.Linha + 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(direita) && ExisteInimigo(direita) && Tab.Peca(direita) == Partida.VulneravelEnPassant)
{
matriz[direita.Linha + 1, direita.Coluna] = true;
}
}
#endregion
}
return(matriz);
}
// Metodo para verificar os possiveis movimentos do do Bispo
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas]; // Criar uma matriz de linhas e colunas igual ao do tabuleiro especificado
Posicao posicao = new Posicao(0, 0);
// Verificar Nordeste
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao)) // Enquanto a posiçao for valida e posso mover para la
{
matriz[posicao.Linha, posicao.Coluna] = true; // A matriz irá receber essa posição
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor) // Se tiver peça lá e for diferente de cor para o While
{
break;
}
posicao.Linha = posicao.Linha - 1; // Para verificar a proxima posição nordeste
posicao.Coluna = posicao.Coluna - 1; // Para verificar a proxima posição nordeste
}
// Verificar Sudoeste
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
while (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao)) // Enquanto a posiçao for valida e posso mover para la
{
matriz[posicao.Linha, posicao.Coluna] = true; // A matriz irá receber essa posição
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor) // Se tiver peça lá e for diferente de cor para o While
{
break;
}
posicao.Linha = posicao.Linha + 1; // Para verificar a proxima posição sudoeste
posicao.Coluna = posicao.Coluna - 1; // Para verificar a proxima posição sudoeste
}
// Verificar Nordeste
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao)) // Enquanto a posiçao for valida e posso mover para la
{
matriz[posicao.Linha, posicao.Coluna] = true; // A matriz irá receber essa posição
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor) // Se tiver peça lá e for diferente de cor para o While
{
break;
}
posicao.Coluna = posicao.Coluna + 1; // Para verificar a proxima posição nordeste
posicao.Linha = posicao.Linha - 1; // Para verificar a proxima posição nordeste
}
// Verificar Sudeste
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
while (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao)) // Enquanto a posiçao for valida e posso mover para la
{
matriz[posicao.Linha, posicao.Coluna] = true; // A matriz irá receber essa posição
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor) // Se tiver peça lá e for diferente de cor para o While
{
break;
}
posicao.Coluna = posicao.Coluna + 1; // Para verificar a proxima posição sudeste
posicao.Linha = posicao.Linha + 1; // Para verificar a proxima posição sudeste
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicao = new Posicao(0, 0);
//acima
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna);
}
//direita
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha, posicao.Coluna + 1);
}
//abaixo
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna);
}
//esquerda
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha, posicao.Coluna - 1);
}
//NO
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna - 1);
}
//NE
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna + 1);
}
//SO
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna - 1);
}
//SE
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna + 1);
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao pos = new Posicao(0, 0);
//Acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//SE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Abaixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//SO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//NO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// #jogadaespecial roque
if (QtdMovimentos == 0 && !Partida.Cheque)
{
// #jogadaespecial 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.Peca(p1) == null && Tabuleiro.Peca(p2) == null)
{
mat[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
// #jogadaespecial 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.Peca(p1) == null && Tabuleiro.Peca(p2) == null && Tabuleiro.Peca(p3) == null)
{
mat[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicao = new Posicao(0, 0);
if (Cor == Cor.Branca)
{
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && Livre(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
posicao.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && Livre(posicao) && QtdMovimentos == 0)
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && ExisteInimigo(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && ExisteInimigo(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// #jogadaespecial En Passant
if (Posicao.Linha == 3)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tabuleiro.Peca(esquerda) == Partida.VulneravelEnPassant)
{
matriz[esquerda.Linha - 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(direita) && ExisteInimigo(direita) && Tabuleiro.Peca(direita) == Partida.VulneravelEnPassant)
{
matriz[direita.Linha - 1, direita.Coluna] = true;
}
}
}
else
{
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && Livre(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
posicao.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && Livre(posicao) && QtdMovimentos == 0)
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && ExisteInimigo(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && ExisteInimigo(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// #jogadaespecial En Passant
if (Posicao.Linha == 4)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tabuleiro.Peca(esquerda) == Partida.VulneravelEnPassant)
{
matriz[esquerda.Linha + 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(direita) && ExisteInimigo(direita) && Tabuleiro.Peca(direita) == Partida.VulneravelEnPassant)
{
matriz[direita.Linha + 1, direita.Coluna] = true;
}
}
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] movimentosPossiveis = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao p = new Posicao(0, 0);
//Norte
p.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha - 2, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha - 2, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
//Leste
p.DefinirValores(Posicao.Linha - 2, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha + 2, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
//Sul
p.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha + 2, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha + 2, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
//Oeste
p.DefinirValores(Posicao.Linha - 2, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha + 2, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
p.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 2);
if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
{
movimentosPossiveis[p.Linha, p.Coluna] = true;
}
return(movimentosPossiveis);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = 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))
{
mat[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))
{
mat[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))
{
mat[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))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.GetPeca(posicao) != null && Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.MoverPosicaoEsquerda();
}
// NO
posicao.DefinirValores(this.Posicao.Linha - 1, this.Posicao.Coluna - 1);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (this.Tabuleiro.GetPeca(posicao) != null && this.Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna - 1);
}
// NE
posicao.DefinirValores(this.Posicao.Linha - 1, this.Posicao.Coluna + 1);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (this.Tabuleiro.GetPeca(posicao) != null && this.Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna + 1);
}
// SE
posicao.DefinirValores(this.Posicao.Linha + 1, this.Posicao.Coluna + 1);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (this.Tabuleiro.GetPeca(posicao) != null && this.Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna + 1);
}
// SO
posicao.DefinirValores(this.Posicao.Linha + 1, this.Posicao.Coluna - 1);
while (this.Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (this.Tabuleiro.GetPeca(posicao) != null && this.Tabuleiro.GetPeca(posicao).Cor != this.Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna - 1);
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//Acima
pos.DefinirValores(Position.Linha - 1, Position.Coluna);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Linha -= 1;
}
//Abaixo
pos.DefinirValores(Position.Linha + 1, Position.Coluna);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Linha += 1;
}
//Direita
pos.DefinirValores(Position.Linha, Position.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Coluna += 1;
}
//Esquerda
pos.DefinirValores(Position.Linha, Position.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Coluna -= 1;
}
//Nordeste
pos.DefinirValores(Position.Linha - 1, Position.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Linha--;
pos.Coluna++;
}
//Sudeste
pos.DefinirValores(Position.Linha + 1, Position.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Linha++;
pos.Coluna++;
}
//Sudoeste
pos.DefinirValores(Position.Linha + 1, Position.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Linha++;
pos.Coluna--;
}
//Noroeste
pos.DefinirValores(Position.Linha - 1, Position.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.PegaPeca(pos) != null && Tab.PegaPeca(pos).Color != Color)
{
break;
}
pos.Linha--;
pos.Coluna--;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicao = new Posicao(0, 0);
// Acima
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Nordeste
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Direita
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Sudeste
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Abaixo
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Sudoeste
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Esquerda
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Noroestes
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// #jogadaespecial Roque
if (QtdMovimentos == 0 && !Partida.Xeque)
{
// #jogadaespecial Roque Pequeno
Posicao posicaoTorreRoquePequeno = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (TesteTorreParaRoque(posicaoTorreRoquePequeno))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tabuleiro.Peca(p1) == null && Tabuleiro.Peca(p2) == null)
{
matriz[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
// #jogadaespecial Roque Grande
Posicao posicaoTorreRoqueGrande = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (TesteTorreParaRoque(posicaoTorreRoqueGrande))
{
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.Peca(p1) == null && Tabuleiro.Peca(p2) == null && Tabuleiro.Peca(p3) == null)
{
matriz[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
if (Cor == Cor.Branca)
{
//N Direction 1
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//N Direction 2
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QteMovimentos == 0)
{
matriz[pos.Linha, pos.Coluna] = true;
}
//NW
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// #jogada especial en passant
if (Posicao.Linha == 3)
{
Posicao posicaoEsquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(posicaoEsquerda) && ExisteInimigo(posicaoEsquerda) && Tab.Peca(posicaoEsquerda) == _partida.VulneravelEnPassant)
{
matriz[posicaoEsquerda.Linha - 1, posicaoEsquerda.Coluna] = true;
}
Posicao posicaoDireita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(posicaoDireita) && ExisteInimigo(posicaoDireita) && Tab.Peca(posicaoDireita) == _partida.VulneravelEnPassant)
{
matriz[posicaoDireita.Linha - 1, posicaoDireita.Coluna] = true;
}
}
}
else
{
//S Direction 1
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//S Direction 2
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QteMovimentos == 0)
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SW
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// #jogada especial en passant
if (Posicao.Linha == 4)
{
Posicao posicaoEsquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(posicaoEsquerda) && ExisteInimigo(posicaoEsquerda) && Tab.Peca(posicaoEsquerda) == _partida.VulneravelEnPassant)
{
matriz[posicaoEsquerda.Linha + 1, posicaoEsquerda.Coluna] = true;
}
Posicao posicaoDireita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(posicaoDireita) && ExisteInimigo(posicaoDireita) && Tab.Peca(posicaoDireita) == _partida.VulneravelEnPassant)
{
matriz[posicaoDireita.Linha + 1, posicaoDireita.Coluna] = true;
}
}
}
return(matriz);
}
public override bool[,] movimentosPossiveis()
{
//A torre pode se mover para esquerda/direita/acima/abaixo até que chegue no final do tabuleiro
// ou até atingir/capturar uma peça
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
pos.linha = posicao.linha;
//NE
pos.DefinirValores(posicao.linha - 1, posicao.coluna + 1);
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha--;
pos.coluna++;
}
pos.DefinirValores(posicao.linha - 1, posicao.coluna - 1);
//NO
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha--;
pos.coluna--;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna - 1);
//SO
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha++;
pos.coluna--;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna + 1);
//SE
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha++;
pos.coluna++;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
if (cor == Cor.Branca)
{
pos.DefinirValores(posicao.linha - 1, posicao.coluna);
if (tab.PosicaoValida(pos) && livre(pos))
{
mat[pos.linha, pos.coluna] = true;
}
pos.DefinirValores(posicao.linha - 2, posicao.coluna);
if (tab.PosicaoValida(pos) && livre(pos) && qteMovimentos == 0)
{
mat[pos.linha, pos.coluna] = true;
}
pos.DefinirValores(posicao.linha - 1, posicao.coluna - 1);
if (tab.PosicaoValida(pos) && ExisteInimio(pos))
{
mat[pos.linha, pos.coluna] = true;
}
pos.DefinirValores(posicao.linha - 1, posicao.coluna + 1);
if (tab.PosicaoValida(pos) && ExisteInimio(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// #jogadaespecial en passant
if (posicao.linha == 3)
{
Posicao esquerda = new Posicao(posicao.linha, posicao.coluna - 1);
if (tab.PosicaoValida(esquerda) && ExisteInimio(esquerda) && tab.peca(esquerda) == partida.vulneravelEnPassant)
{
mat[esquerda.linha - 1, esquerda.coluna] = true;
}
Posicao direita = new Posicao(posicao.linha, posicao.coluna + 1);
if (tab.PosicaoValida(direita) && ExisteInimio(direita) && tab.peca(direita) == partida.vulneravelEnPassant)
{
mat[direita.linha - 1, direita.coluna] = true;
}
}
}
else
{
pos.DefinirValores(posicao.linha + 1, posicao.coluna);
if (tab.PosicaoValida(pos) && livre(pos))
{
mat[pos.linha, pos.coluna] = true;
}
pos.DefinirValores(posicao.linha + 2, posicao.coluna);
if (tab.PosicaoValida(pos) && livre(pos) && qteMovimentos == 0)
{
mat[pos.linha, pos.coluna] = true;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna - 1);
if (tab.PosicaoValida(pos) && ExisteInimio(pos))
{
mat[pos.linha, pos.coluna] = true;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.PosicaoValida(pos) && ExisteInimio(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// #jogadaespecial en passant
if (posicao.linha == 4)
{
Posicao esquerda = new Posicao(posicao.linha, posicao.coluna - 1);
if (tab.PosicaoValida(esquerda) && ExisteInimio(esquerda) && tab.peca(esquerda) == partida.vulneravelEnPassant)
{
mat[esquerda.linha + 1, esquerda.coluna] = true;
}
Posicao direita = new Posicao(posicao.linha, posicao.coluna + 1);
if (tab.PosicaoValida(direita) && ExisteInimio(direita) && tab.peca(direita) == partida.vulneravelEnPassant)
{
mat[direita.linha + 1, direita.coluna] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matrizMovimentosPossiveis = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicao = new Posicao(0, 0);
// acima
posicao.DefinirValores(this.Posicao.Linha - 1, this.Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// ne
posicao.DefinirValores(this.Posicao.Linha - 1, this.Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// direita
posicao.DefinirValores(this.Posicao.Linha, this.Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// se
posicao.DefinirValores(this.Posicao.Linha + 1, this.Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// abaixo
posicao.DefinirValores(this.Posicao.Linha + 1, this.Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// so
posicao.DefinirValores(this.Posicao.Linha + 1, this.Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// esquerda
posicao.DefinirValores(this.Posicao.Linha, this.Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
// no
posicao.DefinirValores(this.Posicao.Linha - 1, this.Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && this.PodeMover(posicao))
{
matrizMovimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
}
return(matrizMovimentosPossiveis);
}
public override bool[,] MovimentosPossiveisXequeMate()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
//MOVE 01
pos.DefinirValores(posicao.linha - 1, posicao.coluna - 2);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna + 1] = true;
mat[pos.linha, pos.coluna + 2] = true;
mat[pos.linha + 1, pos.coluna + 2] = true;
}
}
//MOVE 02
pos.DefinirValores(posicao.linha - 1, posicao.coluna + 2);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna - 1] = true;
mat[pos.linha, pos.coluna - 2] = true;
mat[pos.linha + 1, pos.coluna - 2] = true;
}
}
//MOVE 03
pos.DefinirValores(posicao.linha + 1, posicao.coluna - 2);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna + 1] = true;
mat[pos.linha, pos.coluna + 2] = true;
mat[pos.linha - 1, pos.coluna + 2] = true;
}
}
//MOVE 04
pos.DefinirValores(posicao.linha + 1, posicao.coluna + 2);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna - 1] = true;
mat[pos.linha, pos.coluna - 2] = true;
mat[pos.linha - 1, pos.coluna - 2] = true;
}
}
//MOVE 05
pos.DefinirValores(posicao.linha - 2, posicao.coluna - 1);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna + 1] = true;
mat[pos.linha + 1, pos.coluna] = true;
mat[pos.linha + 2, pos.coluna] = true;
}
}
//MOVE 06
pos.DefinirValores(posicao.linha - 2, posicao.coluna + 1);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna - 1] = true;
mat[pos.linha + 1, pos.coluna] = true;
mat[pos.linha + 2, pos.coluna] = true;
}
}
//MOVE 07
pos.DefinirValores(posicao.linha + 2, posicao.coluna - 1);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna + 1] = true;
mat[pos.linha - 1, pos.coluna] = true;
mat[pos.linha - 2, pos.coluna] = true;
}
}
//MOVE 08
pos.DefinirValores(posicao.linha + 2, posicao.coluna + 1);
if (tab.posicaoValida(pos) && PodeMover(pos))
{
if (tab.RetornaMatrizPeca(pos) is Rei)
{
mat[pos.linha, pos.coluna] = true;
mat[pos.linha, pos.coluna - 1] = true;
mat[pos.linha - 1, pos.coluna] = true;
mat[pos.linha - 2, pos.coluna] = true;
}
}
return(mat);
}
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);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao posicao = new Posicao(0, 0);
// acima
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// ne
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// direita
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// se
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// abaixo
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// so
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// esquerda
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// no
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(posicao) && podeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
}
// #jogadaespecial roque
if (QuantidadeMovimentos == 0 && !partida.Xeque)
{
// #jogadaespecial roque pequeno
Posicao posicaoT1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (testeTorreParaRoque(posicaoT1))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tabuleiro.Peca(p1) == null && Tabuleiro.Peca(p2) == null)
{
mat[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
// #jogadaespecial roque grande
Posicao posicaoT2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (testeTorreParaRoque(posicaoT2))
{
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.Peca(p1) == null && Tabuleiro.Peca(p2) == null && Tabuleiro.Peca(p3) == null)
{
mat[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//Acima
pos.DefinirValores(Posicao.Linha - 1, pos.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Nordeste
pos.DefinirValores(Posicao.Linha - 1, pos.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Direita
pos.DefinirValores(Posicao.Linha, pos.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Sudeste
pos.DefinirValores(Posicao.Linha + 1, pos.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Abaixo
pos.DefinirValores(Posicao.Linha + 1, pos.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Sudoete
pos.DefinirValores(Posicao.Linha + 1, pos.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Esquerda
pos.DefinirValores(Posicao.Linha, pos.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Noroeste
pos.DefinirValores(Posicao.Linha - 1, pos.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao pos = new Posicao(0, 0);
if (Cor == Cor.Branco)
{
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && Livre(pos) && QteMovimentos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//#jogada Especial El Passant
if (Posicao.Linha == 3)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tabuleiro.Peca(esquerda) == Partida.VulneravelElPassant)
{
mat[2, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(direita) && ExisteInimigo(direita) && Tabuleiro.Peca(direita) == Partida.VulneravelElPassant)
{
mat[2, direita.Coluna] = true;
}
}
}
if (Cor == Cor.Preta)
{
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && Livre(pos) && QteMovimentos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
if (Posicao.Linha == 4)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tabuleiro.Peca(esquerda) == Partida.VulneravelElPassant)
{
mat[5, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(direita) && ExisteInimigo(direita) && Tabuleiro.Peca(direita) == Partida.VulneravelElPassant)
{
mat[5, direita.Coluna] = true;
}
}
}
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
pos.linha = posicao.linha;
//acima
pos.DefinirValores(posicao.linha - 1, posicao.coluna);
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha--;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna);
//abaixo
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha++;
}
pos.DefinirValores(posicao.linha, posicao.coluna - 1);
//esquerda
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.coluna--;
}
pos.DefinirValores(posicao.linha, posicao.coluna + 1);
//direita
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.coluna++;
}
//NE
pos.DefinirValores(posicao.linha - 1, posicao.coluna + 1);
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha--;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna - 1);
//NO
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.linha++;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna - 1);
//SO
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.coluna--;
}
pos.DefinirValores(posicao.linha + 1, posicao.coluna + 1);
//SE
while (tab.posicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.coluna++;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//Esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha, pos.Coluna - 1);
}
//Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha, pos.Coluna + 1);
}
//Acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha - 1, pos.Coluna);
}
//Abaixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha + 1, pos.Coluna);
}
//NO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha - 1, pos.Coluna - 1);
}
//NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha - 1, pos.Coluna + 1);
}
//SE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha + 1, pos.Coluna + 1);
}
//SO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.peca(pos) != null && Tab.peca(pos).Cor != Cor)
{
break;
}
pos.DefinirValores(pos.Linha + 1, pos.Coluna - 1);
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao posicao = new Posicao(0, 0);
//NorOeste
posicao.DefinirValores(PosicaoPeca.Linha - 1, PosicaoPeca.Coluna - 1);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna - 1);
}
//NordEste
posicao.DefinirValores(PosicaoPeca.Linha - 1, PosicaoPeca.Coluna + 1);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna + 1);
}
//SudEste
posicao.DefinirValores(PosicaoPeca.Linha + 1, PosicaoPeca.Coluna + 1);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna + 1);
}
//SudOeste
posicao.DefinirValores(PosicaoPeca.Linha + 1, PosicaoPeca.Coluna - 1);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna - 1);
}
//acima
posicao.DefinirValores(PosicaoPeca.Linha - 1, PosicaoPeca.Coluna);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Linha -= 1;
}
//abaixo
posicao.DefinirValores(PosicaoPeca.Linha + 1, PosicaoPeca.Coluna);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Linha += 1;
}
//direita
posicao.DefinirValores(PosicaoPeca.Linha, PosicaoPeca.Coluna + 1);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Coluna += 1;
}
//esquerda
posicao.DefinirValores(PosicaoPeca.Linha, PosicaoPeca.Coluna - 1);
while (Tab.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tab.Peca(posicao) != null && Tab.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Coluna -= 1;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
// norte
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Linha = pos.Linha - 1;
}
}
// nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Coluna = pos.Coluna + 1;
pos.Linha = pos.Linha - 1;
}
}
// leste
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Coluna = pos.Coluna + 1;
}
}
// sudeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Coluna = pos.Coluna + 1;
pos.Linha = pos.Linha + 1;
}
}
// sul
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Linha = pos.Linha + 1;
}
}
// sudoeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Coluna = pos.Coluna - 1;
pos.Linha = pos.Linha + 1;
}
}
// oeste
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Coluna = pos.Coluna - 1;
}
}
// noroeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
while (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor)
{
break;
}
pos.Coluna = pos.Coluna - 1;
pos.Linha = pos.Linha - 1;
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
if (Cor == Cor.Branca)
{
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QteMovimetos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// jogada especial en passant
if (Posicao.Linha == 3)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(esquerda) &&
Tab.Peca(esquerda) == partida.VuneralvelEnPassant)
{
mat[esquerda.Linha - 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(direita) && ExisteInimigo(direita) &&
Tab.Peca(direita) == partida.VuneralvelEnPassant)
{
mat[direita.Linha - 1, direita.Coluna] = true;
}
}
}
else
{
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QteMovimetos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// jogada especial en passant
if (Posicao.Linha == 4)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(esquerda) &&
Tab.Peca(esquerda) == partida.VuneralvelEnPassant)
{
mat[esquerda.Linha + 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(direita) && ExisteInimigo(direita) &&
Tab.Peca(direita) == partida.VuneralvelEnPassant)
{
mat[direita.Linha + 1, direita.Coluna] = true;
}
}
}
return(mat);
}
// Metodo para verificar os possiveis movimentos do REI
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas]; // Criar uma matriz de linhas e colunas igual ao do tabuleiro especificado
Posicao posicao = new Posicao(0, 0);
// Verificar acima
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Verificar Nordeste
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Verificar Direita
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Verificar Sudeste
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Verificar Abaixo
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Verificar Sudoeste
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Verificar Esquerda
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Verificar Noroeste
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.TestarPosicao(posicao) && PodeMover(posicao))
{
matriz[posicao.Linha, posicao.Coluna] = true;
}
// Roque
if (QtdMovimentos == 0 && !Partida.Xeque) // Verifica se o rei ainda não moveu e se ele não está em xeque
{
// Roque pequeno
Posicao posicaoTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3); // Pega a peça que está 3 cassas ao lado direito do rei
if (TesteTorreParaRoque(posicaoTorre1)) // Se for uma torre e estiver valida para o roque
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1); // Pega a posição que está ao lado direito do rei (+ 1)
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2); // Pega a posição que está ao lado direito do rei (+ 2)
if (Tabuleiro.Peca(p1) == null && Tabuleiro.Peca(p2) == null) // Testa se as duas posições estão vazias
{
matriz[Posicao.Linha, Posicao.Coluna + 2] = true; // Então essa posição é valida
}
}
// Roque Grande
Posicao posicaoTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4); // Pega a peça que está 3 cassas ao lado direito do rei
if (TesteTorreParaRoque(posicaoTorre1)) // Se for uma torre e estiver valida para o roque
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna - 1); // Pega a posição que está ao lado direito do rei (+ 1)
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna - 2); // Pega a posição que está ao lado direito do rei (+ 2)
Posicao p3 = new Posicao(Posicao.Linha, Posicao.Coluna - 3); // Pega a posição que está ao lado direito do rei (+ 3)
if (Tabuleiro.Peca(p1) == null && Tabuleiro.Peca(p2) == null && Tabuleiro.Peca(p3) == null) // Testa se as tres posições estão vazias
{
matriz[Posicao.Linha, Posicao.Coluna - 2] = true; // Então essa posição é valida
}
}
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//NE Direction
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//NE Direction 2
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//NW Direction
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//NW Direction 2
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SE Direction
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SE Direction 2
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SW Direction
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SW Direction 2
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
return(matriz);
}