private bool podeMover(Posicao proxima)
{
Peca P = tabuleiro.peca(proxima);
return(P == null || P.cor != cor);
}
public override bool[,] movimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
//norte
pos.definirValores(posicao.linha - 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
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;
}
//leste
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;
}
//sul
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;
}
//oeste
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 rosque
if (qteMovimentos == 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;
}
}
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.linhas, posicao.colunas - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas, pos.colunas - 1);
}
// direita
pos.definirValores(posicao.linhas, posicao.colunas + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas, pos.colunas + 1);
}
// acima
pos.definirValores(posicao.linhas - 1, posicao.colunas);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas - 1, pos.colunas);
}
// abaixo
pos.definirValores(posicao.linhas + 1, posicao.colunas);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas + 1, pos.colunas);
}
// NO
pos.definirValores(posicao.linhas - 1, posicao.colunas - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas - 1, pos.colunas - 1);
}
// NE
pos.definirValores(posicao.linhas - 1, posicao.colunas + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas - 1, pos.colunas + 1);
}
// SE
pos.definirValores(posicao.linhas + 1, posicao.colunas + 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas + 1, pos.colunas + 1);
}
// SO
pos.definirValores(posicao.linhas + 1, posicao.colunas - 1);
while (tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.linhas, pos.colunas] = true;
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
pos.definirValores(pos.linhas + 1, pos.colunas - 1);
}
return(mat);
}
public override bool [,] movimentosPossiveis()
{
bool[,] auxMatriz = new bool[tab.linhas, tab.colunas];
//teste de movimento
Posicao pos = new Posicao(0, 0);
// acima
pos.definirValor(posicao.linha - 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// acima a direita
pos.definirValor(posicao.linha - 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// direita
pos.definirValor(posicao.linha, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// abaixo a direita
pos.definirValor(posicao.linha + 1, posicao.coluna + 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// abaixo
pos.definirValor(posicao.linha + 1, posicao.coluna);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// abaixo a esquerda
pos.definirValor(posicao.linha + 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// esquerda
pos.definirValor(posicao.linha, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// acima a esqeurda
pos.definirValor(posicao.linha - 1, posicao.coluna - 1);
if (tab.posicaoValida(pos) && podeMover(pos))
{
auxMatriz[pos.linha, pos.coluna] = true;
}
// JogadaEspecial Roque
if (qtdMovto == 0 && !partida.xeque)
{
// Roque Pequeno
Posicao posTorre1 = new Posicao(posicao.linha, posicao.coluna + 3);
if (testeTorreRoque(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)
{
auxMatriz[posicao.linha, posicao.coluna + 2] = true;
}
}
// Roque Grande
Posicao posTorre2 = new Posicao(posicao.linha, posicao.coluna - 4);
if (testeTorreRoque(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)
{
auxMatriz[posicao.linha, posicao.coluna - 2] = true;
}
}
}
return(auxMatriz);
}
private bool livre(Posicao pos)
{
return(tab.peca(pos) == null);
}
private bool PodeMover(Posicao pos)
{
Peca p = Tab.Peca(pos);
return(p == null || p.Cor != Cor);
}
private bool podeMover(Posicao pos)
{
Peca p = tab.peca(pos);
return(p == null || p.cor != cor);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] movimentos = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
Posicao aux = new Posicao(0, 0);
Posicao aux2 = new Posicao(0, 0);
if (Cor == Cor.Vermelho)
{
aux.DefinirPosicao(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.VerificarPosicao(aux) && Livre(aux))
{
movimentos[aux.Linha, aux.Coluna] = true;
}
aux.DefinirPosicao(Posicao.Linha - 2, Posicao.Coluna);
aux2.DefinirPosicao(Posicao.Linha - 1, Posicao.Coluna);
if (Tabuleiro.VerificarPosicao(aux) && Livre(aux) && Livre(aux2) && QtdMovimentos == 0)
{
movimentos[aux.Linha, aux.Coluna] = true;
}
aux.DefinirPosicao(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tabuleiro.VerificarPosicao(aux) && ExisteInimigo(aux))
{
movimentos[aux.Linha, aux.Coluna] = true;
}
aux.DefinirPosicao(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tabuleiro.VerificarPosicao(aux) && ExisteInimigo(aux))
{
movimentos[aux.Linha, aux.Coluna] = true;
}
}
else
{
aux.DefinirPosicao(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.VerificarPosicao(aux) && Livre(aux))
{
movimentos[aux.Linha, aux.Coluna] = true;
}
aux.DefinirPosicao(Posicao.Linha + 2, Posicao.Coluna);
aux2.DefinirPosicao(Posicao.Linha + 1, Posicao.Coluna);
if (Tabuleiro.VerificarPosicao(aux) && Livre(aux) && Livre(aux2) && QtdMovimentos == 0)
{
movimentos[aux.Linha, aux.Coluna] = true;
}
aux.DefinirPosicao(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tabuleiro.VerificarPosicao(aux) && ExisteInimigo(aux))
{
movimentos[aux.Linha, aux.Coluna] = true;
}
aux.DefinirPosicao(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tabuleiro.VerificarPosicao(aux) && ExisteInimigo(aux))
{
movimentos[aux.Linha, aux.Coluna] = true;
}
}
return(movimentos);
}
public override bool[,] movimentosPossiveis()
{
bool[,] matriz = 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))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Nordeste
pos.definirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
if (Tab.posicaoValida(pos) && podeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Direita
pos.definirValores(Posicao.Linha, Posicao.Coluna + 1);
if (Tab.posicaoValida(pos) && podeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Sudeste
pos.definirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
if (Tab.posicaoValida(pos) && podeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Abaixo
pos.definirValores(Posicao.Linha + 1, Posicao.Coluna);
if (Tab.posicaoValida(pos) && podeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Sudoeste
pos.definirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
if (Tab.posicaoValida(pos) && podeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Esquerda
pos.definirValores(Posicao.Linha, Posicao.Coluna - 1);
if (Tab.posicaoValida(pos) && podeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// Noroeste
pos.definirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
if (Tab.posicaoValida(pos) && podeMover(pos))
{
matriz[pos.Linha, pos.Coluna] = true;
}
// #JogadaEspecial Roque
if (QteMovimentos == 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)
{
matriz[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)
{
matriz[Posicao.Linha, Posicao.Coluna - 2] = true;
}
}
}
return(matriz);
}
private bool ExisteInimigo(Posicao posicao)
{
Peca peca = Tabuleiro.ObterPeca(posicao);
return(peca != null && peca.Cor != Cor);
}
private bool Livre(Posicao posicao)
{
return(Tabuleiro.ObterPeca(posicao) == null);
}
public override bool[,] MovimentosPossiveis()
{
bool[,] mat = new bool[tab.linhas, tab.colunas];
Posicao pos = new Posicao(0, 0);
//Acima
pos.DefinirPosicao(posicao.linha - 1, posicao.coluna);
//Enquanto posição valida dentro do tabuleiro AND Ppode mover
while (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true; //Pode mover pra lá
//Vai se mover ate
//1. Se a posicao da peça for !null (ou seja tem ALGUEM) = PARAAAAA
//2. Se a posição tiver alguem de cor diferente da peça =PARAAAAAA
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//caso if seja falso, continua o WHILE
pos.linha = pos.linha - 1;
}
//Abaixo
pos.DefinirPosicao(posicao.linha + 1, posicao.coluna);
//Enquanto posição valida dentro do tabuleiro AND Ppode mover
while (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true; //Pode mover pra lá
//Vai se mover ate
//1. Se a posicao da peça for !null (ou seja tem ALGUEM) = PARAAAAA
//2. Se a posição tiver alguem de cor diferente da peça =PARAAAAAA
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//caso if seja falso, continua o WHILE
pos.linha = pos.linha + 1;
}
//Direita
pos.DefinirPosicao(posicao.linha, posicao.coluna + 1);
//Enquanto posição valida dentro do tabuleiro AND Ppode mover
while (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true; //Pode mover pra lá
//Vai se mover ate
//1. Se a posicao da peça for !null (ou seja tem ALGUEM) = PARAAAAA
//2. Se a posição tiver alguem de cor diferente da peça =PARAAAAAA
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//caso if seja falso, continua o WHILE
pos.coluna = pos.coluna + 1;
}
//Esquerda
pos.DefinirPosicao(posicao.linha, posicao.coluna - 1);
//Enquanto posição valida dentro do tabuleiro AND Ppode mover
while (tab.PosicaoValida(pos) && PodeMover(pos))
{
mat[pos.linha, pos.coluna] = true; //Pode mover pra lá
//Vai se mover ate
//1. Se a posicao da peça for !null (ou seja tem ALGUEM) = PARAAAAA
//2. Se a posição tiver alguem de cor diferente da peça =PARAAAAAA
if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
{
break;
}
//caso if seja falso, continua o WHILE
pos.coluna = pos.coluna - 1;
}
//NO
pos.DefinirPosicao(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.DefinirPosicao(pos.linha - 1, pos.coluna - 1);
}
//NE
pos.DefinirPosicao(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.DefinirPosicao(pos.linha - 1, pos.coluna + 1);
}
//SE
pos.DefinirPosicao(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.DefinirPosicao(pos.linha + 1, pos.coluna + 1);
}
//SO
pos.DefinirPosicao(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.DefinirPosicao(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);
}
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 (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[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);
}
private bool testeTorreParaRoque(Posicao pos)
{
Peca p = Tab.peca(pos);
return(p != null && p is Torre && p.Cor == Cor && p.QteMovimentos == 0);
}
private bool testeTorreRoque(Posicao proxima)
{
Peca P = tabuleiro.peca(proxima);
return(P != null && P is Torre && P.cor == cor && P.QuantMovimentos == 0);
}
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); // cima
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(Posicao.Linha + 1, Posicao.Coluna); //baixo
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(Posicao.Linha, Posicao.Coluna - 1); //esquerda
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(Posicao.Linha, Posicao.Coluna + 1); //direita
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(Posicao.Linha - 1, Posicao.Coluna - 1); // cima esq
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(Posicao.Linha - 1, Posicao.Coluna + 1); //cima dir
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(Posicao.Linha + 1, Posicao.Coluna - 1); //baixo esq
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
pos.definirValores(Posicao.Linha + 1, Posicao.Coluna + 1); //baixo dir
if (Tab.posicaoValida(pos) && podeMover(pos))
{
mat[pos.Linha, pos.Coluna] = true;
}
// roque
if (QteMovimentos == 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[tabuleiro.linhas, tabuleiro.colunas];
Posicao proxima = new Posicao(0, 0);
//acima da posição do rei:
proxima.defValores(posicao.linhas - 1, posicao.colunas);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
//acima da posição do rei(nordeste):
proxima.defValores(posicao.linhas - 1, posicao.colunas + 1);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
//direita da posição do rei:
proxima.defValores(posicao.linhas, posicao.colunas + 1);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
//suldeste da posição do rei:
proxima.defValores(posicao.linhas + 1, posicao.colunas + 1);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
//abaixo da posição do rei:
proxima.defValores(posicao.linhas + 1, posicao.colunas);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
//suldoeste da posição do rei:
proxima.defValores(posicao.linhas + 1, posicao.colunas - 1);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
//Esquerda da posição do rei:
proxima.defValores(posicao.linhas, posicao.colunas - 1);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
//noroeste da posição do rei:
proxima.defValores(posicao.linhas - 1, posicao.colunas - 1);
if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
{
mat[proxima.linhas, proxima.colunas] = true;
}
// #jogadaEspecial roque
if (QuantMovimentos == 0 && !partida.xeque)
{
//roque pequeno:
Posicao posicaoTorre1 = new Posicao(posicao.linhas, posicao.colunas + 3);
if (testeTorreRoque(posicaoTorre1))
{
Posicao P1 = new Posicao(posicao.linhas, posicao.colunas + 1);
Posicao P2 = new Posicao(posicao.linhas, posicao.colunas + 2);
if (tabuleiro.peca(P1) == null && tabuleiro.peca(P2) == null)
{
mat[posicao.linhas, posicao.colunas + 2] = true;
}
}
//roque grande:
Posicao posicaoTorre2 = new Posicao(posicao.linhas, posicao.colunas - 4);
if (testeTorreRoque(posicaoTorre1))
{
Posicao P1 = new Posicao(posicao.linhas, posicao.colunas - 1);
Posicao P2 = new Posicao(posicao.linhas, posicao.colunas - 2);
Posicao P3 = new Posicao(posicao.linhas, posicao.colunas - 3);
if (tabuleiro.peca(P1) == null && tabuleiro.peca(P2) == null && tabuleiro.peca(P3) == null)
{
mat[posicao.linhas, posicao.colunas - 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);
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);
}
private bool PodeMover(Posicao pos)
{
Peca p = Tab.Peca(pos); //pega a posicao da peça
return(p == null || p.Cor != Cor); //só vai pode mover quando a casa estiver vazia e a cor da peça for diferente
}
private bool testeTorreRoque(Posicao pos)
{
Peca p = tab.peca(pos);
return(p != null && p is Torre && p.cor == cor && p.qtdMovto == 0);
}
private bool TesteTorreRoque(Posicao pos)
{
Peca p = Tab.Peca(pos);
return p != null && p is Torre && p.Cor == Cor && p.QtdeMovimentos == 0;
}
private bool existeInimigo(Posicao pos)
{
Peca p = tab.peca(pos);
return(p != null && p.cor != cor);
}
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);
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) && qteMovimento == 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) && qteMovimento == 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[,] 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;
}
//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 = pos.Linha - 1;
pos.Coluna = 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.Linha = pos.Linha + 1;
pos.Coluna = 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.Linha = pos.Linha - 1;
pos.Coluna = 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.Linha = pos.Linha - 1;
pos.Coluna = pos.Coluna - 1;
}
return(mat);
}