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);
}
}
}
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;
}
}
}
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);
}
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);
}
}
}
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);
}
}
}
}
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();
}
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();
}
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();
}
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);
}
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);
}
}
}
}
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);
}
}
}
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;
}
// 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);
}
}
// 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);
}
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;
}
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);
// 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);
}
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);
}
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);
}
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);
}
}
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);
}
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;
}
// 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);
}
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);
}