Ejemplo n.º 1
0
        public async Task get_Movimientos_Personajes(TcpClient cliente, string paquete)
        {
            Account cuenta = cliente.account;

            string[] separador_jugadores = paquete.Substring(3).Split('|'), informaciones;
            string   _loc6, nombre_template, tipo;

            for (int i = 0; i < separador_jugadores.Length; ++i)
            {
                _loc6 = separador_jugadores[i];
                if (_loc6.Length != 0)
                {
                    informaciones = _loc6.Substring(1).Split(';');
                    if (_loc6[0].Equals('+'))
                    {
                        Cell  celda = cuenta.game.map.GetCellFromId(short.Parse(informaciones[0]));
                        Pelea pelea = cuenta.game.fight;
                        int   id    = int.Parse(informaciones[3]);
                        nombre_template = informaciones[4];
                        tipo            = informaciones[5];
                        if (tipo.Contains(","))
                        {
                            tipo = tipo.Split(',')[0];
                        }

                        switch (int.Parse(tipo))
                        {
                        case -1:
                        case -2:
                            if (cuenta.accountState == AccountStates.FIGHTING)
                            {
                                int  vida   = int.Parse(informaciones[12]);
                                byte pa     = byte.Parse(informaciones[13]);
                                byte pm     = byte.Parse(informaciones[14]);
                                byte equipo = byte.Parse(informaciones[15]);

                                pelea.get_Agregar_Luchador(new Luchadores(id, true, vida, pa, pm, celda, vida, equipo));
                            }
                            break;

                        case -3:    //monstruos
                            string[] templates = nombre_template.Split(',');
                            string[] niveles   = informaciones[7].Split(',');

                            Monstruos monstruo = new Monstruos(id, int.Parse(templates[0]), celda, int.Parse(niveles[0]));
                            monstruo.lider_grupo = monstruo;

                            for (int m = 1; m < templates.Length; ++m)
                            {
                                monstruo.moobs_dentro_grupo.Add(new Monstruos(id, int.Parse(templates[m]), celda, int.Parse(niveles[m])));
                            }

                            cuenta.game.map.entities.TryAdd(id, monstruo);
                            break;

                        case -4:    //NPC
                            cuenta.game.map.entities.TryAdd(id, new Npcs(id, int.Parse(nombre_template), celda));
                            break;

                        case -5:
                        case -6:
                        case -7:
                        case -8:
                        case -9:
                        case -10:
                            break;

                        default:    // jugador
                            if (cuenta.accountState != AccountStates.FIGHTING)
                            {
                                if (cuenta.game.character.id != id)
                                {
                                    cuenta.game.map.entities.TryAdd(id, new Personajes(id, nombre_template, byte.Parse(informaciones[7].ToString()), celda));
                                }
                                else
                                {
                                    cuenta.game.character.celda = celda;
                                }
                            }
                            else
                            {
                                int  vida   = int.Parse(informaciones[14]);
                                byte pa     = byte.Parse(informaciones[15]);
                                byte pm     = byte.Parse(informaciones[16]);
                                byte equipo = byte.Parse(informaciones[24]);

                                pelea.get_Agregar_Luchador(new Luchadores(id, true, vida, pa, pm, celda, vida, equipo));

                                if (cuenta.game.character.id == id && cuenta.fightExtension.configuracion.posicionamiento != PosicionamientoInicioPelea.INMOVIL)
                                {
                                    await Task.Delay(300);

                                    /** la posicion es aleatoria pero el paquete GP siempre aparecera primero el team donde esta el pj **/
                                    short celda_posicion = pelea.get_Celda_Mas_Cercana_O_Lejana(cuenta.fightExtension.configuracion.posicionamiento == PosicionamientoInicioPelea.CERCA_DE_ENEMIGOS, pelea.celdas_preparacion);
                                    await Task.Delay(300);

                                    if (celda_posicion != celda.cellId)
                                    {
                                        cuenta.connexion.SendPacket("Gp" + celda_posicion, true);
                                    }
                                    else
                                    {
                                        cuenta.connexion.SendPacket("GR1");
                                    }
                                }
                                else if (cuenta.game.character.id == id)
                                {
                                    await Task.Delay(300);

                                    cuenta.connexion.SendPacket("GR1");    //boton listo
                                }
                            }
                            break;
                        }
                    }
                    else if (_loc6[0].Equals('-'))
                    {
                        if (cuenta.accountState != AccountStates.FIGHTING)
                        {
                            int id = int.Parse(_loc6.Substring(1));
                            cuenta.game.map.entities.TryRemove(id, out Entidad entidad);
                        }
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public async Task get_Iniciar_Accion(TcpClient cliente, string paquete)
        {
            string[]       separador = paquete.Substring(2).Split(';');
            int            id_accion = int.Parse(separador[1]);
            Account        cuenta    = cliente.account;
            CharacterClass personaje = cuenta.game.character;

            if (id_accion > 0)
            {
                int        id_entidad = int.Parse(separador[2]);
                byte       tipo_gkk_movimiento;
                Cell       celda;
                Luchadores luchador;
                Map        mapa  = cuenta.game.map;
                Pelea      pelea = cuenta.game.fight;

                switch (id_accion)
                {
                case 1:
                    celda = mapa.GetCellFromId(Hash.Get_Cell_From_Hash(separador[3].Substring(separador[3].Length - 2)));

                    if (!cuenta.IsFighting())
                    {
                        if (id_entidad == personaje.id && celda.cellId > 0 && personaje.celda.cellId != celda.cellId)
                        {
                            tipo_gkk_movimiento = byte.Parse(separador[0]);

                            await cuenta.game.manager.movimientos.evento_Movimiento_Finalizado(celda, tipo_gkk_movimiento, true);
                        }
                        else if (mapa.entities.TryGetValue(id_entidad, out Entidad entidad))
                        {
                            entidad.celda = celda;

                            if (GlobalConfig.show_debug_messages)
                            {
                                cuenta.logger.log_informacion("DEBUG", "Mouvement détecté d'une entité vers la cellule : " + celda.cellId);
                            }
                        }
                        mapa.GetEntitiesRefreshEvent();
                    }
                    else
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);
                        if (luchador != null)
                        {
                            luchador.celda = celda;

                            if (luchador.id == personaje.id)
                            {
                                tipo_gkk_movimiento = byte.Parse(separador[0]);

                                await Task.Delay(400 + (100 * personaje.celda.GetDistanceBetweenCells(celda)));

                                cuenta.connexion.SendPacket("GKK" + tipo_gkk_movimiento);
                            }
                        }
                    }
                    break;

                case 4:
                    separador = separador[3].Split(',');
                    celda     = mapa.GetCellFromId(short.Parse(separador[1]));

                    if (!cuenta.IsFighting() && id_entidad == personaje.id && celda.cellId > 0 && personaje.celda.cellId != celda.cellId)
                    {
                        personaje.celda = celda;
                        await Task.Delay(150);

                        cuenta.connexion.SendPacket("GKK1");
                        mapa.GetEntitiesRefreshEvent();
                        cuenta.game.manager.movimientos.movimiento_Actualizado(true);
                    }
                    break;

                case 5:
                    if (cuenta.IsFighting())
                    {
                        separador = separador[3].Split(',');
                        luchador  = pelea.get_Luchador_Por_Id(int.Parse(separador[0]));

                        if (luchador != null)
                        {
                            luchador.celda = mapa.GetCellFromId(short.Parse(separador[1]));
                        }
                    }
                    break;

                case 102:
                    if (cuenta.IsFighting())
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);
                        byte pa_utilizados = byte.Parse(separador[3].Split(',')[1].Substring(1));

                        if (luchador != null)
                        {
                            luchador.pa -= pa_utilizados;
                        }
                    }
                    break;

                case 103:
                    if (cuenta.IsFighting())
                    {
                        int id_muerto = int.Parse(separador[3]);

                        luchador = pelea.get_Luchador_Por_Id(id_muerto);
                        if (luchador != null)
                        {
                            luchador.esta_vivo = false;
                        }
                    }
                    break;

                case 129:     //movimiento en pelea con exito
                    if (cuenta.IsFighting())
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);
                        byte pm_utilizados = byte.Parse(separador[3].Split(',')[1].Substring(1));

                        if (luchador != null)
                        {
                            luchador.pm -= pm_utilizados;
                        }

                        if (luchador.id == personaje.id)
                        {
                            pelea.get_Movimiento_Exito(true);
                        }
                    }
                    break;

                case 151:    //obstaculos invisibles
                    if (cuenta.IsFighting())
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);

                        if (luchador != null && luchador.id == personaje.id)
                        {
                            cuenta.logger.log_Error("INFORMATION", "Il n'est pas possible d'effectuer cette action à cause d'un obstacle invisible.");
                            pelea.get_Hechizo_Lanzado(short.Parse(separador[3]), false);
                        }
                    }
                    break;

                case 181:     //efecto de invocacion (pelea)
                    celda = mapa.GetCellFromId(short.Parse(separador[3].Substring(1)));
                    short id_luchador = short.Parse(separador[6]);
                    short vida        = short.Parse(separador[15]);
                    byte  pa          = byte.Parse(separador[16]);
                    byte  pm          = byte.Parse(separador[17]);
                    byte  equipo      = byte.Parse(separador[25]);

                    pelea.get_Agregar_Luchador(new Luchadores(id_luchador, true, vida, pa, pm, celda, vida, equipo, id_entidad));
                    break;

                case 302:    //fallo critico
                    if (cuenta.IsFighting() && id_entidad == cuenta.game.character.id)
                    {
                        pelea.get_Hechizo_Lanzado(0, false);
                    }
                    break;

                case 300:     //hechizo lanzado con exito
                    if (cuenta.IsFighting() && id_entidad == cuenta.game.character.id)
                    {
                        short celda_id_lanzado = short.Parse(separador[3].Split(',')[1]);
                        pelea.get_Hechizo_Lanzado(celda_id_lanzado, true);
                    }
                    break;

                case 501:
                    int tiempo_recoleccion = int.Parse(separador[3].Split(',')[1]);
                    celda = mapa.GetCellFromId(short.Parse(separador[3].Split(',')[0]));
                    byte tipo_gkk_recoleccion = byte.Parse(separador[0]);

                    await cuenta.game.manager.recoleccion.evento_Recoleccion_Iniciada(id_entidad, tiempo_recoleccion, celda.cellId, tipo_gkk_recoleccion);

                    break;

                case 900:
                    cuenta.connexion.SendPacket("GA902" + id_entidad, true);
                    cuenta.logger.log_informacion("INFORMATION", "Le défi avec le personnage ID : " + id_entidad + " est annulée");
                    break;
                }
            }
        }
Ejemplo n.º 3
0
        public async Task get_Movimientos_Personajes(ClienteTcp cliente, string paquete)
        {
            Cuenta cuenta = cliente.cuenta;

            string[] separador_jugadores = paquete.Substring(3).Split(new char[]
            {
                '|'
            });
            int num;

            for (int i = 0; i < separador_jugadores.Length; i = num)
            {
                string _loc6 = separador_jugadores[i];
                bool   flag  = _loc6.Length != 0;
                if (flag)
                {
                    string[] informaciones = _loc6.Substring(1).Split(new char[]
                    {
                        ';'
                    });
                    bool flag2 = _loc6[0].Equals('+');
                    if (flag2)
                    {
                        Celda  celda           = cuenta.juego.mapa.get_Celda_Id(short.Parse(informaciones[0]));
                        Pelea  pelea           = cuenta.juego.pelea;
                        int    id              = int.Parse(informaciones[3]);
                        string nombre_template = informaciones[4];
                        string tipo            = informaciones[5];
                        bool   flag3           = tipo.Contains(",");
                        if (flag3)
                        {
                            tipo = tipo.Split(new char[]
                            {
                                ','
                            })[0];
                        }
                        string[]  templates;
                        string[]  niveles;
                        Monstruos monstruo;
                        switch (int.Parse(tipo))
                        {
                        case -10:
                        case -9:
                        case -8:
                        case -7:
                        case -6:
                        case -5:
                            break;

                        case -4:
                            cuenta.juego.mapa.entidades.TryAdd(id, new Npcs(id, int.Parse(nombre_template), celda));
                            break;

                        case -3:
                            templates = nombre_template.Split(new char[]
                            {
                                ','
                            });
                            niveles = informaciones[7].Split(new char[]
                            {
                                ','
                            });
                            monstruo             = new Monstruos(id, int.Parse(templates[0]), celda, int.Parse(niveles[0]));
                            monstruo.lider_grupo = monstruo;
                            for (int j = 1; j < templates.Length; j = num)
                            {
                                monstruo.moobs_dentro_grupo.Add(new Monstruos(id, int.Parse(templates[j]), celda, int.Parse(niveles[j])));
                                num = j + 1;
                            }
                            cuenta.juego.mapa.entidades.TryAdd(id, monstruo);
                            break;

                        case -2:
                        case -1:
                        {
                            bool flag4 = cuenta.Estado_Cuenta == EstadoCuenta.LUCHANDO;
                            if (flag4)
                            {
                                int  vida   = int.Parse(informaciones[12]);
                                byte pa     = byte.Parse(informaciones[13]);
                                byte pm     = byte.Parse(informaciones[14]);
                                byte equipo = byte.Parse(informaciones[15]);
                                pelea.get_Agregar_Luchador(new Luchadores(id, true, vida, pa, pm, celda, vida, equipo));
                            }
                            break;
                        }

                        default:
                        {
                            bool flag5 = cuenta.Estado_Cuenta != EstadoCuenta.LUCHANDO;
                            if (flag5)
                            {
                                bool flag6 = cuenta.juego.personaje.id != id;
                                if (flag6)
                                {
                                    cuenta.juego.mapa.entidades.TryAdd(id, new Personajes(id, nombre_template, byte.Parse(informaciones[7].ToString()), celda));
                                }
                                else
                                {
                                    cuenta.juego.personaje.celda = celda;
                                }
                            }
                            else
                            {
                                int  vida2   = int.Parse(informaciones[14]);
                                byte pa2     = byte.Parse(informaciones[15]);
                                byte pm2     = byte.Parse(informaciones[16]);
                                byte equipo2 = byte.Parse(informaciones[24]);
                                pelea.get_Agregar_Luchador(new Luchadores(id, true, vida2, pa2, pm2, celda, vida2, equipo2));
                                bool flag7 = cuenta.juego.personaje.id == id && cuenta.pelea_extension.configuracion.posicionamiento != PosicionamientoInicioPelea.INMOVIL;
                                if (flag7)
                                {
                                    await Task.Delay(300);

                                    short celda_posicion = pelea.get_Celda_Mas_Cercana_O_Lejana(cuenta.pelea_extension.configuracion.posicionamiento == PosicionamientoInicioPelea.CERCA_DE_ENEMIGOS, pelea.celdas_preparacion);
                                    if (celda_posicion != celda.id)
                                    {
                                        cuenta.conexion.enviar_Paquete("Gp" + celda_posicion.ToString(), true);
                                    }
                                    else
                                    {
                                        cuenta.conexion.enviar_Paquete("GR1", false);
                                    }
                                }
                                else if (cuenta.juego.personaje.id == id)
                                {
                                    await Task.Delay(300);

                                    cuenta.conexion.enviar_Paquete("GR1", false);
                                }
                            }
                            break;
                        }
                        }
                        templates = null;
                        niveles   = null;
                        monstruo  = null;
                        celda     = null;
                        pelea     = null;
                    }
                    else if (_loc6[0].Equals('-'))
                    {
                        if (cuenta.Estado_Cuenta != EstadoCuenta.LUCHANDO)
                        {
                            int     id2 = int.Parse(_loc6.Substring(1));
                            Entidad entidad;
                            cuenta.juego.mapa.entidades.TryRemove(id2, out entidad);
                            entidad = null;
                        }
                    }
                }
                num = i + 1;
            }
        }
Ejemplo n.º 4
0
        public async Task get_Iniciar_Accion(ClienteTcp cliente, string paquete)
        {
            string[]       separador = paquete.Substring(2).Split(';');
            int            id_accion = int.Parse(separador[1]);
            Cuenta         cuenta    = cliente.cuenta;
            PersonajeJuego personaje = cuenta.juego.personaje;

            if (id_accion > 0)
            {
                int        id_entidad = int.Parse(separador[2]);
                byte       tipo_gkk_movimiento;
                Celda      celda;
                Luchadores luchador;
                Mapa       mapa  = cuenta.juego.mapa;
                Pelea      pelea = cuenta.juego.pelea;

                switch (id_accion)
                {
                case 1:
                    celda = mapa.get_Celda_Id(Hash.get_Celda_Id_Desde_hash(separador[3].Substring(separador[3].Length - 2)));

                    if (!cuenta.esta_luchando())
                    {
                        if (id_entidad == personaje.id && celda.id > 0 && personaje.celda.id != celda.id)
                        {
                            tipo_gkk_movimiento = byte.Parse(separador[0]);

                            await cuenta.juego.manejador.movimientos.evento_Movimiento_Finalizado(celda, tipo_gkk_movimiento, true);
                        }
                        else if (mapa.entidades.TryGetValue(id_entidad, out Entidad entidad))
                        {
                            entidad.celda = celda;

                            if (GlobalConf.mostrar_mensajes_debug)
                            {
                                cuenta.logger.log_informacion("DEBUG", "movimiento détecté d'une entité vers la cellule : " + celda.id);
                            }
                        }
                        mapa.evento_Entidad_Actualizada();
                    }
                    else
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);
                        if (luchador != null)
                        {
                            luchador.celda = celda;

                            if (luchador.id == personaje.id)
                            {
                                tipo_gkk_movimiento = byte.Parse(separador[0]);

                                await Task.Delay(400 + (100 * personaje.celda.get_Distancia_Entre_Dos_Casillas(celda)));

                                cuenta.conexion.enviar_Paquete("GKK" + tipo_gkk_movimiento);
                            }
                        }
                    }
                    break;

                case 4:
                    separador = separador[3].Split(',');
                    celda     = mapa.get_Celda_Id(short.Parse(separador[1]));

                    if (!cuenta.esta_luchando() && id_entidad == personaje.id && celda.id > 0 && personaje.celda.id != celda.id)
                    {
                        personaje.celda = celda;
                        await Task.Delay(150);

                        cuenta.conexion.enviar_Paquete("GKK1");
                        mapa.evento_Entidad_Actualizada();
                        cuenta.juego.manejador.movimientos.movimiento_Actualizado(true);
                    }
                    break;

                case 5:
                    if (cuenta.esta_luchando())
                    {
                        separador = separador[3].Split(',');
                        luchador  = pelea.get_Luchador_Por_Id(int.Parse(separador[0]));

                        if (luchador != null)
                        {
                            luchador.celda = mapa.get_Celda_Id(short.Parse(separador[1]));
                        }
                    }
                    break;

                case 102:
                    if (cuenta.esta_luchando())
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);
                        byte pa_utilizados = byte.Parse(separador[3].Split(',')[1].Substring(1));

                        if (luchador != null)
                        {
                            luchador.pa -= pa_utilizados;
                        }
                    }
                    break;

                case 103:
                    if (cuenta.esta_luchando())
                    {
                        int id_muerto = int.Parse(separador[3]);

                        luchador = pelea.get_Luchador_Por_Id(id_muerto);
                        if (luchador != null)
                        {
                            luchador.esta_vivo = false;
                        }
                    }
                    break;

                case 129:     //movimiento en pelea con exito
                    if (cuenta.esta_luchando())
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);
                        byte pm_utilizados = byte.Parse(separador[3].Split(',')[1].Substring(1));

                        if (luchador != null)
                        {
                            luchador.pm -= pm_utilizados;
                        }

                        if (luchador.id == personaje.id)
                        {
                            pelea.get_Movimiento_Exito(true);
                        }
                    }
                    break;

                case 151:    //obstaculos invisibles
                    if (cuenta.esta_luchando())
                    {
                        luchador = pelea.get_Luchador_Por_Id(id_entidad);

                        if (luchador != null && luchador.id == personaje.id)
                        {
                            cuenta.logger.log_Error("INFORMATION", "Il n'est pas possible d'effectuer cette action à cause d'un obstacle invisible.");
                            pelea.get_Hechizo_Lanzado(short.Parse(separador[3]), false);
                        }
                    }
                    break;

                case 181:     //efecto de invocacion (pelea)
                    celda = mapa.get_Celda_Id(short.Parse(separador[3].Substring(1)));
                    short id_luchador = short.Parse(separador[6]);
                    short vida        = short.Parse(separador[15]);
                    byte  pa          = byte.Parse(separador[16]);
                    byte  pm          = byte.Parse(separador[17]);
                    byte  equipo      = byte.Parse(separador[25]);

                    pelea.get_Agregar_Luchador(new Luchadores(id_luchador, true, vida, pa, pm, celda, vida, equipo, id_entidad));
                    break;

                case 302:    //fallo critico
                    if (cuenta.esta_luchando() && id_entidad == cuenta.juego.personaje.id)
                    {
                        pelea.get_Hechizo_Lanzado(0, false);
                    }
                    break;

                case 300:     //hechizo lanzado con exito
                    if (cuenta.esta_luchando() && id_entidad == cuenta.juego.personaje.id)
                    {
                        short celda_id_lanzado = short.Parse(separador[3].Split(',')[1]);
                        pelea.get_Hechizo_Lanzado(celda_id_lanzado, true);
                    }
                    break;

                case 501:
                    int tiempo_recoleccion = int.Parse(separador[3].Split(',')[1]);
                    celda = mapa.get_Celda_Id(short.Parse(separador[3].Split(',')[0]));
                    byte tipo_gkk_recoleccion = byte.Parse(separador[0]);

                    await cuenta.juego.manejador.recoleccion.evento_Recoleccion_Iniciada(id_entidad, tiempo_recoleccion, celda.id, tipo_gkk_recoleccion);

                    break;

                case 900:
                    cuenta.conexion.enviar_Paquete("GA902" + id_entidad, true);
                    cuenta.logger.log_informacion("INFORMATION", "Le défi avec le personnage ID : " + id_entidad + " est annulée");
                    break;
                }
            }
        }
Ejemplo n.º 5
0
        public async Task get_Iniciar_Accion(ClienteTcp cliente, string paquete)
        {
            string[] separador = paquete.Substring(2).Split(new char[]
            {
                ';'
            });
            int            id_accion = int.Parse(separador[1]);
            Cuenta         cuenta    = cliente.cuenta;
            PersonajeJuego personaje = cuenta.juego.personaje;
            bool           flag      = id_accion > 0;

            if (flag)
            {
                int        id_entidad = int.Parse(separador[2]);
                Mapa       mapa       = cuenta.juego.mapa;
                Pelea      pelea      = cuenta.juego.pelea;
                int        num        = id_accion;
                int        num2       = num;
                int        num3       = num2;
                Celda      celda;
                Luchadores luchador;
                if (num3 <= 151)
                {
                    if (num3 <= 102)
                    {
                        switch (num3)
                        {
                        case 1:
                        {
                            celda = mapa.get_Celda_Id(Hash.get_Celda_Id_Desde_hash(separador[3].Substring(separador[3].Length - 2)));
                            bool flag2 = !cuenta.esta_luchando();
                            if (flag2)
                            {
                                bool flag3 = id_entidad == personaje.id && celda.id > 0 && personaje.celda.id != celda.id;
                                if (flag3)
                                {
                                    byte tipo_gkk_movimiento = byte.Parse(separador[0]);
                                    await cuenta.juego.manejador.movimientos.evento_Movimiento_Finalizado(celda, tipo_gkk_movimiento, true);
                                }
                                else
                                {
                                    Entidad entidad;
                                    if (mapa.entidades.TryGetValue(id_entidad, out entidad))
                                    {
                                        entidad.celda = celda;
                                        if (GlobalConf.mostrar_mensajes_debug)
                                        {
                                            cuenta.logger.log_informacion("DEBUG", "Detectado movimiento de una entidad a la casilla: " + celda.id.ToString());
                                        }
                                    }
                                    entidad = null;
                                }
                                mapa.evento_Entidad_Actualizada();
                            }
                            else
                            {
                                luchador = pelea.get_Luchador_Por_Id(id_entidad);
                                if (luchador != null)
                                {
                                    luchador.celda = celda;
                                    if (luchador.id == personaje.id)
                                    {
                                        byte tipo_gkk_movimiento = byte.Parse(separador[0]);
                                        await Task.Delay(400 + 100 *personaje.celda.get_Distancia_Entre_Dos_Casillas(celda));

                                        cuenta.conexion.enviar_Paquete("GKK" + tipo_gkk_movimiento.ToString(), false);
                                    }
                                }
                            }
                            break;
                        }

                        case 2:
                        case 3:
                            break;

                        case 4:
                            separador = separador[3].Split(new char[]
                            {
                                ','
                            });
                            celda = mapa.get_Celda_Id(short.Parse(separador[1]));
                            if (!cuenta.esta_luchando() && id_entidad == personaje.id && celda.id > 0 && personaje.celda.id != celda.id)
                            {
                                personaje.celda = celda;
                                await Task.Delay(150);

                                cuenta.conexion.enviar_Paquete("GKK1", false);
                                mapa.evento_Entidad_Actualizada();
                                cuenta.juego.manejador.movimientos.movimiento_Actualizado(true);
                            }
                            break;

                        case 5:
                            if (cuenta.esta_luchando())
                            {
                                separador = separador[3].Split(new char[]
                                {
                                    ','
                                });
                                luchador = pelea.get_Luchador_Por_Id(int.Parse(separador[0]));
                                if (luchador != null)
                                {
                                    luchador.celda = mapa.get_Celda_Id(short.Parse(separador[1]));
                                }
                            }
                            break;

                        default:
                            if (num3 == 102)
                            {
                                if (cuenta.esta_luchando())
                                {
                                    luchador = pelea.get_Luchador_Por_Id(id_entidad);
                                    byte pa_utilizados = byte.Parse(separador[3].Split(new char[]
                                    {
                                        ','
                                    })[1].Substring(1));
                                    if (luchador != null)
                                    {
                                        Luchadores luchadores = luchador;
                                        luchadores.pa -= pa_utilizados;
                                    }
                                }
                            }
                            break;
                        }
                    }
                    else if (num3 != 103)
                    {
                        if (num3 != 129)
                        {
                            if (num3 == 151)
                            {
                                if (cuenta.esta_luchando())
                                {
                                    luchador = pelea.get_Luchador_Por_Id(id_entidad);
                                    if (luchador != null && luchador.id == personaje.id)
                                    {
                                        cuenta.logger.log_Error("INFORMATION", "No es posible realizar esta acción por culpa de un obstáculo invisible.");
                                        pelea.get_Hechizo_Lanzado(short.Parse(separador[3]), false);
                                    }
                                }
                            }
                        }
                        else if (cuenta.esta_luchando())
                        {
                            luchador = pelea.get_Luchador_Por_Id(id_entidad);
                            byte pm_utilizados = byte.Parse(separador[3].Split(new char[]
                            {
                                ','
                            })[1].Substring(1));
                            if (luchador != null)
                            {
                                Luchadores luchadores2 = luchador;
                                luchadores2.pm -= pm_utilizados;
                            }
                            if (luchador.id == personaje.id)
                            {
                                pelea.get_Movimiento_Exito(true);
                            }
                        }
                    }
                    else if (cuenta.esta_luchando())
                    {
                        int id_muerto = int.Parse(separador[3]);
                        luchador = pelea.get_Luchador_Por_Id(id_muerto);
                        if (luchador != null)
                        {
                            luchador.esta_vivo = false;
                        }
                    }
                }
                else if (num3 <= 300)
                {
                    if (num3 != 181)
                    {
                        if (num3 == 300)
                        {
                            if (cuenta.esta_luchando() && id_entidad == cuenta.juego.personaje.id)
                            {
                                short celda_id_lanzado = short.Parse(separador[3].Split(new char[]
                                {
                                    ','
                                })[1]);
                                pelea.get_Hechizo_Lanzado(celda_id_lanzado, true);
                            }
                        }
                    }
                    else
                    {
                        celda = mapa.get_Celda_Id(short.Parse(separador[3].Substring(1)));
                        short id_luchador = short.Parse(separador[6]);
                        short vida        = short.Parse(separador[15]);
                        byte  pa          = byte.Parse(separador[16]);
                        byte  pm          = byte.Parse(separador[17]);
                        byte  equipo      = byte.Parse(separador[25]);
                        pelea.get_Agregar_Luchador(new Luchadores((int)id_luchador, true, (int)vida, pa, pm, celda, (int)vida, equipo, id_entidad));
                    }
                }
                else if (num3 != 302)
                {
                    if (num3 != 501)
                    {
                        if (num3 == 900)
                        {
                            cuenta.conexion.enviar_Paquete("GA902" + id_entidad.ToString(), true);
                            cuenta.logger.log_informacion("INFORMATION", "Desafio del personaje id: " + id_entidad.ToString() + " cancelado");
                        }
                    }
                    else
                    {
                        int tiempo_recoleccion = int.Parse(separador[3].Split(new char[]
                        {
                            ','
                        })[1]);
                        celda = mapa.get_Celda_Id(short.Parse(separador[3].Split(new char[]
                        {
                            ','
                        })[0]));
                        byte tipo_gkk_recoleccion = byte.Parse(separador[0]);
                        await cuenta.juego.manejador.recoleccion.evento_Recoleccion_Iniciada(id_entidad, tiempo_recoleccion, celda.id, tipo_gkk_recoleccion);
                    }
                }
                else if (cuenta.esta_luchando() && id_entidad == cuenta.juego.personaje.id)
                {
                    pelea.get_Hechizo_Lanzado(0, false);
                }
                celda    = null;
                luchador = null;
                mapa     = null;
                pelea    = null;
            }
        }