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);
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 + 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;
}
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)
{
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)
{
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)
{
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)
{
break;
}
pos.coluna = pos.coluna - 1;
}
//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);
//DAMA É UMA MISTURA DE TORRE COM BISPO
//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);
}
//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.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)
{
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)
{
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)
{
break;
}
pos.coluna = pos.coluna - 1;
}
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] matrix = 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))
{
matrix[pos.linha, pos.coluna] = true;
}
// ne
pos.definirValores(posicao.linha - 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
matrix[pos.linha, pos.coluna] = true;
}
// direita
pos.definirValores(posicao.linha, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
matrix[pos.linha, pos.coluna] = true;
}
// se
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
matrix[pos.linha, pos.coluna] = true;
}
// abaixo
pos.definirValores(posicao.linha + 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
matrix[pos.linha, pos.coluna] = true;
}
// so
pos.definirValores(posicao.linha + 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
matrix[pos.linha, pos.coluna] = true;
}
// esquerda
pos.definirValores(posicao.linha, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
matrix[pos.linha, pos.coluna] = true;
}
// no
pos.definirValores(posicao.linha - 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
matrix[pos.linha, pos.coluna] = true;
}
// #jogada especial roque
if (qtdeMovimentos == 0 && !partida.xeque)
{
// #jogada especial roque pequeno
Posicao posTorreDireita = new Posicao(posicao.linha, posicao.coluna + 3);
}
return(matrix);
}
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);
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);
}
// sul
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);
}
// leste
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);
}
// oeste
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);
}
// 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);
}
// suldeste
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);
}
// suldoeste
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 - norte
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--;
}
// direita - leste
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++;
}
// esquerda - oeste
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--;
}
// abaixo - sul
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++;
}
// 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.linha--;
}
// 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.coluna++;
}
// 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.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.linha++;
}
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] matAux = new bool[tabu.linhas, tabu.colunas];
Posicao pos = new Posicao(0, 0);
//Acima
pos.definirValores(posicao.linha - 1, posicao.coluna);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Nordeste
pos.definirValores(posicao.linha - 1, posicao.coluna + 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Direita
pos.definirValores(posicao.linha, posicao.coluna + 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Sudeste
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Abaixo
pos.definirValores(posicao.linha + 1, posicao.coluna);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Sudoeste
pos.definirValores(posicao.linha + 1, posicao.coluna - 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Esquerda
pos.definirValores(posicao.linha, posicao.coluna - 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Noroeste
pos.definirValores(posicao.linha - 1, posicao.coluna - 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
return(matAux);
}
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)
{
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)
{
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)
{
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)
{
break;
}
pos.Coluna = pos.Coluna - 1;
}
//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);
//Noroeste = Linha - 1, Coluna - 1
pos.definirValores(posicao.linha - 1, posicao.coluna - 1);
//Lógica do Bispo
//Caso a posição seja válida e for possível mover
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//Se tiver algo na posição e for de cor diferente
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.definirValores(pos.linha - 1, pos.coluna - 1);
}
//Nordeste = Linha - 1, Coluna + 1
pos.definirValores(posicao.linha - 1, posicao.coluna + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//Se tiver algo na posição e for de cor diferente
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.definirValores(pos.linha - 1, pos.coluna + 1);
}
//Sudeste = Linha + 1, Coluna + 1
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//Se tiver algo na posição e for de cor diferente
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.definirValores(pos.linha + 1, pos.coluna + 1);
}
//Sudoeste = Linha + 1, Coluna - 1
pos.definirValores(posicao.linha + 1, posicao.coluna - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//Se tiver algo na posição e for de cor diferente
if (tab.peca(pos) != null && tab.peca(pos).cor != this.cor)
{
break;
}
pos.definirValores(pos.linha + 1, pos.coluna - 1);
}
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] mat = new bool[this.Tab.Linhas, this.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;
}
//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;
}
//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;
}
//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;
}
//#JogadadaEspecial ROQUE
if (qtdeMovimentos == 0 && !partida.xeque)
{
//#Roque PEQUENO
Posicao posT1 = new Posicao(Posicao.linha, Posicao.coluna + 3);
if (TorreTesteRoque(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 (TorreTesteRoque(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);
}
//é usado override para sobrescrever o método
//da superclasse
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);
//A torre precisa checar até o fim do tabuleiro
//Checa se a casa está livre ou há peça adversária
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
//checa se a posição está nula ou se a cor
//da peça é a do adversário
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break; //forço a parada
}
//caso a situação acima não for verdade
//posição linha recebe -1
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;
//checa se a posição está nula ou se a cor
//da peça é a do adversário
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break; //forço a parada
}
//caso a situação acima não for verdade
//posição linha recebe +1
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;
//checa se a posição está nula ou se a cor
//da peça é a do adversário
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break; //forço a parada
}
//caso a situação acima não for verdade
//posição coluna recebe +1
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;
//checa se a posição está nula ou se a cor
//da peça é a do adversário
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break; //forço a parada
}
//caso a situação acima não for verdade
//posição coluna recebe -1
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 posicao 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.linha -= 1;
}
// Verificando posicao 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.linha += 1;
}
// Verificando posicao 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.coluna += 1;
}
// Verificando posicao 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.coluna -= 1;
}
//Verificando 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);
}
//Verificando 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);
}
//Verificando 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);
}
//Verificando 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);
// verificando
// 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;
}
// #JogadaEspecial: Roque
if (qteMovimentos == 0 && !partida.xeque)
{
// Checando a posição da torre
// #Roque Pequeno
Posicao posT1 = new Posicao(posicao.linha, posicao.coluna + 3);
if (testeDoReiParaRoque(posT1))
{
// Teste para ver se as duas posições ao lado do rei estão vagas
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 (testeDoReiParaRoque(posT2))
{
// Teste para ver se as duas posições ao lado do rei estão vagas
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);
//Norte
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.Linha - 1;
}
//Nordeste
//Leste
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.Coluna + 1;
}
//Sudeste
//Sul
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.Linha + 1;
}
//Sudoeste
//Oeste
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.Coluna - 1;
}
//Noroeste
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
/*
* TESTE DE POSIÇÕES
*/
//ACIMA -> MESMA COLUNA UMA LINHA A MENOS
pos.definirValores(posicao.linha - 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//NORDESTE -> COLUNA+1 LINHA-1
pos.definirValores(posicao.linha - 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//LESTE -> COLUNA+1 LINHA+0
pos.definirValores(posicao.linha, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//SUDESTE -> COLUNA+1 LINHA+1
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//SUL -> COLUNA1 LINHA+1
pos.definirValores(posicao.linha + 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//SUDOESTE -> COLUNA-1 LINHA+1
pos.definirValores(posicao.linha + 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//OESTE -> COLUNA-1 LINHA+0
pos.definirValores(posicao.linha, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//NOROESTE -> COLUNA-1 LINHA-1
pos.definirValores(posicao.linha - 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//#JOGADA ESPECIAL ROQUE
//VERIFICA SE O REI JA EXECUTOU ALGUM MOVIMENTO OU SE ENCONTRA-SE EM XEQUE
if (qteMovimentos == 0 && !partida.xeque)
{
//jogada especial roque pequeno, posição onde deve haver uma torre
Posicao posT1 = new Posicao(posicao.linha, posicao.coluna + 3);
Posicao p1 = new Posicao(posicao.linha, posicao.coluna + 1);
Posicao p2 = new Posicao(posicao.linha, posicao.coluna + 2);
if (testeTorreParaRoque(posT1) && (tab.peca(p1) == null) && (tab.peca(p2) == null))
{
mat[posicao.linha, posicao.coluna + 2] = true;
}
//jogada especial roque grande
Posicao posT2 = new Posicao(posicao.linha, posicao.coluna - 4);
Posicao p3 = new Posicao(posicao.linha, posicao.coluna - 1);
Posicao p4 = new Posicao(posicao.linha, posicao.coluna - 2);
Posicao p5 = new Posicao(posicao.linha, posicao.coluna - 3);
if (testeTorreParaRoque(posT2) && (tab.peca(p3) == null) && (tab.peca(p4) == null) && (tab.peca(p5) == null))
{
mat[posicao.linha, posicao.coluna - 2] = true;
}
}
return(mat);//retorna a matriz dos movimentos possiveis do rei
}
//método sobrescrevendo o da superclasse Peca
public override bool[,] movimentosPossiveis()
{
/* REGRA:
* O peão tem uma lógica uma pouco diferente das demais peças
* Se o peão é branco, ele só pode se mover pra cima
* Se o peão é preto, ele só pode se mover pra baixo
*/
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
if (cor == Cor.Branca)
{
//o peão pode andar duas casas para cima, caso seja seu primeiro movimento
pos.definirValores(posicao.linha - 2, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos) && qteMovimentos == 0)
{
mat[pos.linha, pos.coluna] = true;
}
//a partir do segundo movimento, ele só pode andar uma casa
pos.definirValores(posicao.linha - 1, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//ele pode andar uma casa nas diagonais, caso possua uma peça adversária
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---------
//-----------Em Passant------------
if (posicao.linha == 3)
{
Posicao esquerda = new Posicao(posicao.linha, posicao.coluna - 1);
if (tab.posicaoValida(esquerda) && existeInimigo(esquerda) && tab.peca(esquerda) == partida.vulneravelEmPassant)
{
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.vulneravelEmPassant)
{
mat[direita.linha - 1, direita.coluna] = true;
}
}
}
else
{
//primeiro movimento
pos.definirValores(posicao.linha + 2, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos) && qteMovimentos == 0)
{
mat[pos.linha, pos.coluna] = true;
}
//a partir do segundo movimento
pos.definirValores(posicao.linha + 1, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//ele pode andar uma casa nas diagonais, caso possua uma peça adversária
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---------
//-----------Em Passant------------
if (posicao.linha == 4)
{
Posicao esquerda = new Posicao(posicao.linha, posicao.coluna - 1);
if (tab.posicaoValida(esquerda) && existeInimigo(esquerda) && tab.peca(esquerda) == partida.vulneravelEmPassant)
{
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.vulneravelEmPassant)
{
mat[direita.linha + 1, direita.coluna] = true;
}
}
}
return(mat);
}
/// <summary>
/// Cria matriz de posições possíveis para a peça.
/// </summary>
/// <returns></returns>
public override bool[,] movimentosPossiveis()
{
bool[,] matrizValida = new bool[tab.linhas, tab.colunas]; //Matriz de booleanos é inicializada como false.
Posicao pos = new Posicao(0, 0);
if (cor == Cor.Branca) // Se peça for branca, sobe (linha diminui):
{
// Se não existe inimigo nas casa a frente:
pos.definirValores(posicao.Linha - 1, posicao.Coluna);
if (tab.posicaoValida(pos) && livre(pos))
{
matrizValida[pos.Linha, pos.Coluna] = true;
// Se primeira casa é válida, testa segunda:
pos.definirValores(posicao.Linha - 2, posicao.Coluna);
if (tab.posicaoValida(pos) && livre(pos) && qtdMovimentos == 0) // Se for o primeiro movimento do peão, pode andar 2 casas. Não vê se tem peça na frente?
{
matrizValida[pos.Linha, pos.Coluna] = true;
}
}
// Se existe inimigo nas diagonais imediatas:
pos.definirValores(posicao.Linha - 1, posicao.Coluna - 1);
if (tab.posicaoValida(pos) && existeInimigo(pos))
{
matrizValida[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(posicao.Linha - 1, posicao.Coluna + 1);
if (tab.posicaoValida(pos) && existeInimigo(pos))
{
matrizValida[pos.Linha, pos.Coluna] = true;
}
// Jogada especial: En Passant:
if (posicao.Linha == 3) // Só é possível nesta linha.
{
// À esquerda:
Posicao esquerda = new Posicao(posicao.Linha, posicao.Coluna - 1);
if (tab.posicaoValida(esquerda) && existeInimigo(esquerda) && tab.peca(esquerda) == partida.vulneravelEnPassant)
{
matrizValida[esquerda.Linha - 1, esquerda.Coluna] = true;
}
// À direita:
Posicao direita = new Posicao(posicao.Linha, posicao.Coluna + 1);
if (tab.posicaoValida(direita) && existeInimigo(direita) && tab.peca(direita) == partida.vulneravelEnPassant)
{
matrizValida[direita.Linha - 1, direita.Coluna] = true;
}
}
}
else // Se peça for branca, desce (linha aumenta):
{
// Se não existe inimigo nas casas a frente:
pos.definirValores(posicao.Linha + 1, posicao.Coluna);
if (tab.posicaoValida(pos) && livre(pos))
{
matrizValida[pos.Linha, pos.Coluna] = true;
// Se primeira casa é válida, testa segunda:
pos.definirValores(posicao.Linha + 2, posicao.Coluna);
if (tab.posicaoValida(pos) && livre(pos) && qtdMovimentos == 0) // Se for o primeiro movimento do peão, pode andar 2 casas. Não vê se tem peça na frente?
{
matrizValida[pos.Linha, pos.Coluna] = true;
}
}
// Se existe inimigo nas diagonais imediatas:
pos.definirValores(posicao.Linha + 1, posicao.Coluna - 1);
if (tab.posicaoValida(pos) && existeInimigo(pos))
{
matrizValida[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(posicao.Linha + 1, posicao.Coluna + 1);
if (tab.posicaoValida(pos) && existeInimigo(pos))
{
matrizValida[pos.Linha, pos.Coluna] = true;
}
// Jogada especial: En Passant:
if (posicao.Linha == 4) // Só é possível nesta linha.
{
// À esquerda:
Posicao esquerda = new Posicao(posicao.Linha, posicao.Coluna - 1);
if (tab.posicaoValida(esquerda) && existeInimigo(esquerda) && tab.peca(esquerda) == partida.vulneravelEnPassant)
{
matrizValida[esquerda.Linha + 1, esquerda.Coluna] = true;
}
// À direita:
Posicao direita = new Posicao(posicao.Linha, posicao.Coluna + 1);
if (tab.posicaoValida(direita) && existeInimigo(direita) && tab.peca(direita) == partida.vulneravelEnPassant)
{
matrizValida[direita.Linha + 1, direita.Coluna] = true;
}
}
}
return(matrizValida);
}
//método sobrescrevendo o da superclasse Peca
public override bool[,] movimentosPossiveis()
{
/* REGRA:
* A torre pode se mover na horizontal e na vertical até encontrar uma peça ou acabar o tabuleiro
*/
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
//Posição acima da posição da Torre
pos.definirValores(posicao.linha - 1, posicao.coluna);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//forçar a parada do while quando encontrar uma peça adversária
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//continua verificando nas linhas acima da posição atual da torre
pos.linha = pos.linha - 1;
}
//Posição abaixo da posição da Torre
pos.definirValores(posicao.linha + 1, posicao.coluna);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//forçar a parada do while quando encontrar uma peça adversária
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//continua verificando nas linhas acima da posição atual da torre
pos.linha = pos.linha + 1;
}
//Posição direita da posição da Torre
pos.definirValores(posicao.linha, posicao.coluna + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//forçar a parada do while quando encontrar uma peça adversária
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//continua verificando nas linhas acima da posição atual da torre
pos.coluna = pos.coluna + 1;
}
//Posição esquerda da posição da Torre
pos.definirValores(posicao.linha, posicao.coluna - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
//forçar a parada do while quando encontrar uma peça adversária
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//continua verificando nas linhas acima da posição atual da torre
pos.coluna = pos.coluna - 1;
}
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] mat = new bool[tab.rows, tab.columns];
Posicao pos = new Posicao(0, 0);
//ESQUERDA
pos.definirValores(posicao.rows, posicao.columns - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows, pos.columns - 1);
}
//DIREITA
pos.definirValores(posicao.rows, posicao.columns + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows, pos.columns + 1);
}
//ACIMA
pos.definirValores(posicao.rows - 1, posicao.columns);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows - 1, pos.columns);
}
//BAIXO
pos.definirValores(posicao.rows + 1, posicao.columns);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows + 1, pos.columns);
}
//NOROESTE
pos.definirValores(posicao.rows - 1, posicao.columns - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows - 1, pos.columns - 1);
}
//NORDESTE
pos.definirValores(posicao.rows - 1, posicao.columns + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows - 1, pos.columns + 1);
}
//SULDESTE
pos.definirValores(posicao.rows + 1, posicao.columns + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows + 1, pos.columns + 1);
}
//SULDOESTE
pos.definirValores(posicao.rows + 1, posicao.columns - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.rows, pos.columns] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.rows + 1, pos.columns - 1);
}
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
//LESTE
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);
}
//OESTE
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);
}
//SUL
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);
}
//NORTE
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);
}
//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);
}
//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);
}
//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);
}
//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);
}
return(mat);
}
public override bool[,] movimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
//Verificar acima
pos.definirValores(posicao.linha - 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Verificar diagonal superior direita
pos.definirValores(posicao.linha - 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Verificar direita
pos.definirValores(posicao.linha, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Verificar diagonal inferior direita
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Verificar abaixo
pos.definirValores(posicao.linha + 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Verificar diagonal inferior esquerda
pos.definirValores(posicao.linha + 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Verificar esquerda
pos.definirValores(posicao.linha, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Verificar diagonal superior esquerda
pos.definirValores(posicao.linha - 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// #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 + 2] = true;
}
}
}
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);
}
//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);
}
//suldoeste
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);
// N
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;
}
// L
pos.definirValores(posicao.linha, 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;
}
// S
pos.definirValores(posicao.linha + 1, posicao.coluna);
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;
}
// O
pos.definirValores(posicao.linha, 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 posTorre1 = new Posicao(posicao.linha, posicao.coluna + 3);
if (testeTorreParaRoque(posTorre1))
{
Posicao pos1 = new Posicao(posicao.linha, posicao.coluna + 1);
Posicao pos2 = new Posicao(posicao.linha, posicao.coluna + 2);
if (tab.peca(pos1) == null && tab.peca(pos2) == null)
{
mat[posicao.linha, posicao.coluna + 2] = true;
}
}
// roque grande
Posicao posTorre2 = new Posicao(posicao.linha, posicao.coluna - 4);
if (testeTorreParaRoque(posTorre2))
{
Posicao pos1 = new Posicao(posicao.linha, posicao.coluna - 1);
Posicao pos2 = new Posicao(posicao.linha, posicao.coluna - 2);
Posicao pos3 = new Posicao(posicao.linha, posicao.coluna - 3);
if (tab.peca(pos1) == null && tab.peca(pos2) == null && tab.peca(pos3) == 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;
}
//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;
}
//#jogadaespecial roque
if (qteMovimentos == 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[,] movimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
if (cor == Cor.Branca)
{
//acima
pos.definirValores(posicao.linha - 1, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//acima duplo
pos.definirValores(posicao.linha - 2, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos) && qtdMovimentos == 0)
{
mat[pos.linha, pos.coluna] = true;
}
//acima direita
pos.definirValores(posicao.linha - 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && pecaInimiga(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//cima esquerda
pos.definirValores(posicao.linha - 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && pecaInimiga(pos))
{
mat[pos.linha, pos.coluna] = true;
}
}
else
{
//abaixo
pos.definirValores(posicao.linha + 1, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//abaixo duplo
pos.definirValores(posicao.linha + 2, posicao.coluna);
if (tab.posicaoValida(pos) && livre(pos) && qtdMovimentos == 0)
{
mat[pos.linha, pos.coluna] = true;
}
//abaixo direita
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && pecaInimiga(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//abaixo esquerda
pos.definirValores(posicao.linha + 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && pecaInimiga(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);
//top
pos.definirValores(posicao.linha - 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Top-right
pos.definirValores(posicao.linha - 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//right
pos.definirValores(posicao.linha, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Botton-right
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Botton
pos.definirValores(posicao.linha + 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Botton-left
pos.definirValores(posicao.linha + 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//left
pos.definirValores(posicao.linha, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
//Top-left
pos.definirValores(posicao.linha - 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linha, pos.coluna] = true;
}
// #jogadaespecial roque
if (qteMovimentos == 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[,] movimentoPossiveis()
{
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;
}
// Direita //
pos.definirValores(posicao.linha, 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;
}
// Abaixo //
pos.definirValores(posicao.linha + 1, posicao.coluna);
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;
}
// Esquerda //
pos.definirValores(posicao.linha, 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;
}
if (qteMovimentos == 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);
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) && 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
{
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) && 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[,] matAux = new bool[tabu.linhas, tabu.colunas];
Posicao pos = new Posicao(0, 0);
//Cima-Dir 1
pos.definirValores(posicao.linha + 2, posicao.coluna + 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Cima-Esq 1
pos.definirValores(posicao.linha + 2, posicao.coluna - 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Baixo-Dir 1
pos.definirValores(posicao.linha - 2, posicao.coluna + 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Baixo-Esq 1
pos.definirValores(posicao.linha - 2, posicao.coluna - 1);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Cima-Dir 2
pos.definirValores(posicao.linha + 1, posicao.coluna + 2);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Cima-Esq 2
pos.definirValores(posicao.linha + 1, posicao.coluna - 2);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Baixo-Dir 2
pos.definirValores(posicao.linha - 1, posicao.coluna + 2);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
//Baixo-Esq 2
pos.definirValores(posicao.linha - 1, posicao.coluna - 2);
if (tabu.posicaoValida(pos) && podeMover(pos))
{
matAux[pos.linha, pos.coluna] = true;
}
return(matAux);
}
