public override void Update(GameTime gameTime)
{
KeyboardState tecla = Keyboard.GetState();
if (tecla.IsKeyUp(Keys.Escape))
{
teclaEstavaPressionada = false;
}
else if (tecla.IsKeyDown(Keys.Escape) && !teclaEstavaPressionada)
{
Nucleo nucleo = (Nucleo)Game.Services.GetService(typeof(Nucleo));
nucleo.telaNova = TelasJogoEnum.TelaPause;
}
personagemJogador.Atualiza();
inimigo.Direcao = new Vector2(1.0f, 0.0f);
inimigo.Atualiza();
foreach (Tiro tiro in personagemJogador.listaTirosNoJogo)
{
if (inimigo.areaColidir().Intersects(tiro.RetanguloNaTela()))
{
tiro.StatusTiro = false;
inimigo.Vivo = false;
inimigo.Velocidade = 200000.0f;
}
}
//vai filhao \o/
base.Update(gameTime);
}
public static void imprimirEjecucionLenta(int reloj, Nucleo n0, Nucleo n1)
{
Console.WriteLine("Reloj: " + reloj.ToString());
Console.WriteLine("Hilillos en ejecucion:");
Console.WriteLine("\t - Nucleo 0:" + n0.IDHililloEjecutandose);
Console.WriteLine("\t - Nucleo 1:" + n1.IDHililloEjecutandose);
}
/// <summary>
/// Método que valida al usuario
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void LoginTvCableAuthenticate(object sender, AuthenticateEventArgs e)
{
try
{//Se captura las variables del texto de inicio de sesión
string username = LoginTvcable.UserName;
string pwd = LoginTvcable.Password;
string rol = SimulacionWebUser(username);
var userIedentificatio = new Nucleo();
var Userfuncionalidad = userIedentificatio.GetFuncionalidadPorUsuario(username, rol);
if (Userfuncionalidad.ResponseDescription == "Ok")
{
Session["UserAutentication"] = Userfuncionalidad;
FormsAuthentication.RedirectFromLoginPage(LoginTvcable.UserName, LoginTvcable.RememberMeSet);
Base.WriteLog(Base.ErrorTypeEnum.Start, 1, "Ha iniciado Sesión el usuario :" + username + ", con rol :" + rol);
}
else
{
Session["UserAuthentication"] = null;
}
}
catch (Exception ex)
{
Base.WriteLog(Base.ErrorTypeEnum.Error, 2, "Excepción al verificar el usuario , mensaje" + ex.Message + ". Excepción; " + ex.ToString());
}
}
// Start is called before the first frame update
void Start()
{
rb = GetComponent <Rigidbody>();
target = GameObject.FindGameObjectWithTag("NucleoTarget");
nucleo = FindObjectOfType <Nucleo>();
moveDirection = (target.transform.position - transform.position).normalized * moveSpeed;
rb.velocity = new Vector3(moveDirection.x, moveDirection.y, moveDirection.z);
Destroy(gameObject, 3f);
}
// Start is called before the first frame update
void Start()
{
nav = GetComponent <NavMeshAgent>();
nucleo = GameObject.FindGameObjectWithTag("Nucleo").GetComponent <Nucleo>();
nucleoT = GameObject.FindGameObjectWithTag("Nucleo").transform;
anim = GetComponent <Animator>();
colliderS = GetComponent <SphereCollider>();
rb = GetComponent <Rigidbody>();
}
//TODO: AGREGAR LW Y SW
/// <summary>
/// Metodo que procesa una instruccion en el IR del nucleo que entra como parametro
/// </summary>
/// <param name="nucleo">Nucleo que va a ejecutar la instruccion</param>
public static void procesarInstruccion(ref Nucleo nucleo)
{
nucleo.PC += Constantes.Byte;
int co = nucleo.RegistroInstruccion.CO;
switch (co)
{
case Codigos.CODIGO_DADDI:
nucleo.Registros[nucleo.RegistroInstruccion.Rf2_Rd] = nucleo.Registros[nucleo.RegistroInstruccion.Rf1] + nucleo.RegistroInstruccion.Rd_inm;
break;
case Codigos.CODIGO_DADD:
nucleo.Registros[nucleo.RegistroInstruccion.Rd_inm] = nucleo.Registros[nucleo.RegistroInstruccion.Rf1] + nucleo.Registros[nucleo.RegistroInstruccion.Rf2_Rd];
break;
case Codigos.CODIGO_DSUB:
nucleo.Registros[nucleo.RegistroInstruccion.Rd_inm] = nucleo.Registros[nucleo.RegistroInstruccion.Rf1] - nucleo.Registros[nucleo.RegistroInstruccion.Rf2_Rd];
break;
case Codigos.CODIGO_DMUL:
nucleo.Registros[nucleo.RegistroInstruccion.Rd_inm] = nucleo.Registros[nucleo.RegistroInstruccion.Rf1] * nucleo.Registros[nucleo.RegistroInstruccion.Rf2_Rd];
break;
case Codigos.CODIGO_DDIV:
nucleo.Registros[nucleo.RegistroInstruccion.Rd_inm] = nucleo.Registros[nucleo.RegistroInstruccion.Rf1] / nucleo.Registros[nucleo.RegistroInstruccion.Rf2_Rd];
break;
case Codigos.CODIGO_BEQZ:
if (nucleo.Registros[nucleo.RegistroInstruccion.Rf1] == 0)
{
nucleo.PC += Constantes.Byte * nucleo.RegistroInstruccion.Rd_inm;
}
break;
case Codigos.CODIGO_BNEZ:
if (nucleo.Registros[nucleo.RegistroInstruccion.Rf1] != 0)
{
nucleo.PC += Constantes.Byte * nucleo.RegistroInstruccion.Rd_inm;
}
break;
case Codigos.CODIGO_JAL:
nucleo.PC += nucleo.RegistroInstruccion.Rd_inm;
break;
case Codigos.CODIGO_JR:
nucleo.PC += nucleo.Registros[nucleo.RegistroInstruccion.Rf1];
break;
case Codigos.CODIGO_FIN:
//Invalido el nucleo.PC
//TODO pop
nucleo.PC = -1;
break;
}
}
public static void impresionFinal(Memoria memoria, Nucleo n0, Nucleo n1, Contexto contexto)
{
Console.WriteLine("-------------------");
memoria.impresionFinal();
Console.WriteLine("Cache de Datos Nucleo 0:");
n0.CacheDatos.impresionFinal();
Console.WriteLine("Cache de Datos Nucleo 1:");
n1.CacheDatos.impresionFinal();
contexto.impresionFinal();
Console.WriteLine("-------------------");
}
void Start()
{
player.enabled = true;
Invoke("InvocarMinion", spawnTime);
InvokeRepeating("speedSpawning", 0f, 10f);
nucleoScript = FindObjectOfType <Nucleo>().GetComponent <Nucleo>();
scriptGameOver = FindObjectOfType <PrenderYApagarGameOver>().GetComponent <PrenderYApagarGameOver>();
//player = FindObjectOfType<Player>().GetComponent<Player>();
scriptGameOver.enabled = false;
canvasGameOver.enabled = false;
canvasWin.enabled = false;
}
// Start is called before the first frame update
void Start()
{
miniS = FindObjectOfType <MiniSpider>();
level2Start = FindObjectOfType <DetectorA2>();
nucleo = FindObjectOfType <Nucleo>();
RespawnPos = puntRespawn.transform.position;
playerMove = FindObjectOfType <PlayerMove>();
healthBar = FindObjectOfType <HealthBar>();
actOleadas = FindObjectOfType <ActivarOleadas>();
spawnEnemy = FindObjectOfType <SpawnEnemigos>();
timer = FindObjectOfType <TimerNucleo>();
}
void Start()
{
agent = GetComponent <NavMeshAgent>();
nucleo = FindObjectOfType <Nucleo>();
anim = GetComponentInChildren <Animator>();
agent.speed = velocidad;
//velocidad = agent.speed;
enemigoScript = GetComponent <Enemigo>();
sourceAudio = FindObjectOfType <AudioSource>().GetComponent <AudioSource>();
soundScript = FindObjectOfType <SoundManager>().GetComponent <SoundManager>();
nucleoScript = FindObjectOfType <Nucleo>().GetComponent <Nucleo>();
}
public static void Main(string[] args)
{
//CreateHostBuilder(args).Build().Run();
CreateHostBuilder(args).StartAsync();
Task.Run(async() =>
{
while (true)
{
await Nucleo.GameLoop();
await Task.Delay(10);
}
});
}
public override void Update(GameTime gameTime)
{
KeyboardState tecla = Keyboard.GetState();
if (tecla.IsKeyUp(Keys.Escape))
{
teclaEstavaPressionada = false;
}
else if (tecla.IsKeyDown(Keys.Escape) && !teclaEstavaPressionada)
{
Nucleo nucleo = (Nucleo)Game.Services.GetService(typeof(Nucleo));
nucleo.telaNova = TelasJogoEnum.TelaJogo;
}
base.Update(gameTime);
}
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 override void Update(GameTime gameTime)
{
KeyboardState tecla = Keyboard.GetState();
MouseState mouse = Mouse.GetState();
Nucleo nucleo = (Nucleo)Game.Services.GetService(typeof(Nucleo));
//é flag mouseEstava pressionado é necessária paracaso o usuario tenha clicado em um botão de uma outra tela e avançou para a tela atual, então setamos ela como false, e só qdo o usuário larga o clique
// deixamos a como false, e somente qdo tiver como false vai ser possível clicar nos botões novos
if (mouse.LeftButton == ButtonState.Released)
{
mouseEstavaPressionado = false;
}
if (btnVoltar.VerificaColisaoMouse(new Point(mouse.X, mouse.Y)) && !mouseEstavaPressionado)
{
btnVoltar.checado = true;
if (mouse.LeftButton == ButtonState.Pressed)
{
nucleo.telaNova = TelasJogoEnum.TelaInicial;
}
}
else
{
btnVoltar.checado = false;
}
if (btnAvancar.VerificaColisaoMouse(new Point(mouse.X, mouse.Y)) && !mouseEstavaPressionado)
{
btnAvancar.checado = true;
if (mouse.LeftButton == ButtonState.Pressed)
{
nucleo.telaNova = TelasJogoEnum.TelaJogo;
}
}
else
{
btnAvancar.checado = false;
}
base.Update(gameTime);
}
public override void Update(GameTime gameTime)
{
Nucleo nucleo = (Nucleo)Game.Services.GetService(typeof(Nucleo));
MouseState mouse = Mouse.GetState();
if (mouse.LeftButton == ButtonState.Released)
{
mouseEstavaPressionado = false;
}
if (btnIniciarEnredo.VerificaColisaoMouse(new Point(mouse.X, mouse.Y))) //dependendo de onde o usuario clicar, iremos ativar uma nova tela
{
btnIniciarEnredo.checado = true;
if (mouse.LeftButton == ButtonState.Pressed && mouseEstavaPressionado == false)
{
nucleo.telaNova = TelasJogoEnum.TelaEnredo;
}
}
else
{
btnIniciarEnredo.checado = false;
}
base.Update(gameTime);
}
public static List <JogadorModel> ModelJogadorDaSessao(Jogador jogadorInserido)
{
List <JogadorModel> listaJogadores = new List <JogadorModel>();
JogadorModel jogadorEnviado = new JogadorModel(jogadorInserido.idJogador, jogadorInserido.sessaoAtual.idSessao, jogadorInserido.nomeJogador, jogadorInserido.coordJogadorX, jogadorInserido.coordJogadorY, jogadorInserido.areaAtual.posicaoMatriz.x, jogadorInserido.areaAtual.posicaoMatriz.y, Nucleo.ChecarQtdJogadoresSessao(jogadorInserido.sessaoAtual));
jogadorEnviado.tipoMensagem = "jogadorDoClient";
listaJogadores.Add(jogadorEnviado);
return(listaJogadores);
}
public static List <JogadorModel> ConverterJogadoresSessaoModel(Jogador jogadorInserido)
{
List <JogadorModel> listaJogadores = new List <JogadorModel>();
listaJogadores.Add(new JogadorModel(jogadorInserido.idJogador, jogadorInserido.sessaoAtual.idSessao, jogadorInserido.nomeJogador, jogadorInserido.coordJogadorX, jogadorInserido.coordJogadorY, jogadorInserido.areaAtual.posicaoMatriz.x, jogadorInserido.areaAtual.posicaoMatriz.y, Nucleo.ChecarQtdJogadoresSessao(jogadorInserido.sessaoAtual)));
foreach (Jogador j in jogadorInserido.sessaoAtual.jogadoresNaSessao)
{
if (j != null && j != jogadorInserido)
{
listaJogadores.Add(new JogadorModel(j.idJogador, j.sessaoAtual.idSessao, j.nomeJogador, j.coordJogadorX, j.coordJogadorY, j.areaAtual.posicaoMatriz.x, j.areaAtual.posicaoMatriz.y, Nucleo.ChecarQtdJogadoresSessao(j.sessaoAtual)));
}
}
return(listaJogadores);
}
public void correr()
{
string [] hilosP0 = solicitarHilos(0);
string[] hilosP1 = solicitarHilos(1);
quantum = solicitarQuantum();
cicloActual = 0;
//Inicializo estructuras
inicializar();
//Lleno memoria de instrucciones
guardarInstrucciones(contextoP0, memInstruccionesP0, hilosP0, 0);
guardarInstrucciones(contextoP1, memInstruccionesP1, hilosP1, 1);
//Pregunto por modo de ejecucion
Console.WriteLine("\n");
Console.WriteLine("Elija su modo de ejecución: Digite 1 para lento o 2 para rápido");
int modo = Int32.Parse(Console.ReadLine());
barrera = new Barrier(4); //Inicializacion de la barrera
//Llamado de los nucleos
contextoP0[0][34] = 0;
Nucleo nucleo0 = new Nucleo(0, 0, contextoP0[0], 0, modo);
Thread nucleo0Thread = new Thread(new ThreadStart(nucleo0.run));
nucleo0Thread.Name = "P0 Nucleo 0";
nucleo0Thread.Start();
contextoP0[1][34] = 0;
Nucleo nucleo1 = new Nucleo(0, 1, contextoP0[1], 1, modo);
Thread nucleo1Thread = new Thread(new ThreadStart(nucleo1.run));
nucleo1Thread.Name = "P0 Nucleo 1";
nucleo1Thread.Start();
contextoP1[0][34] = 0;
Nucleo nucleo2 = new Nucleo(1, 2, contextoP1[0], 0, modo);
Thread nucleo2Thread = new Thread(new ThreadStart(nucleo2.run));
nucleo2Thread.Name = "P1 Nucleo 2";
nucleo2Thread.Start();
//Sincronizador de ciclos
bool flag = true;
while (barrera.ParticipantCount > 1)
{
if (reloj % 100 == 0 && modo == 1) //Se verifica si es el ciclo oportuno y si está en el modo correcto
{
lock (ConsoleWriterLock)
{
Console.Write("\n");
Console.WriteLine("Digite enter para continuar");
Console.ReadKey();
}
}
//Interlocked.Increment(ref reloj);
barrera.SignalAndWait();
cicloActual++;
reloj++;
}
barrera.SignalAndWait(); // Barrera de finalización
//finalizar
finalizar(hilosP0, hilosP1);
Console.Read();
if (modo == 1)
{
Console.Read();
}
}
public void procesarLW(ref Nucleo nucleo, ref Bus bus)
{
}
// Start is called before the first frame update
void Start()
{
playerM = FindObjectOfType <PlayerMove>();
healthBar = FindObjectOfType <HealthBar>();
nucleo = FindObjectOfType <Nucleo>();
}
void Start()
{
nucleoScript = FindObjectOfType <Nucleo>().GetComponent <Nucleo>();
imagenVerde = GetComponent <Image>();
maxHealth = nucleoScript.vidaNucleo;
}
public void procesarLW(ref Nucleo nucleo, ref Nucleo otro, ref Bus bus, ref Memoria memoria)
{
IR insActual = nucleo.RegistroInstruccion;
int posMemoria = insActual.Rf1 + insActual.Rd_inm;
int bloqueMemoria = posMemoria / 4; //Poner 16 en constante
int palabra = (posMemoria % 4) / Constantes.Numero_Bloques_Cache;
int posicionEnCache = bloqueMemoria % Constantes.Numero_Bloques_Cache;
while (nucleo.CacheDatos.Bloques[posicionEnCache].Estado_Posicion == Constantes.Estado_PosicionCache_Bloqueado)
{
//Ticks the reloj
}
//Verificar etiqueta
//En caso de que SI este el bloque
if (nucleo.CacheDatos.Bloques[posicionEnCache].Etiqueta == bloqueMemoria)
{
string estadoActualBloque = nucleo.CacheDatos.Bloques[posicionEnCache].Estado;
//Hit
if (estadoActualBloque != Constantes.Estado_Invalido)
{
nucleo.Registros[insActual.Rf2_Rd] = nucleo.CacheDatos.Bloques[posicionEnCache].Bloque.Palabras[palabra];
}
//Miss
else
{
while (bus.Bloqueado)
{
//ticks de reloj
}
bus.Bloqueado = true;
nucleo.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Bloqueado;
//Verificar si esta en la otra cache
while (otro.CacheDatos.Bloques[posicionEnCache].Estado_Posicion == Constantes.Estado_PosicionCache_Bloqueado)
{
//tics de reloj
}
otro.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Bloqueado;
if (otro.CacheDatos.Bloques[posicionEnCache].Etiqueta == bloqueMemoria)
{
//Se copia a memoria, Se pone en compartido, se copia a mi cache
memoria.Datos[bloqueMemoria] = otro.CacheDatos.Bloques[posicionEnCache].Bloque;
otro.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
nucleo.CacheDatos.Bloques[posicionEnCache].Bloque = otro.CacheDatos.Bloques[posicionEnCache].Bloque;
nucleo.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
//esperar 40 ciclos de reloj
}
else
{
nucleo.CacheDatos.Bloques[posicionEnCache].Bloque = memoria.Datos[bloqueMemoria];
nucleo.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
//Esperar 40 ticks
}
otro.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Libre;
nucleo.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Libre;
bus.Bloqueado = false;
}
}
else //En caso de que NO este el bloque
{
while (bus.Bloqueado)
{
//ticks de reloj
}
bus.Bloqueado = true;
nucleo.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Bloqueado;
//Si mi bloque en posicionCache esta en M, deberiamos escribir primero a memoria
if (nucleo.CacheDatos.Bloques[posicionEnCache].Estado == Constantes.Estado_Modificado)
{
memoria.Datos[bloqueMemoria] = nucleo.CacheDatos.Bloques[posicionEnCache].Bloque;
//Espero 40 ticks
}
//Verificar si esta en la otra cache
while (otro.CacheDatos.Bloques[posicionEnCache].Estado_Posicion == Constantes.Estado_PosicionCache_Bloqueado)
{
//tics de reloj
}
otro.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Bloqueado;
if (otro.CacheDatos.Bloques[posicionEnCache].Etiqueta == bloqueMemoria)
{
switch (otro.CacheDatos.Bloques[posicionEnCache].Estado)
{
case Constantes.Estado_Compartido:
nucleo.CacheDatos.Bloques[posicionEnCache].Bloque = otro.CacheDatos.Bloques[posicionEnCache].Bloque;
nucleo.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
break;
case Constantes.Estado_Modificado:
memoria.Datos[bloqueMemoria] = otro.CacheDatos.Bloques[posicionEnCache].Bloque;
otro.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
nucleo.CacheDatos.Bloques[posicionEnCache].Bloque = otro.CacheDatos.Bloques[posicionEnCache].Bloque;
nucleo.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
//esperar 40 ciclos de reloj
break;
case Constantes.Estado_Invalido:
nucleo.CacheDatos.Bloques[posicionEnCache].Bloque = memoria.Datos[bloqueMemoria];
nucleo.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
//esperar 40 ciclos de reloj
break;
}
}
else //Si no está en la otra caché subir de memoria
{
nucleo.CacheDatos.Bloques[posicionEnCache].Bloque = memoria.Datos[bloqueMemoria];
nucleo.CacheDatos.Bloques[posicionEnCache].Estado = Constantes.Estado_Compartido;
//Esperar 40 ticks
}
otro.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Libre;
nucleo.CacheDatos.Bloques[posicionEnCache].Estado_Posicion = Constantes.Estado_PosicionCache_Libre;
bus.Bloqueado = false;
}
}
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);
}