Example #1
0
        public void Promocao(Peca peca)
        {
            Posicao posicao = peca.Posicao;

            Tabuleiro.RemoverPeca(posicao);
            _pecasNaPartida.Remove(peca);
            Peca dama = new Dama(peca.Cor, Tabuleiro);

            Tabuleiro.ColocarPeca(dama, posicao);
            _pecasNaPartida.Add(dama);
        }
        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 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 (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 ser por em Xeque!");
            }

            Peca p = Tabuleiro.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 = 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 (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;
            }
        }
Example #4
0
        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))
                {
                    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();
            }

            //#JOGADA ESPECIAL EN PASSANT
            if (P is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
            {
                VulneravelEnPassant = P;
            }
            else
            {
                VulneravelEnPassant = null;
            }
        }
Example #5
0
        public void RealizarJogada(Posicao origem, Posicao destino)
        {
            Peca pecaCapturada = ExecutarMovimento(origem, destino);

            if (EstaEmXeque(JogadorAtual))
            {
                DesfazerMovimento(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++;
                MudarJogador();
            }

            // #jogadaespecial en passant
            if (p is Peao && (destino.linha == origem.linha - 2 || destino.linha == origem.linha + 2))
            {
                VulneravelEnPassant = p;
            }
            else
            {
                VulneravelEnPassant = null;
            }
        }
Example #6
0
        public Peca Promocao(char c, Peca p)
        {
            Peca aux;

            switch (c)
            {
            case 'd':
                aux = new Dama(p.Cor, Tab);
                return(aux);

            case 'D':
                aux = new Dama(p.Cor, Tab);
                return(aux);

            case 'b':
                aux = new Bispo(p.Cor, Tab);
                return(aux);

            case 'B':
                aux = new Bispo(p.Cor, Tab);
                return(aux);

            case 'c':
                aux = new Cavalo(p.Cor, Tab);
                return(aux);

            case 'C':
                aux = new Cavalo(p.Cor, Tab);
                return(aux);

            case 't':
                aux = new Torre(p.Cor, Tab);
                return(aux);

            case 'T':
                aux = new Torre(p.Cor, Tab);
                return(aux);

            default:
                throw new TabuleiroException("O jogo quebrou por favo reinicie!");
            }
        }
Example #7
0
        public void RealizaJogada(Posicao origem, Posicao destino)
        {
            Peca pecaCapturada = ExecutarMovimento(origem, destino);
            Peca pecaMovida    = Tabuleiro.Peca(destino);

            if (EstaEmXeque(JogadorAtual))
            {
                DesfazMovimento(origem, destino, pecaCapturada);
                throw new TabuleiroException("Você não pode se colocar em xeque!");
            }

            //#JogadaEspecial Promoção
            if (pecaMovida is Peao)
            {
                if ((pecaMovida.Cor == Cor.Branca && destino.Linha == 0) || (pecaMovida.Cor == Cor.Preta && destino.Linha == 7))
                {
                    pecaMovida = Tabuleiro.RetirarPeca(destino);
                    PecasEmJogo.Remove(pecaMovida);

                    Peca dama = new Dama(Tabuleiro, pecaMovida.Cor);
                    Tabuleiro.ColocarPeca(dama, destino);
                    PecasEmJogo.Add(dama);
                }
            }

            EmXeque = EstaEmXeque(CorAdversariaACor(JogadorAtual));

            if (TesteXequeMate(CorAdversariaACor(JogadorAtual)))
            {
                Terminada = true;
            }
            else
            {
                Turno++;
                MudaJogador();
            }

            //#JogadaEspecial En Passant
            bool isVuneravelEnPassant = pecaMovida is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2);

            PecaVuneravelAEnPassant = isVuneravelEnPassant ? pecaMovida : null;
        }
Example #8
0
        public void NovaJogada(Posicao origem, Posicao destino)
        {
            Peca pecaCapturada = ExecutarMovimento(origem, destino);

            if (EstaEmXeque())
            {
                DesfazerMovimento(origem, destino, pecaCapturada);
                throw new TabuleiroException("UM JOGADOR NÃO PODE SE COLOCAR EM XEQUE!");
            }
            Peca peca = Tabuleiro.ObterPeca(destino);

            //Teste Jogada Especial "Promoção" (trocar peão por dama se chegar ao outro lado do tabuleiro)
            if (peca is Peao)
            {
                if ((peca.Cor == Cor.Azul && destino.Linha == 7) || (peca.Cor == Cor.Vermelho && destino.Linha == 0))
                {
                    peca = Tabuleiro.RemoverPeca(destino);
                    _pecasNaPartida.Remove(peca);
                    Peca dama = new Dama(peca.Cor, Tabuleiro);
                    Tabuleiro.ColocarPeca(dama, destino);
                    _pecasNaPartida.Add(dama);
                    Tela.JogadaEspecialPromocao();
                }
            }

            AlteraJogador();

            if (EstaXequeMate())
            {
                Terminada = true;
            }
            else
            {
                IncrementaTurno();
            }
        }
        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 se pode colocar me xeque!");
            }

            //Jogada especial Promoção
            Peca p = tab.peca(destino);

            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.Write("Entre com o valor  para o tipo de peça desejado: 1-cavalo, 2,bispo , 3-torre e 4-dama: ");
                    int n = int.Parse(Console.ReadLine());
                    switch (n)
                    {
                    case 1:
                        Peca Cavalo = new Cavalo(tab, p.Cor);
                        tab.colocarPeca(Cavalo, destino);
                        pecas.Add(Cavalo);
                        break;

                    case 2:
                        Peca Bispo = new Bispo(tab, p.Cor);
                        tab.colocarPeca(Bispo, destino);
                        pecas.Add(Bispo);
                        break;

                    case 3:
                        Peca Torre = new Torre(tab, p.Cor);
                        tab.colocarPeca(Torre, destino);
                        pecas.Add(Torre);
                        break;

                    case 4:
                        Peca Dama = new Dama(tab, p.Cor);
                        tab.colocarPeca(Dama, destino);
                        pecas.Add(Dama);
                        break;
                    }
                }
            }

            if (estaEmXeque(corAdversaria(jogadorAtual)))
            {
                xeque = true;
            }
            else
            {
                xeque = false;
            }

            if (testeXequeMate(corAdversaria(jogadorAtual)))
            {
                terminada = true;
            }
            else
            {
                turno++;
                mudaJogador();
            }


            //Jogada especial enpassant
            if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
            {
                vulneravelEnPassant = p;
            }
            else
            {
                vulneravelEnPassant = null;
            }
        }
Example #10
0
        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);

            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);
                    while (true)
                    {
                        Console.Clear();
                        Console.WriteLine("Para qual peça você deseja promover o peão?");
                        Console.WriteLine("(A) Bispo");
                        Console.WriteLine("(B) Cavalo");
                        Console.WriteLine("(C) Rainha");
                        Console.WriteLine("(D) Torre");
                        char pecaEscolhida = char.Parse(Console.ReadLine());
                        if (pecaEscolhida == 'A' || pecaEscolhida == 'a')
                        {
                            Peca bispo = new Bispo(Tab, p.Cor);
                            Tab.ColocarPeca(bispo, destino);
                            Pecas.Add(bispo);
                            break;
                        }
                        else if (pecaEscolhida == 'B' || pecaEscolhida == 'b')
                        {
                            Peca cavalo = new Cavalo(Tab, p.Cor);
                            Tab.ColocarPeca(cavalo, destino);
                            Pecas.Add(cavalo);
                            break;
                        }
                        else if (pecaEscolhida == 'C' || pecaEscolhida == 'c')
                        {
                            Peca dama = new Dama(Tab, p.Cor);
                            Tab.ColocarPeca(dama, destino);
                            Pecas.Add(dama);
                            break;
                        }
                        else if (pecaEscolhida == 'D' || pecaEscolhida == 'd')
                        {
                            Peca torre = new Torre(Tab, p.Cor);
                            Tab.ColocarPeca(torre, destino);
                            Pecas.Add(torre);
                            break;
                        }
                        else
                        {
                            Console.WriteLine("Opção inválida!");
                            Console.ReadLine();
                        }
                    }
                }
            }
            if (EstaEmXeque(Adversaria(JogadorAtual)))
            {
                Xeque = true;
            }
            else
            {
                Xeque = false;
            }
            if (TesteXequeMate(Adversaria(JogadorAtual)))
            {
                Terminada = true;
            }
            else
            {
                Turno++;
                MudaJogador();
            }
            //Jogada En Passant
            if (p is Peao && (destino.Linha == origem.Linha - 2 || destino.Linha == origem.Linha + 2))
            {
                VulneravelEnPassant = p;
            }
            else
            {
                VulneravelEnPassant = null;
            }
        }