public async Task <IActionResult> Edit(int id, [Bind("ID,JogadorPts,TotalPts,DiaPts")] Placar placar)
{
if (id != placar.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(placar);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlacarExists(placar.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(placar));
}
public async Task <IActionResult> Edit(int id, [Bind("PlacarId,JogadorId,TotalPontos,HorarioId")] Placar placar)
{
if (id != placar.PlacarId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
db.Update(placar);
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlacarExists(placar.PlacarId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["JogadorId"] = new SelectList(db.Set <Jogador>(), "JogadorId", "Nacionalidade", placar.JogadorId);
return(View(placar));
}
public async Task <IActionResult> Edit(int id, [Bind("PlacarId,JogadorId,total,data")] Placar placar)
{
if (id != placar.PlacarId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(placar);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlacarExists(placar.PlacarId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["JogadorId"] = new SelectList(_context.jogadores, "JogadorId", "Nome", placar.JogadorId);
return(View(placar));
}
private void GravaHiScore()
{
//Instanciar a DAL
gamerDAL = new GamerDAL();
Placar placar = new Placar();
var frm = new frmTelaInicial();
placar.NomeJogador = this.nomeGamer;
if (!this.nomeGamer.Equals(""))
{
placar.NomeJogador = this.nomeGamer;
}
else
{
placar.NomeJogador = "Player 1";
}
placar.ScoreJogador = pontos;
placar.DataScoreJogador = DateTime.Now;
placar.TempoJogo = minutos.ToString("00") + ":" + segundos.ToString("00");
//Chama a funcao inserir da DAL passando o objeto populado como parametro
if (!gamerDAL.Inserir(placar))
{
//Deu pau! Exibir mensagem para o usuario
MessageBox.Show("Erro ao inserir os dados: \r\n\r\n" +
gamerDAL.MensagemErro, "Mario Like Game");
}
}
//Referencias
private void _Referencias()
{
_jogador = GetNode <Jogador>("Principal/Jogador");
if (_jogador == null)
{
_Erro("Jogador não encontrado", "_Referencias");
}
_memLocal = GetNode <Memoria>("/root/MemLocal");
if (_memLocal == null)
{
_Erro("MemLocal não encontrado", "_Referencias");
}
_memGlobal = GetNode <Memoria>("/root/MemGlobal");
if (_memGlobal == null)
{
_Erro("MemGlobal não encontrado", "_Referencias");
}
_placar = GetNode <Placar>("Interface/Placar");
if (_placar == null)
{
_Erro("Placar não encontrado", "_Referencias");
}
_relogio = GetNode <Relogio>("Relogio");
if (_relogio == null)
{
_Erro("Relogio não encontrado", "_Referencias");
}
_msgTela = GetNode <MsgTela>("Interface/Tela/MsgTela");
if (_msgTela == null)
{
_Erro("MsgTela não encontrado", "_Referencias");
}
}
// Use this for initialization
void Awake()
{
posicaoInicial = transform.position;
rb = GetComponent <Rigidbody>();
playerDeAudio = GetComponent <AudioSource>();
placar = FindObjectOfType <Placar>();
velocidadeAtual = velocidadeInicial;
}
public async Task <IActionResult> Create([Bind("ID,JogadorPts,TotalPts,DiaPts")] Placar placar)
{
if (ModelState.IsValid)
{
_context.Add(placar);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(placar));
}
public async Task <IActionResult> Create([Bind("Id,pontos,jogadorId,data")] Placar placar)
{
if (ModelState.IsValid)
{
_context.Add(placar);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(placar));
}
public async Task <IActionResult> Create([Bind("PlacarId,JogadorId,TotalPontos,HorarioId")] Placar placar)
{
if (ModelState.IsValid)
{
db.Add(placar);
await db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["JogadorId"] = new SelectList(db.Set <Jogador>(), "JogadorId", "Nome", placar.JogadorId);
return(View(placar));
}
public async Task <IActionResult> Create([Bind("PlacarId,JogadorId,total,data")] Placar placar)
{
if (ModelState.IsValid)
{
_context.Add(placar);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["JogadorId"] = new SelectList(_context.jogadores, "JogadorId", "Nome", placar.JogadorId);
return(View(placar));
}
public async Task <IActionResult> Create([Bind("PlacarID,JogadorID,Data,Pontuacao")] Placar placar)
{
if (ModelState.IsValid)
{
_context.Add(placar);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["JogadorID"] = new SelectList(_context.Jogador, "JogadorID", "JogadorID", placar.JogadorID);
return(View(placar));
}
public static void ExecutarNovaPartida()
{
var partida = PartidaFactory.ConstruirPartida();
var random = new Random();
var placar = new Placar(partida, random.Next(5), random.Next(5));
Database.Database.SalvarResultado(placar);
TvService.ExibirResultado(placar);
}
public async Task <IActionResult> Create([Bind("PlacarId,AtletaId,Pontos,Data")] Placar placar)
{
if (ModelState.IsValid)
{
_context.Add(placar);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["AtletaId"] = new SelectList(_context.Atleta, "AtletaId", "Nome", placar.AtletaId);
return(View(placar));
}
public List <Placar> Listar()
{
//Instanciar a lista
List <Placar> resultado = new List <Placar>();
//Declarar o comando
SqlCommand comando = new SqlCommand();
comando.Connection = conexao;
comando.CommandText = "SELECT TOP 10 id_Jogador, nome_Jogador, score_Jogador, data_Score, tempo " +
" FROM Score ORDER BY score_Jogador DESC, tempo, data_Score";
//Executar o comando
try
{
//Abrir a conexao
conexao.Open();
//Executar o comando e receber o resultado
SqlDataReader leitor = comando.ExecuteReader();
//Verificarse encontrou algo
while (leitor.Read() == true)
{
//instancio o objeto
Placar placar = new Placar();
placar.IdJogador = Convert.ToInt32(leitor["id_Jogador"]);
placar.NomeJogador = Convert.ToString(leitor["nome_Jogador"]);
placar.ScoreJogador = Convert.ToInt32(leitor["score_Jogador"]);
placar.DataScoreJogador = Convert.ToDateTime(leitor["data_Score"]);
placar.TempoJogo = Convert.ToString(leitor["tempo"]);
//Adicionar na lista
resultado.Add(placar);
}
//Fechar o leitor
leitor.Close();
}
catch (Exception ex)
{
//Se entrou aqui entao deu pau :(
string mensagem = ex.Message;
}
finally
{
conexao.Close();
}
return(resultado);
}
public NewItemPage(ItemsViewModel viewModel)
{
InitializeComponent();
Item = new Placar();
if (Config.Current != null)
{
Item.Regra = viewModel.Regras.FirstOrDefault(a => a.Nome == Config.Current.RegraDefault);
}
ViewModel = viewModel;
BindingContext = this;
}
public Placar LerResultado()
{
var placar = new Placar();
var entrada = Console.ReadLine();
var mandante = entrada.Split(' ')[0];
var visitante = entrada.Split(' ')[1];
var golsMandante = Int32.Parse(mandante);
var golsVisitante = Int32.Parse(visitante);
placar.DefinirPlacar(golsMandante, golsVisitante);
return(placar);
}
public bool Inserir(Placar placar)
{
bool resultado = false;
//Limpa mensagem de erro
MensagemErro = "";
//Declarar Comando SQL
SqlCommand comando = new SqlCommand();
comando.Connection = conexao;
comando.CommandText = "INSERT INTO Score (nome_Jogador, score_Jogador, data_Score, tempo) " +
"VALUES (@Nome,@Score,@Data, @Tempo);";
//Criar os parametros
comando.Parameters.AddWithValue("@Nome", placar.NomeJogador);
comando.Parameters.AddWithValue("@Score", placar.ScoreJogador);
comando.Parameters.AddWithValue("@Data", placar.DataScoreJogador);
comando.Parameters.AddWithValue("@Tempo", placar.TempoJogo);
//Executar o Comando
try
{
//Abrir a conexao
conexao.Open();
//Executar o comando
comando.ExecuteNonQuery();
//Se chegou até aqui, entao fununcinou! :)
resultado = true;
}
catch (Exception ex)
{
//Se entrou aqui, entao deu pau
MensagemErro = ex.Message;
}
finally
{
//Finalizar fechando a conexao
conexao.Close();
}
return(resultado);
}
public void Insert(Placar p)
{
//Connection Factory: Classe que gerencia o local da conexão, tendo o método responsável por obter a conexão
cf = new ConnectionFactory();
//StringBuilder: Construtor de String e o Método Append concatena cada linha dentro da variável chamada query
StringBuilder query = new StringBuilder();
query.AppendLine("INSERT INTO TB_PLACAR ");
query.AppendLine("(ID_PARTIDA_PLACAR, ID_SELECAO, BL_MANDANTE, NR_GOL, NR_GOL_PRORROGACAO, NR_GOL_DECISAO_PENALTIS) ");
query.AppendLine("VALUES (@ID_PARTIDA_PLACAR, @ID_SELECAO, @BL_MANDANTE, @NR_GOL, @NR_GOL_PRORROGACAO, @NR_GOL_DECISAO_PENALTIS) ");
query.AppendLine("SELECT SCOPE_IDENTITY(); ");//Linha Responsável por retornar id que foi Inserido
//CreateCommand: Inicializa o objeto SqlCommand associando o comando com a conexão do Banco onde será executado
cf.Comando = cf.Conexao.CreateCommand();
//Abaixo os parametros que no momento da execução serão substituídos pelos valor das propriedades
cf.Comando.Parameters.AddWithValue("@ID_PARTIDA_PLACAR", p.IdPartida);
cf.Comando.Parameters.AddWithValue("@ID_SELECAO", p.IdSelecao);
cf.Comando.Parameters.AddWithValue("@BL_MANDANTE", p.BlMandante);
cf.Comando.Parameters.AddWithValue("@NR_GOL", p.NrGol);
cf.Comando.Parameters.AddWithValue("@NR_GOL_PRORROGACAO", p.NrGolProrrogacao);
cf.Comando.Parameters.AddWithValue("@NR_GOL_DECISAO_PENALTIS", p.NrGolPenaltis);
//CommandType indica que o comando será via texto, poderia ser uma procedure no banco de dados por exemplo.
cf.Comando.CommandType = CommandType.Text;//Clicar com o Direito para adicionar Using
//CommandText: Propriedade do objeto command que receberá o texto do comando a ser executado.
cf.Comando.CommandText = query.ToString();
//Abre a conexão
cf.Conexao.Open();
//ExecuteScalar retornar a primeira coluna do último select executado
//Como o Scope_identity retorna a chave primária inserida, ele retornará o ID que guardaremos para o objeto
p.IdPlacar = Convert.ToInt32(cf.Comando.ExecuteScalar());
//Fecha a conexão
cf.Conexao.Close();
}
private async void IncluirPlacar(NewItemPage source, Placar placar)
{
var clas = ((await DataStore.GetItemsAsync(true)) ?? new Classificacao[0])
.OrderBy(a => a.Posicao)
.ToArray();
var novoPlacar = placar as Placar;
var clasJA = clas.FirstOrDefault(a => a.Jogador == novoPlacar.JogadorA.Nome);
var clasJB = clas.FirstOrDefault(a => a.Jogador == novoPlacar.JogadorB.Nome);
var ultimaPosicao = clas[clas.Length - 1].Posicao;
novoPlacar.PosicaoA = (clasJA?.Posicao) ?? (++ultimaPosicao);
novoPlacar.PosicaoAntA = (clasJA?.PosicaoAnterior);
novoPlacar.PosicaoB = (clasJB?.Posicao) ?? (++ultimaPosicao);
novoPlacar.PosicaoAntB = (clasJB?.PosicaoAnterior);
await PlacarDataStore.AddItemAsync(novoPlacar);
RecalcularClassificacaoAsync(null);
}
private void AtualizarPosicao(PosicaoList <Classificacao> clas,
Posicao <Classificacao> vencedor, Posicao <Classificacao> derrotado, Placar placar)
{
int qtdeQueda;
bool trocaPosicao;
var regra = placar.Regra;
if (regra.Nome == RegrasBusiness.ESTOU_FORA)
{
if (vencedor.Data.Jogador != derrotado.Data.Jogador)
{
var msg = "Quando um jogador desiste, a partida deve ser entre ele mesmo.";
msg += $"\r\n[ Data: {placar.Data} - '{vencedor.Data.Jogador}' x '{derrotado.Data.Jogador}']";
throw new InvalidOperationException(msg);
}
clas.RemoveByKey(derrotado.Data.Jogador);
return;
}
switch (regra.Nome)
{
case RegrasBusiness.DESAFIO_DENTE_POR_DENTE:
trocaPosicao = vencedor.Index > derrotado.Index;
qtdeQueda = Math.Abs(vencedor.Index - derrotado.Index);
break;
case RegrasBusiness.DESAFIO_LIDER:
if (vencedor.Index != 0 && derrotado.Index != 0)
{
var msg = $"O desafio entre '{vencedor.Data.Jogador}' e "
+ $"'{derrotado.Data.Jogador}' é inválido. "
+ "Nenhum dos dois possui a liderança.";
msg += $"\r\n[ Data: {placar.Data} - '{vencedor.Data.Jogador}' x '{derrotado.Data.Jogador}']";
throw new InvalidOperationException(msg);
}
trocaPosicao = (vencedor.Index != 0);
qtdeQueda = Math.Abs(derrotado.Index - (clas.Count - 1));
break;
default:
trocaPosicao = vencedor.Index > derrotado.Index;
qtdeQueda = 1;
break;
}
if (trocaPosicao)
{
var(posDerrotado, posVencedor) = (vencedor.Index, derrotado.Index);
clas[posDerrotado] = derrotado.Data;
clas[posVencedor] = vencedor.Data;
return;
}
clas.Remove(derrotado.Index);
clas.InsertOrUpdate(derrotado.Index + qtdeQueda, derrotado.Data);
}
public void DefinirPlacar(Placar p)
{
Placar = p;
}
public static void SalvarResultado(Placar placar)
{
Console.WriteLine("Resultado da partida de PING PONG registrado no banco de dados");
}
protected void btnSalvar_Click(object sender, EventArgs e)
{
try
{
if (ddlSelecaoOrdem1.SelectedValue == ddlSelecaoOrdem2.SelectedValue)
{
throw new Exception("Escolha duas seleções diferentes");
}
Partida p = new Partida();
p.IdEstadio = Convert.ToInt32(ddlEstadio.SelectedValue);
p.IdFase = Convert.ToInt32(ddlFase.SelectedValue);
p.DtPartida = Convert.ToDateTime(txtData.Text);
p.DsPartida = string.Format("{0} x {1}", ddlSelecaoOrdem1.SelectedItem.Text, ddlSelecaoOrdem2.SelectedItem.Text);
p.ListaPlacar = new List <Placar>();
Placar p1 = new Placar();
p1.BlMandante = true;
p1.IdSelecao = Convert.ToInt32(ddlSelecaoOrdem1.SelectedValue);
p1.NrGol = Convert.ToInt32(txtPlacarSelecao1.Text);
if (!string.IsNullOrEmpty(txtPlacarSelecao1Prorrogacao.Text))
{
p1.NrGolProrrogacao = Convert.ToInt32(txtPlacarSelecao1Prorrogacao.Text);
}
else
{
p1.NrGolProrrogacao = 0;
}
if (!string.IsNullOrEmpty(txtPlacarSelecao1Penaltis.Text))
{
p1.NrGolPenaltis = Convert.ToInt32(txtPlacarSelecao1Penaltis.Text);
}
else
{
p1.NrGolPenaltis = 0;
}
p.ListaPlacar.Add(p1);
Placar p2 = new Placar();
p2.BlMandante = false;
p2.IdSelecao = Convert.ToInt32(ddlSelecaoOrdem2.SelectedValue);
p2.NrGol = Convert.ToInt32(txtPlacarSelecao2.Text);
if (!string.IsNullOrEmpty(txtPlacarSelecao2Prorrogacao.Text))
{
p2.NrGolProrrogacao = Convert.ToInt32(txtPlacarSelecao2Prorrogacao.Text);
}
else
{
p2.NrGolProrrogacao = 0;
}
if (!string.IsNullOrEmpty(txtPlacarSelecao2Penaltis.Text))
{
p2.NrGolPenaltis = Convert.ToInt32(txtPlacarSelecao2Penaltis.Text);
}
else
{
p2.NrGolPenaltis = 0;
}
p.ListaPlacar.Add(p2);
if (partidaService.Insert(p))
{
CarregarPartidas();
Response.Write("Partida salva com sucesso.");
}
}
catch (Exception ex)
{
Response.Write(ex.Message);
}
}
public static void ExibirResultado(Placar placar)
{
Console.WriteLine(placar);
}