Esempio n. 1
0
        public override bool[,] MovimentosPossiveis()
        {
            bool[,] movimentos = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];

            Posicao p = new Posicao(Posicao.Linha, Posicao.Coluna);

            //ACIMA
            p.SetPosicao(p.Linha - 1, p.Coluna);
            while (Tabuleiro.PosicaoValida(p) && PodeMover(p))
            {
                movimentos[p.Linha, p.Coluna] = true;
                if (Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor != this.Cor)
                {
                    break;
                }
                p.Linha -= 1;
            }

            //ABAIXO
            p.SetPosicao(Posicao.Linha, Posicao.Coluna);
            p.SetPosicao(p.Linha + 1, p.Coluna);
            while (Tabuleiro.PosicaoValida(p) && PodeMover(p))
            {
                movimentos[p.Linha, p.Coluna] = true;
                if (Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor != this.Cor)
                {
                    break;
                }
                p.Linha += 1;
            }

            //DIREITA
            p.SetPosicao(Posicao.Linha, Posicao.Coluna);
            p.SetPosicao(p.Linha, p.Coluna + 1);
            while (Tabuleiro.PosicaoValida(p) && PodeMover(p))
            {
                movimentos[p.Linha, p.Coluna] = true;
                if (Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor != this.Cor)
                {
                    break;
                }
                p.Coluna += 1;
            }

            //ESQUERDA
            p.SetPosicao(Posicao.Linha, Posicao.Coluna);
            p.SetPosicao(p.Linha, p.Coluna - 1);
            while (Tabuleiro.PosicaoValida(p) && PodeMover(p))
            {
                movimentos[p.Linha, p.Coluna] = true;
                if (Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor != this.Cor)
                {
                    break;
                }
                p.Coluna -= 1;
            }


            return(movimentos);
        }
Esempio n. 2
0
        public override bool[,] MovimentosPossiveis()
        {
            var movimentosPossiveis = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
            var posicao             = new Posicao(0, 0);

            posicao.AlterarPosicao(Posicao.Linha - 1, Posicao.Coluna);
            while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
            {
                movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
                if (Tabuleiro.ExistePeca(posicao) && Tabuleiro.GetPeca(posicao).Cor != Cor)
                {
                    break;
                }

                posicao.AlterarPosicao(posicao.Linha - 1, posicao.Coluna);
            }

            posicao.AlterarPosicao(Posicao.Linha + 1, Posicao.Coluna);
            while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
            {
                movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
                if (Tabuleiro.ExistePeca(posicao) && Tabuleiro.GetPeca(posicao).Cor != Cor)
                {
                    break;
                }

                posicao.AlterarPosicao(posicao.Linha + 1, posicao.Coluna);
            }

            posicao.AlterarPosicao(Posicao.Linha, Posicao.Coluna - 1);
            while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
            {
                movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
                if (Tabuleiro.ExistePeca(posicao) && Tabuleiro.GetPeca(posicao).Cor != Cor)
                {
                    break;
                }

                posicao.AlterarPosicao(posicao.Linha, posicao.Coluna - 1);
            }

            posicao.AlterarPosicao(Posicao.Linha, Posicao.Coluna + 1);
            while (Tabuleiro.PosicaoValida(posicao) && PodeMover(posicao))
            {
                movimentosPossiveis[posicao.Linha, posicao.Coluna] = true;
                if (Tabuleiro.ExistePeca(posicao) && Tabuleiro.GetPeca(posicao).Cor != Cor)
                {
                    break;
                }

                posicao.AlterarPosicao(posicao.Linha, posicao.Coluna + 1);
            }

            return(movimentosPossiveis);
        }
        public override bool[,] MovimentosPossiveis()
        {
            bool[,] matrizDeMovimentos = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
            Posicao pos = new Posicao(0, 0);

            //Acima
            pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
            while (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
                if (Tabuleiro.ExistePeca(pos) && Tabuleiro.Peca(pos).Cor != Cor)
                {
                    break;
                }
                pos.Linha--;
            }

            //Abaixo
            pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
            while (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
                if (Tabuleiro.ExistePeca(pos) && Tabuleiro.Peca(pos).Cor != Cor)
                {
                    break;
                }
                pos.Linha++;
            }

            //Direita
            pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
            while (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
                if (Tabuleiro.ExistePeca(pos) && Tabuleiro.Peca(pos).Cor != Cor)
                {
                    break;
                }
                pos.Coluna++;
            }

            //Esquerda
            pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
            while (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
                if (Tabuleiro.ExistePeca(pos) && Tabuleiro.Peca(pos).Cor != Cor)
                {
                    break;
                }
                pos.Coluna--;
            }

            return(matrizDeMovimentos);
        }
Esempio n. 4
0
        public void ValidarOrigem(Posicao origem)
        {
            if (!Tabuleiro.ExistePeca(origem))
            {
                throw new TabuleiroException("Não existe peça na posição de origem escolhida!");
            }

            if (JogadorAtual != Tabuleiro.Peca(origem).Cor)
            {
                throw new TabuleiroException("A peça de origem escolhida não é sua!");
            }

            if (!Tabuleiro.Peca(origem).ExistemMovimentosPossiveis())
            {
                throw new TabuleiroException("Não existem movimentos possíveis para a peça escolhida!");
            }
        }
 public void ValidarPosicaoDeOrigem(Posicao posicao)
 {
     if (!Tabuleiro.ExistePeca(posicao)) // Testa se a existe peça na posição e se a posição é valida
     {
     }
     if (Tabuleiro.Peca(posicao) == null) // Testa se existe peca na posiçao escolhida
     {
         throw new TabuleiroExcecao("Não existe peça na posição de origem escolhida");
     }
     if (JogadorAtual != Tabuleiro.Peca(posicao).Cor) // Teste se o jogador atual (cor) é diferente da peca que ele irá mover (cor)
     {
         throw new TabuleiroExcecao("A peça de origm escolhida não é sua!");
     }
     if (!Tabuleiro.Peca(posicao).ExisteMovimentosPossiveis()) //Testa se NÂO exite movimentos possiveis
     {
         throw new TabuleiroExcecao("Não há movimentos possíveis para a peça de origem escolhida");
     }
 }
Esempio n. 6
0
        private Peca ExecutaMovimento(Posicao origem, Posicao destino)
        {
            Peca pecaCapturada = null;

            Peca peca = Tabuleiro.RetirarPeca(origem);

            peca.IncrementaQteDeMovimentos();

            if (Tabuleiro.ExistePeca(destino))
            {
                pecaCapturada = Tabuleiro.RetirarPeca(destino);
                _pecasCapturadas.Add(pecaCapturada);
                _pecas.Remove(pecaCapturada);
            }

            Tabuleiro.ColocarPeca(peca, destino);

            // Jogada especial
            // Roque
            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(origemTorre);
                torre.IncrementaQteDeMovimentos();
                Tabuleiro.ColocarPeca(torre, destinoTorre);
            }
            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(origemTorre);
                torre.IncrementaQteDeMovimentos();
                Tabuleiro.ColocarPeca(torre, destinoTorre);
            }

            return(pecaCapturada);
        }
        public override bool[,] MovimentosPossiveis()
        {
            bool[,] matrizDeMovimentos = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];
            Posicao pos = new Posicao(0, 0);

            //Acima
            pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            //NE
            pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            //Direita
            pos.DefinirValores(Posicao.Linha, Posicao.Coluna + 1);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            //SE
            pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            //Abaixo
            pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            //SO
            pos.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            //esquerda
            pos.DefinirValores(Posicao.Linha, Posicao.Coluna - 1);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            //NO
            pos.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
            if (Tabuleiro.PosicaoValida(pos) && PodeMover(pos))
            {
                matrizDeMovimentos[pos.Linha, pos.Coluna] = true;
            }

            // #JogadaEspecial Roque
            if (QuantidadeDeMovimentos == 0 && !Partida.EmXeque)
            {
                //Roque Pequeno
                Posicao posicaoTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
                if (TesteTorreParaRoque(posicaoTorre1))
                {
                    Posicao p1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
                    Posicao p2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);
                    if (!Tabuleiro.ExistePeca(p1) && !Tabuleiro.ExistePeca(p2))
                    {
                        matrizDeMovimentos[Posicao.Linha, Posicao.Coluna + 2] = true;
                    }
                }
                //Roque Grande
                Posicao posicaoTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
                if (TesteTorreParaRoque(posicaoTorre2))
                {
                    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 (!Tabuleiro.ExistePeca(p1) && !Tabuleiro.ExistePeca(p2) && !Tabuleiro.ExistePeca(p3))
                    {
                        matrizDeMovimentos[Posicao.Linha, Posicao.Coluna - 2] = true;
                    }
                }
            }

            return(matrizDeMovimentos);
        }
Esempio n. 8
0
        public override bool[,] MovimentosPossiveis()
        {
            bool[,] movimentos = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];

            Posicao p = new Posicao(Posicao.Linha, Posicao.Coluna);

            //ACIMA(PEÇAS BRANCAS)
            if (Cor == Cor.Branco)
            {
                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                p.SetPosicao(p.Linha - 1, p.Coluna);
                if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
                {
                    movimentos[p.Linha, p.Coluna] = true;

                    p.SetPosicao(p.Linha - 1, p.Coluna);
                    if (Tabuleiro.PosicaoValida(p) && PodeMover(p) && QtdeMovimentos == 0)
                    {
                        movimentos[p.Linha, p.Coluna] = true;
                    }
                }

                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                p.SetPosicao(p.Linha - 1, p.Coluna - 1);
                if (Tabuleiro.PosicaoValida(p) && Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor == Cor.Preto && PodeMover(p))
                {
                    movimentos[p.Linha, p.Coluna] = true;
                }

                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                p.SetPosicao(p.Linha - 1, p.Coluna + 1);
                if (Tabuleiro.PosicaoValida(p) && Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor == Cor.Preto && PodeMover(p))
                {
                    movimentos[p.Linha, p.Coluna] = true;
                }

                //En Passant Branca

                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                if (p.Linha == 3)
                {
                    Posicao esquerda = new Posicao(p.Linha, p.Coluna - 1);
                    if (Tabuleiro.PosicaoValida(esquerda) && Tabuleiro.ExistePeca(esquerda) && Tabuleiro.Peca(esquerda).Cor == Cor.Preto &&
                        Tabuleiro.Peca(esquerda) == partida.EnPassant)
                    {
                        movimentos[esquerda.Linha - 1, esquerda.Coluna] = true;
                    }

                    Posicao direita = new Posicao(p.Linha, p.Coluna + 1);
                    if (Tabuleiro.PosicaoValida(direita) && Tabuleiro.ExistePeca(direita) && Tabuleiro.Peca(direita).Cor == Cor.Preto &&
                        Tabuleiro.Peca(direita) == partida.EnPassant)
                    {
                        movimentos[direita.Linha - 1, direita.Coluna] = true;
                    }
                }
            }

            //ABAIXO(PEÇAS PRETAS)
            else if (Cor == Cor.Preto)
            {
                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                p.SetPosicao(p.Linha + 1, p.Coluna);
                if (Tabuleiro.PosicaoValida(p) && PodeMover(p))
                {
                    movimentos[p.Linha, p.Coluna] = true;

                    p.SetPosicao(p.Linha + 1, p.Coluna);
                    if (Tabuleiro.PosicaoValida(p) && PodeMover(p) && QtdeMovimentos == 0)
                    {
                        movimentos[p.Linha, p.Coluna] = true;
                    }
                }

                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                p.SetPosicao(p.Linha + 1, p.Coluna - 1);
                if (Tabuleiro.PosicaoValida(p) && Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor == Cor.Branco && PodeMover(p))
                {
                    movimentos[p.Linha, p.Coluna] = true;
                }

                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                p.SetPosicao(p.Linha + 1, p.Coluna + 1);
                if (Tabuleiro.PosicaoValida(p) && Tabuleiro.ExistePeca(p) && Tabuleiro.Peca(p).Cor == Cor.Branco && PodeMover(p))
                {
                    movimentos[p.Linha, p.Coluna] = true;
                }

                //En Passant Preta

                p.SetPosicao(Posicao.Linha, Posicao.Coluna);
                if (p.Linha == 4)
                {
                    Posicao esquerda = new Posicao(p.Linha, p.Coluna - 1);
                    if (Tabuleiro.PosicaoValida(esquerda) && Tabuleiro.ExistePeca(esquerda) && Tabuleiro.Peca(esquerda).Cor == Cor.Branco &&
                        Tabuleiro.Peca(esquerda) == partida.EnPassant)
                    {
                        movimentos[esquerda.Linha + 1, esquerda.Coluna] = true;
                    }

                    Posicao direita = new Posicao(p.Linha, p.Coluna + 1);
                    if (Tabuleiro.PosicaoValida(direita) && Tabuleiro.ExistePeca(direita) && Tabuleiro.Peca(direita).Cor == Cor.Branco &&
                        Tabuleiro.Peca(direita) == partida.EnPassant)
                    {
                        movimentos[direita.Linha + 1, direita.Coluna] = true;
                    }
                }
            }
            return(movimentos);
        }