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);
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.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.Linha ++;
}
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.Coluna ++;
}
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.Coluna --;
}
return mat;
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linha, Tab.Coluna];
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 + 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 + 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;
}
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, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ABAIXO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ESQUERDA
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//DIREITA
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//SE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//SO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//NO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//JOGADA ESPECIAL ROQUE
if (QtdMovimentos == 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 (Tab.Peca(P1) == null && Tab.Peca(P2) == null)
{
mat[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 (Tab.Peca(P1) == null && Tab.Peca(P2) == null && Tab.Peca(P3) == null)
{
mat[Posicao.Linha, Posicao.Coluna - 3] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//NORTE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//NORDESTE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//LESTE
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SUDESTE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SUL
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//SUDOESTE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//OESTE
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//NOROESTE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoEhValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
return(matriz);
}
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 pos = new Posicao(0, 0);
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Jogadas especiais
if (QntMovimentos == 0 && !Partida.Xeque)
{
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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null)
{
mat[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.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, posicao.coluna);
while (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
if (tab.Peca(pos) != null &&
tab.Peca(pos).cor != cor)
// acho que está errado, tem que parar independente da cor.
{
break;
}
pos.linha = pos.linha - 1;
}
// 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)
// acho que está errado, tem que parar independente da cor.
{
break;
}
pos.linha = pos.linha + 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)
// acho que está errado, tem que parar independente da cor.
{
break;
}
pos.coluna = pos.coluna + 1;
}
// 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)
// acho que está errado, tem que parar independente da cor.
{
break;
}
pos.coluna = pos.coluna - 1;
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//verificando acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//verificando nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//verificando direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//verificando sudeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//verificando abaixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//verificando sudoeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//verificando esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//verificando noroeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// #jogadaespecial roque
if (QtdMovimentos == 0 && !Partida.Xeque)
{
//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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null)
{
mat[pos.Linha, pos.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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.Peca(p3) == null)
{
mat[pos.Linha, pos.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, Posicao.Coluna - 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ABAIXO
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//ESQUERDA
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//DIREITA
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//NE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 2);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//SE
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//SO
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//NO
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[,] 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;
}
//Capturar pecas adversarias
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;
}
// #jogadaespecial 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.VulneravelEnPassant)
{
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.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;
}
//Capturar pecas adversarias
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;
}
// #jogadaespecial 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.VulneravelEnPassant)
{
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.VulneravelEnPassant)
{
mat[direita.linha + 1, direita.coluna] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
if (Cor == Cor.Branca)
{
//cima
pos.DefinirValores(Pos.Linha - 1, Pos.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//cima - primeira jogada
pos.DefinirValores(Pos.Linha - 2, Pos.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QtdeMovimentos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
//cima - direita - capturar inimigo
pos.DefinirValores(Pos.Linha - 1, Pos.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//cima - esquerda - capturar inimigo
pos.DefinirValores(Pos.Linha - 1, Pos.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//#jogadaEspecial - en passant
if (Pos.Linha == 3)
{
Posicao esquerda = new Posicao(Pos.Linha, Pos.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tab.Peca(esquerda) == Partida.vulneravelEnPassant)
{
mat[esquerda.Linha - 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Pos.Linha, Pos.Coluna + 1);
if (Tab.PosicaoValida(direita) && ExisteInimigo(direita) && Tab.Peca(direita) == Partida.vulneravelEnPassant)
{
mat[direita.Linha - 1, direita.Coluna] = true;
}
}
}
else
{
//baixo
pos.DefinirValores(Pos.Linha + 1, Pos.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//baixo - primeira jogada
pos.DefinirValores(Pos.Linha + 2, Pos.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QtdeMovimentos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
//baixo - direita - capturar inimigo
pos.DefinirValores(Pos.Linha + 1, Pos.Coluna + 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//baixo - esquerda - capturar inimigo
pos.DefinirValores(Pos.Linha + 1, Pos.Coluna - 1);
if (Tab.PosicaoValida(pos) && ExisteInimigo(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//#jogadaEspecial - en passant
if (Pos.Linha == 4)
{
Posicao esquerda = new Posicao(Pos.Linha, Pos.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(esquerda) && Tab.Peca(esquerda) == Partida.vulneravelEnPassant)
{
mat[esquerda.Linha + 1, esquerda.Coluna] = true;
}
Posicao direita = new Posicao(Pos.Linha, Pos.Coluna + 1);
if (Tab.PosicaoValida(direita) && ExisteInimigo(direita) && Tab.Peca(direita) == Partida.vulneravelEnPassant)
{
mat[direita.Linha + 1, direita.Coluna] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tabuleiro.Linha, Tabuleiro.Coluna];
Posicao posicao = new Posicao(0, 0);
//acima
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Linha--;
}
//abaixo
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Linha++;
}
//direita
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Coluna++;
}
//esquerda
posicao.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.Coluna--;
}
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna - 1);
}
posicao.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha - 1, posicao.Coluna + 1);
}
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[posicao.Linha, posicao.Coluna] = true;
if (Tabuleiro.Peca(posicao) != null && Tabuleiro.Peca(posicao).Cor != Cor)
{
break;
}
posicao.DefinirValores(posicao.Linha + 1, posicao.Coluna + 1);
}
posicao.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
{
mat[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(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
//Serão descritos os movimentos do Rei.
//Norte
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Sudeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Sul
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Sudoeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Oeste
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Noroeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.VerificarPosicao(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// #JogadaEspecial Roque
if (QtdMovimentos == 0 && !partida.Xeque)
{
// #JogadaEspecial Roque Pequeno
Posicao PosTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (TesteTorreParaRoque(PosTorre1))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tab.Peca(p1) == null && Tab.Peca(p2) == null)
{
mat[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
// #JogadaEspecial Roque Grande
Posicao PosTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (TesteTorreParaRoque(PosTorre2))
{
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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.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, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Sudeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Abaixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Suldoeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// #JOGADA ESPECIAL: ROQUE
if (QteMovimentos == 0 && !Partida.Xeque)
{
//JOGADA ESPECIAL: ROQUE PEQUENO
Posicao PosTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (TesteTorreParaRoque(PosTorre1))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tab.Peca(p1) == null && Tab.Peca(p2) == null)
{
mat[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
// JOGADA ESPECIAL: ROQUE GRANDE
Posicao PosTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (TesteTorreParaRoque(PosTorre2))
{
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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.Peca(p3) == null)
{
mat[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linha, Tabuleiro.Coluna];
Posicao pos = new Posicao(0, 0);
//ne1
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//ne2
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 2);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//se1
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 2);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//se2
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//no1
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//ne2
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 2);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//se1
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 2);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//se2
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linha, Tabuleiro.Coluna];
Posicao pos = new Posicao(0, 0);
if (Cor == Cor.Branca)
{
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.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 (Tabuleiro.PosicaoValida(pos) && Livre(pos) && Livre(p2) && QtdMovimento == 0)
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//#jogada especial 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
{
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.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 (Tabuleiro.PosicaoValida(pos) && Livre(pos) && QtdMovimento == 0 && Livre(p2))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && ExisteInimigo(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//#jogada especial 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;
}
}
}
//acima
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao aux = new Posicao(0, 0);
//cima
aux.DefinirValores(Pos.Linha - 1, Pos.Coluna);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
//cima - direita
aux.DefinirValores(Pos.Linha - 1, Pos.Coluna + 1);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
//direita
aux.DefinirValores(Pos.Linha, Pos.Coluna + 1);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
//baixo - direita
aux.DefinirValores(Pos.Linha + 1, Pos.Coluna + 1);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
//baixo
aux.DefinirValores(Pos.Linha + 1, Pos.Coluna);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
//baixo - esquerda
aux.DefinirValores(Pos.Linha + 1, Pos.Coluna - 1);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
//esquerda
aux.DefinirValores(Pos.Linha, Pos.Coluna - 1);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
//cima - esquerda
aux.DefinirValores(Pos.Linha - 1, Pos.Coluna - 1);
if (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
}
if (QtdeMovimentos == 0 && !Partida.Xeque)
{
//#jogadasEspecial - roque pequeno
Posicao posTorre1 = new Posicao(Pos.Linha, Pos.Coluna + 3);
if (TesteTorreRoque(posTorre1))
{
Posicao p1 = new Posicao(Pos.Linha, Pos.Coluna + 1);
Posicao p2 = new Posicao(Pos.Linha, Pos.Coluna + 2);
if (Tab.Peca(p1) == null && Tab.Peca(p2) == null)
{
mat[Pos.Linha, Pos.Coluna + 2] = true;
}
}
//#jogadaEspecial - roque grande
Posicao posTorre2 = new Posicao(Pos.Linha, Pos.Coluna - 4);
if (TesteTorreRoque(posTorre2))
{
Posicao p1 = new Posicao(Pos.Linha, Pos.Coluna - 1);
Posicao p2 = new Posicao(Pos.Linha, Pos.Coluna - 2);
Posicao p3 = new Posicao(Pos.Linha, Pos.Coluna - 3);
if (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.Peca(p3) == null)
{
mat[Pos.Linha, Pos.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, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//sudeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//abaixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//sudoeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//noroeste
pos.DefinirValores(Posicao.Linha - 1, 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[Tab.Linhas, Tab.Colunas];
Posicao pos = new Posicao(0, 0);
if (Cor == Cor.Branca)
{
//anda uma casa para frente
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//no começo do jogo pode andar duas casas
pos.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QtdMovimentos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
//vai pegar a peça do inimigo
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.VulneravelEnPassant)
{
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.VulneravelEnPassant)
{
mat[direita.Linha - 1, direita.Coluna] = true;
}
}
}
else
{
//anda uma casa para frente
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//no começo do jogo pode andar duas casas
pos.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Livre(pos) && QtdMovimentos == 0)
{
mat[pos.Linha, pos.Coluna] = true;
}
//vai pegar a peça do inimigo
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.VulneravelEnPassant)
{
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.VulneravelEnPassant)
{
mat[direita.Linha + 1, direita.Coluna] = 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, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//NO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// Esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// Baixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// SE
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// SO
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// #JogadaEspecial - Roque
if (QuantMovimentos == 0 && !Partida.Xeque)
{
// #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 (Tab.Peca(p1) == null && Tab.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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.Peca(p3) == null)
{
mat[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPosiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
// acima
pos.DefinirValores(posicao.linha - 1, posicao.coluna);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// nordeste
pos.DefinirValores(posicao.linha - 1, posicao.coluna + 1);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// direita
pos.DefinirValores(posicao.linha, posicao.coluna + 1);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// sudeste
pos.DefinirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// abaixo
pos.DefinirValores(posicao.linha + 1, posicao.coluna);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// sudoeste
pos.DefinirValores(posicao.linha + 1, posicao.coluna - 1);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// esquerda
pos.DefinirValores(posicao.linha, posicao.coluna - 1);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// noroeste
pos.DefinirValores(posicao.linha - 1, posicao.coluna - 1);
if (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// jogadas especiais
if (qteMovimentos == 0 && !Partida.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 (tab.peca(p1) == null && tab.peca(p2) == null)
{
mat[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 (tab.peca(p1) == null && tab.peca(p2) == null && tab.peca(p3) == null)
{
mat[posicao.linha, posicao.coluna - 2] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linha, Tab.Coluna];
Posicao pos = new Posicao(0, 0);
//acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//diagonal invertida acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Diagonal Principal baixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//baixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Diagonal invertida baixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//diagonal Principal acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && Podemover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Jogada Especial
if (QtdMovimentos == 0 && !partida.Xeque)
{
//Roque Pequeno
Posicao posT1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
if (TesteTorreRoque(posT1))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
if (Tab.Peca(p1) == null && Tab.Peca(p2) == null)
{
mat[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
//Roque grade
Posicao posT2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
if (TesteTorreRoque(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 (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.Peca(p3) == null)
{
mat[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] matriz = new bool[Tabuleiro.Linha, Tabuleiro.Coluna];
Posicao pos = new Posicao(0, 0);
//acima
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//ne
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//abaixo
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//se
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//no
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//so
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
//#jogada especial roque
if (QtdMovimento == 0 && !Partida.Xeque)
{
//#jogada especial 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)
{
matriz[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
//#jogada especial 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)
{
matriz[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(matriz);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linha, Tab.Coluna];
Posicao pos = new Posicao(0, 0);
//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);
}
//diagonal invertida acima
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);
}
//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);
}
//Diagonal Principal baixo
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);
}
//baixo
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);
}
//Diagonal invertida baixo
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);
}
//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);
}
//diagonal Principal acima
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.Linha, Tab.Coluna];
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) && QtdMovimentos == 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
if (Posicao.Linha == 3)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(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) && ExisteInimigo(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) && QtdMovimentos == 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
if (Posicao.Linha == 4)
{
Posicao esquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(esquerda) && ExisteInimigo(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) && ExisteInimigo(direita) && Tab.Peca(direita) == partida.VulneravelEnPassant)
{
mat[direita.Linha + 1, direita.Coluna] = true;
}
}
}
return(mat);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[Tab.Linhas, Tab.Colunas];
Posicao aux = new Posicao(0, 0);
//cima
aux.DefinirValores(Pos.Linha - 1, Pos.Coluna);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Linha = aux.Linha - 1;
}
//direita
aux.DefinirValores(Pos.Linha, Pos.Coluna + 1);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Coluna = aux.Coluna + 1;
}
//baixo
aux.DefinirValores(Pos.Linha + 1, Pos.Coluna);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Linha = aux.Linha + 1;
}
//esquerda
aux.DefinirValores(Pos.Linha, Pos.Coluna - 1);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Coluna = aux.Coluna - 1;
}
//cima - direita
aux.DefinirValores(Pos.Linha - 1, Pos.Coluna + 1);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Linha = aux.Linha - 1;
aux.Coluna = aux.Coluna + 1;
}
//Cima - esquerda
aux.DefinirValores(Pos.Linha - 1, Pos.Coluna - 1);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Coluna = aux.Coluna - 1;
aux.Linha = aux.Linha - 1;
}
//baixo - direita
aux.DefinirValores(Pos.Linha + 1, Pos.Coluna + 1);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Linha = aux.Linha + 1;
aux.Coluna = aux.Coluna + 1;
}
//baixo - esquerda
aux.DefinirValores(Pos.Linha + 1, Pos.Coluna - 1);
while (Tab.PosicaoValida(aux) && PodeMover(aux))
{
mat[aux.Linha, aux.Coluna] = true;
if (Tab.Peca(aux) != null && Tab.Peca(aux).Cor != Cor)
{
break;
}
aux.Coluna = aux.Coluna - 1;
aux.Linha = aux.Linha + 1;
}
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);
}
//Direta
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);
}
//noroeste
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);
}
//nordeste
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);
}
//sudeste
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);
}
//sudoeste
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 pos = new Posicao(0, 0);
//Acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//suldeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//abaixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//SuldoOeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Noroeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
//Jogada Especial
if (QtdMovimentos == 0 && !Partida.Xeque)
{
//Roque Pequeno
Posicao posicaoTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3); //vai verificar se a torre está nesta posicao
if (TesteTorreParaRoque(posicaoTorre1))
{
Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
//vai verificar se as duas posições do lado do rei está sem peça
if (Tab.Peca(p1) == null && Tab.Peca(p2) == null)
{
mat[Posicao.Linha, Posicao.Coluna + 2] = true;
}
}
//Roque Grande
Posicao posicaoTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4); //vai verificar se a torre está nesta posicao
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);
//vai verificar se as duas posições do lado do rei está sem peça
if (Tab.Peca(p1) == null && Tab.Peca(p2) == null && Tab.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);
//N
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tab.VerificarPosicao(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);
}
//NE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tab.VerificarPosicao(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);
}
//E
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
while (Tab.VerificarPosicao(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);
}
//SE
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tab.VerificarPosicao(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);
}
//S
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tab.VerificarPosicao(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);
}
//SO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tab.VerificarPosicao(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);
}
//O
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
while (Tab.VerificarPosicao(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);
}
//NO
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tab.VerificarPosicao(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 pos = new Posicao(0, 0);
//Acima
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.Linha -= 1; //vai continuar verificando a linha
}
//Abaixo
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.Linha += 1; //incrementa a linha e continua verificando
}
//Direita
pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.Coluna += 1; //incrementa a Coluna e continua verificando
}
//Esquerda
pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.Coluna -= 1; //incrementa a linha e continua verificando
}
//Noroeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.DefinirValores(pos.Linha - 1, pos.Coluna - 1);
}
//Nordeste
pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.DefinirValores(pos.Linha - 1, pos.Coluna + 1);
}
//Suldeste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.DefinirValores(pos.Linha + 1, pos.Coluna - 1);
}
//SudoEste
pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
while (Tab.PosicaoValida(pos) && PodeMover(pos)) //enquanto for verdade, vai movendo
{
mat[pos.Linha, pos.Coluna] = true;
if (Tab.Peca(pos) != null && Tab.Peca(pos).Cor != Cor) //se pegar uma peça diversaria vai parar
{
break;
}
pos.DefinirValores(pos.Linha + 1, pos.Coluna + 1);
}
return(mat);
}