private Disputa CalcularFinal(List <Disputa> disputas)
        {
            while (disputas.Count > 1)
            {
                var novasDisputas = new List <Disputa>();

                for (int i = 0; i < disputas.Count; i = i + 2)
                {
                    Filme filmeA = CalcularVencedor(disputas[i]);
                    Filme filmeB = CalcularVencedor(disputas[i + 1]);

                    Disputa disputa = new Disputa();
                    disputa.FilmeA = filmeA;
                    disputa.FilmeB = filmeB;

                    novasDisputas.Add(disputa);
                }

                disputas = novasDisputas;
            }

            if (disputas.Count == 1)
            {
                return(disputas[0]);
            }
            else
            {
                return(null);
            }
        }
Beispiel #2
0
        public FaseSemiFinal(Disputa resultadoPrimeiraDisputa, Disputa resultadoSegundaDisputa, Disputa resultadoTerceiraDisputa, Disputa resultadoQuartaDisputa)
        {
            FaseSemiFinalValidate.Validar(resultadoPrimeiraDisputa, resultadoSegundaDisputa, resultadoTerceiraDisputa, resultadoQuartaDisputa);

            PrimeiraDisputa = Disputa.GerarDisputa(resultadoPrimeiraDisputa.Vencedor, resultadoSegundaDisputa.Vencedor);
            SegundaDisputa  = Disputa.GerarDisputa(resultadoTerceiraDisputa.Vencedor, resultadoQuartaDisputa.Vencedor);
        }
        public IActionResult GerarCampeonato(string json)
        {
            try
            {
                List <Filme> filmes = JsonConvert.DeserializeObject <List <Filme> >(json);

                List <Disputa> disputas = MontarDisputas(filmes);

                Disputa final = CalcularFinal(disputas);

                ResultadoCampeonato resultado = CalcularResultado(final);

                var result = new
                {
                    Campeao     = resultado.Campeao,
                    Vicecampeao = resultado.Vicecampeao
                };

                return(Ok(result));
            }
            catch (Exception e)
            {
                var result = new
                {
                    Campeao     = new Filme(),
                    Vicecampeao = new Filme()
                };

                return(Ok(result));
            }
        }
        private ResultadoCampeonato CalcularResultado(Disputa disputa)
        {
            ResultadoCampeonato resultado = new ResultadoCampeonato();

            if (disputa.FilmeA.Nota > disputa.FilmeB.Nota)
            {
                resultado.Campeao     = disputa.FilmeA;
                resultado.Vicecampeao = disputa.FilmeB;
            }
            else if (disputa.FilmeA.Nota < disputa.FilmeB.Nota)
            {
                resultado.Campeao     = disputa.FilmeB;
                resultado.Vicecampeao = disputa.FilmeA;
            }
            else
            {
                if (string.Compare(disputa.FilmeA.Titulo, disputa.FilmeB.Titulo) < 0)
                {
                    resultado.Campeao     = disputa.FilmeA;
                    resultado.Vicecampeao = disputa.FilmeB;
                }
                else
                {
                    resultado.Campeao     = disputa.FilmeB;
                    resultado.Vicecampeao = disputa.FilmeA;
                }
            }

            return(resultado);
        }
        public void GerarDisputaTest()
        {
            var result = Disputa.GerarDisputa(filme1, filme2);

            Assert.IsNotNull(result);
            Assert.AreEqual <Filme>(result.Vencedor, filme1);
            Assert.AreEqual <Filme>(result.Perdedor, filme2);
        }
        public void Inicializar()
        {
            var listaFilmes = CriacaoListaFilmes.Criar();

            PrimeiraDisputa = Disputa.GerarDisputa(listaFilmes[0], listaFilmes[1]);
            SegundaDisputa  = Disputa.GerarDisputa(listaFilmes[2], listaFilmes[3]);
            TerceiraDisputa = Disputa.GerarDisputa(listaFilmes[4], listaFilmes[4]);
            QuartaDisputa   = Disputa.GerarDisputa(listaFilmes[5], listaFilmes[6]);
        }
Beispiel #7
0
        public void GerarFaseFinalTest()
        {
            var disputa1 = Disputa.GerarDisputa(PrimeiraDisputa.Vencedor, SegundaDisputa.Vencedor);

            var result = FaseFinal.GerarFaseFinal(PrimeiraDisputa, SegundaDisputa);

            Assert.AreEqual(disputa1.Vencedor, result.PrimeiroLugar);
            Assert.AreEqual(disputa1.Perdedor, result.SeguntoLugar);
            Assert.AreEqual(SegundaDisputa.Perdedor, result.TerceiroLugar);
        }
        public void GerarDisputaMesmaNotaTest()
        {
            filme2.AverageRating = filme1.AverageRating;
            filme2.PrimaryTitle  = $"A{filme2.PrimaryTitle}";
            var result = Disputa.GerarDisputa(filme1, filme2);

            Assert.IsNotNull(result);
            Assert.AreEqual <Filme>(result.Vencedor, filme2);
            Assert.AreEqual <Filme>(result.Perdedor, filme1);
        }
Beispiel #9
0
 internal static void Validar(Disputa PrimeiraDisputa, Disputa SegundaDisputa)
 {
     if (PrimeiraDisputa == null)
     {
         throw new ArgumentNullException(nameof(PrimeiraDisputa), $"A {nameof(PrimeiraDisputa)} esta nula");
     }
     if (SegundaDisputa == null)
     {
         throw new ArgumentNullException(nameof(SegundaDisputa), $"A {nameof(SegundaDisputa)} esta nula");
     }
 }
        public void GerarFaseSemiFinalTest()
        {
            var disputa1 = Disputa.GerarDisputa(PrimeiraDisputa.Vencedor, SegundaDisputa.Vencedor);
            var disputa2 = Disputa.GerarDisputa(TerceiraDisputa.Vencedor, QuartaDisputa.Vencedor);

            var result = FaseSemiFinal.GerarFaseSemiFinal(PrimeiraDisputa, SegundaDisputa, TerceiraDisputa, QuartaDisputa);

            Assert.AreEqual(disputa1.Perdedor, result.PrimeiraDisputa.Perdedor);
            Assert.AreEqual(disputa1.Vencedor, result.PrimeiraDisputa.Vencedor);
            Assert.AreEqual(disputa2.Perdedor, result.SegundaDisputa.Perdedor);
            Assert.AreEqual(disputa2.Vencedor, result.SegundaDisputa.Vencedor);
        }
Beispiel #11
0
        internal static void Validar(Disputa resultadoPrimeiraDisputa, Disputa resultadoSegundaDisputa, Disputa resultadoTerceiraDisputa, Disputa resultadoQuartaDisputa)
        {
            if (resultadoPrimeiraDisputa == null)
            {
                throw new ArgumentNullException(nameof(resultadoPrimeiraDisputa), $"O {nameof(resultadoPrimeiraDisputa)} esta nulo");
            }
            if (resultadoSegundaDisputa == null)
            {
                throw new ArgumentNullException(nameof(resultadoSegundaDisputa), $"O {nameof(resultadoSegundaDisputa)} esta nulo");
            }
            if (resultadoTerceiraDisputa == null)
            {
                throw new ArgumentNullException(nameof(resultadoTerceiraDisputa), $"O {nameof(resultadoTerceiraDisputa)} esta nulo");
            }
            if (resultadoQuartaDisputa == null)
            {
                throw new ArgumentNullException(nameof(resultadoQuartaDisputa), $"O {nameof(resultadoQuartaDisputa)} esta nulo");
            }

            if (resultadoPrimeiraDisputa.Perdedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoPrimeiraDisputa.Perdedor), $"O {nameof(resultadoPrimeiraDisputa.Perdedor)} esta nulo");
            }
            if (resultadoPrimeiraDisputa.Vencedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoPrimeiraDisputa.Vencedor), $"O {nameof(resultadoPrimeiraDisputa.Vencedor)} esta nulo");
            }
            if (resultadoSegundaDisputa.Perdedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoSegundaDisputa.Perdedor), $"O {nameof(resultadoSegundaDisputa.Perdedor)} esta nulo");
            }
            if (resultadoSegundaDisputa.Vencedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoSegundaDisputa.Vencedor), $"O {nameof(resultadoSegundaDisputa.Vencedor)} esta nulo");
            }
            if (resultadoTerceiraDisputa.Perdedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoTerceiraDisputa.Perdedor), $"O {nameof(resultadoTerceiraDisputa.Perdedor)} esta nulo");
            }
            if (resultadoTerceiraDisputa.Vencedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoTerceiraDisputa.Vencedor), $"O {nameof(resultadoTerceiraDisputa.Vencedor)} esta nulo");
            }
            if (resultadoQuartaDisputa.Perdedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoQuartaDisputa.Perdedor), $"O {nameof(resultadoQuartaDisputa.Perdedor)} esta nulo");
            }
            if (resultadoQuartaDisputa.Vencedor == null)
            {
                throw new ArgumentNullException(nameof(resultadoQuartaDisputa.Vencedor), $"O {nameof(resultadoQuartaDisputa.Vencedor)} esta nulo");
            }
        }
        private static Filme ObtenhaVencedorDaDisputa(Disputa disputa)
        {
            if (disputa.Filme1.Nota > disputa.Filme2.Nota)
            {
                return(disputa.Filme1);
            }

            if (disputa.Filme1.Nota < disputa.Filme2.Nota)
            {
                return(disputa.Filme2);
            }

            return(string.Compare(disputa.Filme1.Titulo, disputa.Filme2.Titulo, StringComparison.InvariantCultureIgnoreCase) < 0 ? disputa.Filme1 : disputa.Filme2);
        }
        public async Task <IActionResult> AtaqueComHabilidade(Disputa d)
        {
            Personagem atacante = await _context.Personagens
                                  .Include(p => p.PersonagemHabilidades).ThenInclude(ph => ph.Habilidade)
                                  .FirstOrDefaultAsync(p => p.Id == d.AtacanteId);

            Personagem oponente = await _context.Personagens
                                  .FirstOrDefaultAsync(p => p.Id == d.OponenteId);

            PersonagemHabilidade ph = await _context.PersonagemHabilidades
                                      .Include(p => p.Habilidade)
                                      .FirstOrDefaultAsync(phBusca => phBusca.HabilidadeId == d.HabilidadeId);

            if (ph == null)
            {
                d.Narracao = $"{atacante.Nome} não possui esta habilidade.";
            }
            else
            {
                int dano = ph.Habilidade.Dano + (new Random().Next(atacante.Inteligencia));
                dano = dano - new Random().Next(oponente.Defesa);

                if (dano > 0)
                {
                    oponente.PontosVida = oponente.PontosVida - (int)dano;
                }
                if (oponente.PontosVida <= 0)
                {
                    d.Narracao += $"{oponente.Nome} foi derrotado";
                }

                _context.Personagens.Update(oponente);
                await _context.SaveChangesAsync();

                StringBuilder dados = new StringBuilder();
                dados.AppendFormat(" Atacante: {0}", atacante.Nome);
                dados.AppendFormat(" Oponente: {0}", oponente.Nome);
                dados.AppendFormat(" Pontos de vida do atacante: {0}", atacante.PontosVida);
                dados.AppendFormat(" Pontos de vida do oponente: {0}", oponente.PontosVida);
                dados.AppendFormat(" Dano: {0}", dano);

                d.Narracao += dados.ToString();
            }
            return(Ok(d));
        }
        private List <Disputa> MontarDisputas(List <Filme> filmes)
        {
            Filme[] filmesOrdenados = filmes.OrderBy(o => o.Titulo).ToArray();

            List <Disputa> disputas = new List <Disputa>();

            for (int i = 0; i < 4; i++)
            {
                Disputa disputa = new Disputa();

                disputa.FilmeA = filmesOrdenados[i];
                disputa.FilmeB = filmesOrdenados[7 - i];

                disputas.Add(disputa);
            }

            return(disputas);
        }
        public void GerarFaseEliminatoriaTest()
        {
            var disputa1 = Disputa.GerarDisputa(GrupoA[0], GrupoB[1]);
            var disputa2 = Disputa.GerarDisputa(GrupoB[0], GrupoA[1]);
            var disputa4 = Disputa.GerarDisputa(GrupoD[0], GrupoC[1]);
            var disputa3 = Disputa.GerarDisputa(GrupoC[0], GrupoD[1]);

            var result = FaseEliminatoria.GerarFaseEliminatoria(GrupoA, GrupoB, GrupoC, GrupoD);

            Assert.AreEqual(disputa1.Perdedor, result.PrimeiraDisputa.Perdedor);
            Assert.AreEqual(disputa1.Vencedor, result.PrimeiraDisputa.Vencedor);
            Assert.AreEqual(disputa2.Perdedor, result.SegundaDisputa.Perdedor);
            Assert.AreEqual(disputa2.Vencedor, result.SegundaDisputa.Vencedor);
            Assert.AreEqual(disputa3.Perdedor, result.TerceiraDisputa.Perdedor);
            Assert.AreEqual(disputa3.Vencedor, result.TerceiraDisputa.Vencedor);
            Assert.AreEqual(disputa4.Perdedor, result.QuartaDisputa.Perdedor);
            Assert.AreEqual(disputa4.Vencedor, result.QuartaDisputa.Vencedor);
        }
        private Filme CalcularVencedor(Disputa disputa)
        {
            Filme vencedor = new Filme();

            if (disputa.FilmeA.Nota > disputa.FilmeB.Nota)
            {
                vencedor = disputa.FilmeA;
            }
            else if (disputa.FilmeA.Nota < disputa.FilmeB.Nota)
            {
                vencedor = disputa.FilmeB;
            }
            else
            {
                vencedor = string.Compare(disputa.FilmeA.Titulo, disputa.FilmeB.Titulo) < 0 ? disputa.FilmeA : disputa.FilmeB;
            }

            return(vencedor);
        }
        public async Task <IActionResult> AtaqueComArma(Disputa d)
        {
            Personagem atacante = await _context.Personagens
                                  .Include(p => p.Arma)
                                  .FirstOrDefaultAsync(p => p.Id == d.AtacanteId);

            Personagem oponente = await _context.Personagens
                                  .FirstOrDefaultAsync(p => p.Id == d.OponenteId);


            int dano = atacante.Arma.Dano + (new Random().Next(atacante.Forca));

            dano = dano - new Random().Next(oponente.Defesa);

            if (dano > 0)
            {
                oponente.PontosVida = oponente.PontosVida - (int)dano;
            }
            if (oponente.PontosVida <= 0)
            {
                d.Narracao = $"{oponente.Nome} foi derrotado";
            }

            _context.Personagens.Update(oponente);
            await _context.SaveChangesAsync();

            StringBuilder dados = new StringBuilder();

            dados.AppendFormat("Atacante: {0}", atacante.Nome);
            dados.AppendFormat("Oponente: {0}", oponente.Nome);
            dados.AppendFormat("Pontos de vida do atacante: {0}", atacante.PontosVida);
            dados.AppendFormat("Pontos de vida do oponente: {0}", oponente.PontosVida);
            dados.AppendFormat("Dano {0}", dano);

            d.Narracao += dados.ToString();

            return(Ok(d));
        }
 public void GerarDisputaTest_ParametroSemNotaDecimal_ThrowsArgumentNullException()
 {
     filme2.AverageRating = "Teste";
     var result = Disputa.GerarDisputa(filme1, filme2);
 }
 public void GerarDisputaTest_ParametroSemNota_ThrowsArgumentNullException()
 {
     filme2.AverageRating = string.Empty;
     var result = Disputa.GerarDisputa(filme1, filme2);
 }
 public void GerarDisputaTest_DoisParametroNulo_ThrowsArgumentNullException()
 {
     var result = Disputa.GerarDisputa(null, null);
 }
        public async Task <IActionResult> DisputaEmGrupo(Disputa d)
        {
            //Busca no banco de dados os personagens juntamente com as armas e  habilidades
            List <Personagem> personagens =
                await _context.Personagens
                .Include(p => p.Arma)
                .Include(p => p.PersonagemHabilidades).ThenInclude(ph => ph.Habilidade)
                .Where(p => d.ListaIdPersonagens.Contains(p.Id)).ToListAsync();


            bool derrotado = false;

            while (!derrotado)
            {
                foreach (Personagem atacante in personagens)
                {
                    //Cria uma lista de oponentes excluindo o personagem que fará o ataque
                    List <Personagem> oponentes = personagens.Where(p => p.Id != atacante.Id).ToList();
                    //Faz um sorteio que escolherá o oponente entre a lista criada anteriormente
                    Personagem oponente = oponentes[new Random().Next(oponentes.Count)];

                    int    dano        = 0;
                    string ataqueUsado = string.Empty;

                    bool ataqueUsaArma = new Random().Next(2) == 0;

                    if (ataqueUsaArma)
                    {
                        //Programação do ataque com arma
                        dano        = atacante.Arma.Dano + (new Random().Next(atacante.Forca));
                        dano        = dano - new Random().Next(oponente.Defesa);
                        ataqueUsado = atacante.Arma.Nome;

                        if (dano > 0)
                        {
                            oponente.PontosVida = oponente.PontosVida - (int)dano;
                        }
                    }
                    else
                    {
                        //Programação do ataque com habilidade
                        int        sorteioHabilidadeId = new Random().Next(atacante.PersonagemHabilidades.Count);
                        Habilidade habilidadeEscolhida = atacante.PersonagemHabilidades[sorteioHabilidadeId].Habilidade;
                        ataqueUsado = habilidadeEscolhida.Nome;

                        dano = habilidadeEscolhida.Dano + (new Random().Next(atacante.Inteligencia));
                        dano = dano - new Random().Next(oponente.Defesa);

                        if (dano > 0)
                        {
                            oponente.PontosVida = oponente.PontosVida - (int)dano;
                        }
                    }

                    string resultado = string.Format("{0} atacou {1} usando {2} com dano {3}.", atacante.Nome, oponente.Nome, ataqueUsado, dano);
                    d.Resultados.Add(resultado);

                    if (oponente.PontosVida <= 0)
                    {
                        derrotado = true;
                        atacante.Vitorias++;
                        oponente.Derrotas++;
                        d.Resultados.Add($"{oponente.Nome} foi derrotado.");
                        d.Resultados.Add($"{atacante.Nome} ganhou com {atacante.PontosVida} restantes.");
                        break;
                    }
                }

                //Fora do foreach: Recomposição dos pontos de vida, atualização do número de lutas.
                personagens.ForEach(p =>
                {
                    p.Disputas++;
                    p.PontosVida = 100;
                });
            }
            _context.Personagens.UpdateRange(personagens);
            await _context.SaveChangesAsync();

            return(Ok(d));
        }
Beispiel #22
0
 public static FaseSemiFinal GerarFaseSemiFinal(Disputa resultadoPrimeiraDisputa, Disputa resultadoSegundaDisputa, Disputa resultadoTerceiraDisputa, Disputa resultadoQuartaDisputa) =>
 new FaseSemiFinal(resultadoPrimeiraDisputa, resultadoSegundaDisputa, resultadoTerceiraDisputa, resultadoQuartaDisputa);
Beispiel #23
0
 public void Inicializar()
 {
     listaFilmes     = CriacaoListaFilmes.Criar();
     PrimeiraDisputa = Disputa.GerarDisputa(listaFilmes[0], listaFilmes[1]);
     SegundaDisputa  = Disputa.GerarDisputa(listaFilmes[2], listaFilmes[3]);
 }