示例#1
0
 public void CriarPosicaoValida(Point point)
 {
     if (PosicaoDentroDoTabuleiro(point))
     {
         PecaDama vPeca = new PecaDama();
         vPeca.Tipo = TipoPeca.PosicaoValida;
         vPeca.Jogador = Jogador.GM;
         vPeca.Pos = point;
         PecasTabuleiro.Add(vPeca);
         ListaLugaresValidos.Add(vPeca);
     }
 }
示例#2
0
        public void ExibirPossibilidadeMovimento(PecaDama peca)
        {
            List<PecaDama> pecasCandidatasEliminacao = PecasCandidatasEliminacao(peca);

            //movimento de eliminacao
            if (pecasCandidatasEliminacao.Any())
            {
                ExibirMovimentoAtaque(peca, pecasCandidatasEliminacao);
            }
            else//movimento normal
            {
                ExibirMovimento(peca);
            }
        }
        public void retorna_pecas_vizinhas_inimigas_a_partir_da_peca ()
        {
            
            this.CriarTabuleiroFake();

            PecaDama pecaTeste = new PecaDama { Pos = new Point(6, 6), Tipo = TipoPeca.Peao, Jogador = Jogador.Agil };

            RegraPeao regraPeao = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos);

            List<PecaDama> pecasInimigas = regraPeao.RetornaPecasVizinhasInimigas(pecaTeste);

            List<PecaDama> pecasInimigasCandidatas = regraPeao.RetornaPecasComPossibilidadeEliminacao(pecaTeste, pecasInimigas);

            regraPeao.ExibirMovimentoAtaque(pecaTeste, pecasInimigasCandidatas);

        }
示例#4
0
        public void ExibirMovimentoAtaque(PecaDama peca, List<PecaDama> pecasCandidatasEliminacao)
        {

            foreach (var pecaInimigaCandidata in pecasCandidatasEliminacao)
            {
                //nordeste
                if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
                {

                    CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X + 2, peca.Pos.Y + 2));
                }
                //sudeste
                if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
                {

                    CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X + 2, peca.Pos.Y - 2));
                }

                //noroeste
                if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
                {

                    CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X - 2, peca.Pos.Y + 2));

                }

                //sudoeste
                if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
                {

                    CriarPosicaoEliminacao(pecaInimigaCandidata, new Point(peca.Pos.X - 2, peca.Pos.Y - 2));
                }
            }
        }
示例#5
0
 private void MovimentarPecaIA(PecaDama peca)
 {
     _pecaSelecionada.Pos = peca.Pos;
 }
示例#6
0
 private void MovimentarPeca(PecaDama peca)
 {
     _pecaSelecionada.Pos = peca.Pos;
     _gridPecaSelecionada.Background = null;
 }
示例#7
0
 private bool TurnoCorreto(PecaDama peca)
 {
     if (peca.Jogador == Jogador.GM)
     {
         return true;
     }
     if (_turnoTeste.ObterTurno() != peca.Jogador)
     {
         return false;
     }
     return true;
 }
示例#8
0
        public PecaDama VirarDama(PecaDama peca)
        {

            peca.Tipo = TipoPeca.Dama;

            //var rotateAnimation = new DoubleAnimation(0, 360, TimeSpan.FromSeconds(1));
            //var rt = (RotateTransform)TabuleiroDama.RenderTransform;


            //rt.CenterX = 0.5;
            //rt.CenterY = 0.5;
            //rt.BeginAnimation(RotateTransform.AngleProperty, rotateAnimation);

            return peca;
        }
示例#9
0
        private void CriarPossibilidadeMovimento(PecaDama peca, Grid grid)
        {
            RegraPeao regraPeao = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos);
            RegraDama regraDama = new RegraDama(_pecasTabuleiro, _listaLugaresValidos);

            switch (peca.Tipo)
            {
                case TipoPeca.Peao:
                    regraPeao.ExibirPossibilidadeMovimento(peca);
                    break;
                case TipoPeca.Dama:
                    regraDama.ExibirPossibilidadeMovimento(peca);
                    break;
            }
        }
示例#10
0
        private void PecaClickIA(PecaDama peca)
        {


            if (!TurnoCorreto(peca))
                return;

            if (EstaMovimentando(peca))
            {

                bool atacou = false;
                if (EstaAtacando(peca))
                {
                    RemoverPecaInimiga(peca.PecaAEliminar);
                    atacou = true;
                }
                MovimentarPecaIA(peca);

                LimparLugaresValidos();

                //verificando se ainda tem possibilidade de ataque
                if (atacou)
                {
                    List<PecaDama> pecasCandidatasEliminacao = ObterPecasCandidatasEliminacao(_pecaSelecionada);
                    if (pecasCandidatasEliminacao.Count > 0)
                    {
                        PecaClickIA(_pecaSelecionada);
                        return;
                    }
                    NumeroJogadasRestantes.Content = 20;
                }
                else
                {
                    NumeroJogadasRestantes.Content = Convert.ToInt32(NumeroJogadasRestantes.Content) - 1;
                }
                //-----------------------------

                RetirarDoTabuleiroPecasMortas();
                VerificarTransformacaoDama(_pecaSelecionada);
                TerminarJogadaTurnoAtual();
                SomarNumeroDeJogadas();
                ContarTempoJogada();

                VerificarFimDePartida();


            }
            else
            {
                if (!PecaAtacanteEJogoEmAtaque(peca))
                {
                    return;
                }

                SelecionarPeca(peca);
                LimparPinturaAreaSelecinada();
                //PintarAreaSelecinada(grid);
                LimparLugaresValidos();
                CriarPossibilidadeMovimento(_pecaSelecionada, null);

            }

        }
示例#11
0
        private void ExibirMovimentoParaFrente(PecaDama peca)
        {
            double xValido;
            double yValido;

            if (peca.Jogador == Jogador.Agil)
            {
                yValido = peca.Pos.Y + 1;
            }
            else
            {
                yValido = peca.Pos.Y - 1;
            }
            xValido = peca.Pos.X - 1;
            if (!TemPeca(peca, xValido, yValido))
            {
                CriarPosicaoValida(new Point(xValido, yValido));

            }
            xValido = peca.Pos.X + 1;
            if (!TemPeca(peca, xValido, yValido))
            {
                CriarPosicaoValida(new Point(xValido, yValido));

            }
        }
示例#12
0
        public List<PecaDama> PecasCandidatasEliminacao(PecaDama peca)
        {
            List<PecaDama> pecasVizinhasInimigas = RetornaPecasVizinhasInimigas(peca);
            List<PecaDama> pecasCandidatasEliminacao = RetornaPecasComPossibilidadeEliminacao(peca, pecasVizinhasInimigas);

            return pecasCandidatasEliminacao;
        }
示例#13
0
        public List<PecaDama> RetornaPecasComPossibilidadeEliminacao(PecaDama peca, List<PecaDama> pecasVizinhasInimigas)
        {
            List<PecaDama> pecasInimigasCandidatas = new List<PecaDama>();
            if (pecasVizinhasInimigas.Count == 0)
                return pecasInimigasCandidatas;

            IEnumerable<PecaDama> pecas;

            foreach (var pecaInimigaCandidata in pecasVizinhasInimigas)
            {
                //nordeste
                if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
                {

                    pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 2 && x.Pos.Y == peca.Pos.Y + 2).ToList();
                    if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X + 2, peca.Pos.Y + 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
                        if (!pecaInimigaCandidata.IsDead)
                            pecasInimigasCandidatas.Add(pecaInimigaCandidata);

                }
                //sudeste
                if (peca.Pos.X + 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
                {
                    pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 2 && x.Pos.Y == peca.Pos.Y - 2).ToList();
                    if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X + 2, peca.Pos.Y - 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
                        if (!pecaInimigaCandidata.IsDead)
                            pecasInimigasCandidatas.Add(pecaInimigaCandidata);

                }

                //noroeste
                if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y + 1 == pecaInimigaCandidata.Pos.Y)
                {

                    pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 2 && x.Pos.Y == peca.Pos.Y + 2).ToList();
                    if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X - 2, peca.Pos.Y + 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
                        if (!pecaInimigaCandidata.IsDead)
                            pecasInimigasCandidatas.Add(pecaInimigaCandidata);

                }

                //sudoeste
                if (peca.Pos.X - 1 == pecaInimigaCandidata.Pos.X
                    && peca.Pos.Y - 1 == pecaInimigaCandidata.Pos.Y)
                {

                    pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 2 && x.Pos.Y == peca.Pos.Y - 2).ToList();
                    if ((!pecas.Any() && PosicaoDentroDoTabuleiro(new Point(peca.Pos.X - 2, peca.Pos.Y - 2))) || (pecas.Any() && pecas.First().Tipo == TipoPeca.PosicaoValida))
                        if (!pecaInimigaCandidata.IsDead)
                            pecasInimigasCandidatas.Add(pecaInimigaCandidata);

                }

            }


            return pecasInimigasCandidatas;
        }
示例#14
0
        public List<PecaDama> RetornaPecasVizinhasInimigas(PecaDama peca)
        {

            List<PecaDama> pecasVizinhasInimigas = new List<PecaDama>();

            IEnumerable<PecaDama> pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 1 && x.Pos.Y == peca.Pos.Y + 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
            if (pecas.Any())
                pecasVizinhasInimigas.Add(pecas.First());

            pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 1 && x.Pos.Y == peca.Pos.Y - 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
            if (pecas.Any())
                pecasVizinhasInimigas.Add(pecas.First());

            pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + 1 && x.Pos.Y == peca.Pos.Y + 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
            if (pecas.Any())
                pecasVizinhasInimigas.Add(pecas.First());

            pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - 1 && x.Pos.Y == peca.Pos.Y - 1 && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
            if (pecas.Any())
                pecasVizinhasInimigas.Add(pecas.First());


            return pecasVizinhasInimigas;
        }
示例#15
0
        private void ExibirMovimento(PecaDama peca)
        {
            double xValido;
            double yValido;


            //nordeste
            for (int i = 1; i < 8; i++)
            {
                xValido = peca.Pos.X + i;
                yValido = peca.Pos.Y + i;

                if (!TemPeca(peca, xValido, yValido))
                {
                    CriarPosicaoValida(new Point(xValido, yValido));
                }
                else
                {
                    break;
                }

            }

            //noroeste
            for (int i = 1; i < 8; i++)
            {
                xValido = peca.Pos.X - i;
                yValido = peca.Pos.Y + i;

                if (!TemPeca(peca, xValido, yValido))
                {
                    CriarPosicaoValida(new Point(xValido, yValido));
                }
                else
                {
                    break;
                }
            }

            //sudeste
            for (int i = 1; i < 8; i++)
            {
                xValido = peca.Pos.X + i;
                yValido = peca.Pos.Y - i;

                if (!TemPeca(peca, xValido, yValido))
                {
                    CriarPosicaoValida(new Point(xValido, yValido));
                }
                else
                {
                    break;
                }
            }

            //sudoeste
            for (int i = 1; i < 8; i++)
            {
                xValido = peca.Pos.X - i;
                yValido = peca.Pos.Y - i;

                if (!TemPeca(peca, xValido, yValido))
                {
                    CriarPosicaoValida(new Point(xValido, yValido));
                }
                else
                {
                    break;
                }
            }


        }
示例#16
0
 private void SelecionarPeca(PecaDama peca)
 {
     _pecaSelecionada = peca;
 }
示例#17
0
 public bool EstaMovimentando(PecaDama peca)
 {
     if (peca.Tipo == TipoPeca.PosicaoValida)
     {
         return true;
     }
     return false;
 }
示例#18
0
        private List<PecaDama> ObterPecasCandidatasEliminacao(PecaDama peca)
        {
            List<PecaDama> pecas = new List<PecaDama>();
            RegraPeao regraPeao = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos);
            RegraDama regraDama = new RegraDama(_pecasTabuleiro, _listaLugaresValidos);

            switch (peca.Tipo)
            {
                case TipoPeca.Peao:
                    pecas = regraPeao.PecasCandidatasEliminacao(peca);
                    break;
                case TipoPeca.Dama:
                    pecas = regraDama.PecasCandidatasEliminacao(peca);
                    break;
            }
            return pecas;
        }
示例#19
0
        private PecaDama VerificarTransformacaoDama(PecaDama pecaSelecionada)
        {
            if (pecaSelecionada.Jogador == Jogador.Classico && pecaSelecionada.Pos.Y.Equals(0) && pecaSelecionada.Tipo != TipoPeca.Dama)
            {
                pecaSelecionada = VirarDama(pecaSelecionada);
            }
            if (pecaSelecionada.Jogador == Jogador.Agil && pecaSelecionada.Pos.Y.Equals(7) && pecaSelecionada.Tipo != TipoPeca.Dama)
            {
                pecaSelecionada = VirarDama(pecaSelecionada);
            }


            return pecaSelecionada;

        }
示例#20
0
 private bool PecaAtacanteEJogoEmAtaque(PecaDama peca)
 {
     List<PecaDama> pecasEmAtaque = new RegraPeao(_pecasTabuleiro, _listaLugaresValidos).PecasEmAtaque(peca.Jogador);
     if (pecasEmAtaque.Count > 0 && !pecasEmAtaque.Exists(x => x == peca))
     {
         return false;
     }
     return true;
 }
示例#21
0
 private void RemoverPecaInimiga(PecaDama pecaAEliminar)
 {
     pecaAEliminar.IsDead = true;
 }
示例#22
0
 private bool EstaAtacando(PecaDama peca)
 {
     if (peca.PecaAEliminar != null)
     {
         return true;
     }
     return false;
 }
示例#23
0
 protected bool TemPeca(PecaDama peca, double posicaoXaValidar, double posicaoYaValidar)
 {
     bool temPeca =
             PecasTabuleiro.Any(item => item.Pos.Equals(new Point(posicaoXaValidar, posicaoYaValidar)));
     return temPeca;
 }
示例#24
0
        private List<PecaDama> RetornaPecasVizinhasInimigas(PecaDama peca)
        {
            List<PecaDama> pecasVizinhasInimigas = new List<PecaDama>();

            IEnumerable<PecaDama> pecas;

            //nordeste
            for (int i = 1; i < 8; i++)
            {
                pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + i && x.Pos.Y == peca.Pos.Y + i
                                                    && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
                if (pecas.Any())
                {
                    pecasVizinhasInimigas.Add(pecas.First());
                    break;
                }
                
            }

            //noroeste
            for (int i = 1; i < 8; i++)
            {
                pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - i && x.Pos.Y == peca.Pos.Y + i
                                            && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
                if (pecas.Any())
                {
                    pecasVizinhasInimigas.Add(pecas.First());
                    break;
                }
                    
            }

            //sudeste
            for (int i = 1; i < 8; i++)
            {
                pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X + i
                                            && x.Pos.Y == peca.Pos.Y - i && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
                if (pecas.Any())
                {
                    pecasVizinhasInimigas.Add(pecas.First());
                    break;
                }
                    
            }

            //sudoeste
            for (int i = 1; i < 8; i++)
            {
                pecas = PecasTabuleiro.Where(x => x.Pos.X == peca.Pos.X - i && x.Pos.Y == peca.Pos.Y - i
                                            && x.Jogador == ObterTipoJogadorInimigo(peca.Jogador)).ToList();
                if (pecas.Any())
                {
                    pecasVizinhasInimigas.Add(pecas.First());
                    break;
                }
                    

            }

            return pecasVizinhasInimigas;
        }