示例#1
0
        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);
        }
示例#2
0
 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);
 }
示例#3
0
 /// <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());
     }
 }
示例#4
0
 // 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);
 }
示例#5
0
 // 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>();
 }
示例#6
0
        //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;
            }
        }
示例#7
0
 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("-------------------");
 }
示例#8
0
 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;
 }
示例#9
0
 // 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>();
 }
示例#10
0
 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>();
 }
示例#11
0
 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);
         }
     });
 }
示例#12
0
        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);
        }
示例#13
0
        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.");
        }
示例#14
0
        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);
        }
示例#15
0
        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);
        }
示例#18
0
        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)
 {
 }
示例#20
0
 // Start is called before the first frame update
 void Start()
 {
     playerM   = FindObjectOfType <PlayerMove>();
     healthBar = FindObjectOfType <HealthBar>();
     nucleo    = FindObjectOfType <Nucleo>();
 }
示例#21
0
 void Start()
 {
     nucleoScript = FindObjectOfType <Nucleo>().GetComponent <Nucleo>();
     imagenVerde  = GetComponent <Image>();
     maxHealth    = nucleoScript.vidaNucleo;
 }
示例#22
0
        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;
            }
        }
示例#23
0
        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);
        }