public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tab.linhas, tab.colunas];

            Posicao pos = new Posicao(0, 0);

            //acima
            pos.definirPosicao(posicao.linha - 1, posicao.coluna);
            while (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
                if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
                {
                    break;
                }

                pos.linha--;
            }

            //direita
            pos.definirPosicao(posicao.linha, posicao.coluna + 1);
            while (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
                if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
                {
                    break;
                }

                pos.coluna++;
            }
            //esquerda
            pos.definirPosicao(posicao.linha, posicao.coluna - 1);
            while (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
                if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
                {
                    break;
                }

                pos.coluna--;
            }

            //abaixo
            pos.definirPosicao(posicao.linha + 1, posicao.coluna);
            while (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
                if (tab.peca(pos) != null && tab.peca(pos).cor != cor)
                {
                    break;
                }

                pos.linha++;
            }

            return(mat);
        }
Пример #2
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao aux = new Posicao(0, 0);

            //verifica o movimento para o norte
            aux.definirPosicao(posicao.linha - 1, posicao.coluna);
            while (tabuleiro.posicaoValida(aux) && podeMover(aux))
            {
                mat[aux.linha, aux.coluna] = true;
                if (tabuleiro.peca(aux) != null)
                {
                    break;
                }
                aux.linha--;
            }

            //verifica o movimento para o leste
            aux.definirPosicao(posicao.linha, posicao.coluna + 1);
            while (tabuleiro.posicaoValida(aux) && podeMover(aux))
            {
                mat[aux.linha, aux.coluna] = true;
                if (tabuleiro.peca(aux) != null)
                {
                    break;
                }
                aux.coluna++;
            }

            //verifica o movimento para o sul
            aux.definirPosicao(posicao.linha + 1, posicao.coluna);
            while (tabuleiro.posicaoValida(aux) && podeMover(aux))
            {
                mat[aux.linha, aux.coluna] = true;
                if (tabuleiro.peca(aux) != null)
                {
                    break;
                }
                aux.linha++;
            }

            //verifica o movimento para o oeste
            aux.definirPosicao(posicao.linha, posicao.coluna - 1);
            while (tabuleiro.posicaoValida(aux) && podeMover(aux))
            {
                mat[aux.linha, aux.coluna] = true;
                if (tabuleiro.peca(aux) != null)
                {
                    break;
                }
                aux.coluna--;
            }

            return(mat);
        }
Пример #3
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao aux = new Posicao(0, 0);

            if (cor == Cor.Branca)
            {
                aux.definirPosicao(posicao.linha - 1, posicao.coluna);
                if (tabuleiro.posicaoValida(aux) && podeMover(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }

                aux.definirPosicao(posicao.linha - 2, posicao.coluna);
                if (qtdMovimentos == 0 && tabuleiro.posicaoValida(aux) && podeMover(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }

                aux.definirPosicao(posicao.linha - 1, posicao.coluna + 1);
                if (tabuleiro.posicaoValida(aux) && podeCapturar(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }

                aux.definirPosicao(posicao.linha - 1, posicao.coluna - 1);
                if (tabuleiro.posicaoValida(aux) && podeCapturar(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }
            }
            else
            {
                aux.definirPosicao(posicao.linha + 1, posicao.coluna);
                if (tabuleiro.posicaoValida(aux) && podeMover(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }

                aux.definirPosicao(posicao.linha + 2, posicao.coluna);
                if (qtdMovimentos == 0 && tabuleiro.posicaoValida(aux) && podeMover(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }

                aux.definirPosicao(posicao.linha + 1, posicao.coluna + 1);
                if (tabuleiro.posicaoValida(aux) && podeCapturar(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }

                aux.definirPosicao(posicao.linha + 1, posicao.coluna - 1);
                if (tabuleiro.posicaoValida(aux) && podeCapturar(aux))
                {
                    mat[aux.linha, aux.coluna] = true;
                }
            }
            return(mat);
        }
Пример #4
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tabuleiro.linhas, tabuleiro.colunas];
            Posicao aux = new Posicao(0, 0);

            for (int i = posicao.linha - 1; i <= posicao.linha + 1; i++)
            {
                for (int j = posicao.coluna - 1; j <= posicao.coluna + 1; j++)
                {
                    aux.definirPosicao(i, j);
                    if (tabuleiro.posicaoValida(aux) && podeMover(aux))
                    {
                        mat[i, j] = true;
                    }
                }
            }

            if (partida.jogadorAtual == cor && testeRoquePequeno())
            {
                mat[posicao.linha, posicao.coluna + 2] = true;
            }

            if (partida.jogadorAtual == cor && testeRoqueGrande())
            {
                mat[posicao.linha, posicao.coluna - 3] = true;
            }

            return(mat);
        }
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tab.linhas, tab.colunas];

            Posicao pos = new Posicao(0, 0);


            pos.definirPosicao(posicao.linha - 1, posicao.coluna - 2);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            pos.definirPosicao(posicao.linha - 2, posicao.coluna - 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            pos.definirPosicao(posicao.linha - 2, posicao.coluna + 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            pos.definirPosicao(posicao.linha - 1, posicao.coluna + 2);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            pos.definirPosicao(posicao.linha + 1, posicao.coluna + 2);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            pos.definirPosicao(posicao.linha + 2, posicao.coluna + 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            pos.definirPosicao(posicao.linha + 2, posicao.coluna - 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            pos.definirPosicao(posicao.linha + 1, posicao.coluna - 2);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            return(mat);
        }
Пример #6
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tab.linhas, tab.colunas];

            Posicao pos = new Posicao(0, 0);

            //acima
            pos.definirPosicao(posicao.linha - 1, posicao.coluna);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //NE - Nordeste
            pos.definirPosicao(posicao.linha - 1, posicao.coluna + 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //direita
            pos.definirPosicao(posicao.linha, posicao.coluna + 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //SE - Sudeste
            pos.definirPosicao(posicao.linha + 1, posicao.coluna + 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //abaixo
            pos.definirPosicao(posicao.linha + 1, posicao.coluna);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //SO - Sudoeste
            pos.definirPosicao(posicao.linha + 1, posicao.coluna - 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //Esquerda
            pos.definirPosicao(posicao.linha, posicao.coluna - 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //NO - Noroeste
            pos.definirPosicao(posicao.linha - 1, posicao.coluna - 1);
            if (tab.posicaoValida(pos) && podeMover(pos))
            {
                mat[pos.linha, pos.coluna] = true;
            }

            //#jogadaespecial roque
            if (qteMovimentos == 0 && !partida.xeque)
            {
                //jogadaespecial roque pequeno
                Posicao posT1 = new Posicao(posicao.linha, posicao.coluna + 3);
                if (testeTorreParaRoque(posT1))
                {
                    Posicao P1 = new Posicao(posicao.linha, posicao.coluna + 1);
                    Posicao P2 = new Posicao(posicao.linha, posicao.coluna + 2);
                    if (tab.peca(P1) == null && tab.peca(P2) == null)
                    {
                        mat[P2.linha, P2.coluna] = true;
                    }
                }

                //jogadaespecial_roque_grande
                Posicao posT2 = new Posicao(posicao.linha, posicao.coluna - 4);
                if (testeTorreParaRoque(posT1))
                {
                    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 (tab.peca(P1) == null && tab.peca(P2) == null && tab.peca(P3) == null)
                    {
                        mat[P2.linha, P2.coluna] = true;
                    }
                }
            }

            return(mat);
        }
Пример #7
0
        public override bool[,] movimentosPossiveis()
        {
            bool[,] mat = new bool[tab.linhas, tab.colunas];

            Posicao pos = new Posicao(0, 0);

            if (cor == Cor.Branca)
            {
                pos.definirPosicao(posicao.linha - 1, posicao.coluna);
                if (tab.posicaoValida(pos) && livre(pos))
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                pos.definirPosicao(posicao.linha - 2, posicao.coluna);
                if (tab.posicaoValida(pos) && livre(pos) && qteMovimentos == 0)
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                pos.definirPosicao(posicao.linha - 1, posicao.coluna - 1);
                if (tab.posicaoValida(pos) && existeInimigo(pos))
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                pos.definirPosicao(posicao.linha - 1, posicao.coluna + 1);
                if (tab.posicaoValida(pos) && existeInimigo(pos))
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                //#JogadaEspecial EnPassant
                if (posicao.linha == 3)
                {
                    Posicao esquerda = new Posicao(posicao.linha, posicao.coluna - 1);
                    if (tab.posicaoValida(esquerda) && existeInimigo(esquerda) && tab.peca(esquerda) == partida.vulneravelEnPassant)
                    {
                        mat[esquerda.linha - 1, esquerda.coluna] = true;
                    }

                    Posicao direita = new Posicao(posicao.linha, posicao.coluna + 1);
                    if (tab.posicaoValida(direita) && existeInimigo(direita) && tab.peca(direita) == partida.vulneravelEnPassant)
                    {
                        mat[direita.linha - 1, direita.coluna] = true;
                    }
                }
            }
            else
            {
                pos.definirPosicao(posicao.linha + 1, posicao.coluna);
                if (tab.posicaoValida(pos) && livre(pos))
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                pos.definirPosicao(posicao.linha + 2, posicao.coluna);
                if (tab.posicaoValida(pos) && livre(pos) && qteMovimentos == 0)
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                pos.definirPosicao(posicao.linha + 1, posicao.coluna - 1);
                if (tab.posicaoValida(pos) && existeInimigo(pos))
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                pos.definirPosicao(posicao.linha + 1, posicao.coluna + 1);
                if (tab.posicaoValida(pos) && existeInimigo(pos))
                {
                    mat[pos.linha, pos.coluna] = true;
                }

                //#JogadaEspecial EnPassant
                if (posicao.linha == 4)
                {
                    Posicao esquerda = new Posicao(posicao.linha, posicao.coluna - 1);
                    if (tab.posicaoValida(esquerda) && existeInimigo(esquerda) && tab.peca(esquerda) == partida.vulneravelEnPassant)
                    {
                        mat[esquerda.linha + 1, esquerda.coluna] = true;
                    }

                    Posicao direita = new Posicao(posicao.linha, posicao.coluna + 1);
                    if (tab.posicaoValida(direita) && existeInimigo(direita) && tab.peca(direita) == partida.vulneravelEnPassant)
                    {
                        mat[direita.linha + 1, direita.coluna] = true;
                    }
                }
            }

            return(mat);
        }