public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executarMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colcar em xeque!");
}
Peca p = tab.peca(destino);
//jogadaespecial promocao
if (p is Peao)
{
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequemate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
turno++;
mudaJogador();
}
//jogadaespecial en passant
if (p is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
{
vulneravelEnPassant = p;
}
else
{
vulneravelEnPassant = null;
}
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (ValidaPosicaoXeque(CorPecaJogador))
{
DesfazerMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Não é possível colocar-se em posição de xeque!");
}
Peca pecaMovida = Tabuleiro.Peca(destino);
// promocao
if (pecaMovida is Peao)
{
if ((pecaMovida.Cor == Cor.Branca && destino.Linha == 0) || (pecaMovida.Cor == Cor.Preta && destino.Linha == 7))
{
pecaMovida = Tabuleiro.RetirarPeca(destino);
PecasJogo.Remove(pecaMovida);
Peca dama = new Dama(Tabuleiro, pecaMovida.Cor);
Tabuleiro.ColocarPeca(dama, destino);
PecasJogo.Add(dama);
}
}
if (ValidaPosicaoXeque(IdentificarCorAdversaria(CorPecaJogador)))
{
Xeque = true;
}
else
{
Xeque = false;
}
if (ValidaXequeMate(IdentificarCorAdversaria(CorPecaJogador)))
{
Terminada = true;
}
else
{
Turno++;
MudaCorPeca();
}
// en passant
if (pecaMovida is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
PecaEnPassant = pecaMovida;
}
else
{
PecaEnPassant = null;
}
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (EstaEmXeque(JogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque.");
}
Peca p = Tab.Peca(destino);
//#jogadaEspecial - promocao
if (p is Peao)
{
if (p.Cor == Cor.Branca && destino.Linha == 0 || p.Cor == Cor.Preta && destino.Linha == 7)
{
p = Tab.RetirarPeca(destino);
_pecas.Remove(p);
Peca dama = new Dama(Tab, p.Cor);
Tab.ColocarPeca(dama, destino);
_pecas.Add(dama);
}
}
if (EstaEmXeque(Adversaria(JogadorAtual)))
{
Xeque = true;
}
else
{
Xeque = false;
}
if (TesteXequemate(Adversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
//#jodadaEspecial - en passant
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravelEnPassant = p;
}
else
{
VulneravelEnPassant = null;
}
}
public void movimentoJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = movimento(origem, destino);
if (emXeque(jogador))
{
desfazerMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Não é possível movimentar, seu rei vai ficar em xeque");
}
Peca auxPeca = tabu.peca(destino);
// jogada promoção
if (auxPeca is Peao)
{
if ((auxPeca.cor == Cor.Branco && destino.linha == 0) || (auxPeca.cor == Cor.Preto && destino.linha == 7))
{
auxPeca = tabu.removerPeca(destino);
pecas.Remove(auxPeca);
Peca dama = new Dama(tabu, auxPeca.cor);
tabu.incluirPeca(dama, destino);
pecas.Add(dama);
}
}
// jogada promoção
if (emXeque(adversaria(jogador)))
{
xeque = true;
}
else
{
xeque = false;
}
if (xequeMate(adversaria(jogador)))
{
finalizada = true;
}
else
{
turno++;
mudaJogador();
}
// jogada en passant
if (auxPeca is Peca && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
{
enPassant = auxPeca;
}
else
{
enPassant = null;
}
// jogada en passant
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca PecaCapturada = ExecutaMovimento(origem, destino);
if (Xeque(JogadorAtual))
{
DesfazMovimento(origem, destino, PecaCapturada);
throw new TabuleiroException("Você não pode se colocar em Xeque!!");
}
Peca p = Tab.Peca(destino);
//Promocao
if (p is Peao)
{
if ((p.Cor == Cor.Branco && destino.Linha == 0) || (p.Cor == Cor.Preto && destino.Linha == 7))
{
p = Tab.RetirarPeca(destino);
Minha.Remove(p);
Peca dama = new Dama(Tab, p.Cor);
Tab.ColocarPeca(dama, destino);
Minha.Add(dama);
}
}
if (Xeque(Adversaria(JogadorAtual)))
{
EXeque = true;
}
else
{
EXeque = false;
}
if (XequeMate(Adversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
//#EnPassant
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravelEnPassant = p;
}
else
{
VulneravelEnPassant = null;
}
}
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
Peca pecaDestino = this.Tabuleiro.peca(destino);
if (estaEmXeque(JogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
// promoção
if (pecaDestino is Peao)
{
if ((pecaDestino.Cor == Cor.Branca && destino.Linha == 0) || (pecaDestino.Cor == Cor.Preta && destino.Linha == 7))
{
pecaDestino = this.Tabuleiro.retirarPeca(destino);
this.Pecas.Remove(pecaDestino);
Peca Dama = new Dama(this.Tabuleiro, pecaDestino.Cor);
this.Tabuleiro.ColocarPeca(Dama, destino);
this.Pecas.Add(Dama);
}
}
if (estaEmXeque(adversaria(JogadorAtual)))
{
this.xeque = true;
}
else
{
this.xeque = false;
}
if (testeXequemate(adversaria(JogadorAtual)))
{
this.Terminada = true;
}
else
{
this.Turno++;
mudaJogador();
}
// en passant
if (pecaDestino is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
this.vulneravelEnPassant = pecaDestino;
}
else
{
this.vulneravelEnPassant = null;
}
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (OReiEstaEmXeque(JogadorAtual))
{
DesfazerMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = Tabuleiro.Peca(destino);
//Jogada Especial Promoção
if (p is Peao)
{
bool PeaoBrancoEstaNaUltimaLinha = (p.Cor == Cor.Branca) && (destino.Linha == 0);
bool PeaoPretoEstaNaUltimaLinha = (p.Cor == Cor.Preta) && (destino.Linha == 7);
bool EhPromocao = PeaoBrancoEstaNaUltimaLinha || PeaoPretoEstaNaUltimaLinha;
if (EhPromocao)
{
p = Tabuleiro.RetirarPeca(destino);
_pecas.Remove(p);
Peca dama = new Dama(Tabuleiro, p.Cor);
Tabuleiro.ColocarPeca(dama, destino);
_pecas.Add(dama);
}
}
xeque = OReiEstaEmXeque(CorAdversaria(JogadorAtual));
if (EhXequeMate(CorAdversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
//Jogada Especial EnPassant
bool EhOPrimeiroMovimento = (destino.Linha == origem.Linha - 2) || (destino.Linha == origem.Linha + 2);
if ((p is Peao) && EhOPrimeiroMovimento)
{
EnPassant = p;
}
else
{
EnPassant = null;
}
}
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
// Se após a jogada, o jogador atual se colocou em xeque
// a jogada precisa ser desfeita, pois não é permitido se colocar em xeque
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = tab.peca(destino);
// #jogadaespecial promocao
if (p is Peao)
{
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
// Verifica se após a jogada do jogador atual, o adversário ficou em xeque
xeque = estaEmXeque(adversaria(jogadorAtual));
if (testeXequemate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
turno++;
mudaJogador();
}
// #jogadaespecial En Passant
if (p is Peao && destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2)
{
vulneravelEnPassant = p;
}
else
{
vulneravelEnPassant = null;
}
}
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
if (estaEmXeque(JogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em Xeque!");
}
Peca p = Tab.peca(destino);
// # JOGADA ESPECIAL - PROMOÇÃO
if (p is Peao)
{
if ((p.Cor == Cor.Branca && destino.Linha == 0) || (p.Cor == Cor.Preta && destino.Linha == 7))
{
p = Tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(p.Cor, Tab);
Tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
if (estaEmXeque(adversaria(JogadorAtual)))
{
Xeque = true;
}
else
{
Xeque = false;
}
if (testeXequemate(adversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
mudaJogador();
}
// # JOGADA ESPECIAL - EN PASSANT
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravelEnPassant = p;
}
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (EstaEmXeque(JogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = Tab.Peca(destino);
//Jogada Especial: Promoção
if (p is Peao)
{
if ((p.Cor == Cor.Branca && destino.Linha == 0) || (p.Cor == Cor.Preta && destino.Linha == 7))
{
p = Tab.RetirarPeca(destino);
Pecas.Remove(p);
Peca dama = new Dama(p.Cor, Tab);
Tab.ColocarPeca(dama, destino);
Pecas.Add(dama);
Console.WriteLine("\nSeu peão será promovido à DAMA!\nPressione enter para continuar.");
Console.ReadLine();
}
}
Xeque = (EstaEmXeque(Adversario(JogadorAtual))) ? true : false;
if (TesteXequeMate(Adversario(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
//Jogada Especial: En Passant
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravelEnPassant = p;
}
else
{
VulneravelEnPassant = null;
}
}
private Peca EscolhePromo(Tabuleiro tabuleiro, Cor cor)
{
char resp = ' ';
int aux = 0;
while (aux == 0)
{
System.Console.Write("Escolha sua promoção(D/B/T/C): ");
resp = char.Parse(Console.ReadLine());
if (resp == 'd' || resp == 'D')
{
Peca p = new Dama(tabuleiro, cor);
if (FoiCapturada(p))
{
return(p);
}
}
else if (resp == 't' || resp == 'T')
{
Peca p = new Torre(tabuleiro, cor);
if (FoiCapturada(p))
{
return(p);
}
}
else if (resp == 'b' || resp == 'B')
{
Peca p = new Bispo(tabuleiro, cor);
if (FoiCapturada(p))
{
return(p);
}
}
else if (resp == 'c' || resp == 'C')
{
Peca p = new Cavalo(tabuleiro, cor);
if (FoiCapturada(p))
{
return(p);
}
}
Console.WriteLine("Peça inexistente, tente novamente!");
Console.WriteLine();
}
return(null);
}
public void realizarJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executarMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))
{
desfazerMovimento(origem, destino, pecaCapturada);
throw new Excecao("Você não pode se colocar em xeque!");
}
Peca peca = this.tabuleiro.peca(destino);
// #jogadas especiais - promoção
if (peca is Peao)
{
if ((peca.cor == Cor.Branca && destino.linha == 0) || (peca.cor == Cor.Preta && destino.linha == 7))
{
peca = this.tabuleiro.retirarPeca(destino);
pecas.Remove(peca);
Peca dama = new Dama(this.tabuleiro, peca.cor);
this.tabuleiro.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
this.xeque = estaEmXeque(pecaAdversaria(jogadorAtual)) ? true : false;
if (estaEmXequemate(pecaAdversaria(jogadorAtual)))
{
this.finalizada = true;
}
else
{
alternarJogador();
this.turno++;
}
// #jogadas especiais - en passant
if (peca is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
{
capturaEspecial = peca;
}
else
{
capturaEspecial = null;
}
}
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
if (estahEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = tab.peca(destino);
// #JogadaEspecial: Promoção...
if (p is Peao)
{
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
if (estahEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequeMate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
turno++;
mudaJogador();
}
}
public void escolhaPromocao(string s)
{
pecaPromocao = tab.retirarPeca(posicaoPecaPromocao);
pecas.Remove(pecaPromocao);
Peca p;
int i = 0;
if (int.TryParse(s, out i))
{
switch (i)
{
case 1:
p = new Dama(tab, pecaPromocao.cor);
break;
case 2:
p = new Bispo(tab, pecaPromocao.cor);
break;
case 3:
p = new Torre(tab, pecaPromocao.cor);
break;
case 4:
p = new Cavalo(tab, pecaPromocao.cor);
break;
default:
p = new Dama(tab, pecaPromocao.cor);
break;
}
tab.colocarPeca(p, posicaoPecaPromocao);
pecas.Add(p);
promocao = false;
}
else
{
p = new Dama(tab, pecaPromocao.cor);
tab.colocarPeca(p, posicaoPecaPromocao);
pecas.Add(p);
promocao = false;
throw new TabuleiroException("Valor digitado não é um número óu é inválido! Peça será uma Dama!");
}
}
public void checarPromocao()
{
if (promocao != null)
{
Console.WriteLine("Peao promovido! Escolha uma promocao:");
Console.WriteLine("1 - Bispo.");
Console.WriteLine("2 - Cavalo.");
Console.WriteLine("3 - Dama.");
Console.WriteLine("4 - Torre.");
int n = 3;
Posicao destino = promocao.pos;
tab.retirarPeca(destino);
pecas.Remove(promocao);
Peca nova = new Dama(tab, promocao.cor);
if (int.TryParse(Console.ReadLine(), out n))
{
if (n == 1)
{
nova = new Bispo(tab, promocao.cor);
}
else if (n == 2)
{
nova = new Cavalo(tab, promocao.cor);
}
else if (n == 4)
{
nova = new Torre(tab, promocao.cor);
}
}
tab.adicionarPeca(nova, destino);
pecas.Add(nova);
promocao = null;
}
}
//MÉTODO COM NIVEL MAIS ALTO DE ABSTRAÇÃO
public void realizaJogada(Posicao origem, Posicao destino)
{
//REALIZA A JOGODA
Peca pecaCapturada = executaMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))//teste
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em Xeque!");
}
Peca p = tab.peca(destino);//armazena peça que foi movida
//#JOGADA ESPECIAL PROMOCAO
//verifica se a peça que efetuou a jogada é um peão
if (p is Peao)
{
//verifica se o peão alcançou a linha máxima de sua cor
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
//remove a peça do tabuleiro
p = tab.retirarPeca(destino);
pecas.Remove(p);
//como forma de simplificar será colocado uma dama dentro do tabuleiro não haverá a escolha
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequemate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
//INCREMENTA O TURNO DO JOGO
turno++;
//ALTERA A VEZ DE QUEM IRÁ JOGAR
mudaJogador();
}
//#JOGADA ESPECIAL EN PASSANT
//testa se a peça é um peão e se a mesma efetuou o movimento especial inicial de mover duas posições tanto para preta
//como para branca
if (p is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
{
vulneravelEnPassant = p;
}
else
{
vulneravelEnPassant = null;
}
}
public void RealizaJogada(Posicao origem, Posicao destino, string opPromocao)
{
Peca pecaCapturada = executaMovimento(origem, destino);
if (EstaEmXeque(jogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Não podes colocar-te em xeque!");
}
Peca p = tab.GetPeca(destino);
// #jogadaespecial Promocao
if (p is Peao)
{
if ((p.Cor == Cor.Branca && destino.Linha == 0) || (p.Cor == Cor.Preta && destino.Linha == 7))
{
p = tab.RetirarPeca(destino);
Pecas.Remove(p);
if (opPromocao != null && opPromocao != "N")
{
switch (opPromocao)
{
case "D":
{
Peca dama = new Dama(p.Cor, tab);
tab.ColocarPeca(dama, destino);
Pecas.Add(dama);
break;
}
case "B":
{
Peca bispo = new Bispo(p.Cor, tab);
tab.ColocarPeca(bispo, destino);
Pecas.Add(bispo);
break;
}
case "C":
{
Peca cavalo = new Cavalo(p.Cor, tab);
tab.ColocarPeca(cavalo, destino);
Pecas.Add(cavalo);
break;
}
case "T":
{
Peca torre = new Torre(p.Cor, tab);
tab.ColocarPeca(torre, destino);
Pecas.Add(torre);
break;
}
default:
{
throw new TabuleiroException("Peça errada para Promocao!");
}
}
}
}
}
if (EstaEmXeque(Adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (TesteXequeMate(Adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
Turno++;
mudaJogador();
}
//#jogadaespecial En Passant
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
vulneravelEnPassant = p;
}
else
{
vulneravelEnPassant = null;
}
}
/// <summary>
/// metodo que executa a jogada passada pelo jogador e solicita confirmacoes de xeque e xequemate
/// </summary>
/// <param name="origem"></param>
/// <param name="destino"></param>
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = tab.peca(destino);
//#jogadaEspecial Promocao
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Amarela && destino.linha == 7))
{
bool pergunta = false;
while (!pergunta)
{
Console.WriteLine("Deseja transformar seu Peao em qual Peca? D/C/T/B");
char resposta = char.Parse(Console.ReadLine());
if (resposta == 'd' || resposta == 'D')
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
pergunta = true;
}
else if (resposta == 'c' || resposta == 'C')
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca cavalo = new Cavalo(tab, p.cor);
tab.colocarPeca(cavalo, destino);
pecas.Add(cavalo);
pergunta = true;
}
else if (resposta == 't' || resposta == 'T')
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca torre = new Torre(tab, p.cor);
tab.colocarPeca(torre, destino);
pecas.Add(torre);
pergunta = true;
}
else if (resposta == 'b' || resposta == 'B')
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca bispo = new Bispo(tab, p.cor);
tab.colocarPeca(bispo, destino);
pecas.Add(bispo);
pergunta = true;
}
else
{
Console.WriteLine("Opcao invalida");
}
}
}
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequemate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
turno++;
mudaJogador();
}
//#JogadaEspecial En Passant
if (p is Peao && destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2)
{
vulneravelEnPassant = p;
}
else
{
vulneravelEnPassant = null;
}
}
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
if (estaEmXeque(JogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = Tab.peca(destino);
//jogada especial promocao
if (p is Peao)
{
if ((p.Cor == Cor.Branca && destino.Linha == 0) || (p.Cor == Cor.Preta && destino.Linha == 7))
{
bool result = false;
Console.WriteLine();
Console.Write("Qual peça deseja substituir seu Peão 1-Dama 2-Cavalo 3-Bispo 4-Torre: ");
int opcao = int.Parse(Console.ReadLine());
while (!result)
{
if (opcao < 1)
{
result = false;
Console.Write("Opção inválida! Informe uma das seguintes opções 1-Dama 2-Cavalo 3-Bispo 4-Torre: ");
opcao = int.Parse(Console.ReadLine());
}
else if (opcao > 4)
{
result = false;
Console.Write("Opção inválida! Informe uma das seguintes opções 1-Dama 2-Cavalo 3-Bispo 4-Torre: ");
opcao = int.Parse(Console.ReadLine());
}
else
{
result = true;
}
}
p = Tab.retirarPeca(destino);
Pecas.Remove(p);
switch (opcao)
{
case 1:
Peca dama = new Dama(p.Cor, Tab);
Tab.colocarPeca(dama, destino);
Pecas.Add(dama);
break;
case 2:
Peca cavalo = new Cavalo(p.Cor, Tab);
Tab.colocarPeca(cavalo, destino);
Pecas.Add(cavalo);
break;
case 3:
Peca bispo = new Bispo(p.Cor, Tab);
Tab.colocarPeca(bispo, destino);
Pecas.Add(bispo);
break;
case 4:
Peca torre = new Torre(p.Cor, Tab);
Tab.colocarPeca(torre, destino);
Pecas.Add(torre);
break;
}
}
}
if (estaEmXeque(adversaria(JogadorAtual)))
{
Xeque = true;
}
else
{
Xeque = false;
}
if (testeXequemate(adversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
mudaJogador();
}
// jogada especial en passant
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
vuleravelEmPassant = p;
}
else
{
vuleravelEmPassant = null;
}
}
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))
{
desfazMvimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque.");
}
Peca p = tab.peca(destino);
// Promoção
if (p is Peao)
{
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
bool foiPromovido = false;
Console.WriteLine("Informe a peça desejada (D, T, B, C): ");
while (foiPromovido == false)
{
string promovida = Console.ReadLine();
if (promovida == "C")
{
Peca cavalo = new Cavalo(tab, p.cor);
tab.colocarPeca(cavalo, destino);
pecas.Add(cavalo);
foiPromovido = true;
}
else if (promovida == "D")
{
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
foiPromovido = true;
}
else if (promovida == "T")
{
Peca torre = new Torre(tab, p.cor);
tab.colocarPeca(torre, destino);
pecas.Add(torre);
foiPromovido = true;
}
else if (promovida == "B")
{
Peca bispo = new Bispo(tab, p.cor);
tab.colocarPeca(bispo, destino);
pecas.Add(bispo);
foiPromovido = true;
}
else
{
Console.WriteLine("Peça informada não é válida");
Console.WriteLine("Informe a peça desejada (D, T, B, C): ");
promovida = Console.ReadLine();
foiPromovido = false;
}
}
}
}
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequeMate(adversaria(jogadorAtual)))
{
terminada = true;
Console.WriteLine("XEQUE MATE");
}
else
{
turno++;
mudaJogador();
}
//enPassant
if (p is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
{
vulneravelEnPassant = p;
}
else
{
vulneravelEnPassant = null;
}
}
/// <summary>
/// Executa o movimento, confere se está em xeque, itera o turno, muda jogador.
/// </summary>
/// <param name="origem"></param>
/// <param name="destino"></param>
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executaMovimento(origem, destino);
// Jogada não pode deixar jogador atual em xeque:
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = tab.peca(destino);
// Jogada especial: En Passant:
// Se for peão e [moveu duas casas para baixo (preta) ou moveu duas casas para cima (branca)]
if (p is Peao)
{
if ((destino.Linha == origem.Linha - 2) || (destino.Linha == origem.Linha + 2))
{
vulneravelEnPassant = p;
}
}
// Se nessa jogada não há um peão en passant, anula variável novamente (jogada só pode ser executada imediatamente após a movimentação do peão.
else
{
vulneravelEnPassant = null;
}
// Jogada Especial: Promoção:
if (p is Peao)
{
if ((p.cor == Cor.Branca && destino.Linha == 0) || (p.cor == Cor.Preta && destino.Linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
// Checando se adversário está em xeque:
if (estaEmXeque(corAdversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
// Se realizei a jogada e o adversário do jagador atual está em xeque-mate:
if (testeXequeMate(corAdversaria(jogadorAtual)))
{
terminada = true;
}
else
{
// Itera turno:
turno++;
// Muda Jogador:
if (jogadorAtual == Cor.Branca)
{
jogadorAtual = Cor.Preta;
}
else
{
jogadorAtual = Cor.Branca;
}
}
}
//realiza as jogadas em turno
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca capturada = executaMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, capturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = tab.peca(destino);
// # JOGADA ESPECIAL PROMOÇÃO
if (p is Peao)
{
if ((p.cor == Cor.Branco && destino.linha == 0) || (p.cor == Cor.Preto && destino.linha == 7))
{
tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(tab, p.cor);
Peca cavalo = new Cavalo(tab, p.cor);
Peca bispo = new Bispo(tab, p.cor);
Peca torre = new Torre(tab, p.cor);
Console.WriteLine("Escolha a peça que substituira o Peão: ");
Console.WriteLine("DAMA(rainha) = 1");
Console.WriteLine("CAVALO = 2");
Console.WriteLine("BISPO = 3");
Console.WriteLine("TORRE = 4");
Console.Write("Sua Escolha: ");
int num = int.Parse(Console.ReadLine());
switch (num)
{
case 1:
tab.colocarPeca(dama, destino);
pecas.Add(dama);
break;
case 2:
tab.colocarPeca(cavalo, destino);
pecas.Add(cavalo);
break;
case 3:
tab.colocarPeca(bispo, destino);
pecas.Add(bispo);
break;
case 4:
tab.colocarPeca(torre, destino);
pecas.Add(torre);
break;
default:
throw new TabuleiroException("Escolha incorreta!, PERDEU A PEÇA!!!");
}
}
}
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequeMate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
turno++;
mudarJogador();
}
// # JOGADA ESPECIAL EN PASSANT
vulneravelEnPassant = (p is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2)) ? p : null;
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
if (EstaEmXeque(JogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = Tab.peca(destino);
// #jogadaespecial promocao
if (p is Peao)
{
if ((p.Cor == Cor.Branca && destino.Linha == 0) || (p.Cor == Cor.Preta && destino.Linha == 7))
{
p = Tab.RetirarPeca(destino);
Pecas.Remove(p);
Console.WriteLine();
Console.Write("Escolha entre Bispo, Cavalo, Dama e Torre (B/C/D/T): ");
Char pecaescolhida = char.Parse(Console.ReadLine());
if (pecaescolhida == 'B')
{
Peca peca = new Bispo(Tab, p.Cor);
Tab.ColocarPeca(peca, destino);
Pecas.Add(peca);
}
else if (pecaescolhida == 'C')
{
Peca peca = new Cavalo(Tab, p.Cor);
Tab.ColocarPeca(peca, destino);
Pecas.Add(peca);
}
else if (pecaescolhida == 'D')
{
Peca peca = new Dama(Tab, p.Cor);
Tab.ColocarPeca(peca, destino);
Pecas.Add(peca);
}
else if (pecaescolhida == 'T')
{
Peca peca = new Torre(Tab, p.Cor);
Tab.ColocarPeca(peca, destino);
Pecas.Add(peca);
}
else
{
throw new TabuleiroException("Peça inválida!");
}
}
}
if (EstaEmXeque(Adversaria(JogadorAtual)))
{
Xeque = true;
}
else
{
Xeque = false;
}
if (TesteXequemate(Adversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
//#Jogadaespecial en passant
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravelEnPassant = p;
}
else
{
VulneravelEnPassant = null;
}
}
public Peca executaMovimento(Posicao origem, Posicao destino)
{
Peca p = tab.retirarPeca(origem);
p.incrementarQteMovimentos();
Peca pecaCapturada = tab.retirarPeca(destino);
tab.colocarPeca(p, destino);
if (pecaCapturada != null)
{
capturadas.Add(pecaCapturada);
}
// #jogadaespecial promocao
if (p is Peao)
{
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
// #jogadaespecial roque pequeno
if (p is Rei && destino.coluna == origem.coluna + 2)
{
Posicao origemT = new Posicao(origem.linha, origem.coluna + 3);
Posicao destinoT = new Posicao(origem.linha, origem.coluna + 1);
Peca T = tab.retirarPeca(origemT);
T.incrementarQteMovimentos();
tab.colocarPeca(T, destinoT);
}
// #jogadaespecial roque grande
if (p is Rei && destino.coluna == origem.coluna - 2)
{
Posicao origemT = new Posicao(origem.linha, origem.coluna - 4);
Posicao destinoT = new Posicao(origem.linha, origem.coluna - 1);
Peca T = tab.retirarPeca(origemT);
T.incrementarQteMovimentos();
tab.colocarPeca(T, destinoT);
}
// #jogadaespecial en passant
if (p is Peao)
{
if (origem.coluna != destino.coluna && pecaCapturada == null)
{
Posicao posP;
if (p.cor == Cor.Branca)
{
posP = new Posicao(destino.linha + 1, destino.coluna);
}
else
{
posP = new Posicao(destino.linha - 1, destino.coluna);
}
pecaCapturada = tab.retirarPeca(posP);
capturadas.Add(pecaCapturada);
}
}
return(pecaCapturada);
}
//conta o turno da partida
/* REGRA:
* o usuário não pode mover uma peça de modo que seu rei fique em xeque
*/
public void realizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executarMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = tab.peca(destino);
//---------Jogada Especial---------
//------------Promoção--------------
/* REGRA:
* A jogada promoção é quando um peão atinge a linha final do tabuleiro adversário,
* quando isso ocorre, ele pode ser transformar em outra peça a escolha do jogador,
* mas geralmente a rainha é escolhida, por poder se locomover em qualquer direção
*/
if (p is Peao)
{
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
//transformamos o peão automaticamente numa rainha, para simplificar a implementação
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequeMate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
turno++;
mudarJogador();
}
//---------Jogada Especial---------
//-----------Em Passant------------
if (p is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
{
vulneravelEmPassant = p;
}
else
{
vulneravelEmPassant = null;
}
}
public void realizaJogada(Posicao origem, Posicao destino)
{
// Se executou um movimento e capturou uma peça
Peca pecaCapturada = executaMovimento(origem, destino);
// O jogador não se pode colocar em xeque. Então caso acontece, desfazer a jogada
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque. Aperte Enter para tentar novamente!");
}
// Pegando a peça que foi movida
Peca p = tab.peca(destino);
// Jogada especial: Promoção
if (p is Peao)
{
// Se um peão branco chegou na linha 0 OU um peão preto chegou na linha 7
if ((p.cor == Cor.Branca && destino.linha == 0) || (p.cor == Cor.Preta && destino.linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
// Usuário não terá opção de escolher peça. Peão será substituído por uma Rainha
Peca dama = new Dama(tab, p.cor);
// Colocando Rainha no lugar do Peão
tab.colocarPeca(dama, destino);
pecas.Add(dama);
}
}
// Se o jogador adversário que estiver em xeque, jogada é permitida
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
// Se após jogada, o adversário estiver em xequemate
if (testeXequemate(adversaria(jogadorAtual)))
{
// Partida termina!
terminada = true;
}
else
{
// Incrementa turno pra mudar jogador
turno++;
mudaJogador();
}
// Jogada Especial: En Passant
// Se o Peão andou duas linhas a mais ou a menos pela primeira vez
if (p is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
{
// Peça está vulnerável
vulneravelEnPassant = p;
}
else
{
// Não tem peça vulnerável
vulneravelEnPassant = null;
}
}
public void realizarJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = executarMovimento(origem, destino);
if (estaEmXeque(jogadorAtual))
{
desfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
Peca p = tab.peca(destino);
// #jogadaespecial promocao
if (p is Peao)
{
if ((p.cor == Cor.Branco && destino.Linha == 0) || (p.cor == Cor.Preto && destino.Linha == 7))
{
p = tab.retirarPeca(destino);
pecas.Remove(p);
ConsoleColor aux = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine();
Console.WriteLine("#--- PROMOÇÃO! ---#");
Console.WriteLine("Opções de promoção:");
Console.WriteLine(" - Dama[D]\n - Torre[T]\n - Bispo[B]\n - Cavalo[C]");
Console.ForegroundColor = aux;
Console.Write("Digite o caractere da opção escolhida: ");
char escolha = char.Parse(Console.ReadLine());
switch (escolha)
{
//DAMA
case 'D':
Peca dama = new Dama(tab, p.cor);
tab.colocarPeca(destino, dama);
pecas.Add(dama);
break;
case 'd':
Peca dama1 = new Dama(tab, p.cor);
tab.colocarPeca(destino, dama1);
pecas.Add(dama1);
break;
//TORRE
case 'T':
Peca torre = new Torre(tab, p.cor);
tab.colocarPeca(destino, torre);
pecas.Add(torre);
break;
case 't':
Peca torre1 = new Torre(tab, p.cor);
tab.colocarPeca(destino, torre1);
pecas.Add(torre1);
break;
//BISPO
case 'B':
Peca bispo = new Bispo(tab, p.cor);
tab.colocarPeca(destino, bispo);
pecas.Add(bispo);
break;
case 'b':
Peca bispo1 = new Bispo(tab, p.cor);
tab.colocarPeca(destino, bispo1);
pecas.Add(bispo1);
break;
//CAVALO
case 'C':
Peca cavalo = new Cavalo(tab, p.cor);
tab.colocarPeca(destino, cavalo);
pecas.Add(cavalo);
break;
case 'c':
Peca cavalo1 = new Cavalo(tab, p.cor);
tab.colocarPeca(destino, cavalo1);
pecas.Add(cavalo1);
break;
}
}
}
if (estaEmXeque(adversaria(jogadorAtual)))
{
xeque = true;
}
else
{
xeque = false;
}
if (testeXequemate(adversaria(jogadorAtual)))
{
terminada = true;
}
else
{
turno++;
mudaJogador();
}
// #jogadaespecial en passant
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
vulneravelEnPassant = p;
}
else
{
vulneravelEnPassant = null;
}
}
