private Luchadores get_Objetivo_Mas_Cercano(PeleaHechizos hechizo)
{
if (hechizo.focus == HechizoFocus.ENCIMA)
{
return(pelea.jugador_luchador);
}
if (hechizo.focus == HechizoFocus.CELDA_VACIA)
{
return(null);
}
//TODO: esta vivo, evitar invocaciones, % vida, % resistencias
bool filtro(Luchadores luchador)
{
if (cuenta.pelea_extension.configuracion.ignorar_invocaciones && luchador.es_invocacion)
{
return(false);
}
return(luchador.porcentaje_vida <= hechizo.vida_objetivo);
}
return(hechizo.focus == HechizoFocus.ENEMIGO ? pelea.get_Enemigo_Mas_Cercano(filtro) : pelea.get_Obtener_Aliado_Mas_Cercano(filtro));
}
private async Task <ResultadoLanzandoHechizo> lanzar_Hechizo_Celda_Vacia(PeleaHechizos hechizo_pelea)
{
if (pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id) != FallosLanzandoHechizo.NINGUNO)
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
if (hechizo_pelea.focus == HechizoFocus.CELDA_VACIA && pelea.get_Cuerpo_A_Cuerpo_Enemigo().Count() == 4)
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
Hechizo hechizo = cuenta.juego.personaje.get_Hechizo(hechizo_pelea.id);
HechizoStats hechizo_stats = hechizo.get_Stats();
List <short> rangos_disponibles = pelea.get_Rango_Hechizo(pelea.jugador_luchador.celda, hechizo_stats, mapa);
foreach (short rango in rangos_disponibles)
{
if (pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id, pelea.jugador_luchador.celda, mapa.get_Celda_Id(rango), mapa) == FallosLanzandoHechizo.NINGUNO)
{
if (hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.CAC || hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.AMBOS && mapa.get_Celda_Id(rango).get_Distancia(pelea.jugador_luchador.celda) != 1)
{
continue;
}
await pelea.get_Lanzar_Hechizo(hechizo_pelea.id, rango);
return(ResultadoLanzandoHechizo.LANZADO);
}
}
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
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);
}
private async Task get_Procesar_hechizo()
{
if (cuenta?.esta_Luchando() == false || configuracion == null)
{
return;
}
if (hechizo_index >= hechizos.Count)
{
await antes_Fin_Turno();
return;
}
PeleaHechizos hechizo_actual = hechizos[hechizo_index];
if (hechizo_actual.lanzamientos_restantes == 0)
{
await get_Procesar_Siguiente_Hechizo(hechizo_actual, true);
return;
}
if (!(turno == 1 || hechizo_actual.turno_lanzado == 0 || turno == (hechizo_actual.turno_lanzado + 1)))
{
await get_Procesar_Siguiente_Hechizo(hechizo_actual);
return;
}
ResultadoLanzandoHechizo resultado = await manejador_hechizos.manejador_Hechizos(hechizo_actual);
switch (resultado)
{
case ResultadoLanzandoHechizo.NO_LANZADO:
await get_Procesar_Siguiente_Hechizo(hechizo_actual);
break;
case ResultadoLanzandoHechizo.LANZADO:
hechizo_lanzado = true;
hechizo_actual.lanzamientos_restantes--;
esperando_sequencia = true;
break;
case ResultadoLanzandoHechizo.MOVIDO:
esperando_sequencia = true;
break;
}
}
private void button_bajar_hechizo_Click(object sender, EventArgs e)
{
if (listView_hechizos_pelea.FocusedItem == null || listView_hechizos_pelea.FocusedItem.Index == listView_hechizos_pelea.Items.Count - 1)
{
return;
}
ObservableCollection <PeleaHechizos> hechizos = cuenta.pelea_extension.configuracion.hechizos;
PeleaHechizos temporal = hechizos[listView_hechizos_pelea.FocusedItem.Index + 1];
hechizos[listView_hechizos_pelea.FocusedItem.Index + 1] = hechizos[listView_hechizos_pelea.FocusedItem.Index];
hechizos[listView_hechizos_pelea.FocusedItem.Index] = temporal;
cuenta.pelea_extension.configuracion.guardar();
refrescar_Lista_Hechizos();
}
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 NodoRango get_Nodo_Rango(Celda celda, MovimientoNodo node, PeleaHechizos hechizo_pelea, HechizoStats hechizo_stats)
{
Dictionary <short, byte> enemigos_golpeados = new Dictionary <short, byte>();
List <short> rango = pelea.get_Rango_Hechizo(celda, hechizo_stats, mapa);
for (int i = 0; i < rango.Count; i++)
{
byte tec = get_Total_Enemigos_Atacados(celda, mapa.get_Celda_Id(rango[i]), hechizo_pelea, hechizo_stats);
if (tec > 0)
{
enemigos_golpeados.Add(rango[i], tec);
}
}
return(new NodoRango(celda, enemigos_golpeados, node));
}
private async Task get_Procesar_Siguiente_Hechizo(PeleaHechizos hechizo_actual, bool actualizar_turno = false)
{
if (cuenta?.esta_Luchando() == false)
{
return;
}
hechizo_actual.lanzamientos_restantes = hechizo_actual.lanzamientos_x_turno;
hechizo_index++;
if (actualizar_turno)
{
hechizo_actual.turno_lanzado = turno;
}
await get_Procesar_hechizo();
}
public async Task <ResultadoLanzandoHechizo> manejador_Hechizos(PeleaHechizos hechizo)
{
if (hechizo_para_lanzar != -1 && hechizo_para_lanzar == hechizo.id)
{
if (GlobalConf.mostrar_mensajes_debug)
{
cuenta.logger.log_informacion("DEBUG", $"Se ha lanzado el hechizo {hechizo.nombre} atacando a {enemigos_tocados} enemigos en la celda {celda_objetivo}");
}
await pelea.get_Lanzar_Hechizo(hechizo.id, celda_objetivo);
hechizo_para_lanzar = -1;
celda_objetivo = -1;
enemigos_tocados = 0;
return(ResultadoLanzandoHechizo.LANZADO);
}
if (!get_Distancia_Buena(hechizo))
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
if (hechizo.necesita_piedra)//Para capturar
{
ObjetosInventario arma = cuenta.juego.personaje.inventario.get_Objeto_en_Posicion(InventarioPosiciones.ARMA);
if (arma != null && arma.id_modelo != 83)
{
return(await get_Lanzar_Hechizo_Simple(hechizo));
}
else
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
}
if (hechizo.focus == HechizoFocus.CELDA_VACIA)
{
return(await lanzar_Hechizo_Celda_Vacia(hechizo));
}
if (hechizo.metodo_lanzamiento == MetodoLanzamiento.AMBOS && !hechizo.es_aoe)
{
return(await get_Lanzar_Hechizo_Simple(hechizo));
}
if (hechizo.metodo_lanzamiento == MetodoLanzamiento.ALEJADO && !hechizo.es_aoe && !pelea.esta_Cuerpo_A_Cuerpo_Con_Enemigo())
{
return(await get_Lanzar_Hechizo_Simple(hechizo));
}
if (hechizo.metodo_lanzamiento == MetodoLanzamiento.CAC && !hechizo.es_aoe && pelea.esta_Cuerpo_A_Cuerpo_Con_Enemigo())
{
return(await get_Lanzar_Hechizo_Simple(hechizo));
}
if (hechizo.metodo_lanzamiento == MetodoLanzamiento.CAC && !hechizo.es_aoe && !pelea.esta_Cuerpo_A_Cuerpo_Con_Enemigo())
{
return(await get_Mover_Lanzar_hechizo_Simple(hechizo, get_Objetivo_Mas_Cercano(hechizo)));
}
if (hechizo.es_aoe)
{
if (pelea.total_enemigos_vivos > 1)
{
return(await lanzar_Hechizo_AOE(hechizo));
}
else
{
return(await get_Lanzar_Hechizo_Simple(hechizo));
}
}
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
private byte get_Total_Enemigos_Atacados(Celda celda_actual, Celda celda_objetivo, PeleaHechizos hechizo_pelea, HechizoStats hechizo_stats)
{
byte n = 0;
List <Celda> zona = pelea.get_Zona_Hechizo(celda_actual, celda_objetivo, hechizo_stats, mapa);
if (zona != null)
{
foreach (Celda celda in zona)
{
if (hechizo_pelea.auto_golpearse && celda.id == celda_actual.id)
{
return(0);
}
if (hechizo_pelea.golpear_aliados)
{
foreach (Luchadores aliado in pelea.get_Aliados)
{
if (aliado.celda.id == celda.id)
{
return(0);
}
}
}
foreach (Luchadores enemigo in pelea.get_Enemigos)
{
if (enemigo.celda.id == celda.id)
{
n++;
}
}
}
}
return(n);
}
private async Task <ResultadoLanzandoHechizo> lanzar_Hechizo_AOE(PeleaHechizos hechizo_pelea)
{
if (hechizo_pelea.focus == HechizoFocus.ALIADO || hechizo_pelea.focus == HechizoFocus.CELDA_VACIA)
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
if (pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id) != FallosLanzandoHechizo.NINGUNO)
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
Hechizo hechizo = cuenta.juego.personaje.get_Hechizo(hechizo_pelea.id);
HechizoStats hechizo_stats = hechizo.get_Stats();
List <NodoRango> entradas = new List <NodoRango>();
NodoRango entrada;
//Celda actual del jugador
entrada = get_Nodo_Rango(pelea.jugador_luchador.celda, null, hechizo_pelea, hechizo_stats);
if (entrada.enemigos_atacos_en_celda.Count > 0)
{
entradas.Add(entrada);
}
foreach (KeyValuePair <short, MovimientoNodo> kvp in PeleasPathfinder.get_Celdas_Accesibles(pelea, mapa, pelea.jugador_luchador.celda))
{
if (!kvp.Value.alcanzable)
{
continue;
}
entrada = get_Nodo_Rango(mapa.get_Celda_Id(kvp.Key), kvp.Value, hechizo_pelea, hechizo_stats);
if (entrada.enemigos_atacos_en_celda.Count > 0)
{
entradas.Add(entrada);
}
}
short celda_id = -1;
short desde_celda_id = -1;
KeyValuePair <short, MovimientoNodo>?node = null;
byte enemigos_atacados = 0;
int pm_utilizados = 99;
foreach (NodoRango nodo in entradas)
{
foreach (KeyValuePair <short, byte> kvp in nodo.enemigos_atacos_en_celda)
{
if (hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.CAC && !pelea.esta_Cuerpo_A_Cuerpo_Con_Enemigo(nodo.celda))
{
continue;
}
if (pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id, nodo.celda, mapa.get_Celda_Id(kvp.Key), mapa) != FallosLanzandoHechizo.NINGUNO)
{
continue;
}
if (kvp.Value >= enemigos_atacados)
{
if (kvp.Value > enemigos_atacados || (kvp.Value == enemigos_atacados && nodo.pm_utilizados <= pm_utilizados))
{
enemigos_atacados = kvp.Value;
celda_id = kvp.Key;
desde_celda_id = nodo.celda.id;
pm_utilizados = nodo.pm_utilizados;
if (nodo.nodo != null)
{
node = new KeyValuePair <short, MovimientoNodo>(desde_celda_id, nodo.nodo);
}
}
}
}
}
if (celda_id != -1)
{
if (node == null)
{
if (GlobalConf.mostrar_mensajes_debug)
{
cuenta.logger.log_informacion("DEBUG", $"Se ha lanzado el hechizo {hechizo.nombre} atacando a {enemigos_atacados} enemigos en la celda {celda_id}");
}
await pelea.get_Lanzar_Hechizo(hechizo_pelea.id, celda_id);
return(ResultadoLanzandoHechizo.LANZADO);
}
else
{
hechizo_para_lanzar = hechizo.id;
celda_objetivo = celda_id;
enemigos_tocados = enemigos_atacados;
await cuenta.juego.manejador.movimientos.get_Mover_Celda_Pelea(node);
return(ResultadoLanzandoHechizo.MOVIDO);
}
}
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
private async Task <ResultadoLanzandoHechizo> get_Mover_Lanzar_hechizo_Simple(PeleaHechizos hechizo_pelea, Luchadores enemigo)
{
KeyValuePair <short, MovimientoNodo>?nodo = null;
int pm_utilizados = 99;
foreach (KeyValuePair <short, MovimientoNodo> movimiento in PeleasPathfinder.get_Celdas_Accesibles(pelea, mapa, pelea.jugador_luchador.celda))
{
if (!movimiento.Value.alcanzable)
{
continue;
}
if (hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.CAC && !pelea.esta_Cuerpo_A_Cuerpo_Con_Enemigo(mapa.get_Celda_Id(movimiento.Key)))
{
continue;
}
if (pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id, mapa.get_Celda_Id(movimiento.Key), enemigo.celda, mapa) != FallosLanzandoHechizo.NINGUNO)
{
continue;
}
if (movimiento.Value.camino.celdas_accesibles.Count <= pm_utilizados)
{
nodo = movimiento;
pm_utilizados = movimiento.Value.camino.celdas_accesibles.Count;
}
}
if (nodo != null)
{
await cuenta.juego.manejador.movimientos.get_Mover_Celda_Pelea(nodo);
return(ResultadoLanzandoHechizo.MOVIDO);
}
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
