public void Remover_Usuario_Pretas_E_Brancas_E_Adicionar_Expectadores_Como_Pretas_E_Brancas()
{
Partida partida = new Partida();
Usuario jogadorBrancas = new Usuario("loginBrancas", "*****@*****.**", "brancas");
Usuario jogadorPretas = new Usuario("loginPretas", "*****@*****.**", "pretas");
Usuario expectador1 = new Usuario("expectador1", "*****@*****.**", "expectador1");
Usuario expectador2 = new Usuario("expectador2", "*****@*****.**", "expectador2");
partida.InserirUsuario(jogadorBrancas);
partida.InserirUsuario(jogadorPretas);
partida.InserirUsuario(expectador1);
partida.InserirUsuario(expectador2);
var resposta1 = partida.RemoverJogador(jogadorPretas);
var resposta2 = partida.RemoverJogador(jogadorBrancas);
JogadorModel respotaEsperada1 = new JogadorModel(null, "PRETAS");
JogadorModel respotaEsperada2 = new JogadorModel(null, "BRANCAS");
Assert.IsTrue(partida.Expectadores.Count == 0);
Assert.AreNotEqual(jogadorBrancas, partida.JogadorBrancas);
Assert.AreNotEqual(jogadorPretas, partida.JogadorPretas);
Assert.AreEqual(expectador1, partida.JogadorPretas);
Assert.AreEqual(expectador2, partida.JogadorBrancas);
Assert.AreEqual(respotaEsperada1.IdConexao, resposta1.IdConexao);
Assert.AreEqual(respotaEsperada2.IdConexao, resposta2.IdConexao);
Assert.AreEqual(respotaEsperada1.Funcao, resposta1.Funcao);
Assert.AreEqual(respotaEsperada2.Funcao, resposta2.Funcao);
}
public void AtualizarRanking(JogadorModel Jogador)
{
var jsonData = File.ReadAllText(_PathArquivo, Encoding.UTF8).Replace("\0", "");
var Ranking = JsonConvert.DeserializeObject <RankingModel>(jsonData);
if (Ranking.Jogadores == null)
{
Ranking.Jogadores = new List <JogadorModel>();
}
if (Ranking.Jogadores.Any(j => j.Nome.ToLower() == Jogador.Nome.ToLower()))
{
Ranking.Jogadores.SingleOrDefault(j => j.Nome.ToLower() == Jogador.Nome.ToLower()).Moedas += Jogador.Moedas;
}
else
{
Ranking.Jogadores.Add(Jogador);
}
jsonData = JsonConvert.SerializeObject(Ranking, new JsonSerializerSettings {
Formatting = Formatting.None
});
Task.Run(async() => { await EscreverTexto(jsonData); });
}
public async Task <JogadorModel> AtualizarJogador(JogadorModel jogadorNew)
{
var jsonData = File.ReadAllText(_PathArquivo, Encoding.UTF8).Replace("\0", "");
var Ranking = JsonConvert.DeserializeObject <RankingModel>(jsonData);
if (Ranking.Jogadores == null)
{
Ranking.Jogadores = new List <JogadorModel>();
}
if (Ranking.Jogadores.Any(j => j.Nome.ToLower() == jogadorNew.Nome.ToLower()))
{
var jogadorOld = Ranking.Jogadores.SingleOrDefault(j => j.Nome.ToLower() == jogadorNew.Nome.ToLower());
var indexJogadorOld = Ranking.Jogadores.IndexOf(jogadorOld);
Ranking.Jogadores[indexJogadorOld] = jogadorNew;
jsonData = JsonConvert.SerializeObject(Ranking, new JsonSerializerSettings {
Formatting = Formatting.None
});
await EscreverTexto(jsonData);
}
return(jogadorNew);
}
public override Task OnDisconnected(bool stopCalled)
{
Usuario usuario = USUARIOS.FirstOrDefault(x => x.UserHash == Context.ConnectionId);
if (usuario != null)
{
Partida partida = SALAS.FirstOrDefault(x => x.Key == usuario.SalaHash).Value;
if (partida != null)
{
JogadorModel jogador = partida.RemoverJogador(usuario);
if (jogador != null)
{
AtualizarJogadores(jogador);
}
if (partida.JogadorBrancas == null && partida.JogadorPretas == null && partida.Expectadores.Count == 0)
{
SALAS.Remove(usuario.SalaHash);
return(base.OnDisconnected(stopCalled));
}
}
this.Consultar(usuario.SalaHash);
USUARIOS.Remove(usuario);
}
return(base.OnDisconnected(stopCalled));
}
// public string heroiLargada {get;set;}
// public int numRound{get;set;}
public void proximoJogador(JogadorModel jogAtual)
{
if (jogAtual.tipoJogador == 1)
{
proximoAJogar = 2;
}
}
private async Task GuardarDados()
{
//Validar dados atuais.
if (!ValidarDados())
{
return;
}
//Se o jogador antes estava bloqueado, é necessário criar um model para o mesmo.
if (_jogador.Bloqueado)
{
JogadorModel jogadorModel = new JogadorModel(Nome.Valor, Email.Valor, Genero.ObterModel(), Foto, Handicap.ObterModel(), Tee.ObterModel());
_jogador.DefinirModel(jogadorModel);
//Avisar que utilizador foi criado.
MediadorMensagensService.Instancia.Avisar(MediadorMensagensService.ViewModelMensagens.JogadorAdicionado, _jogador);
}
else
{
//O modelo já está criado. Basta atualizar os valores do mesmo.
_jogador.Nome = Nome.Valor;
_jogador.Email = Email.Valor;
_jogador.Foto = Foto;
_jogador.Foto = Foto;
_jogador.Genero = Genero;
_jogador.Tee = Tee;
_jogador.Handicap = Handicap;
}
//Fechar PopUp.
await base.NavigationService.SairDeEditarJogador();
LimparMemoria();
}
public async Task <ActionResult> CadastraJogador(JogadorModel jogador)
{
try
{
if (ModelState.IsValid)
{
var cadastrou = await _escalacaoBLL.CadastrarJogador(new JogadorMOD()
{
Altura = jogador.Altura,
Apelido = jogador.Apelido,
CodigoTime = jogador.CodigoTime,
DataNascimento = jogador.DataNascimento,
Nome = jogador.Nome,
NumeroCamisa = jogador.NumeroCamisa,
Posicao = jogador.Posicao,
Sobrenome = jogador.Sobrenome,
Time = jogador.Time
}, Session["user"].ToString());
if (cadastrou)
{
return(Json(new { Sucesso = true, Mensagem = "Jogador cadastrado com sucesso!" }));
}
return(Json(new { Sucesso = false, Mensagem = "Ocorreu um erro ao cadastrar o jogador" }));
}
return(Json(new { Sucesso = false, Mensagem = "Ops! Campos não preenchidos corretamente" }));
}
catch (Exception e)
{
return(Json(new { Sucesso = false, Mensagem = e.Message }));
}
}
public JogadorWrapperViewModel(JogadorModel jogadorModel)
{
_jogadorModel = jogadorModel;
Genero = new GeneroWrapperViewModel(_jogadorModel.Genero);
Tee = new TeeWrapperViewModel(_jogadorModel.Tee);
Handicap = new HandicapWrapperViewModel(_jogadorModel.Handicap);
Pontuacoes = new ObservableCollection <PontuacaoWrapperViewModel>(_jogadorModel.Pontuacoes.Select(p => new PontuacaoWrapperViewModel(p)));
}
public IActionResult Delete(int?id, [Bind] Jogador jogador)
{
using (JogadorModel model = new JogadorModel())
{
model.Delete(id);
return(RedirectToAction("Index"));
}
}
public IActionResult Update(int?id)
{
using (JogadorModel model = new JogadorModel())
{
Jogador jogador = model.GetJogador(id);
return(View(jogador));
}
}
// GET: Jogador
public IActionResult Index()
{
using (JogadorModel model = new JogadorModel())
{
List <Jogador> lista = model.Read();
return(View(lista));
}
}
public ForcaRetornoJogadaModel Realizar(ForcaModel _Forca, string Jogador = "", string Mensagem = "")
{
if (_Forca == null)
{
_RetornoJogadaModel.Mensagem = $"Nenhum jogo iniciado, use !iniciarjogo para criar um novo.";
return(_RetornoJogadaModel);
}
_RetornoJogadaModel.Jogo = _Forca;
//Existe jogador?
if (!_Forca.Participantes.Any(p => p.Nome.ToLower() == Jogador.ToLower()))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} use o comando !participar para jogar.";
return(_RetornoJogadaModel);
}
//Jogador não possui tentativas?
if (_Forca.Participantes.Any(p => p.Nome.ToLower() == Jogador.ToLower() && p.Tentativas == 0))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} suas tentativas acabaram, aguarde o próximo jogo.";
return(_RetornoJogadaModel);
}
//Valida formato de resposta
var chute = Mensagem.Split(' ');
if (!chute.Length.Equals(2))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} para chutar use o comando !chute <palavra>!";
return(_RetornoJogadaModel);
}
//Valida se chute corresponde a palavra
var resposta = chute[1].ToLower();
var isChuteCorreto = _Forca.Palavra.ToLower().Equals(resposta);
if (!isChuteCorreto)
{
//_RetornoJogadaModel.Mensagem = $"@{Jogador} seu chute está errado!";
return(_RetornoJogadaModel);
}
_RetornoJogadaModel.Mensagem = $"@{Jogador} chutou corretamente! A palavra é {_Forca.Palavra.ToUpper()}";
HubSingleton.Instance.ForcaHubContext.Clients.All.encerradocomvencedor(_RetornoJogadaModel.Mensagem);
_RetornoJogadaModel.Jogo = null;
var moedasGanhas = _Forca.Palavra.Length * 10;
var jogador = new JogadorModel {
Nome = Jogador, Moedas = moedasGanhas
};
_RankingRepositorio.AtualizarRanking(jogador);
return(_RetornoJogadaModel);
}
public void Atualizar_Jogador()
{
var groupManagerMock = new Mock <IGroupManager>();
var connectionId = Guid.NewGuid().ToString();
var groupsJoined = new List <string>();
groupManagerMock.Setup(g => g.Add(connectionId, It.IsAny <string>()))
.Returns(Task.FromResult <object>(null))
.Callback <string, string>((cid, groupToJoin) =>
groupsJoined.Add(groupToJoin));
var hub = new MyHub(context);
var mockClients = new Mock <IHubCallerConnectionContext <dynamic> >();
hub.Clients = mockClients.Object;
hub.Context = new HubCallerContext(request: null,
connectionId: connectionId);
hub.Groups = groupManagerMock.Object;
dynamic all = new ExpandoObject();
bool sendCalled1 = false;
bool sendCalled2 = false;
bool sendCalled3 = false;
string resposta1 = null;
string resposta2 = null;
string resposta3 = null;
string login = "******";
string salaHashCriada = null;
all.criarSala = new Action <string>((salaHash) => {
salaHashCriada = salaHash;
});
mockClients.Setup(m => m.Caller).Returns((ExpandoObject)all);
hub.CriarSala();
all.infoJogador = new Action <string>((resposta) => {
});
hub.InserirUsuario(login, salaHashCriada);
mockClients.Setup(m => m.Caller).Returns((ExpandoObject)all);
all.infoJogador = new Action <string>((resposta) => {
sendCalled1 = true;
resposta1 = resposta;
});
all.ativaSom = new Action <string>((resposta) => {
sendCalled2 = true;
resposta2 = resposta;
});
all.alterarTabuleiro = new Action <string>((resposta) => {
sendCalled3 = true;
resposta3 = resposta;
});
mockClients.Setup(m => m.Client(connectionId)).Returns((ExpandoObject)all);
JogadorModel jogador = new JogadorModel(connectionId, "BRANCAS");
hub.AtualizarJogadores(jogador);
Assert.IsTrue(sendCalled1);
Assert.IsTrue(sendCalled2);
Assert.IsTrue(sendCalled3);
}
public IActionResult Delete(int id)
{
Jogador jogador = new Jogador();
using (JogadorModel model = new JogadorModel())
{
jogador = model.GetJogador(id);
return(View(jogador));
}
}
public void DefinirModel(JogadorModel jogadorModel)
{
_jogadorModel = jogadorModel;
Nome = jogadorModel.Nome;
Email = jogadorModel.Email;
Foto = jogadorModel.Foto;
Genero = new GeneroWrapperViewModel(_jogadorModel.Genero);
Tee = new TeeWrapperViewModel(_jogadorModel.Tee);
Handicap = new HandicapWrapperViewModel(_jogadorModel.Handicap);
Pontuacoes = new ObservableCollection <PontuacaoWrapperViewModel>(_jogadorModel.Pontuacoes.Select(p => new PontuacaoWrapperViewModel(p)));
}
public HttpResponseMessage SalvarJogador(JogadorModel model)
{
try
{
_jogadorService.SalvarJogador(new Jogador(model.Nome, model.CPF));
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public void PossivelMapearModelos()
{
var model = new JogadorModel
{
Id = Guid.NewGuid(),
Nome = "Bento",
Cidade = "São Paulo"
};
var entity = Mapper.Map <JogadorEntity>(model);
Assert.NotNull(entity);
Assert.Equal(entity.Nome, model.Nome);
}
public IActionResult Create(IFormCollection form)
{
Jogador jogador = new Jogador();
jogador.Nome = form["Nome"];
jogador.Idade = Convert.ToInt32(form["Idade"]);
jogador.NumeroCamisa = Convert.ToInt32(form["NumeroCamisa"]);
jogador.GolsMarcados = Convert.ToInt32(form["GolsMarcados"]);
using (JogadorModel model = new JogadorModel())
{
model.Create(jogador);
return(RedirectToAction("Index"));
}
}
public void ResetJogador()
{
if (!Bloqueado)
{
Nome = String.Empty;
Email = String.Empty;
Foto = null;
Genero = null;
Tee = null;
Handicap = null;
Pontuacoes = null;
_jogadorModel = null;
}
}
public override async Task OnConnected(WebSocket socketInserido)
{
await base.OnConnected(socketInserido);
var socketId = connections.PegarIdPorSocket(socketInserido);
//await SendMessageToAll($"******* {nomeDoUsuario} entrou no chat. ******");
Jogador jogadorEncontrado = Jogador.ProcurarJogadorConectadoPorWebSocket(socketInserido);
JogadorModel jogadorModelo = new JogadorModel(jogadorEncontrado.idJogador, jogadorEncontrado.sessaoAtual.idSessao, jogadorEncontrado.nomeJogador, jogadorEncontrado.coordJogadorX, jogadorEncontrado.coordJogadorY, jogadorEncontrado.areaAtual.posicaoMatriz.x, jogadorEncontrado.areaAtual.posicaoMatriz.y, Nucleo.ChecarQtdJogadoresSessao(jogadorEncontrado.sessaoAtual));
var message1 = JsonConvert.SerializeObject(JogadorModel.ConverterJogadoresSessaoModel(jogadorEncontrado));
var message2 = JsonConvert.SerializeObject(CelulaModel.ConverterParaCelulaModel(jogadorEncontrado.areaAtual.dungeonInserida));
var message3 = JsonConvert.SerializeObject(JogadorModel.ModelJogadorDaSessao(jogadorEncontrado));
//
string nomeDoUsuario = jogadorEncontrado.nomeJogador;
await SendMessageToSession(message1, jogadorEncontrado.sessaoAtual);
await SendMessage(jogadorEncontrado.socketDoJogador, message2);
await SendMessage(jogadorEncontrado.socketDoJogador, message3);
}
public override async Task Receive(WebSocket socket, WebSocketReceiveResult result, byte[] buffer)
{
Console.WriteLine("Entrou no Receive");
Jogador jogadorEncontrado = Jogador.ProcurarJogadorConectadoPorWebSocket(socket);
Nucleo.ChecarInput(Encoding.UTF8.GetString(buffer, 0, result.Count), jogadorEncontrado);
Console.WriteLine("Passou pelo Checar Input");
JogadorModel jogadorModelo = new JogadorModel(jogadorEncontrado.idJogador, jogadorEncontrado.sessaoAtual.idSessao, jogadorEncontrado.nomeJogador, jogadorEncontrado.coordJogadorX, jogadorEncontrado.coordJogadorX, jogadorEncontrado.areaAtual.posicaoMatriz.x, jogadorEncontrado.areaAtual.posicaoMatriz.y, Nucleo.ChecarQtdJogadoresSessao(jogadorEncontrado.sessaoAtual));
var message1 = JsonConvert.SerializeObject(JogadorModel.ConverterJogadoresSessaoModel(jogadorEncontrado));
var message2 = JsonConvert.SerializeObject(CelulaModel.ConverterParaCelulaModel(jogadorEncontrado.areaAtual.dungeonInserida));
var message3 = JsonConvert.SerializeObject(JogadorModel.ModelJogadorDaSessao(jogadorEncontrado));
//
string nomeDoUsuario = jogadorEncontrado.nomeJogador;
await SendMessageToSession(message1, jogadorEncontrado.sessaoAtual);
await SendMessage(jogadorEncontrado.socketDoJogador, message2);
await SendMessage(jogadorEncontrado.socketDoJogador, message3);
Console.WriteLine("Fim do Receive.");
}
public HttpResponseMessage ObterJogador(int id)
{
try
{
var jogador = _jogadorService.ObterJogadorPorId(id);
if (jogador == null)
{
throw new Exception("Jogador não encontrado ");
}
var model = new JogadorModel();
model.Nome = jogador.Nome;
model.CPF = jogador.CPF;
return(Request.CreateResponse(HttpStatusCode.OK, model));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public ForcaRetornoJogadaModel Realizar(ForcaModel _Forca, string Jogador = "", string Mensagem = "")
{
if (_Forca == null)
{
_RetornoJogadaModel.Mensagem = $"Nenhum jogo iniciado, use !iniciarjogo para criar um novo.";
return(_RetornoJogadaModel);
}
_RetornoJogadaModel.Jogo = _Forca;
var returnfeedback = string.Empty;
var textoJogadores = _Forca.Participantes.Count > 1 ? "jogadores" : "jogador";
var jogadorJaParticipando = _Forca
.Participantes
.Any(p => p.Nome.ToLower() == Jogador.ToLower());
//Se o jogador já entrou no jogo, avisar ele.
if (jogadorJaParticipando)
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} você já entrou no jogo. Use !resposta <letra>, !chute <palavra> para jogar. Até o momento temos {_Forca.Participantes.Count} {textoJogadores}.";
return(_RetornoJogadaModel);
}
var novoJogador = new JogadorModel
{
Nome = Jogador
};
_Forca.Participantes.Add(novoJogador);
HubSingleton.Instance.ForcaHubContext.Clients.All.adicionajogador(novoJogador);
_RetornoJogadaModel.Mensagem = $"@{Jogador} você entrou no jogo. Use !resposta <letra>, !chute <palavra> para jogar. Até o momento temos {_Forca.Participantes.Count} {textoJogadores}.";
_RetornoJogadaModel.Jogo = _Forca;
return(_RetornoJogadaModel);
}
public override void OnNotificacao(string evento_caminho, Object alvo, params object[] dados)
{
switch (evento_caminho)
{
case Notificacao.Fase.Inicio:
model = GetComponent <JogadorModel>();
view = GetComponent <JogadorView>();
aux = false;
view.Comecar(model.pontosParaPowerUp1, model.pontosParaPowerUp2, model.pontosParaPowerUp3);
break;
case Notificacao.Jogador.PerdeuVida:
view.Dano(20);
model.Vidas -= (int)dados[0];
if (model.Vidas <= 0)
{
model.Vidas = 0;
app.Notificar(Notificacao.Fase.Fim, this);
}
app.Notificar(Notificacao.Atualizar.AtualizarUI, this);
break;
case Notificacao.Jogador.GanhouPontos:
model.Pontos += (int)dados[0];
model.PtsPowerUp += (int)dados[1];
switch (model.PtsPowerUp)
{
case int n when n >= 100:
model.PtsPowerUp = 100;
break;
}
view.GanhouPontos(model.PtsPowerUp);
app.Notificar(Notificacao.Atualizar.AtualizarUI, this);
break;
case Notificacao.Jogador.UsouPowerUp:
switch (model.PtsPowerUp)
{
case int n when n >= model.pontosParaPowerUp1 && n < model.pontosParaPowerUp2:
for (int i = 0; i < TesteDados.Toupeiras.Length; i++)
{
if (TesteDados.Toupeiras[i].GetComponent <ToupeiraModel>().Vida > 0)
{
aux = true;
}
}
if (aux)
{
app.Notificar(Notificacao.Jogador.MatarUmaToupeiraAleatoria, this);
}
else
{
aux = false;
}
break;
case int n when n >= model.pontosParaPowerUp2 && n < model.pontosParaPowerUp3:
for (int i = 0; i < TesteDados.Toupeiras.Length; i++)
{
if (TesteDados.Toupeiras[i].GetComponent <ToupeiraModel>().Vida > 0)
{
aux = true;
}
}
if (aux)
{
app.Notificar(Notificacao.Jogador.MatarTodasToupeiras, this);
}
else
{
aux = false;
}
break;
case int n when n >= model.pontosParaPowerUp3:
AudioSource audioSource = GetComponent <AudioSource>();
audioSource.clip = model.somPowerUp3;
audioSource.Play();
TesteDados.PowerUp3 = true;
app.Notificar(Notificacao.Fase.Parar, this);
break;
}
model.PtsPowerUp = 0;
app.Notificar(Notificacao.Atualizar.AtualizarUI, this);
break;
case Notificacao.Fase.Fim:
app.DebugJogador("FaseFim");
TesteDados.PowerUp3 = false;
TesteDados.JogoPausado = false;
TesteDados.PontosUltimaFase = model.Pontos;
break;
}
}
void Start()
{
this.playerModel = this.GetComponent <JogadorModel>();
}
public void AtualizarJogadores(JogadorModel jogador)
{
Clients.Client(jogador.IdConexao).infoJogador(jogador.Funcao);
Clients.Client(jogador.IdConexao).ativaSom("troca usuario");
Clients.Client(jogador.IdConexao).alterarTabuleiro("Você é um jogador!");
}
public ForcaRetornoJogadaModel Realizar(ForcaModel _Forca, string Jogador = null, string Mensagem = "")
{
if (_Forca == null)
{
_RetornoJogadaModel.Mensagem = $"Nenhum jogo iniciado, use !iniciarjogo para criar um novo.";
return(_RetornoJogadaModel);
}
_RetornoJogadaModel.Jogo = _Forca;
//Existe jogador?
if (!_Forca.Participantes.Any(p => p.Nome.ToLower() == Jogador.ToLower()))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} use o comando !participar para jogar.";
return(_RetornoJogadaModel);
}
//Jogador não possui tentativas?
if (_Forca.Participantes.Any(p => p.Nome.ToLower() == Jogador.ToLower() && p.Tentativas == 0))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} suas tentativas acabaram, aguarde o próximo jogo.";
return(_RetornoJogadaModel);
}
//Jogador mandou mensagem?
if (string.IsNullOrEmpty(Mensagem))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} não tenho bola de cristal, jogue usando !resposta <letra> ou chute uma palavra usando !chute <palavra>.";
return(_RetornoJogadaModel);
}
//Tentativa está correta?
var mensagemArray = Mensagem.ToLower().Split(' ');
if (!mensagemArray.Length.Equals(2))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} jogue usando !resposta <letra> ou chute uma palavra usando !chute <palavra>.";
return(_RetornoJogadaModel);
}
//Tentativa está correta?
var resposta = mensagemArray.Last();
if (!resposta.Length.Equals(1))
{
_RetornoJogadaModel.Mensagem = $"@{_RetornoJogadaModel.Mensagem} jogue usando !resposta <letra> ou chute uma palavra usando !chute <palavra>.";
return(_RetornoJogadaModel);
}
var sbResposta = new StringBuilder(_Forca.Segredo);
var letras = _Forca.Palavra.Select(c => c).ToList();
var icExisteOcorrenciaDaLetra = false;
for (int index = 0; index < letras.Count; index++)
{
var letra = letras[index].ToString();
if (!resposta.Equals(letra))
{
continue;
}
sbResposta[index] = resposta.ToCharArray()[0];
icExisteOcorrenciaDaLetra = true;
}
_Forca.Segredo = sbResposta.ToString().ToUpper();
if (icExisteOcorrenciaDaLetra)
{
//_RetornoJogadaModel.Mensagem = $"@{Jogador} você acertou uma letra da palavra: {_Forca.Segredo}.";
HubSingleton.Instance.ForcaHubContext.Clients.All.respostacerta(_Forca.Segredo);
if (!_Forca.Segredo.Contains("#"))
{
_RetornoJogadaModel.Mensagem = $"@{Jogador} venceu! A palavra é {_Forca.Palavra}!";
HubSingleton.Instance.ForcaHubContext.Clients.All.encerradocomvencedor(_RetornoJogadaModel.Mensagem);
_RetornoJogadaModel.Jogo = null;
var moedasGanhas = _Forca.Palavra.Length * 10;
var jogador = new JogadorModel {
Nome = Jogador, Moedas = moedasGanhas
};
_RankingRepositorio.AtualizarRanking(jogador);
return(_RetornoJogadaModel);
}
_RetornoJogadaModel.Jogo = _Forca;
return(_RetornoJogadaModel);
}
if (!icExisteOcorrenciaDaLetra)
{
_Forca.Participantes.SingleOrDefault(p => p.Nome.ToLower() == Jogador.ToLower()).Tentativas -= 1;
var jogadorParticipante = _Forca.Participantes.SingleOrDefault(p => p.Nome.ToLower() == Jogador.ToLower());
//_RetornoJogadaModel.Mensagem = $"@{Jogador} você não acertou, segue a palavra: {_Forca.Segredo}! Tentativas restantes: {jogadorParticipante.Tentativas}.";
_RetornoJogadaModel.Jogo = _Forca;
HubSingleton.Instance.ForcaHubContext.Clients.All.respostaErrada(jogadorParticipante);
if (!_Forca.Participantes.Any(p => p.Tentativas > 0))
{
_RetornoJogadaModel.Mensagem = $"Ninguém acertou, a palavra era {_Forca.Palavra}!";
HubSingleton.Instance.ForcaHubContext.Clients.All.encerradosemvencedor(_RetornoJogadaModel.Mensagem);
_RetornoJogadaModel.Jogo = null;
return(_RetornoJogadaModel);
}
return(_RetornoJogadaModel);
}
return(_RetornoJogadaModel);
}
