public Peca ExecutarMovimento(Posicao origem, Posicao destino)
{
Peca p = Tab.RetirarPeca(origem);
p.QtdMovimento();
Peca pecaCapturada = Tab.RetirarPeca(destino);
Tab.ColocarPeca(p, destino);
if (pecaCapturada != null)
{
Capturadas.Add(pecaCapturada);
}
//# Jogada especial roque pequeno
if (p is Rei && destino.Coluna == origem.Coluna + 2)
{
Posicao origemT = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoT = new Posicao(destino.Linha, destino.Coluna + 1);
Peca t = Tab.RetirarPeca(origemT);
t.QtdMovimento();
Tab.ColocarPeca(t, destinoT);
}
//# Jogada especial roque grande
if (p is Rei && destino.Coluna == origem.Coluna - 2)
{
Posicao origemT = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoT = new Posicao(destino.Linha, destino.Coluna - 1);
Peca t = Tab.RetirarPeca(origemT);
t.QtdMovimento();
Tab.ColocarPeca(t, destinoT);
}
//# Jogada especial Empasant
if (p is Peao)
{
if (origem.Coluna != destino.Coluna && pecaCapturada == null)
{
Posicao posP;
if (p.Cor == Cor.Branco)
{
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);
}
static void Main(string[] args)
{
Tabuleiro tab = new Tabuleiro(8, 8);
tab.ColocarPeca(new Torre(tab, Cor.Preta), new Posicao(0, 0));
tab.ColocarPeca(new Torre(tab, Cor.Preta), new Posicao(1, 3));
tab.ColocarPeca(new Rei(tab, Cor.Preta), new Posicao(2, 4));
Tela.ImprimirTabuleiro(tab);
Console.ReadKey();
}
private void DesfazMovimento(Posicao origem, Posicao destino, Peca pecaCapturada)
{
Peca pecaDestino = Tabuleiro.RetirarPeca(destino);
pecaDestino.DecrementarQtdeMovimentos();
if (pecaCapturada != null)
{
Tabuleiro.ColocarPeca(pecaCapturada, destino);
PecasCapturadas.Remove(pecaCapturada);
}
Tabuleiro.ColocarPeca(pecaDestino, origem);
if (pecaDestino is Rei && destino.Coluna == origem.Coluna + 2)
{
DesfazRoquePequeno(origem);
}
if (pecaDestino is Rei && destino.Coluna == origem.Coluna - 2)
{
DesfazRoqueGrande(origem);
}
if (pecaDestino is Peao)
{
DesfazEnPassant(pecaDestino, pecaCapturada, origem, destino);
}
}
private void DesfazMovimento(Posicao origem, Posicao destino, Peca pecaCapturada)
{
Peca peca = Tabuleiro.RetirarPeca(destino);
peca.DecrementaQteDeMovimentos();
Tabuleiro.ColocarPeca(peca, origem);
if (pecaCapturada != null)
{
Tabuleiro.ColocarPeca(pecaCapturada, destino);
_pecas.Add(pecaCapturada);
_pecasCapturadas.Remove(pecaCapturada);
}
if (peca is Rei && destino.Coluna == origem.Coluna + 2)
{
var origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
var destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementaQteDeMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
else if (peca is Rei && destino.Coluna == origem.Coluna - 2)
{
var origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
var destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementaQteDeMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
}
private Peca ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca peca = Tabuleiro.RetirarPeca(origem);
peca.IncrementarQtdeMovimentos();
Peca pecaCapturada = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(peca, destino);
if (pecaCapturada != null)
{
PecasCapturadas.Add(pecaCapturada);
}
if (peca is Rei && destino.Coluna == origem.Coluna + 2)
{
ExecutaRoquePequeno(origem);
}
if (peca is Rei && destino.Coluna == origem.Coluna - 2)
{
ExecutaRoqueGrande(origem);
}
if (peca is Peao)
{
ExecutaEnPassant(peca, pecaCapturada, origem, destino);
}
return(pecaCapturada);
}
public Peca ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca p = Tabuleiro.RetirarPeca(origem);
p.IncrementarQuantidadeDeMovimentos();
Peca pecaCapturada = Tabuleiro.RetirarPeca(destino); // caso exista peça na posição de destino, ela será retirada.
Tabuleiro.ColocarPeca(p, destino);
if (pecaCapturada != null)
{
Capturadas.Add(pecaCapturada);
}
//#jogadaespecial roque pequeno
if (p is Rei && destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca torre = Tabuleiro.RetirarPeca(origemTorre);
torre.IncrementarQuantidadeDeMovimentos();
Tabuleiro.ColocarPeca(torre, destinoTorre);
}
//#jogadaespecial roque grande
if (p is Rei && destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca torre = Tabuleiro.RetirarPeca(origemTorre);
torre.IncrementarQuantidadeDeMovimentos();
Tabuleiro.ColocarPeca(torre, destinoTorre);
}
//#jogadaespecial en passant
if (p is Peao)
{
if (origem.Coluna != destino.Coluna && pecaCapturada == null)
{
Posicao posPeao;
if (p.Cor == Cor.Branca)
{
posPeao = new Posicao(destino.Linha + 1, destino.Coluna);
}
else
{
posPeao = new Posicao(destino.Linha - 1, destino.Coluna);
}
pecaCapturada = Tabuleiro.RetirarPeca(posPeao);
Capturadas.Add(pecaCapturada);
}
}
return(pecaCapturada);
}
public Peca ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca peca = Tabuleiro.RetirarPeca(origem);
peca.IncrementarQtdMovimentos();
Peca pecaCapturada = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(peca, destino);
if (pecaCapturada != null)
{
Capturadas.Add(pecaCapturada);
}
// #jogadaespecial Roque Pequeno
if (peca is Rei && destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca pecaTorre = Tabuleiro.RetirarPeca(origemTorre);
pecaTorre.IncrementarQtdMovimentos();
Tabuleiro.ColocarPeca(pecaTorre, destinoTorre);
}
// #jogadaespecial Roque Grande
if (peca is Rei && destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca pecaTorre = Tabuleiro.RetirarPeca(origemTorre);
pecaTorre.IncrementarQtdMovimentos();
Tabuleiro.ColocarPeca(pecaTorre, destinoTorre);
}
// #jogadaespecial En Passant
if (peca is Peao)
{
if (origem.Coluna != destino.Coluna && pecaCapturada == null)
{
Posicao posicaoPeao;
if (peca.Cor == Cor.Branca)
{
posicaoPeao = new Posicao(destino.Linha + 1, destino.Coluna);
}
else
{
posicaoPeao = new Posicao(destino.Linha - 1, destino.Coluna);
}
pecaCapturada = Tabuleiro.RetirarPeca(posicaoPeao);
Capturadas.Add(pecaCapturada);
}
}
return(pecaCapturada);
}
private void DesfazRoqueGrande(Posicao origem)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementarQtdeMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
private void ExecutaRoquePequeno(Posicao origem)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca torre = Tabuleiro.RetirarPeca(origemTorre);
torre.IncrementarQtdeMovimentos();
Tabuleiro.ColocarPeca(torre, destinoTorre);
}
static void Main(string[] args)
{
try
{
Tabuleiro tabuleiro = new Tabuleiro(8, 8);
tabuleiro.ColocarPeca(new Torre(tabuleiro, Cor.Preta), new Posicao(0, 0));
tabuleiro.ColocarPeca(new Torre(tabuleiro, Cor.Preta), new Posicao(1, 9));
tabuleiro.ColocarPeca(new Rei(tabuleiro, Cor.Preta), new Posicao(2, 4));
tabuleiro.ColocarPeca(new Rei(tabuleiro, Cor.Preta), new Posicao(0, 0));
Tela.ImprimirTabuleiro(tabuleiro);
}
catch (TabuleiroException ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadLine();
}
public void DesfazMovimento(Posicao origem, Posicao destino, Peca pecaCapturada)
{
Peca p = Tabuleiro.RetirarPeca(destino);
p.DecrementarQuantidadeDeMovimentos();
if (pecaCapturada != null)
{
Tabuleiro.ColocarPeca(pecaCapturada, destino);
Capturadas.Remove(pecaCapturada);
}
Tabuleiro.ColocarPeca(p, origem);
//#jogadaespecial roque pequeno
if (p is Rei && destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementarQuantidadeDeMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
//#jogadaespecial roque grande
if (p is Rei && destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.IncrementarQuantidadeDeMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
// #jogaespecial en passant
if (p is Peao)
{
if (origem.Coluna != destino.Coluna && pecaCapturada == VulneravelEnPassant)
{
Peca peao = Tabuleiro.RetirarPeca(destino);
Posicao posPeao;
if (p.Cor == Cor.Branca)
{
posPeao = new Posicao(3, destino.Coluna);
}
else
{
posPeao = new Posicao(4, destino.Coluna);
}
Tabuleiro.ColocarPeca(peao, posPeao);
}
}
}
// Metodo que desfaz a jogada
public void DesfazMovimento(Posicao origem, Posicao destino, Peca pecaCapturada)
{
Peca peca = Tabuleiro.RetirarPeca(destino); // Retira a peca que foi para o destino
peca.DecrementarMovimentos(); // Tira a quantidade feita no movimento
if (pecaCapturada != null) // Se existir uma peça capturada, preciso devolver ela no lugar do destino
{
Tabuleiro.ColocarPeca(pecaCapturada, destino); // Coloca peca de volta, ela estava no destino
ConjuntoPecasCapturada.Remove(pecaCapturada); // Remove a peca capturada do conjunto de pecas capturadas
}
Tabuleiro.ColocarPeca(peca, origem); // Colocar peca na posição de origem
if (peca is Rei)
{
// Roque pequeno
if (destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementarMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
// Roque grande
if (destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementarMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
}
// En Passant
if (peca is Peao)
{
if (origem.Coluna != destino.Coluna && pecaCapturada == VulneravelEnPassant) // Testa se teve um movimento na diagonal e se a peca capturada foi uma peça vulneravel
{
Peca peao = Tabuleiro.RetirarPeca(destino);
Posicao posicaoAntigaPeao;
if (peca.Cor == Cor.Branca)
{
posicaoAntigaPeao = new Posicao(3, destino.Coluna);
}
else
{
posicaoAntigaPeao = new Posicao(4, destino.Coluna);
}
Tabuleiro.ColocarPeca(peao, posicaoAntigaPeao);
}
}
}
public void ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca peca = Tabuleiro.RetirarPeca(origem);
peca.IncrementarQtdMovimento();
Peca PecaCapturada = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(peca, destino);
}
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 = Tabuleiro.Peca(destino);
// #jogadaespecial promocao
if (p is Peao)
{
if ((p.Cor == Cor.Branca && destino.Linha == 0) || (p.Cor == Cor.Preta && destino.Linha == 7))
{
p = Tabuleiro.RetirarPeca(destino);
Pecas.Remove(p);
Peca dama = new Dama(Tabuleiro, p.Cor);
Tabuleiro.ColocarPeca(dama, destino);
Pecas.Add(dama);
}
}
if (EstaEmXeque(Adversaria(JogadorAtual)))
{
Xeque = true;
}
else
{
Xeque = false;
}
if (XequeMate(Adversaria(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
Peca peao = Tabuleiro.Peca(destino);
// #jogadaespecial en passant
if (peao is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravelEnPassant = peao;
}
else
{
VulneravelEnPassant = null;
}
}
// Metodo que realiza a jogada, verificando se o rei não ficará em xeque, se ficar, tem que desfazer a jogada
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino); // Guardo a peca capturada (se tiver alguma) para depois desfazer o movimento, caso o rei fique em xeque
if (EstaEmXeque(JogadorAtual))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroExcecao("Você não pode se colocar em xeque!");
}
Peca peca = Tabuleiro.Peca(destino); // Qual peça foi movida?
// Jogada especial promocao do peao quando cehgar na ultima casa
if (peca is Peao)
{
if ((peca.Cor == Cor.Branca && destino.Linha == 0) || (peca.Cor == Cor.Preta && destino.Linha == 7)) // Pao da cor branca chegou na ultima linha do tabuleiro ou peao preto que chegou na ultima linha
{
peca = Tabuleiro.RetirarPeca(destino); // Retirar a peca da posicao de destino
ConjuntoPecasNova.Remove(peca); // Remove peca do jogo
Peca dama = new Dama(Tabuleiro, peca.Cor); // Ja coloca a Dama de vez, sem deixar o usuario escolher
Tabuleiro.ColocarPeca(dama, destino);
ConjuntoPecasNova.Add(dama); // Adicionar ao conjunto de pecas novas a dama que criei
}
}
if (EstaEmXeque(Adversaria(JogadorAtual))) // Se a cor adversaria entre em xeque
{
Xeque = true;
}
else
{
Xeque = false;
}
if (TestaXequeMate(Adversaria(JogadorAtual))) // Se o jogador atual (cor) está em xeque mate
{
Terminada = true;
}
else
{
Turno++; // Passar o turno
MudaJogador();
}
// EnPassant
if (peca is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2)) //Verifica se é um peao e se andou 2 casas, se andou é porque é o primeiro movimento
{
VulneravelEnPassant = peca;
}
else
{
VulneravelEnPassant = null;
}
}
static void Main(string[] args)
{
//PosicaoXadrez pos = new PosicaoXadrez('a', 1);
// Console.WriteLine(pos.toPosicao());
Tabuleiro tab = new Tabuleiro(8, 8);
try {
tab.ColocarPeca(new Torre(tab, Cor.Preta), new Posicao(0, 1));
tab.ColocarPeca(new Rei(tab, Cor.Preta), new Posicao(0, 2));
Tela.ImprimirTabuleiro(tab);
Console.WriteLine(tab);
}catch (TabuleiroException tb)
{
Console.WriteLine(tb.Message);
}
}
static void Main(string[] args)
{
try
{
Tabuleiro tab = new Tabuleiro(8, 8);
tab.ColocarPeca(new Torre(tab, Cor.Preta), new Posicao(0, 0));
tab.ColocarPeca(new Torre(tab, Cor.Preta), new Posicao(1, 3));
tab.ColocarPeca(new Rei(tab, Cor.Branca), new Posicao(1, 2));
tab.ColocarPeca(new Rei(tab, Cor.Branca), new Posicao(5, 2));
tab.ColocarPeca(new Rei(tab, Cor.Preta), new Posicao(1, 7));
Tela.imprimirTabuleiro(tab);
}
catch (TabuleiroExcepetion e)
{
Console.WriteLine(e.Message);
throw;
}
Console.ReadKey();
}
public void ExecutarMovimento(Posicao origem, Posicao destino)
{
var pecaMovimentada = tabuleiro.RetirarPecaDaPosicao(origem);
pecaMovimentada.IncrementarQtdMovimentos();
var pecaCapturada = tabuleiro.RetirarPecaDaPosicao(destino);
tabuleiro.ColocarPeca(pecaMovimentada, destino);
}
public Peca MoverPeca(Posicao origem, Posicao destino)
{
Peca P = Tabuleiro.RetirarPeca(origem);
P.IncrementarMovimentos();
Peca Captura = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(P, destino);
if (Captura != null)
{
pecasCapturadas.Add(Captura);
}
//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 = Tabuleiro.RetirarPeca(origemT);
T.IncrementarMovimentos();
Tabuleiro.ColocarPeca(T, destinoT);
}
//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 = Tabuleiro.RetirarPeca(origemT);
T.IncrementarMovimentos();
Tabuleiro.ColocarPeca(T, destinoT);
}
// EN PASSANT
if (P is Peao && destino.Coluna != origem.Coluna && Captura == null)
{
Posicao enPassantPosisao;
if (P.Cor == Cor.Branco)
{
enPassantPosisao = new Posicao(P.Posicao.Linha + 1, P.Posicao.Coluna);
}
else
{
enPassantPosisao = new Posicao(P.Posicao.Linha - 1, P.Posicao.Coluna);
}
if (Tabuleiro.Peca(enPassantPosisao) == EnPassant)
{
Captura = Tabuleiro.RetirarPeca(enPassantPosisao);
pecasCapturadas.Add(Captura);
}
}
return(Captura);
}
public Peca ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca p = Tabuleiro.RetirarPeca(origem);
p.IncrementarQuantidadeMovimentos();
Peca PecaCapturada = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(p, destino);
if (PecaCapturada != null)
{
Capturadas.Add(PecaCapturada);
}
// #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 = Tabuleiro.RetirarPeca(origemT);
T.IncrementarQuantidadeMovimentos();
Tabuleiro.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 = Tabuleiro.RetirarPeca(origemT);
T.IncrementarQuantidadeMovimentos();
Tabuleiro.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 = Tabuleiro.RetirarPeca(posP);
Capturadas.Add(PecaCapturada);
}
}
return(PecaCapturada);
}
private void PromocaoDoPeao(Peca peca, Posicao destino)
{
if ((peca.Cor == Cor.Branco && destino.Linha == 0) || (peca.Cor == Cor.Preto && destino.Linha == 7))
{
peca = Tabuleiro.RetirarPeca(destino);
PecasEmJogo.Remove(peca);
Peca Dama = new Dama(Tabuleiro, peca.Cor);
Tabuleiro.ColocarPeca(Dama, destino);
PecasEmJogo.Add(Dama);
}
}
public Peca ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca peca = Tabuleiro.RetirarPeca(origem);
peca.IncrementarQtdeMovimento();
Peca pecaCapturada = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(peca, destino);
if (pecaCapturada != null)
{
capturadas.Add(pecaCapturada);
}
// Roque pequeno
if (peca is Rei && destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca T = Tabuleiro.RetirarPeca(origemTorre);
T.IncrementarQtdeMovimento();
Tabuleiro.ColocarPeca(T, destinoTorre);
}
// Roque grande
if (peca is Rei && destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca T = Tabuleiro.RetirarPeca(origemTorre);
T.IncrementarQtdeMovimento();
Tabuleiro.ColocarPeca(T, destinoTorre);
}
// En passant
if (peca is Peao)
{
if (origem.Coluna != destino.Coluna && pecaCapturada == null)
{
Posicao PosPeao;
if (peca.Cor == Cor.Branca)
{
PosPeao = new Posicao(destino.Linha + 1, destino.Coluna);
}
else
{
PosPeao = new Posicao(destino.Linha - 1, destino.Coluna);
}
pecaCapturada = Tabuleiro.RetirarPeca(PosPeao);
capturadas.Add(pecaCapturada);
}
}
return(pecaCapturada);
}
static void Main(string[] args)
{
Tabuleiro tab = new Tabuleiro(8, 8);
{
/*
* tab.ColocarPeca(new Torre(Cor.Branca, tab), new Posicao(0, 0));
* tab.ColocarPeca(new Torre(Cor.Branca, tab), new Posicao(0, 7));
* tab.ColocarPeca(new Rei(Cor.Branca, tab), new Posicao(0, 4));
*/
}
// PosicaoXadrez px = new PosicaoXadrez('c', 4);
// Console.WriteLine( px );
// Console.WriteLine(px.ToPosicao());
try
{
tab.ColocarPeca(new Torre(Cor.Preta), new Posicao(0, 7));
tab.ColocarPeca(new Torre(Cor.Preta), new Posicao(0, 0));
tab.ColocarPeca(new Rei(Cor.Preta), new Posicao(0, 4));
tab.ColocarPeca(new Torre(Cor.Branca), new Posicao(7, 0));
tab.ColocarPeca(new Torre(Cor.Branca), new Posicao(7, 7));
tab.ColocarPeca(new Rei(Cor.Branca), new Posicao(7, 3));
Tela.ImprimirTabuleiro(tab);
}
catch (TabuleiroException e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();
}
private Peca ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca p = Tabuleiro.RetirarPeca(origem);
p.IncrementarQtdeMovimentos();
Peca pecaCapturada = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(p, destino);
if (pecaCapturada != null)
{
_capturadas.Add(pecaCapturada);
}
// #JogadaEspecial RoquePequeno
if (p is Rei && destino.Linha == origem.Linha && destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
ExecutaMovimento(origemTorre, destinoTorre); // Usei a recursividade ??
/*
* Peca torre = Tabuleiro.RetirarPeca(origemTorre);
* torre.IncrementarQtdeMovimentos();
* Tabuleiro.ColocarPeca(torre, destinoTorre);
*/
}
// #JogadaEspecial RoqueGrande
if (p is Rei && destino.Linha == origem.Linha && destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
ExecutaMovimento(origemTorre, destinoTorre); // Usei a recursividade ??
/*
* Peca torre = Tabuleiro.RetirarPeca(origemTorre);
* torre.IncrementarQtdeMovimentos();
* Tabuleiro.ColocarPeca(torre, destinoTorre);
*/
}
// #JogadaEspecial EmPassant
// Se Peao andou da diagonal e não capturou ninguém é pq é EnPassant
if (p is Peao && destino.Coluna != origem.Coluna && pecaCapturada == null)
{
pecaCapturada = Tabuleiro.RetirarPeca(VulneravemEnPassant.Posicao); // Fiz este código bem diferente ??
_capturadas.Add(pecaCapturada);
}
return(pecaCapturada);
}
public void DesfazMovimento(Posicao origem, Posicao destino, Peca pecaCapturada)
{
Peca pecaRetirada = Tabuleiro.RetirarPeca(destino);
pecaRetirada.DecrementarQuantidadeMovimentos();
if (pecaCapturada != null)
{
Tabuleiro.ColocarPeca(pecaCapturada, destino);
_pecasCapturadas.Remove(pecaCapturada);
}
Tabuleiro.ColocarPeca(pecaRetirada, origem);
//Jogada Especial Roque Pequeno
if (pecaRetirada is Rei && destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementarQuantidadeMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
//Jogada Especial Roque Grande
if (pecaRetirada is Rei && destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
torre.DecrementarQuantidadeMovimentos();
Tabuleiro.ColocarPeca(torre, origemTorre);
}
//Jogada Especial En Passant
if (pecaRetirada is Peao)
{
if (origem.Coluna != destino.Coluna && pecaCapturada == VulneravelEnPassant)
{
Peca peaoDevolvido = Tabuleiro.RetirarPeca(destino);
Posicao posicaoPeaoDevolvido;
if (pecaRetirada.Cor == Cor.Branca)
{
posicaoPeaoDevolvido = new Posicao(3, destino.Coluna);
}
else
{
posicaoPeaoDevolvido = new Posicao(4, destino.Coluna);
}
Tabuleiro.ColocarPeca(peaoDevolvido, posicaoPeaoDevolvido);
}
}
}
public void ReverterJogada(Posicao origem, Posicao destino, Peca captura)
{
Peca p = Tabuleiro.RetirarPeca(destino);
p.DecrementarMovimentos();
if (captura != null)
{
Tabuleiro.ColocarPeca(captura, destino);
pecasCapturadas.Remove(captura);
}
Tabuleiro.ColocarPeca(p, origem);
//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 = Tabuleiro.RetirarPeca(destinoT);
T.DecrementarMovimentos();
Tabuleiro.ColocarPeca(T, origemT);
}
//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 = Tabuleiro.RetirarPeca(destinoT);
T.DecrementarMovimentos();
Tabuleiro.ColocarPeca(T, origemT);
}
//EN PASSANT
if (p is Peao)
{
if (destino.Coluna != origem.Coluna && captura == EnPassant)
{
Peca peao = Tabuleiro.RetirarPeca(destino);
Posicao pos;
if (p.Cor == Cor.Branco)
{
pos = new Posicao(3, destino.Coluna);
}
else
{
pos = new Posicao(4, destino.Coluna);
}
}
}
}
public Peca ExecutaMovimento(Posicao origem, Posicao destino)
{
Peca p = Tabuleiro.retirarPeca(origem);
p.incrementarQteMovimentos();
Peca pecaCapturada = Tabuleiro.retirarPeca(destino);
Tabuleiro.ColocarPeca(p, destino);
if (pecaCapturada != null)
{
_capituradas.Add(pecaCapturada);
}
// #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 = Tabuleiro.retirarPeca(origemT);
T.incrementarQteMovimentos();
Tabuleiro.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 = Tabuleiro.retirarPeca(origemT);
T.incrementarQteMovimentos();
Tabuleiro.ColocarPeca(T, destinoT);
}
// #jogadaespecial en passant
if (p is Peao)
{
if (origem.coluna != destino.coluna && pecaCapturada == null)
{
Posicao posP;
posP = p.cor == Cor.Branco ?
new Posicao(destino.linha + 1, destino.coluna):
new Posicao(destino.linha - 1, destino.coluna);
pecaCapturada = Tabuleiro.retirarPeca(posP);
_capituradas.Add(pecaCapturada);
}
}
return(pecaCapturada);
}
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 = Tabuleiro.Peca(destino);
// #JogadaEspecial Promocao
// Como o Peao não anda pra trás, não preciso testar a cor
if (p is Peao && (destino.Linha == 0 || destino.Linha == Tabuleiro.Linhas - 1))
{
p = Tabuleiro.RetirarPeca(destino);
_pecas.Remove(p);
// Por padrão usei a Dama, mas tb poderia ser Cavalo, Bispo ou Torre (só não Rei)
Peca dama = new Dama(Tabuleiro, p.Cor);
Tabuleiro.ColocarPeca(dama, destino);
_pecas.Add(dama);
}
Xeque = EstaEmXeque(Adversario(JogadorAtual));
if (TestaXequeMate(Adversario(JogadorAtual)))
{
Terminada = true;
}
else
{
Turno++;
MudaJogador();
}
// #JogadaEspecial EnPassant
// Se Peao e andou 2 casas é pq é o 1º movimento
if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
{
VulneravemEnPassant = p;
}
else
{
VulneravemEnPassant = null;
}
}
private void _desfazMovimento(Posicao origem, Posicao destino, Peca pecaCapturada)
{
Peca p = Tabuleiro.RetirarPeca(destino);
p.DecrementarQtdeMovimentos();
if (pecaCapturada != null)
{
Tabuleiro.ColocarPeca(pecaCapturada, destino);
_capturadas.Remove(pecaCapturada);
}
Tabuleiro.ColocarPeca(p, origem);
if (p is Rei && destino.Linha == origem.Linha && destino.Coluna == origem.Coluna + 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna + 3);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna + 1);
_desfazMovimento(origemTorre, destinoTorre, null); // Usei a recursividade ??
/*
* Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
* torre.DecrementarQtdeMovimentos();
* Tabuleiro.ColocarPeca(torre, origemTorre);
*/
}
// #JogadaEspecial RoqueGrande
if (p is Rei && destino.Linha == origem.Linha && destino.Coluna == origem.Coluna - 2)
{
Posicao origemTorre = new Posicao(origem.Linha, origem.Coluna - 4);
Posicao destinoTorre = new Posicao(origem.Linha, origem.Coluna - 1);
_desfazMovimento(origemTorre, destinoTorre, null); // Usei a recursividade ??
/*
* Peca torre = Tabuleiro.RetirarPeca(destinoTorre);
* torre.DecrementarQtdeMovimentos();
* Tabuleiro.ColocarPeca(torre, origemTorre);
*/
}
// #JogadaEspecial EmPassant
if (p is Peao && destino.Coluna != origem.Coluna && pecaCapturada == VulneravemEnPassant)
{
Peca peao = Tabuleiro.RetirarPeca(destino);
Tabuleiro.ColocarPeca(peao, new Posicao(origem.Linha, destino.Coluna)); // Fiz diferente ??
}
}
public void RealizaJogada(Posicao origem, Posicao destino)
{
Peca pecaCapturada = ExecutaMovimento(origem, destino);
Func <Cor, List <Peca>, List <Peca>, bool> estaEmXeque = TestesPartida.EstaEmXeque;
Func <Cor, List <Peca>, List <Peca>, Tabuleiro.Tabuleiro, PartidaDeXadrez, bool> testeXequemate = TestesPartida.TesteXequemate;
if (estaEmXeque(JogadorAtual, Adversaria(), PecasEmJogo()))
{
DesfazMovimento(origem, destino, pecaCapturada);
throw new TabuleiroException("Você não pode se colocar em xeque!");
}
var peca = Tabuleiro.Peca(destino);
if (peca is Peao)
{
if ((peca.cor == Cor.Branco && destino.linha == 0) || (peca.cor == Cor.Preto && destino.linha == 7))
{
peca = Tabuleiro.retirarPeca(destino);
_pecas.Remove(peca);
Peca dama = new Dama(peca.cor, Tabuleiro);
Tabuleiro.ColocarPeca(dama, destino);
_pecas.Add(dama);
}
}
Xeque = estaEmXeque(JogadorAtual, Adversaria(), PecasEmJogo());
if (testeXequemate.Invoke(JogadorAtual, Adversaria(), PecasEmJogo(), Tabuleiro, this))
{
Terminada = true;
}
else
{
Turno++;
MudarJogador();
}
// #jogadaespecial en passant
VulneravelEnPassant =
peca is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2) ?
peca :
null;
}
