public ActionResult Detalhes(int id = 0, String Msg = "")
{
Torneio torneio = db.Torneio.Find(id);
var userId = WebSecurity.GetUserId(User.Identity.Name);
ViewBag.isInscrito = false;
var inscricao = db.InscricaoTorneio.Where(i => i.torneioId == id && i.userId == userId).Count();
if (inscricao > 0)
{
ViewBag.isInscrito = true;
}
var jogador = db.UserProfiles.Find(userId);
ViewBag.ClasseInscricao = 0;
ViewBag.valor = torneio.valor + "";
if (jogador.barragemId == torneio.barragemId)
{
var ranking = db.Rancking.Where(r => r.userProfile_id == userId).Count();
if (ranking > 10)
{
ViewBag.valor = "gratuito";
}
if (jogador.classe.nivel <= torneio.qtddClasses)
{
ViewBag.ClasseInscricao = jogador.classe.nivel;
}
}
mensagem(Msg);
return(View(torneio));
}
public ActionResult Edit(int id = 0)
{
Torneio torneio = db.Torneio.Find(id);
var userId = WebSecurity.GetUserId(User.Identity.Name);
string perfil = Roles.GetRolesForUser(User.Identity.Name)[0];
var barragemId = 0;
if (perfil.Equals("admin"))
{
barragemId = torneio.barragemId;
}
else
{
barragemId = (from up in db.UserProfiles where up.UserId == userId select up.barragemId).Single();
}
ViewBag.barraId = barragemId;
ViewBag.barragemId = new SelectList(db.BarragemView, "Id", "nome", barragemId);
ViewBag.JogadoresClasses = db.RankingView.Where(r => r.barragemId == barragemId && (r.situacao.Equals("ativo") || r.situacao.Equals("suspenso") || r.situacao.Equals("licenciado"))).OrderBy(r => r.nivel).ThenByDescending(r => r.totalAcumulado).ToList();
ViewBag.Classes = db.Classe.Where(c => c.barragemId == barragemId).ToList();
ViewBag.temRodadaAberta = db.Rodada.Where(u => u.isAberta && u.barragemId == barragemId && !u.isRodadaCarga).Count();
if (torneio == null)
{
return(HttpNotFound());
}
return(View(torneio));
}
public ActionResult IndexTorneio(Torneio tr)
{
var barragemId = tr.barragemId;
ViewBag.contato = (from bg in db.Barragens where bg.Id == barragemId select bg.contato).Single();
return(View(tr));
}
public void DadoUmTorneioComQuatroJogadoresEDuasPartidasIniciaisOVencedorDeveraSerRichard()
{
var armando = new Jogador("Armando", (ElementoJogada)'P');
var dave = new Jogador("Dave", (ElementoJogada)'S');
var richard = new Jogador("Richard", (ElementoJogada)'R');
var michael = new Jogador("Michael", (ElementoJogada)'S');
var partida1 = new Partida();
partida1.AdicionarJogador(armando);
partida1.AdicionarJogador(dave);
var partida2 = new Partida();
partida2.AdicionarJogador(richard);
partida2.AdicionarJogador(michael);
var torneio = new Torneio();
torneio.AdicionarPartidas(partida1);
torneio.AdicionarPartidas(partida2);
torneio = new Jogo().RealizarDisputasTorneio(torneio.CarregarPartidasIncluidas());
Assert.AreEqual(richard, torneio.Vencedor);
}
/// <summary>
/// A partir do torneio, faz o "maata-mata" para descobrir o vencedor do campeonato
/// </summary>
/// <param name="torneio"></param>
/// <returns></returns>
public Rodada rps_tournament_winner(Torneio torneio)
{
List <Rodada> vencedoresDaRodada = new List <Rodada>();
List <Rodada> competidoresRodadaFinal = new List <Rodada>();
foreach (var rodada in torneio.rodadas)
{
//verifica o vencedor de cada rodada
Rodada jogadaVencedora = rps_game_winner(rodada);
vencedoresDaRodada.Add(jogadaVencedora);
//monta mais uma rodada a partir dos vencedores das demais rodadas
if (vencedoresDaRodada.Count == 2)
{
Rodada vencedorPartida = rps_game_winner(vencedoresDaRodada);
competidoresRodadaFinal.Add(vencedorPartida);
vencedoresDaRodada = new List <Rodada>();
}
//monta a rodada de competidores finais
if (competidoresRodadaFinal.Count == 2)
{
Rodada vencedorPartida = rps_game_winner(competidoresRodadaFinal);
return(vencedorPartida);
}
}
return(new Rodada());
}
public string ValidaTorneio(Torneio torneio)
{
StringBuilder erros = new StringBuilder();
if (torneio.Addon == null)
{
erros.AppendLine("Add-On deve ser informado");
}
if (torneio.BuyIn == null)
{
erros.AppendLine("Buy-In deve ser informado");
}
if (torneio.JackPot == null)
{
erros.AppendLine("Jack-Pot deve ser informado");
}
if (torneio.Jantar == null)
{
erros.AppendLine("Jantar deve ser informado");
}
if (torneio.Nome == null || string.IsNullOrWhiteSpace(torneio.Nome))
{
erros.AppendLine("Nome do torneio deve ser informado");
}
if (torneio.ReBuy == null)
{
erros.AppendLine("Re-Buy deve ser informado");
}
if (torneio.TaxaAdm == null)
{
erros.AppendLine("Taxa-Adm deve ser informado");
}
return(erros.ToString());
}
public async Task <ActionResult <Torneio> > PostTorneio(Torneio torneio)
{
_context.Torneio.Add(torneio);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetTorneio), new { id = torneio.Id }, torneio));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,NomeTorneio,QuantidadeJogadores,Inicio")] Torneio torneio)
{
if (id != torneio.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(torneio);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TorneioExists(torneio.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(torneio));
}
public void DadoUmTorneioComQuatroJogadoresEDuasPartidasIniciaisOVencedorDeveraSerAllen()
{
var allen = new Jogador("Allen", (ElementoJogada)'S');
var omer = new Jogador("Omer", (ElementoJogada)'P');
var davidE = new Jogador("David E.", (ElementoJogada)'R');
var richardX = new Jogador("Richard X.", (ElementoJogada)'P');
var partida3 = new Partida();
partida3.AdicionarJogador(allen);
partida3.AdicionarJogador(omer);
var partida4 = new Partida();
partida4.AdicionarJogador(davidE);
partida4.AdicionarJogador(richardX);
var torneio = new Torneio();
torneio.AdicionarPartidas(partida3);
torneio.AdicionarPartidas(partida4);
torneio = new Jogo().RealizarDisputasTorneio(torneio.CarregarPartidasIncluidas());
Assert.AreEqual(allen, torneio.Vencedor);
}
public async Task <IActionResult> PutTorneio(int id, Torneio torneio)
{
if (id != torneio.Id)
{
return(BadRequest());
}
_context.Entry(torneio).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TorneioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Torneio> > PostTorneio(Torneio torneio)
{
var idA = ( int )torneio.EquipeAId;
var idB = (int )torneio.EquipeBId;
torneio.EquipeAId = idA;
torneio.EquipeBId = idB;
IQueryable <Jogador> query = _context.Jogadores
.Where(h => h.EquipeId == idA);
IQueryable <Jogador> queryB = _context.Jogadores
.Where(h => h.EquipeId == idB);
if ((query.Count() == queryB.Count()) && (query.Count() >= 5 && queryB.Count() >= 5))
{
_context.Torneios.Add(torneio);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTorneio", new { id = torneio.Id }, torneio));
}
else
{
return(BadRequest("As equipes precisam conter quantidade de membros iguais."));
}
}
public async Task <IActionResult> Edit(Guid id, [Bind("Codigo,Nome,DataInicio,DataFim,Status,Id")] Torneio torneio)
{
if (id != torneio.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(torneio);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TorneioExists(torneio.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(torneio));
}
public static bool DefinirJogos(Torneio torneio, TorneioContext db)
{
if (torneio.Times.Count != torneio.TotalTimes)
{
return(false);
}
else
{
var times = torneio.Times.ToList();
for (int i = 1; i < torneio.TotalTimes; i++)
{
Jogo novoJogo = new Jogo()
{
Nome = $"Jogo {i}"
};
if (i <= (torneio.TotalTimes / 2))
{
novoJogo.Time1 = times[i];
novoJogo.Time2 = times[i + (torneio.TotalTimes / 2)];
}
//TorneioContext db = new TorneioContext();
//db.Torneios.Find(torneio.Id).Jogos.Add(novoJogo);
torneio.Jogos.Add(novoJogo);
db.SaveChanges();
}
return(true);
}
}
public void DeveRetornarUmaListaComQuatroBatalhas(int quantidadeDeLutadores, int quantidadeDeBatalhasEsperadas)
{
var lutadores = TorneioTestData.MockListaDeLutadores(quantidadeDeLutadores);
var batalhas = Torneio.PrepararBatalhas(lutadores);
Assert.Equal(quantidadeDeBatalhasEsperadas, batalhas.Count);
}
public JsonResult IniciarTorneio(LutadoresViewModel lutadoresViewModel)
{
var lutadores = lutadorRepository.FindAll(lutadoresViewModel.lutadoresId);
var Torneio = new Torneio(lutadores);
var torneioResultado = Torneio.Joga();
return(Json(mapper.Map <ResultadoTorneio, TorneioResultadoModel>(torneioResultado)));
}
public Torneio RealizarDisputasTorneio(List <Partida> partidas)
{
var torneio = new Torneio();
torneio.Vencedor = DisputarJogosDasChaves(partidas, partidas.Count, null);
return(torneio);
}
public ActionResult DeleteConfirmed(int id)
{
Torneio torneio = db.Torneios.Find(id);
db.Torneios.Remove(torneio);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(Torneio torneio)
{
if (ModelState.IsValid)
{
db.Entry(torneio).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(torneio));
}
public ActionResult AlterarTorneio(Torneio torneio)
{
var result = TorneioAplicacao.AlterarTorneio(torneio);
if (result.TemValor())
{
ViewBag.erro = result;
return(View(torneio));
}
return(RedirectToAction("FiltroTorneio"));
}
/// <summary>
/// Ação responsável por retornar os dados necessários para
/// montagem e operação de um jogo.
/// </summary>
/// <param name="id">O id do Jogo.</param>
/// <returns></returns>
public IActionResult Tabuleiro(int id)
{
Torneio torneio = new Torneio();
if (torneio.Id != 0)
{
ViewBag.mensagem = "Modo Torneio";
}
if (torneio.Id == 0)
{
ViewBag.mensagem = "Modo Amistoso";
}
//Recupera Jogo do banco de dados.
//Repare que a inclusão de j.Jogador1, não trará
//j.Jogador1.Usuario, ver na ação de Lobby como fazer.
var jogo = _context.Jogos
.Include(j => j.Jogador1)
.Include(j => j.Jogador2)
.Include(j => j.Tabuleiro)
.Where(j => j.Id == id)
.Select(j => j)
.FirstOrDefault();
//Verifica se o id passado via parâmetro existe no banco de dados.
if (jogo.Jogador1 is JogadorPessoa)
{
//Caso seja, será necessário recuperar
//Jogador.Usuário, para recuperar o nome do Jogador.
jogo.Jogador1 = _context.JogadorPessoas
.Include(j => j.Usuario)
.Where(j => j.Id == jogo.Jogador1Id)
.FirstOrDefault();
}
if (jogo.Jogador2 is JogadorPessoa)
{
jogo.Jogador2 = _context.JogadorPessoas
.Include(j => j.Usuario)
.Where(j => j.Id == jogo.Jogador2Id)
.FirstOrDefault();
}
if (jogo == null)
{
return(NotFound());
}
if (jogo.Tabuleiro == null)
{
jogo.Tabuleiro = new Tabuleiro();
_context.SaveChanges();
}
return(View(jogo));
}
public async Task <IActionResult> Create([Bind("Codigo,Nome,DataInicio,DataFim,Status,Id")] Torneio torneio)
{
if (ModelState.IsValid)
{
torneio.Id = Guid.NewGuid();
_context.Add(torneio);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(torneio));
}
public async Task <IActionResult> Create([Bind("Id,NomeTorneio,QuantidadeJogadores,Inicio")] Torneio torneio)
{
if (ModelState.IsValid)
{
torneio.Dono = User.Identity.Name;
_context.Add(torneio);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(torneio));
}
public void DeveRetornarOMrSatanComoVencedorDoTorneio()
{
var mrSatan = new Lutador("Mr. Satan", 1, 1);
var lutadores = TorneioTestData.MockListaDeLutadores(7);
lutadores.Add(mrSatan);
var torneio = new Torneio(lutadores);
var vencedor = torneio.ExecutarTorneio();
Assert.Equal(mrSatan, vencedor);
}
public ActionResult GerarResultado(int idTorneio, int rodada)
{
//db.Torneios.Include(T => T.Jogos).Include(T => T.Times).Load();
Torneio torneio = db.Torneios.Find(idTorneio);
torneio.GerarResultados(db, rodada);
var parametro = new RouteValueDictionary();
parametro.Add("idTorneio", idTorneio);
return(RedirectToAction("Gerenciar", parametro));
}
public override void InitPopulation()
{
//You should implement the code to initialize the population herez
selection = new Torneio();
population = new List <Individual>();
// jncor
while (population.Count < populationSize)
{
GeneticIndividual new_ind = new GeneticIndividual(topology);
new_ind.Initialize();
population.Add(new_ind);
}
}
public void DeveRetornarOLutadorMaisForteComoVencedorDoTorneio()
{
var vencedorEsperado = new Lutador("Goku", 10_000, 100);
var lutadores = TorneioTestData.MockListaDeLutadores(7);
lutadores.Add(vencedorEsperado);
var torneio = new Torneio(lutadores);
var vencedor = torneio.ExecutarTorneio();
Assert.Equal(vencedorEsperado, vencedor);
}
public string AlterarTorneio(Torneio entidade)
{
var result = Validador.ValidaTorneio(entidade);
if (result != "")
{
return(result);
}
entidade.DataAlteracao = DateTime.Now;
entidade.IdUsuarioAlteracao = AutenticacaoAplicacao.ObterUsuarioLogado().Id;
TorneioRepositorio.Atualizar(entidade);
Contexto.Salvar();
return(result);
}
// GET: Torneios/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Torneio torneio = db.Torneios.Find(id);
if (torneio == null)
{
return(HttpNotFound());
}
return(View(torneio));
}
public async Task <Torneio> CadastrarTorneio(Torneio torneio)
{
var timeNoBanco = ObterTorneioPorId(torneio.Id);
if (timeNoBanco != null)
{
throw new NaoEPossivelCadastrarTorneioComIdJaExistenteException();
}
_contexto.Torneios.Update(torneio);
await _contexto.SaveChangesAsync();
return(torneio);
}
static void Main(string[] args)
{
var listaDoisJogadores = ListaJogadores.ListaDoisJogadores;
var jogadorVencedor = Jogo.RpsGameWinner(listaDoisJogadores);
Console.WriteLine(string.Format("Jogador {0} venceu com a jogada {1}", jogadorVencedor.Nome, jogadorVencedor.Jogada));
Console.ReadKey();
var listaJogadoresTorneio = ListaJogadores.ListaJogadoresTorneio;
var torneio = new Torneio();
var ganhadorTorneio = torneio.RpsTournamentWinner(listaJogadoresTorneio);
Console.WriteLine(string.Format("Jogador {0} venceu o torneio com a jogada {1}", ganhadorTorneio.Nome, ganhadorTorneio.Jogada));
Console.ReadKey();
}
