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);
}
}
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]);
}
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);
}
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);
}
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));
}
public static FaseSemiFinal GerarFaseSemiFinal(Disputa resultadoPrimeiraDisputa, Disputa resultadoSegundaDisputa, Disputa resultadoTerceiraDisputa, Disputa resultadoQuartaDisputa) => new FaseSemiFinal(resultadoPrimeiraDisputa, resultadoSegundaDisputa, resultadoTerceiraDisputa, resultadoQuartaDisputa);
public void Inicializar()
{
listaFilmes = CriacaoListaFilmes.Criar();
PrimeiraDisputa = Disputa.GerarDisputa(listaFilmes[0], listaFilmes[1]);
SegundaDisputa = Disputa.GerarDisputa(listaFilmes[2], listaFilmes[3]);
}
