Beispiel #1
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao proxima = new Posicao(0, 0);

            //acima da posição da torre:

            proxima.defValores(posicao.linhas - 1, posicao.colunas);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.linhas = proxima.linhas - 1;
            }

            //abaixo da posição da torre:

            proxima.defValores(posicao.linhas + 1, posicao.colunas);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.linhas = proxima.linhas + 1;
            }

            //direita da posição da torre:

            proxima.defValores(posicao.linhas, posicao.colunas + 1);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.colunas = proxima.colunas + 1;
            }

            //esquerda da posição da torre:

            proxima.defValores(posicao.linhas, posicao.colunas - 1);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.colunas = proxima.colunas - 1;
            }

            return(mat);
        }
Beispiel #2
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao proxima = new Posicao(0, 0);

            //

            if (cor == Cor.Branca)
            {
                proxima.defValores(posicao.linhas - 1, posicao.colunas);
                if (tabuleiro.posicaoValida(proxima) && livre(proxima))
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }


                proxima.defValores(posicao.linhas - 2, posicao.colunas);
                if (tabuleiro.posicaoValida(proxima) && QuantMovimentos == 0)
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }

                proxima.defValores(posicao.linhas - 1, posicao.colunas - 1);
                if (tabuleiro.posicaoValida(proxima) && existeInimigo(proxima))
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }

                proxima.defValores(posicao.linhas - 1, posicao.colunas + 1);
                if (tabuleiro.posicaoValida(proxima) && existeInimigo(proxima))
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }

                // #jogadaEspecial en Passant

                if (posicao.linhas == 3)
                {
                    Posicao esquerda = new Posicao(posicao.linhas, posicao.colunas - 1);
                    if (tabuleiro.posicaoValida(esquerda) && existeInimigo(esquerda) && tabuleiro.peca(esquerda) == partida.vulneravelEnPassant)
                    {
                        mat[esquerda.linhas - 1, esquerda.colunas] = true;
                    }
                    Posicao direita = new Posicao(posicao.linhas, posicao.colunas + 1);
                    if (tabuleiro.posicaoValida(direita) && existeInimigo(direita) && tabuleiro.peca(direita) == partida.vulneravelEnPassant)
                    {
                        mat[direita.linhas - 1, direita.colunas] = true;
                    }
                }
            }
            else
            {
                proxima.defValores(posicao.linhas + 1, posicao.colunas);
                if (tabuleiro.posicaoValida(proxima) && livre(proxima))
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }


                proxima.defValores(posicao.linhas + 2, posicao.colunas);
                if (tabuleiro.posicaoValida(proxima) && QuantMovimentos == 0)
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }

                proxima.defValores(posicao.linhas + 1, posicao.colunas - 1);
                if (tabuleiro.posicaoValida(proxima) && existeInimigo(proxima))
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }

                proxima.defValores(posicao.linhas + 1, posicao.colunas + 1);
                if (tabuleiro.posicaoValida(proxima) && existeInimigo(proxima))
                {
                    mat[proxima.linhas, proxima.colunas] = true;
                }

                // #jogadaEspecial en Passant

                if (posicao.linhas == 4)
                {
                    Posicao esquerda = new Posicao(posicao.linhas, posicao.colunas - 1);
                    if (tabuleiro.posicaoValida(esquerda) && existeInimigo(esquerda) && tabuleiro.peca(esquerda) == partida.vulneravelEnPassant)
                    {
                        mat[esquerda.linhas + 1, esquerda.colunas] = true;
                    }
                    Posicao direita = new Posicao(posicao.linhas, posicao.colunas + 1);
                    if (tabuleiro.posicaoValida(direita) && existeInimigo(direita) && tabuleiro.peca(direita) == partida.vulneravelEnPassant)
                    {
                        mat[direita.linhas + 1, direita.colunas] = true;
                    }
                }
            }
            return(mat);
        }
Beispiel #3
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao proxima = new Posicao(0, 0);


            //acima da posição do bispo(noroeste):

            proxima.defValores(posicao.linhas - 1, posicao.colunas - 1);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.defValores(proxima.linhas - 1, proxima.colunas - 1);
            }

            //acima da posição do bispo (nordeste):

            proxima.defValores(posicao.linhas - 1, posicao.colunas + 1);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.defValores(proxima.linhas - 1, proxima.colunas + 1);
            }

            //acima da posição do bispo (suldeste):

            proxima.defValores(posicao.linhas + 1, posicao.colunas + 1);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.defValores(proxima.linhas + 1, proxima.colunas + 1);
            }

            //acima da posição do bispo (suldoeste):

            proxima.defValores(posicao.linhas + 1, posicao.colunas - 1);
            while (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
                if (tabuleiro.peca(proxima) != null && tabuleiro.peca(proxima).cor != cor)
                {
                    break;
                }
                proxima.defValores(proxima.linhas + 1, proxima.colunas - 1);
            }


            return(mat);
        }
Beispiel #4
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao proxima = new Posicao(0, 0);

            //acima da posição do rei:

            proxima.defValores(posicao.linhas - 1, posicao.colunas);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //acima da posição do rei(nordeste):

            proxima.defValores(posicao.linhas - 1, posicao.colunas + 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //direita da posição do rei:

            proxima.defValores(posicao.linhas, posicao.colunas + 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //suldeste da posição do rei:

            proxima.defValores(posicao.linhas + 1, posicao.colunas + 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //abaixo da posição do rei:

            proxima.defValores(posicao.linhas + 1, posicao.colunas);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //suldoeste da posição do rei:

            proxima.defValores(posicao.linhas + 1, posicao.colunas - 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //Esquerda da posição do rei:

            proxima.defValores(posicao.linhas, posicao.colunas - 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //noroeste da posição do rei:

            proxima.defValores(posicao.linhas - 1, posicao.colunas - 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            // #jogadaEspecial roque

            if (QuantMovimentos == 0 && !partida.xeque)
            {
                //roque pequeno:

                Posicao posicaoTorre1 = new Posicao(posicao.linhas, posicao.colunas + 3);
                if (testeTorreRoque(posicaoTorre1))
                {
                    Posicao P1 = new Posicao(posicao.linhas, posicao.colunas + 1);
                    Posicao P2 = new Posicao(posicao.linhas, posicao.colunas + 2);
                    if (tabuleiro.peca(P1) == null && tabuleiro.peca(P2) == null)
                    {
                        mat[posicao.linhas, posicao.colunas + 2] = true;
                    }
                }

                //roque grande:

                Posicao posicaoTorre2 = new Posicao(posicao.linhas, posicao.colunas - 4);
                if (testeTorreRoque(posicaoTorre1))
                {
                    Posicao P1 = new Posicao(posicao.linhas, posicao.colunas - 1);
                    Posicao P2 = new Posicao(posicao.linhas, posicao.colunas - 2);
                    Posicao P3 = new Posicao(posicao.linhas, posicao.colunas - 3);
                    if (tabuleiro.peca(P1) == null && tabuleiro.peca(P2) == null && tabuleiro.peca(P3) == null)
                    {
                        mat[posicao.linhas, posicao.colunas - 2] = true;
                    }
                }
            }


            return(mat);
        }
Beispiel #5
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao proxima = new Posicao(0, 0);


            //L:

            proxima.defValores(posicao.linhas - 1, posicao.colunas - 2);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //L:

            proxima.defValores(posicao.linhas - 2, posicao.colunas - 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //L:

            proxima.defValores(posicao.linhas - 2, posicao.colunas + 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //L:

            proxima.defValores(posicao.linhas - 1, posicao.colunas + 2);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //L:

            proxima.defValores(posicao.linhas + 1, posicao.colunas + 2);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //L:

            proxima.defValores(posicao.linhas + 2, posicao.colunas + 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //L:

            proxima.defValores(posicao.linhas + 2, posicao.colunas - 1);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }

            //L:

            proxima.defValores(posicao.linhas + 1, posicao.colunas - 2);
            if (tabuleiro.posicaoValida(proxima) && podeMover(proxima))
            {
                mat[proxima.linhas, proxima.colunas] = true;
            }



            return(mat);
        }