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

            Posicao posicaoAux = new Posicao(0, 0);

            for (int i = -1; i <= 1; i += 2)
            {
                for (int j = -1; j <= 1; j += 2)
                {
                    posicaoAux.DefinirValores(Posicao.Linha + i, Posicao.Coluna + j);

                    while (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
                    {
                        matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;

                        if (Tabuleiro.PecaPosition(posicaoAux) != null && Tabuleiro.PecaPosition(posicaoAux).Cor != Cor)
                        {
                            break;
                        }

                        posicaoAux.Linha  += i;
                        posicaoAux.Coluna += j;
                    }
                }
            }
            return(matriz);
        }
Esempio n. 2
0
        public override bool[,] MovimentosPossiveis()
        {
            bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];

            Posicao posicaoAux = new Posicao(0, 0);

            for (int i = -1; i <= 1; i++)
            {
                for (int j = -1; j <= 1; j++)
                {
                    posicaoAux.DefinirValores(Posicao.Linha + i, Posicao.Coluna + j);

                    if (Tabuleiro.PosicaoValida(posicaoAux) && PodeMover(posicaoAux))
                    {
                        matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
                    }
                }
            }


            if (QuantidadeMovivemtos == 0 && !_partida.JogadorEmXeque)
            {
                // #MovimentoEspecial Roque menor
                Posicao posicaoTorre1 = new Posicao(Posicao.Linha, Posicao.Coluna + 3);
                if (TestarTorreParaRoque(posicaoTorre1))
                {
                    Posicao posicaoAdjacente1 = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
                    Posicao posicaoAdjacente2 = new Posicao(Posicao.Linha, Posicao.Coluna + 2);

                    if ((Tabuleiro.PecaPosition(posicaoAdjacente1) == null &&
                         Tabuleiro.PecaPosition(posicaoAdjacente2) == null))
                    {
                        matriz[Posicao.Linha, Posicao.Coluna + 2] = true;
                    }
                }

                // #MovimentoEspecial Roque maior
                Posicao posicaoTorre2 = new Posicao(Posicao.Linha, Posicao.Coluna - 4);
                if (TestarTorreParaRoque(posicaoTorre2))
                {
                    Posicao posicaoAdjacente1 = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
                    Posicao posicaoAdjacente2 = new Posicao(Posicao.Linha, Posicao.Coluna - 2);
                    Posicao posicaoAdjacente3 = new Posicao(Posicao.Linha, Posicao.Coluna - 3);

                    if (Tabuleiro.PecaPosition(posicaoAdjacente1) == null &&
                        Tabuleiro.PecaPosition(posicaoAdjacente2) == null &&
                        Tabuleiro.PecaPosition(posicaoAdjacente3) == null)
                    {
                        matriz[Posicao.Linha, Posicao.Coluna - 2] = true;
                    }
                }
            }

            return(matriz);
        }
Esempio n. 3
0
        public static void ImprimirTabuleiro(Tabuleiro tabuleiro)
        {
            for (int linha = 0; linha < tabuleiro.Linhas; linha++)
            {
                Console.Write(8 - linha + " ");

                for (int coluna = 0; coluna < tabuleiro.Colunas; coluna++)
                {
                    ImprimirPeca(tabuleiro.PecaPosition(linha, coluna));
                }

                Console.WriteLine();
            }

            Console.WriteLine("  a b c d e f g h");
        }
Esempio n. 4
0
        public static void ImprimirTabuleiro(Tabuleiro tabuleiro, bool[,] PosicoesPossiveis)
        {
            ConsoleColor CorOriginal = Console.BackgroundColor;
            ConsoleColor CorAlterada = ConsoleColor.DarkGray;

            for (int linha = 0; linha < tabuleiro.Linhas; linha++)
            {
                Console.Write(8 - linha + " ");

                for (int coluna = 0; coluna < tabuleiro.Colunas; coluna++)
                {
                    Console.BackgroundColor = (PosicoesPossiveis[linha, coluna]) ? CorAlterada : CorOriginal;

                    ImprimirPeca(tabuleiro.PecaPosition(linha, coluna));
                    Console.BackgroundColor = CorOriginal;
                }

                Console.WriteLine();
            }

            Console.WriteLine("  a b c d e f g h");
        }
Esempio n. 5
0
        private bool PodeMover(Posicao posicao)
        {
            Peca peca = Tabuleiro.PecaPosition(posicao);

            return(peca == null || peca.Cor != Cor);
        }
Esempio n. 6
0
        private bool TestarTorreParaRoque(Posicao posicao)
        {
            Peca peca = Tabuleiro.PecaPosition(posicao);

            return(peca != null && peca is Torre && peca.Cor == Cor && peca.QuantidadeMovivemtos == 0);
        }
Esempio n. 7
0
        public override bool[,] MovimentosPossiveis()
        {
            bool[,] matriz = new bool[Tabuleiro.Linhas, Tabuleiro.Colunas];

            Posicao posicaoAux = new Posicao(0, 0);

            //O peão possui movimentos especificos, e se move diferente dependendo da cor.
            if (Cor == Cor.Branca)
            {
                posicaoAux.DefinirValores(Posicao.Linha - 1, Posicao.Coluna);
                if (Tabuleiro.PosicaoValida(posicaoAux) && Livre(posicaoAux))
                {
                    matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;

                    posicaoAux.DefinirValores(Posicao.Linha - 2, Posicao.Coluna);
                    if (Tabuleiro.PosicaoValida(posicaoAux) && Livre(posicaoAux) && QuantidadeMovivemtos == 0)
                    {
                        matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
                    }
                }

                posicaoAux.DefinirValores(Posicao.Linha - 1, Posicao.Coluna - 1);
                if (Tabuleiro.PosicaoValida(posicaoAux) && ExisteInimigo(posicaoAux))
                {
                    matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
                }

                posicaoAux.DefinirValores(Posicao.Linha - 1, Posicao.Coluna + 1);
                if (Tabuleiro.PosicaoValida(posicaoAux) && ExisteInimigo(posicaoAux))
                {
                    matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
                }

                // #MovimentoEspecial En Passant Brancas
                if (Posicao.Linha == 3)
                {
                    Posicao posicaoEsquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
                    if (Tabuleiro.PosicaoValida(posicaoEsquerda) && ExisteInimigo(posicaoEsquerda) &&
                        Tabuleiro.PecaPosition(posicaoEsquerda) == _partida.VulneravelEnPassant)
                    {
                        matriz[posicaoEsquerda.Linha - 1, posicaoEsquerda.Coluna] = true;
                    }

                    Posicao posicaoDireita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
                    if (Tabuleiro.PosicaoValida(posicaoDireita) && ExisteInimigo(posicaoDireita) &&
                        Tabuleiro.PecaPosition(posicaoDireita) == _partida.VulneravelEnPassant)
                    {
                        matriz[posicaoDireita.Linha - 1, posicaoDireita.Coluna] = true;
                    }
                }
            }
            else
            {
                posicaoAux.DefinirValores(Posicao.Linha + 1, Posicao.Coluna);
                if (Tabuleiro.PosicaoValida(posicaoAux) && Livre(posicaoAux))
                {
                    matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;

                    posicaoAux.DefinirValores(Posicao.Linha + 2, Posicao.Coluna);
                    if (Tabuleiro.PosicaoValida(posicaoAux) && Livre(posicaoAux) && QuantidadeMovivemtos == 0)
                    {
                        matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
                    }
                }

                posicaoAux.DefinirValores(Posicao.Linha + 1, Posicao.Coluna - 1);
                if (Tabuleiro.PosicaoValida(posicaoAux) && ExisteInimigo(posicaoAux))
                {
                    matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
                }

                posicaoAux.DefinirValores(Posicao.Linha + 1, Posicao.Coluna + 1);
                if (Tabuleiro.PosicaoValida(posicaoAux) && ExisteInimigo(posicaoAux))
                {
                    matriz[posicaoAux.Linha, posicaoAux.Coluna] = true;
                }

                // #MovimentoEspecial En Passant Pretas
                if (Posicao.Linha == 4)
                {
                    Posicao posicaoEsquerda = new Posicao(Posicao.Linha, Posicao.Coluna - 1);
                    if (Tabuleiro.PosicaoValida(posicaoEsquerda) && ExisteInimigo(posicaoEsquerda) &&
                        Tabuleiro.PecaPosition(posicaoEsquerda) == _partida.VulneravelEnPassant)
                    {
                        matriz[posicaoEsquerda.Linha + 1, posicaoEsquerda.Coluna] = true;
                    }

                    Posicao posicaoDireita = new Posicao(Posicao.Linha, Posicao.Coluna + 1);
                    if (Tabuleiro.PosicaoValida(posicaoDireita) && ExisteInimigo(posicaoDireita) &&
                        Tabuleiro.PecaPosition(posicaoDireita) == _partida.VulneravelEnPassant)
                    {
                        matriz[posicaoDireita.Linha + 1, posicaoDireita.Coluna] = true;
                    }
                }
            }

            return(matriz);
        }
Esempio n. 8
0
 private bool Livre(Posicao posicao)
 => Tabuleiro.PecaPosition(posicao) == null;
Esempio n. 9
0
        private bool ExisteInimigo(Posicao posicao)
        {
            Peca peca = Tabuleiro.PecaPosition(posicao);

            return(peca != null && peca.Cor != Cor);
        }