Example #1
0
        public async Task get_Cambiar_Pos_Pelea(ClienteTcp cliente, string paquete)
        {
            Cuenta cuenta = cliente.cuenta;

            string[] separador_posiciones = paquete.Substring(4).Split('|');
            int      id_entidad;
            short    celda;
            Mapa     mapa = cuenta.juego.mapa;

            foreach (string posicion in separador_posiciones)
            {
                id_entidad = int.Parse(posicion.Split(';')[0]);
                celda      = short.Parse(posicion.Split(';')[1]);

                if (id_entidad == cuenta.juego.personaje.id)
                {
                    await Task.Delay(150);

                    cliente.enviar_Paquete("GR1");//boton listo
                }

                Luchadores luchador = cuenta.juego.pelea.get_Luchador_Por_Id(id_entidad);
                if (luchador != null)
                {
                    luchador.celda = mapa.get_Celda_Id(celda);
                }
            }
        }
Example #2
0
        public async Task get_Cambiar_Pos_Pelea(ClienteAbstracto cliente, string paquete)
        {
            Cuenta cuenta = cliente.cuenta;

            string[]   separador_posiciones = paquete.Substring(4).Split('|');
            int        id_entidad;
            short      celda;
            Luchadores luchador = null;

            foreach (string posicion in separador_posiciones)
            {
                id_entidad = int.Parse(posicion.Split(';')[0]);
                celda      = short.Parse(posicion.Split(';')[1]);

                if (id_entidad == cuenta.personaje.id)
                {
                    await Task.Delay(300);

                    cuenta.conexion.enviar_Paquete("GR1");//boton listo
                }

                luchador = cuenta.pelea.get_Luchador_Por_Id(id_entidad);

                if (luchador != null)
                {
                    luchador.celda_id = celda;
                }
            }
        }
Example #3
0
        private async Task <ResultadoLanzandoHechizo> get_Lanzar_Hechizo_Simple(PeleaHechizos hechizo)
        {
            if (pelea.get_Puede_Lanzar_hechizo(hechizo.id) != FallosLanzandoHechizo.NINGUNO)
            {
                return(ResultadoLanzandoHechizo.NO_LANZADO);
            }

            Luchadores enemigo = get_Objetivo_Mas_Cercano(hechizo);

            if (enemigo != null)
            {
                FallosLanzandoHechizo resultado = pelea.get_Puede_Lanzar_hechizo(hechizo.id, pelea.jugador_luchador.celda, enemigo.celda, mapa);

                if (resultado == FallosLanzandoHechizo.NINGUNO)
                {
                    await pelea.get_Lanzar_Hechizo(hechizo.id, enemigo.celda.id);

                    return(ResultadoLanzandoHechizo.LANZADO);
                }

                if (resultado == FallosLanzandoHechizo.NO_ESTA_EN_RANGO)
                {
                    return(await get_Mover_Lanzar_hechizo_Simple(hechizo, enemigo));
                }
            }
            else if (hechizo.focus == HechizoFocus.CELDA_VACIA)
            {
                return(await lanzar_Hechizo_Celda_Vacia(hechizo));
            }

            return(ResultadoLanzandoHechizo.NO_LANZADO);
        }
Example #4
0
        public async Task get_Cambiar_Pos_Pelea(TcpClient cliente, string paquete)
        {
            Account cuenta = cliente.account;

            string[] separador_posiciones = paquete.Substring(4).Split('|');
            int      id_entidad;
            short    celda;
            Map      mapa = cuenta.game.map;

            foreach (string posicion in separador_posiciones)
            {
                id_entidad = int.Parse(posicion.Split(';')[0]);
                celda      = short.Parse(posicion.Split(';')[1]);

                if (id_entidad == cuenta.game.character.id)
                {
                    await Task.Delay(150);

                    cliente.SendPacket("GR1");//boton listo
                }

                Luchadores luchador = cuenta.game.fight.get_Luchador_Por_Id(id_entidad);
                if (luchador != null)
                {
                    luchador.celda = mapa.GetCellFromId(celda);
                }
            }
        }
Example #5
0
        public void get_Combate_Info_Stats(TcpClient cliente, string paquete)
        {
            string[] separador = paquete.Substring(4).Split('|');
            Map      mapa      = cliente.account.game.map;

            for (int i = 0; i < separador.Length; ++i)
            {
                string[]   _loc6_   = separador[i].Split(';');
                int        id       = int.Parse(_loc6_[0]);
                Luchadores luchador = cliente.account.game.fight.get_Luchador_Por_Id(id);

                if (_loc6_.Length != 0)
                {
                    bool esta_vivo = _loc6_[1].Equals("0");
                    if (esta_vivo)
                    {
                        int   vida_actual = int.Parse(_loc6_[2]);
                        byte  pa          = byte.Parse(_loc6_[3]);
                        byte  pm          = byte.Parse(_loc6_[4]);
                        short celda       = short.Parse(_loc6_[5]);
                        int   vida_maxima = int.Parse(_loc6_[7]);

                        if (celda > 0)//son espectadores
                        {
                            byte equipo = Convert.ToByte(id > 0 ? 1 : 0);
                            luchador?.get_Actualizar_Luchador(id, esta_vivo, vida_actual, pa, pm, mapa.GetCellFromId(celda), vida_maxima, equipo);
                        }
                    }
                    else
                    {
                        luchador?.get_Actualizar_Luchador(id, esta_vivo, 0, 0, 0, null, 0, 0);
                    }
                }
            }
        }
Example #6
0
        public void get_Agregar_Luchador(Luchadores luchador)
        {
            if (luchador.id == cuenta.juego.personaje.id)
                jugador_luchador = new LuchadorPersonaje(cuenta.juego.personaje.nombre_personaje, cuenta.juego.personaje.nivel, luchador);

            else if (!luchadores.TryAdd(luchador.id, luchador))
                luchador.get_Actualizar_Luchador(luchador.id, luchador.esta_vivo, luchador.vida_actual, luchador.pa, luchador.pm, luchador.celda_id, luchador.vida_maxima, luchador.equipo, luchador.id_invocador);

            get_Ordenar_Luchadores();
        }
Example #7
0
        public void get_Agregar_Luchador(Luchadores luchador)
        {
            if (luchador.id == cuenta.juego.personaje.id)
            {
                jugador_luchador = new LuchadorPersonaje(cuenta.juego.personaje.nombre, cuenta.juego.personaje.nivel, luchador);
            }
            else
            {
                luchadores.TryAdd(luchador.id, luchador);
            }

            get_Ordenar_Luchadores();
        }
Example #8
0
        public void get_Agregar_Luchador(Luchadores luchador)
        {
            if (luchador.id == cuenta.game.character.id)
            {
                jugador_luchador = new LuchadorPersonaje(cuenta.game.character.nombre, cuenta.game.character.nivel, luchador);
            }

            else if (!luchadores.TryAdd(luchador.id, luchador))
            {
                luchador.get_Actualizar_Luchador(luchador.id, luchador.esta_vivo, luchador.vida_actual, luchador.pa, luchador.pm, luchador.celda, luchador.vida_maxima, luchador.equipo, luchador.id_invocador);
            }

            get_Ordenar_Luchadores();
        }
Example #9
0
        private bool get_Distancia_Buena(PeleaHechizos hechizo)
        {
            if (hechizo.distancia_minima == 0)
            {
                return(true);
            }

            Luchadores enemigo_cercano = pelea.get_Enemigo_Mas_Cercano();

            if (enemigo_cercano == null)
            {
                return(false);
            }

            return(pelea.jugador_luchador.celda.get_Distancia(enemigo_cercano.celda) >= hechizo.distancia_minima);
        }
Example #10
0
        private bool is_Spell_capture_lancable()
        {
            bool retour = false;

            if (pelea.get_Enemigos.Count() == 1)
            {
                Luchadores dernierenemi   = pelea.get_Obtener_Enemigo_Mas_Cercano();
                int        viePourcentage = (int)dernierenemi.vida_actual / dernierenemi.vida_maxima;

                if (viePourcentage <= 70)
                {
                    retour = true;
                }
            }
            return(retour);
        }
        public void get_Combate_Info_Stats(ClienteTcp cliente, string paquete)
        {
            string[] array = paquete.Substring(4).Split(new char[]
            {
                '|'
            });
            Mapa mapa = cliente.cuenta.juego.mapa;

            for (int i = 0; i < array.Length; i++)
            {
                string[] array2 = array[i].Split(new char[]
                {
                    ';'
                });
                int        num        = int.Parse(array2[0]);
                Luchadores luchadores = cliente.cuenta.juego.pelea.get_Luchador_Por_Id(num);
                bool       flag       = array2.Length != 0;
                if (flag)
                {
                    bool flag2 = array2[1].Equals("0");
                    bool flag3 = flag2;
                    if (flag3)
                    {
                        int   vida_actual = int.Parse(array2[2]);
                        byte  pa          = byte.Parse(array2[3]);
                        byte  pm          = byte.Parse(array2[4]);
                        short num2        = short.Parse(array2[5]);
                        int   vida_maxima = int.Parse(array2[7]);
                        bool  flag4       = num2 > 0;
                        if (flag4)
                        {
                            byte equipo = Convert.ToByte((num > 0) ? 1 : 0);
                            if (luchadores != null)
                            {
                                luchadores.get_Actualizar_Luchador(num, flag2, vida_actual, pa, pm, mapa.get_Celda_Id(num2), vida_maxima, equipo);
                            }
                        }
                    }
                    else if (luchadores != null)
                    {
                        luchadores.get_Actualizar_Luchador(num, flag2, 0, 0, 0, null, 0, 0);
                    }
                }
            }
        }
Example #12
0
        public void get_Final_Turno(int id_personaje)
        {
            Luchadores luchador = get_Luchador_Por_Id(id_personaje);

            if (luchador == jugador_luchador)
            {
                total_hechizos_lanzados.Clear();
                total_hechizos_lanzados_en_celda.Clear();

                for (int i = hechizos_intervalo.Count - 1; i >= 0; i--)
                {
                    int key = hechizos_intervalo.ElementAt(i).Key;
                    hechizos_intervalo[key]--;
                    if (hechizos_intervalo[key] == 0)
                        hechizos_intervalo.Remove(key);
                }
            }
        }
Example #13
0
        public Luchadores get_Enemigo_Mas_Debil()
        {
            int vida = -1;
            Luchadores enemigo = null;

            foreach (Luchadores enemigo_actual in get_Enemigos)
            {
                if (!enemigo_actual.esta_vivo)
                    continue;

                if (vida == -1 || enemigo_actual.porcentaje_vida < vida)
                {
                    vida = enemigo_actual.porcentaje_vida;
                    enemigo = enemigo_actual;
                }
            }
            return enemigo;
        }
Example #14
0
        // Token: 0x060001C1 RID: 449 RVA: 0x00007F14 File Offset: 0x00006314
        public void get_Agregar_Luchador(Luchadores luchador)
        {
            bool flag = luchador.id == this.cuenta.juego.personaje.id;

            if (flag)
            {
                this.jugador_luchador = new LuchadorPersonaje(this.cuenta.juego.personaje.nombre, this.cuenta.juego.personaje.nivel, luchador);
            }
            else
            {
                bool flag2 = !this.luchadores.TryAdd(luchador.id, luchador);
                if (flag2)
                {
                    luchador.get_Actualizar_Luchador(luchador.id, luchador.esta_vivo, luchador.vida_actual, luchador.pa, luchador.pm, luchador.celda, luchador.vida_maxima, luchador.equipo, luchador.id_invocador);
                }
            }
            this.get_Ordenar_Luchadores();
        }
        // Token: 0x060001E6 RID: 486 RVA: 0x000094B4 File Offset: 0x000078B4
        public async Task get_Mover(bool cercano, Luchadores enemigo)
        {
            KeyValuePair <short, MovimientoNodo>?nodo = null;
            Mapa mapa            = this.cuenta.juego.mapa;
            int  distancia       = -1;
            int  distancia_total = this.Get_Total_Distancia_Enemigo(this.pelea.jugador_luchador.celda);

            foreach (KeyValuePair <short, MovimientoNodo> kvp in PeleasPathfinder.get_Celdas_Accesibles(this.pelea, mapa, this.pelea.jugador_luchador.celda))
            {
                bool flag = !kvp.Value.alcanzable;
                if (!flag)
                {
                    int  temporal_distancia = this.Get_Total_Distancia_Enemigo(mapa.get_Celda_Id(kvp.Key));
                    bool flag2 = (cercano && temporal_distancia <= distancia_total) || (!cercano && temporal_distancia >= distancia_total);
                    if (flag2)
                    {
                        if (cercano)
                        {
                            nodo            = new KeyValuePair <short, MovimientoNodo>?(kvp);
                            distancia_total = temporal_distancia;
                        }
                        else
                        {
                            bool flag3 = kvp.Value.camino.celdas_accesibles.Count >= distancia;
                            if (flag3)
                            {
                                nodo            = new KeyValuePair <short, MovimientoNodo>?(kvp);
                                distancia_total = temporal_distancia;
                                distancia       = kvp.Value.camino.celdas_accesibles.Count;
                            }
                        }
                    }
                    kvp = default(KeyValuePair <short, MovimientoNodo>);
                }
            }
            Dictionary <short, MovimientoNodo> .Enumerator enumerator = default(Dictionary <short, MovimientoNodo> .Enumerator);
            bool flag4 = nodo != null;

            if (flag4)
            {
                await this.cuenta.juego.manejador.movimientos.get_Mover_Celda_Pelea(nodo);
            }
        }
Example #16
0
        // Token: 0x060001BE RID: 446 RVA: 0x00007D54 File Offset: 0x00006154
        public Luchadores get_Enemigo_Mas_Debil()
        {
            int        num    = -1;
            Luchadores result = null;

            foreach (Luchadores luchadores in this.get_Enemigos)
            {
                bool flag = !luchadores.esta_vivo;
                if (!flag)
                {
                    bool flag2 = num == -1 || luchadores.porcentaje_vida < num;
                    if (flag2)
                    {
                        num    = luchadores.porcentaje_vida;
                        result = luchadores;
                    }
                }
            }
            return(result);
        }
Example #17
0
        public Luchadores get_Obtener_Enemigo_Mas_Cercano()
        {
            int distancia = -1, distancia_temporal;
            Luchadores enemigo = null;

            foreach (Luchadores luchador_enemigo in get_Enemigos)
            {
                if (!luchador_enemigo.esta_vivo)
                    continue;

                distancia_temporal = celdas_mapa[jugador_luchador.celda_id].get_Distancia_Entre_Dos_Casillas(luchador_enemigo.celda_id);

                if (distancia == -1 || distancia_temporal < distancia)
                {
                    distancia = distancia_temporal;
                    enemigo = luchador_enemigo;
                }
            }
            return enemigo;
        }
Example #18
0
        public Task get_Combate_Info_Stats(ClienteTcp cliente, string paquete) => Task.Factory.StartNew(() =>
        {
            Cuenta cuenta = cliente.cuenta;
            if (!cuenta.esta_Luchando())
            {
                return;
            }

            string[] monstruos = paquete.Substring(4).Split('|');
            Mapa mapa          = cliente.cuenta.juego.mapa;

            foreach (string monstruo in monstruos)
            {
                string[] _loc6_     = monstruo.Split(';');
                int id              = int.Parse(_loc6_[0]);
                Luchadores luchador = cuenta.juego.pelea.get_Luchador_Por_Id(id);

                if (_loc6_.Length > 0 && luchador != null)
                {
                    bool esta_vivo = _loc6_[1].Equals("0");
                    if (esta_vivo)
                    {
                        int vida_actual = int.Parse(_loc6_[2]);
                        byte pa         = byte.Parse(_loc6_[3]);
                        byte pm         = byte.Parse(_loc6_[4]);
                        short celda     = short.Parse(_loc6_[5]);
                        int vida_maxima = int.Parse(_loc6_[7]);

                        if (celda > 0)//son espectadores
                        {
                            luchador.vida_actual = vida_actual;
                            luchador.vida_maxima = vida_maxima;
                            luchador.pa          = pa;
                            luchador.pm          = pm;
                            luchador.celda       = mapa.get_Celda_Id(celda);
                        }
                    }
                    luchador.esta_vivo = esta_vivo;
                }
            }
        }, TaskCreationOptions.LongRunning);
Example #19
0
        // Token: 0x060001C0 RID: 448 RVA: 0x00007E78 File Offset: 0x00006278
        public Luchadores get_Obtener_Enemigo_Mas_Cercano()
        {
            int        num    = -1;
            Luchadores result = null;

            foreach (Luchadores luchadores in this.get_Enemigos)
            {
                bool flag = !luchadores.esta_vivo;
                if (!flag)
                {
                    int  num2  = this.jugador_luchador.celda.get_Distancia_Entre_Dos_Casillas(luchadores.celda);
                    bool flag2 = num == -1 || num2 < num;
                    if (flag2)
                    {
                        num    = num2;
                        result = luchadores;
                    }
                }
            }
            return(result);
        }
        // Token: 0x0600019E RID: 414 RVA: 0x00007500 File Offset: 0x00005900
        private async Task <ResultadoLanzandoHechizo> get_Lanzar_Hechizo_Simple(HechizoPelea hechizo)
        {
            bool flag = this.pelea.get_Puede_Lanzar_hechizo(hechizo.id) > FallosLanzandoHechizo.NINGUNO;
            ResultadoLanzandoHechizo result;

            if (flag)
            {
                result = ResultadoLanzandoHechizo.NO_LANZADO;
            }
            else
            {
                Luchadores enemigo = this.get_Objetivo_Mas_Cercano(hechizo);
                bool       flag2   = enemigo != null;
                if (flag2)
                {
                    FallosLanzandoHechizo resultado = this.pelea.get_Puede_Lanzar_hechizo(hechizo.id, this.pelea.jugador_luchador.celda, enemigo.celda, this.mapa);
                    bool flag3 = resultado == FallosLanzandoHechizo.NINGUNO;
                    if (flag3)
                    {
                        this.cuenta.logger.log_Fight("COMBAT", "Lancement du sort " + hechizo.nombre + " ...");
                        await this.pelea.get_Lanzar_Hechizo(hechizo.id, enemigo.celda.id);

                        return(ResultadoLanzandoHechizo.LANZADO);
                    }
                    if (resultado == FallosLanzandoHechizo.NO_ESTA_EN_RANGO)
                    {
                        this.cuenta.logger.log_Fight("COMBAT", "Lancement du sort " + hechizo.nombre + " ...");
                        return(await this.get_Mover_Lanzar_hechizo_Simple(hechizo, enemigo));
                    }
                }
                else if (hechizo.focus == HechizoFocus.CELL_VIDE)
                {
                    this.cuenta.logger.log_Fight("COMBAT", "Lancement du sort " + hechizo.nombre + " ...");
                    return(await this.lanzar_Hechizo_Celda_Vacia(hechizo));
                }
                result = ResultadoLanzandoHechizo.NO_LANZADO;
            }
            return(result);
        }
Example #21
0
        public Luchadores get_Enemigo_Mas_Cercano(Func <Luchadores, bool> filtro = null)
        {
            int        distancia = -1, distancia_temporal;
            Luchadores enemigo = null;

            foreach (Luchadores luchador in filtro == null ? get_Enemigos : get_Enemigos.Where(e => filtro(e)))
            {
                if (!luchador.esta_vivo)
                {
                    continue;
                }

                distancia_temporal = jugador_luchador.celda.get_Distancia(luchador.celda);

                if (distancia == -1 || distancia_temporal < distancia)
                {
                    distancia = distancia_temporal;
                    enemigo   = luchador;
                }
            }
            return(enemigo);
        }
Example #22
0
        public Luchadores get_Obtener_Enemigo_Mas_Cercano()
        {
            int        distancia = -1, distancia_temporal;
            Luchadores enemigo = null;

            foreach (Luchadores luchador_enemigo in get_Enemigos)
            {
                if (!luchador_enemigo.esta_vivo)
                {
                    continue;
                }

                distancia_temporal = jugador_luchador.celda.GetDistanceBetweenCells(luchador_enemigo.celda);

                if (distancia == -1 || distancia_temporal < distancia)
                {
                    distancia = distancia_temporal;
                    enemigo   = luchador_enemigo;
                }
            }
            return(enemigo);
        }
Example #23
0
        public async Task get_Mover(bool cercano, Luchadores enemigo)
        {
            KeyValuePair <short, MovimientoNodo>?nodo = null;
            Mapa mapa      = cuenta.juego.mapa;
            int  distancia = -1;

            int distancia_total = Get_Total_Distancia_Enemigo(pelea.jugador_luchador.celda);

            foreach (KeyValuePair <short, MovimientoNodo> kvp in PeleasPathfinder.get_Celdas_Accesibles(pelea, mapa, pelea.jugador_luchador.celda))
            {
                if (!kvp.Value.alcanzable)
                {
                    continue;
                }

                int temporal_distancia = Get_Total_Distancia_Enemigo(mapa.get_Celda_Id(kvp.Key));

                if ((cercano && temporal_distancia <= distancia_total) || (!cercano && temporal_distancia >= distancia_total))
                {
                    if (cercano)
                    {
                        nodo            = kvp;
                        distancia_total = temporal_distancia;
                    }
                    else if (kvp.Value.camino.celdas_accesibles.Count >= distancia)
                    {
                        nodo            = kvp;
                        distancia_total = temporal_distancia;
                        distancia       = kvp.Value.camino.celdas_accesibles.Count;
                    }
                }
            }

            if (nodo != null)
            {
                await cuenta.juego.manejador.movimientos.get_Mover_Celda_Pelea(nodo);
            }
        }
        public async Task get_Mover(bool cercano, Luchadores enemigo)
        {
            KeyValuePair <short, MovimientoNodo>?nodo = null;
            int distancia_total = -1;
            int distancia       = -1;

            distancia_total = Get_Total_Distancia_Enemigo(cuenta.pelea.jugador_luchador.celda_id);

            foreach (KeyValuePair <short, MovimientoNodo> kvp in PeleasPathfinder.get_Celdas_Accesibles(cuenta.pelea, cuenta.personaje.mapa, cuenta.pelea.jugador_luchador.celda_id))
            {
                if (!kvp.Value.alcanzable)
                {
                    continue;
                }

                int tempTotalDistances = Get_Total_Distancia_Enemigo(kvp.Key);

                if ((cercano && tempTotalDistances <= distancia_total) || (!cercano && tempTotalDistances >= distancia_total))
                {
                    if (cercano)
                    {
                        nodo            = kvp;
                        distancia_total = tempTotalDistances;
                    }
                    else if (kvp.Value.camino.celdas_accesibles.Count >= distancia)
                    {
                        nodo            = kvp;
                        distancia_total = tempTotalDistances;
                        distancia       = kvp.Value.camino.celdas_accesibles.Count;
                    }
                }
            }

            if (nodo != null)
            {
                await cuenta.personaje.manejador.movimientos.get_Mover_Celda_Pelea(nodo);
            }
        }
Example #25
0
        public Luchadores get_Obtener_Aliado_Mas_Cercano()
        {
            int        distancia = -1, distancia_temporal;
            Luchadores aliado = null;

            foreach (Luchadores luchador_aliado in get_Aliados)
            {
                if (!luchador_aliado.esta_vivo)
                {
                    continue;
                }

                distancia_temporal = jugador_luchador.celda.get_Distancia_Entre_Dos_Casillas(luchador_aliado.celda);

                if (distancia == -1 || distancia_temporal < distancia)
                {
                    distancia = distancia_temporal;
                    aliado    = luchador_aliado;
                }
            }

            return(aliado);
        }
Example #26
0
        public Luchadores get_Obtener_Aliado_Mas_Cercano(Func <Luchadores, bool> filtro = null)
        {
            int        distancia = -1, distancia_temporal;
            Luchadores aliado = null;

            foreach (Luchadores luchador in filtro == null ? get_Aliados : get_Aliados.Where(f => filtro(f)))
            {
                if (!luchador.esta_vivo)
                {
                    continue;
                }

                distancia_temporal = jugador_luchador.celda.get_Distancia(luchador.celda);

                if (distancia == -1 || distancia_temporal < distancia)
                {
                    distancia = distancia_temporal;
                    aliado    = luchador;
                }
            }

            return(aliado);
        }
        public async Task get_Cambiar_Pos_Pelea(ClienteTcp cliente, string paquete)
        {
            Cuenta cuenta = cliente.cuenta;

            string[] separador_posiciones = paquete.Substring(4).Split(new char[]
            {
                '|'
            });
            Mapa mapa = cuenta.juego.mapa;

            foreach (string posicion in separador_posiciones)
            {
                int id_entidad = int.Parse(posicion.Split(new char[]
                {
                    ';'
                })[0]);
                short celda = short.Parse(posicion.Split(new char[]
                {
                    ';'
                })[1]);
                bool flag = id_entidad == cuenta.juego.personaje.id;
                if (flag)
                {
                    await Task.Delay(150);

                    cliente.enviar_Paquete("GR1", false);
                }
                Luchadores luchador = cuenta.juego.pelea.get_Luchador_Por_Id(id_entidad);
                if (luchador != null)
                {
                    luchador.celda = mapa.get_Celda_Id(celda);
                }
                luchador = null;
                posicion = null;
            }
            string[] array = null;
        }
Example #28
0
        // Token: 0x060001BC RID: 444 RVA: 0x00007C48 File Offset: 0x00006048
        public void get_Final_Turno(int id_personaje)
        {
            Luchadores luchadores = this.get_Luchador_Por_Id(id_personaje);
            bool       flag       = luchadores == this.jugador_luchador;

            if (flag)
            {
                this.total_hechizos_lanzados.Clear();
                this.total_hechizos_lanzados_en_celda.Clear();
                for (int i = this.hechizos_intervalo.Count - 1; i >= 0; i--)
                {
                    int key = this.hechizos_intervalo.ElementAt(i).Key;
                    Dictionary <int, int> dictionary = this.hechizos_intervalo;
                    int key2 = key;
                    int num  = dictionary[key2];
                    dictionary[key2] = num - 1;
                    bool flag2 = this.hechizos_intervalo[key] == 0;
                    if (flag2)
                    {
                        this.hechizos_intervalo.Remove(key);
                    }
                }
            }
        }
        // Token: 0x0600019F RID: 415 RVA: 0x00007550 File Offset: 0x00005950
        private async Task <ResultadoLanzandoHechizo> get_Mover_Lanzar_hechizo_Simple(HechizoPelea hechizo_pelea, Luchadores enemigo)
        {
            KeyValuePair <short, MovimientoNodo>?nodo = null;
            int pm_utilizados = 99;

            foreach (KeyValuePair <short, MovimientoNodo> movimiento in PeleasPathfinder.get_Celdas_Accesibles(this.pelea, this.mapa, this.pelea.jugador_luchador.celda))
            {
                bool flag = !movimiento.Value.alcanzable;
                if (!flag)
                {
                    bool flag2 = hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.CAC && !this.pelea.esta_Cuerpo_A_Cuerpo_Con_Aliado(this.mapa.get_Celda_Id(movimiento.Key));
                    if (!flag2)
                    {
                        bool flag3 = this.pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id, this.mapa.get_Celda_Id(movimiento.Key), enemigo.celda, this.mapa) > FallosLanzandoHechizo.NINGUNO;
                        if (!flag3)
                        {
                            bool flag4 = movimiento.Value.camino.celdas_accesibles.Count <= pm_utilizados;
                            if (flag4)
                            {
                                nodo          = new KeyValuePair <short, MovimientoNodo>?(movimiento);
                                pm_utilizados = movimiento.Value.camino.celdas_accesibles.Count;
                            }
                            movimiento = default(KeyValuePair <short, MovimientoNodo>);
                        }
                    }
                }
            }
            Dictionary <short, MovimientoNodo> .Enumerator enumerator = default(Dictionary <short, MovimientoNodo> .Enumerator);
            bool flag5 = nodo != null;
            ResultadoLanzandoHechizo result;

            if (flag5)
            {
                await this.cuenta.juego.manejador.movimientos.get_Mover_Celda_Pelea(nodo);

                result = ResultadoLanzandoHechizo.MOVIDO;
            }
            else
            {
                result = ResultadoLanzandoHechizo.NO_LANZADO;
            }
            return(result);
        }
Example #30
0
        public static Dictionary <short, MovimientoNodo> get_Celdas_Accesibles(Fight pelea, Map mapa, Cell celda_actual)
        {
            Dictionary <short, MovimientoNodo> celdas = new Dictionary <short, MovimientoNodo>();

            if (pelea.jugador_luchador.pm <= 0)
            {
                return(celdas);
            }

            short maximos_pm = pelea.jugador_luchador.pm;

            List <NodoPelea> celdas_permitidas = new List <NodoPelea>();
            Dictionary <short, NodoPelea> celdas_prohibidas = new Dictionary <short, NodoPelea>();

            NodoPelea nodo = new NodoPelea(celda_actual, maximos_pm, pelea.jugador_luchador.pa, 1);

            celdas_permitidas.Add(nodo);
            celdas_prohibidas[celda_actual.cellId] = nodo;

            while (celdas_permitidas.Count > 0)
            {
                NodoPelea actual = celdas_permitidas.Last();
                celdas_permitidas.Remove(actual);
                Cell        nodo_celda = actual.celda;
                List <Cell> adyecentes = get_Celdas_Adyecentes(nodo_celda, mapa.mapCells);

                int i = 0;
                while (i < adyecentes.Count)
                {
                    Luchadores enemigo = pelea.get_Luchadores.FirstOrDefault(f => f.celda.cellId == adyecentes[i]?.cellId);

                    if (adyecentes[i] != null && enemigo == null)
                    {
                        i++;
                        continue;
                    }
                    adyecentes.RemoveAt(i);
                }

                int  pm_disponibles = actual.pm_disponible - 1;
                int  pa_disponibles = actual.pa_disponible;
                int  distancia      = actual.distancia + 1;
                bool accesible      = pm_disponibles >= 0;

                for (i = 0; i < adyecentes.Count; i++)
                {
                    if (celdas_prohibidas.ContainsKey(adyecentes[i].cellId))
                    {
                        NodoPelea anterior = celdas_prohibidas[adyecentes[i].cellId];
                        if (anterior.pm_disponible > pm_disponibles)
                        {
                            continue;
                        }

                        if (anterior.pm_disponible == pm_disponibles && anterior.pm_disponible >= pa_disponibles)
                        {
                            continue;
                        }
                    }

                    if (!adyecentes[i].IsWalkable())
                    {
                        continue;
                    }

                    celdas[adyecentes[i].cellId] = new MovimientoNodo(nodo_celda.cellId, accesible);
                    nodo = new NodoPelea(adyecentes[i], pm_disponibles, pa_disponibles, distancia);
                    celdas_prohibidas[adyecentes[i].cellId] = nodo;

                    if (actual.distancia < maximos_pm)
                    {
                        celdas_permitidas.Add(nodo);
                    }
                }
            }

            foreach (short celda in celdas.Keys)
            {
                celdas[celda].camino = get_Path_Pelea(celda_actual.cellId, celda, celdas);
            }

            return(celdas);
        }