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);
}
public static List <Hechizo> listar(int mago)
{
ManagerAcessoDato db = new ManagerAcessoDato();
List <Hechizo> lista = new List <Hechizo>();
Hechizo hechizo = new Hechizo();
try
{
db.setearConsulta("select h.Nombre,h.Descripcion from hechizos as h inner join HechizosMagos as hm on hm.idHechizo=h.id where hm.IdMago=" + mago);
db.abrirConexion();
db.ejecutarConsulta();
while (db.Lector.Read())
{
hechizo = new Hechizo();
hechizo.nombre = (string)db.Lector["Nombre"].ToString();
hechizo.descripcion = (string)db.Lector["descripcion"].ToString();
lista.Add(hechizo);
}
return(lista);
}
catch (Exception ex)
{
throw ex;
}
finally
{
db.cerrarConexion();
}
}
public async Task get_Lanzar_Hechizo(int hechizo_id, int celda_id)
{
if (cuenta.Estado_Cuenta != EstadoCuenta.LUCHANDO)
return;
Hechizo hechizo = cuenta.juego.personaje.hechizos.FirstOrDefault(f => f.id == hechizo_id);
HechizoStats datos_hechizo = hechizo.get_Stats(hechizo.nivel);
if (datos_hechizo.intervalo > 0 && !hechizos_intervalo.ContainsKey(hechizo.id))
hechizos_intervalo.Add(hechizo.id, datos_hechizo.intervalo);
if (!total_hechizos_lanzados.ContainsKey(hechizo.id))
total_hechizos_lanzados.Add(hechizo.id, 0);
total_hechizos_lanzados[hechizo.id]++;
if (total_hechizos_lanzados_en_celda.ContainsKey(hechizo.id))
{
if (!total_hechizos_lanzados_en_celda[hechizo.id].ContainsKey(celda_id))
total_hechizos_lanzados_en_celda[hechizo.id].Add(celda_id, 0);
total_hechizos_lanzados_en_celda[hechizo.id][celda_id]++;
}
else
{
total_hechizos_lanzados_en_celda.Add(hechizo.id, new Dictionary<int, int>()
{
{ celda_id, 1 }
});
}
await cuenta.conexion.enviar_Paquete_Async("GA300" + hechizo.id + ';' + celda_id);
}
public List <Hechizo> listarHechizosXMago(Mago mago)
{
AccesoDatosManager accesoDatos = new AccesoDatosManager();
List <Hechizo> listado = new List <Hechizo>();
Hechizo nuevo;
try
{
accesoDatos.setearConsulta("SELECT H.Id, H.Nombre, H.Descripcion, H.IdHechizoQueLoVence FROM HECHIZOSMAGOS AS HM INNER JOIN HECHIZOS AS H ON H.Id = HM.IdHechizo WHERE IdMago = " + mago.ID);
accesoDatos.abrirConexion();
accesoDatos.ejecutarConsulta();
while (accesoDatos.Lector.Read())
{
nuevo = new Hechizo();
nuevo.HechizoVencedor = new Hechizo();
nuevo.ID = accesoDatos.Lector.GetInt32(0);
nuevo.Nombre = accesoDatos.Lector.GetString(1);
nuevo.Descripción = accesoDatos.Lector.GetString(2);
nuevo.HechizoVencedor.ID = accesoDatos.Lector.GetInt32(3);
agregarHechizoV(nuevo);
listado.Add(nuevo);
}
return(listado);
}
catch (Exception ex)
{
throw ex;
}
finally
{
accesoDatos.cerrarConexion();
}
}
public FallosLanzandoHechizo get_Puede_Lanzar_hechizo(short hechizo_id, Celda celda_actual, Celda celda_objetivo, Mapa mapa)
{
Hechizo hechizo = cuenta.juego.personaje.get_Hechizo(hechizo_id);
if (hechizo == null)
{
return(FallosLanzandoHechizo.DESONOCIDO);
}
HechizoStats datos_hechizo = hechizo.get_Stats();
if (datos_hechizo.lanzamientos_por_objetivo > 0 && total_hechizos_lanzados_en_celda.ContainsKey(hechizo_id) && total_hechizos_lanzados_en_celda[hechizo_id].ContainsKey(celda_objetivo.id) && total_hechizos_lanzados_en_celda[hechizo_id][celda_objetivo.id] >= datos_hechizo.lanzamientos_por_objetivo)
{
return(FallosLanzandoHechizo.DEMASIADOS_LANZAMIENTOS_POR_OBJETIVO);
}
if (datos_hechizo.es_celda_vacia && !es_Celda_Libre(celda_objetivo))
{
return(FallosLanzandoHechizo.NECESITA_CELDA_LIBRE);
}
if (datos_hechizo.es_lanzado_linea && !jugador_luchador.celda.get_Esta_En_Linea(celda_objetivo))
{
return(FallosLanzandoHechizo.NO_ESTA_EN_LINEA);
}
if (!get_Rango_hechizo(celda_actual, datos_hechizo, mapa).Contains(celda_objetivo.id))
{
return(FallosLanzandoHechizo.NO_ESTA_EN_RANGO);
}
return(FallosLanzandoHechizo.NINGUNO);
}
public List <Hechizo> listarHechizos()
{
AccesoDatosManager accesoDatos = new AccesoDatosManager();
List <Hechizo> listado = new List <Hechizo>();
Hechizo nuevo;
try
{
accesoDatos.setearConsulta("SELECT * FROM HECHIZOS");
accesoDatos.abrirConexion();
accesoDatos.ejecutarConsulta();
while (accesoDatos.Lector.Read())
{
nuevo = new Hechizo();
nuevo.HechizoVencedor = new Hechizo();
nuevo.ID = accesoDatos.Lector.GetInt32(0);
nuevo.Nombre = accesoDatos.Lector.GetString(1);
nuevo.Descripción = accesoDatos.Lector.GetString(2);
nuevo.HechizoVencedor.ID = accesoDatos.Lector.GetInt32(3);
agregarHechizoV(nuevo);
listado.Add(nuevo);
}
return(listado);
}
catch (Exception ex)
{
throw ex;
}
finally
{
accesoDatos.cerrarConexion();
}
}
public List <Hechizo> ListarHechizo()
{
List <Hechizo> listado = new List <Hechizo>();
AccesoDatosManager accesoDatos = new AccesoDatosManager();
Hechizo hechizo = new Hechizo();
try
{
accesoDatos.setearConsulta("select * from hechizos");
accesoDatos.abrirConexion();
accesoDatos.ejecutarConsulta();
while (accesoDatos.Lector.Read())
{
hechizo = new Hechizo();
hechizo.Id = (int)accesoDatos.Lector["Id"];
hechizo.Nombre = accesoDatos.Lector["Nombre"].ToString();
listado.Add(hechizo);
}
return(listado);
}
catch (Exception ex)
{
throw ex;
}
finally
{
accesoDatos.cerrarConexion();
}
}
public FallosLanzandoHechizo get_Puede_Lanzar_hechizo(short hechizo_id)
{
Hechizo hechizo = cuenta.juego.personaje.get_Hechizo(hechizo_id);
if (hechizo == null)
{
return(FallosLanzandoHechizo.DESONOCIDO);
}
HechizoStats datos_hechizo = hechizo.get_Stats();
if (jugador_luchador.pa < datos_hechizo.coste_pa)
{
return(FallosLanzandoHechizo.PUNTOS_ACCION);
}
if (datos_hechizo.lanzamientos_por_turno > 0 && total_hechizos_lanzados.ContainsKey(hechizo_id) && total_hechizos_lanzados[hechizo_id] >= datos_hechizo.lanzamientos_por_turno)
{
return(FallosLanzandoHechizo.DEMASIADOS_LANZAMIENTOS);
}
if (hechizos_intervalo.ContainsKey(hechizo_id))
{
return(FallosLanzandoHechizo.COOLDOWN);
}
if (datos_hechizo.efectos_normales.Count > 0 && datos_hechizo.efectos_normales[0].id == 181 && contador_invocaciones >= cuenta.juego.personaje.caracteristicas.criaturas_invocables.total_stats)
{
return(FallosLanzandoHechizo.DEMASIADAS_INVOCACIONES);
}
return(FallosLanzandoHechizo.NINGUNO);
}
private async Task <ResultadoLanzandoHechizo> lanzar_Hechizo_Celda_Vacia(HechizoPelea hechizo_pelea)
{
if (_fight.get_Puede_Lanzar_hechizo(hechizo_pelea.id) != FallosLanzandoHechizo.NONE)
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
if (hechizo_pelea.focus == HechizoFocus.CELDA_VACIA && _fight.get_Cuerpo_A_Cuerpo_Enemigo().Count() == 4)
{
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
Hechizo hechizo = cuenta.Game.Character.get_Hechizo(hechizo_pelea.id);
HechizoStats datos_hechizo = hechizo.get_Stats();
List <short> rangos_disponibles = _fight.get_Rango_hechizo(_fight.jugador_luchador.celda, datos_hechizo, _map);
foreach (short rango in rangos_disponibles)
{
if (_fight.get_Puede_Lanzar_hechizo(hechizo_pelea.id, _fight.jugador_luchador.celda, _map.get_Celda_Id(rango), _map) == FallosLanzandoHechizo.NONE)
{
if (hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.CAC || hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.AMBOS && _map.get_Celda_Id(rango).get_Distancia_Entre_Dos_Casillas(_fight.jugador_luchador.celda) != 1)
{
continue;
}
await _fight.get_Lanzar_Hechizo(hechizo_pelea.id, rango);
return(ResultadoLanzandoHechizo.LANZADO);
}
}
return(ResultadoLanzandoHechizo.NO_LANZADO);
}
public FallosLanzandoHechizo get_Puede_Lanzar_hechizo(int hechizo_id, short celda_objetivo, Mapa mapa)
{
Hechizo hechizo = cuenta.personaje.hechizos.FirstOrDefault(f => f.id == hechizo_id);
if (hechizo == null)
{
return(FallosLanzandoHechizo.DESONOCIDO);
}
HechizoStats datos_hechizo = hechizo.get_Hechizo_Stats()[hechizo.nivel];
if (datos_hechizo.lanzamientos_por_objetivo > 0 && total_hechizos_lanzados_en_celda.ContainsKey(hechizo_id) && total_hechizos_lanzados_en_celda[hechizo_id].ContainsKey(celda_objetivo) && total_hechizos_lanzados_en_celda[hechizo_id][celda_objetivo] >= datos_hechizo.lanzamientos_por_objetivo)
{
return(FallosLanzandoHechizo.DEMASIADOS_LANZAMIENTOS_POR_OBJETIVO);
}
if (datos_hechizo.es_celda_vacia && !es_Celda_Libre(celda_objetivo))
{
return(FallosLanzandoHechizo.NECESITA_CELDA_LIBRE);
}
if (datos_hechizo.es_lanzado_linea && !celdas_mapa[jugador_luchador.celda_id].get_Esta_En_Linea(celda_objetivo))
{
return(FallosLanzandoHechizo.NO_ESTA_EN_LINEA);
}
if (!get_Rango_hechizo(jugador_luchador.celda_id, datos_hechizo, mapa).Contains(celda_objetivo))
{
return(FallosLanzandoHechizo.NO_ESTA_EN_RANGO);
}
return(FallosLanzandoHechizo.NINGUNO);
}
public List <Hechizo> listar()
{
List <Hechizo> lista = new List <Hechizo>();
AccesoDatos accesoDatos = new AccesoDatos();
Hechizo hechizo;
try
{
accesoDatos.SetearConsulta("select hechizos.Id,nombre,descripcion from HECHIZOS inner join HECHIZOSMAGOS on HECHIZOS.Id = HECHIZOSMAGOS.IdHechizo");
accesoDatos.AbrirConexion();
accesoDatos.ejecutarConsulta();
while (accesoDatos.Lector.Read())
{
hechizo = new Hechizo();
hechizo.IdHechizo = (int)accesoDatos.Lector["Id"];
hechizo.NombreHechizo = accesoDatos.Lector["Nombre"].ToString();
hechizo.Descripcion = accesoDatos.Lector["Descripcion"].ToString();
lista.Add(hechizo);
}
return(lista);
}
catch (Exception ex)
{
throw ex;
}
finally
{
accesoDatos.cerrarConexion();
}
}
public Hechizo MapearObjeto(HechizoModel hm, short id = 0)
{
Hechizo h = new Hechizo();
h.id = id == 0 ? GenerarId() : id;
h.tipo = hm.Tipo;
h.nombre = hm.Nombre;
h.idImagen = hm.IdImagen;
h.idEfecto = hm.IdEfecto;
h.idSonido = hm.IdSonido;
h.descripcion = hm.Descripcion;
h.palabrasMagicas = hm.PalabrasMagicas;
h.consumo.maxMana = hm.Consumo.MaxMana;
h.consumo.minMana = hm.Consumo.MinMana;
h.consumo.maxEnergia = hm.Consumo.MaxEnergia;
h.consumo.minEnergia = hm.Consumo.MinEnergia;
h.temporales.paralizar = hm.Temporales.Paralizar;
h.temporales.inmovilizar = hm.Temporales.Inmovilizar;
h.temporales.congelar = hm.Temporales.Congelar;
h.ataque.maxDaño = hm.Ataque.MaxDaño;
h.ataque.minDaño = hm.Ataque.MinDaño;
h.ataque.envenenar = hm.Ataque.Envenenar;
return(h);
}
public static List <Hechizo> listar()
{
ManagerAcessoDato db = new ManagerAcessoDato();
List <Hechizo> lista = new List <Hechizo>();
Hechizo hechizo = new Hechizo();
try
{
db.setearConsulta("select h.id,h.Nombre,h.Descripcion,h.IdHechizoQueLoVence as idLoVence,hv.Descripcion as loVence from hechizos as h inner join HechizosMagos as hm on hm.idHechizo=h.id inner join HECHIZOS as hV on hv.Id=h.IdHechizoQueLoVence");
db.abrirConexion();
db.ejecutarConsulta();
while (db.Lector.Read())
{
hechizo = new Hechizo();
hechizo.id = (int)db.Lector["id"];
hechizo.nombre = (string)db.Lector["Nombre"].ToString();
hechizo.descripcion = (string)db.Lector["descripcion"].ToString();
hechizo.loVence = (string)db.Lector["loVence"];
lista.Add(hechizo);
}
return(lista);
}
catch (Exception ex)
{
throw ex;
}
finally
{
db.cerrarConexion();
}
}
public HechizoModel MapearHechizoModel(Hechizo h)
{
HechizoModel hm = new HechizoModel();
try
{
hm.Id = h.id;
hm.Tipo = Convert.ToInt16(h.tipo);
hm.Nombre = h.nombre;
hm.IdImagen = Convert.ToInt16(h.idImagen);
hm.IdEfecto = Convert.ToInt16(h.idEfecto);
hm.IdSonido = Convert.ToInt16(h.idSonido);
hm.Descripcion = h.descripcion;
hm.PalabrasMagicas = h.palabrasMagicas;
hm.Consumo = ConsumoModel.Mapear(h.consumo.maxMana, h.consumo.minMana, h.consumo.maxEnergia, h.consumo.minEnergia);
hm.Temporales = TemporalesModel.Mapear(h.temporales.paralizar, h.temporales.inmovilizar, h.temporales.congelar);
hm.Ataque = AtaqueModel.Mapear(h.ataque.maxDaño, h.ataque.minDaño, h.ataque.envenenar);
}
catch (Exception)
{
return(new HechizoModel());
}
return(hm);
}
public void actualizar_Hechizo_Exito(short celda_id, short hechizo_id)
{
Hechizo hechizo = cuenta.juego.personaje.get_Hechizo(hechizo_id);
HechizoStats datos_hechizo = hechizo.get_Stats();
if (datos_hechizo.intervalo > 0 && !hechizos_intervalo.ContainsKey(hechizo.id))
{
hechizos_intervalo.Add(hechizo.id, datos_hechizo.intervalo);
}
if (!total_hechizos_lanzados.ContainsKey(hechizo.id))
{
total_hechizos_lanzados.Add(hechizo.id, 0);
}
total_hechizos_lanzados[hechizo.id]++;
if (total_hechizos_lanzados_en_celda.ContainsKey(hechizo.id))
{
if (!total_hechizos_lanzados_en_celda[hechizo.id].ContainsKey(celda_id))
{
total_hechizos_lanzados_en_celda[hechizo.id].Add(celda_id, 0);
}
total_hechizos_lanzados_en_celda[hechizo.id][celda_id]++;
}
else
{
total_hechizos_lanzados_en_celda.Add(hechizo.id, new Dictionary <int, int>()
{
{ celda_id, 1 }
});
}
}
public FallosLanzandoHechizo get_Puede_Lanzar_hechizo(int hechizo_id)
{
Hechizo hechizo = cuenta.personaje.get_Hechizo(hechizo_id);
if (hechizo == null)
{
return(FallosLanzandoHechizo.DESONOCIDO);
}
HechizoStats datos_hechizo = hechizo.get_Hechizo_Stats()[hechizo.nivel];
if (jugador_luchador.pa < datos_hechizo.coste_pa)
{
return(FallosLanzandoHechizo.PUNTOS_ACCION);
}
if (datos_hechizo.lanzamientos_por_turno > 0 && total_hechizos_lanzados.ContainsKey(hechizo_id) && total_hechizos_lanzados[hechizo_id] >= datos_hechizo.lanzamientos_por_turno)
{
return(FallosLanzandoHechizo.DEMASIADOS_LANZAMIENTOS);
}
if (hechizos_intervalo.ContainsKey(hechizo_id))
{
return(FallosLanzandoHechizo.COOLDOWN);
}
return(FallosLanzandoHechizo.NINGUNO);
}
private void button_agregar_hechizo_Click(object sender, EventArgs e)
{
Hechizo hechizo = comboBox_lista_hechizos.SelectedItem as Hechizo;
cuenta.CombatExtensions.configuracion.hechizos.Add(new HechizoPelea(hechizo.id, hechizo.nombre, (HechizoFocus)comboBox_focus_hechizo.SelectedIndex, (MetodoLanzamiento)comboBox_modo_lanzamiento.SelectedIndex, Convert.ToByte(numeric_lanzamientos_turno.Value)));
cuenta.CombatExtensions.configuracion.guardar();
refrescar_Lista_Hechizos();
}
private void button_agregar_hechizo_Click(object sender, EventArgs e)
{
Hechizo hechizo = comboBox_lista_hechizos.SelectedItem as Hechizo;
cuenta.pelea_extension.configuracion.hechizos.Add(new HechizoPelea(hechizo.id, hechizo.nombre, (HechizoFocus)comboBox_focus_hechizo.SelectedIndex, checkBox_lanzar_cuerpo_cuerpo.Checked, Convert.ToByte(numeric_lanzamientos_turno.Value), checkBox_AOE.Checked, checkBox_cuidado_aoe.Checked));
cuenta.pelea_extension.configuracion.guardar();
refrescar_Lista_Hechizos();
}
private void Agregar_Hechizo_Load(object sender, EventArgs e)
{
HechizoNegocio hechizoNegocio = new HechizoNegocio();
Hechizo hechizo = new Hechizo();
txtNombreMago.Text = MagoL.Nombre.ToString();
cboHechizos.DataSource = hechizoNegocio.ListarHechizo();
cboHechizos.DisplayMember = "Nombre"; //Nombre de la varible a mostrar en pantalla
cboHechizos.ValueMember = "Id"; // nobre de la variable del id a mostar
}
// Token: 0x060001CB RID: 459 RVA: 0x000082B8 File Offset: 0x000066B8
public FallosLanzandoHechizo get_Puede_Lanzar_hechizo(short hechizo_id)
{
Hechizo hechizo = this.cuenta.juego.personaje.get_Hechizo(hechizo_id);
bool flag = hechizo == null;
FallosLanzandoHechizo result;
if (flag)
{
result = FallosLanzandoHechizo.DESONOCIDO;
}
else
{
HechizoStats stats = hechizo.get_Stats();
bool flag2 = this.jugador_luchador.pa < stats.coste_pa;
if (flag2)
{
result = FallosLanzandoHechizo.PUNTOS_ACCION;
}
else
{
bool flag3 = stats.lanzamientos_por_turno > 0 && this.total_hechizos_lanzados.ContainsKey((int)hechizo_id) && this.total_hechizos_lanzados[(int)hechizo_id] >= (int)stats.lanzamientos_por_turno;
if (flag3)
{
result = FallosLanzandoHechizo.DEMASIADOS_LANZAMIENTOS;
}
else
{
bool flag4 = this.hechizos_intervalo.ContainsKey((int)hechizo_id);
if (flag4)
{
result = FallosLanzandoHechizo.COOLDOWN;
}
else
{
bool flag5 = stats.efectos_normales.Count > 0 && stats.efectos_normales[0].id == 181 && this.contador_invocaciones >= this.cuenta.juego.personaje.caracteristicas.criaturas_invocables.total_stats;
if (flag5)
{
result = FallosLanzandoHechizo.DEMASIADAS_INVOCACIONES;
}
else
{
result = FallosLanzandoHechizo.NINGUNO;
}
}
}
}
}
return(result);
}
// Token: 0x060001CC RID: 460 RVA: 0x000083C8 File Offset: 0x000067C8
public FallosLanzandoHechizo get_Puede_Lanzar_hechizo(short hechizo_id, Celda celda_actual, Celda celda_objetivo, Mapa mapa)
{
Hechizo hechizo = this.cuenta.juego.personaje.get_Hechizo(hechizo_id);
bool flag = hechizo == null;
FallosLanzandoHechizo result;
if (flag)
{
result = FallosLanzandoHechizo.DESONOCIDO;
}
else
{
HechizoStats stats = hechizo.get_Stats();
bool flag2 = stats.lanzamientos_por_objetivo > 0 && this.total_hechizos_lanzados_en_celda.ContainsKey((int)hechizo_id) && this.total_hechizos_lanzados_en_celda[(int)hechizo_id].ContainsKey((int)celda_objetivo.id) && this.total_hechizos_lanzados_en_celda[(int)hechizo_id][(int)celda_objetivo.id] >= (int)stats.lanzamientos_por_objetivo;
if (flag2)
{
result = FallosLanzandoHechizo.DEMASIADOS_LANZAMIENTOS_POR_OBJETIVO;
}
else
{
bool flag3 = stats.es_celda_vacia && !this.es_Celda_Libre(celda_objetivo);
if (flag3)
{
result = FallosLanzandoHechizo.NECESITA_CELDA_LIBRE;
}
else
{
bool flag4 = stats.es_lanzado_linea && !this.jugador_luchador.celda.get_Esta_En_Linea(celda_objetivo);
if (flag4)
{
result = FallosLanzandoHechizo.NO_ESTA_EN_LINEA;
}
else
{
bool flag5 = !this.get_Rango_hechizo(celda_actual, stats, mapa).Contains(celda_objetivo.id);
if (flag5)
{
result = FallosLanzandoHechizo.NO_ESTA_EN_RANGO;
}
else
{
result = FallosLanzandoHechizo.NINGUNO;
}
}
}
}
}
return(result);
}
public bool GuadarDatos(HechizoModel hechizoModel)
{
try
{
Hechizo hechizo = MapearObjeto(hechizoModel);
hechizoRepository.Guardar(hechizo);
return(true);
}
catch (Exception)
{
return(false);
}
}
public bool EditarPorId(short id, HechizoModel hechizoModel)
{
try
{
Hechizo hechizo = MapearObjeto(hechizoModel, id);
hechizoRepository.Editar(id, hechizo);
return(true);
}
catch (Exception)
{
return(false);
}
}
private static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Task.Run(() =>
{
GlobalConf.cargar_Todas_Cuentas();
XElement.Parse(Properties.Resources.interactivos).Descendants("SKILL").ToList().ForEach(i => new ObjetoInteractivoModelo(i.Element("nombre").Value, i.Element("gfx").Value, bool.Parse(i.Element("caminable").Value), i.Element("habilidades").Value, bool.Parse(i.Element("recolectable").Value)));
paquete_recibido = new PaqueteRecibido();
paquete_recibido.Inicializar();
}).ContinueWith(t =>
{
XElement.Parse(Properties.Resources.hechizos).Descendants("HECHIZO").ToList().ForEach(mapa =>
{
Hechizo hechizo = new Hechizo(short.Parse(mapa.Attribute("ID").Value), mapa.Element("NOMBRE").Value);
HechizoStats hechizo_stats = new HechizoStats();
mapa.Descendants("NIVEL").ToList().ForEach(stats =>
{
hechizo_stats.coste_pa = byte.Parse(stats.Attribute("COSTE_PA").Value);
hechizo_stats.alcanze_minimo = byte.Parse(stats.Attribute("RANGO_MINIMO").Value);
hechizo_stats.alcanze_maximo = byte.Parse(stats.Attribute("RANGO_MAXIMO").Value);
hechizo_stats.es_lanzado_linea = bool.Parse(stats.Attribute("LANZ_EN_LINEA").Value);
hechizo_stats.es_lanzado_con_vision = bool.Parse(stats.Attribute("NECESITA_VISION").Value);
hechizo_stats.es_celda_vacia = bool.Parse(stats.Attribute("NECESITA_CELDA_LIBRE").Value);
hechizo_stats.es_alcanze_modificable = bool.Parse(stats.Attribute("RANGO_MODIFICABLE").Value);
hechizo_stats.lanzamientos_por_turno = byte.Parse(stats.Attribute("MAX_LANZ_POR_TURNO").Value);
hechizo_stats.lanzamientos_por_objetivo = byte.Parse(stats.Attribute("MAX_LANZ_POR_OBJETIVO").Value);
hechizo_stats.intervalo = byte.Parse(stats.Attribute("COOLDOWN").Value);
stats.Descendants("EFECTO").ToList().ForEach(efecto =>
{
hechizo_stats.agregar_efecto(new HechizoEfecto(int.Parse(efecto.Attribute("TIPO").Value), Zonas.Parse(efecto.Attribute("ZONA").Value)), bool.Parse(efecto.Attribute("ES_CRITICO").Value));
});
hechizo.get_Agregar_Hechizo_Stats(byte.Parse(stats.Attribute("ID").Value), hechizo_stats);
});
});
}).Wait();
Application.Run(new Principal());
}
// Token: 0x060001BB RID: 443 RVA: 0x00007AF0 File Offset: 0x00005EF0
public void actualizar_Hechizo_Exito(short celda_id, short hechizo_id)
{
Hechizo hechizo = this.cuenta.juego.personaje.get_Hechizo(hechizo_id);
HechizoStats stats = hechizo.get_Stats();
bool flag = stats.intervalo > 0 && !this.hechizos_intervalo.ContainsKey((int)hechizo.id);
if (flag)
{
this.hechizos_intervalo.Add((int)hechizo.id, (int)stats.intervalo);
}
bool flag2 = !this.total_hechizos_lanzados.ContainsKey((int)hechizo.id);
if (flag2)
{
this.total_hechizos_lanzados.Add((int)hechizo.id, 0);
}
Dictionary <int, int> dictionary = this.total_hechizos_lanzados;
int num = (int)hechizo.id;
int num2 = dictionary[num];
dictionary[num] = num2 + 1;
bool flag3 = this.total_hechizos_lanzados_en_celda.ContainsKey((int)hechizo.id);
if (flag3)
{
bool flag4 = !this.total_hechizos_lanzados_en_celda[(int)hechizo.id].ContainsKey((int)celda_id);
if (flag4)
{
this.total_hechizos_lanzados_en_celda[(int)hechizo.id].Add((int)celda_id, 0);
}
Dictionary <int, int> dictionary2 = this.total_hechizos_lanzados_en_celda[(int)hechizo.id];
num = dictionary2[(int)celda_id];
dictionary2[(int)celda_id] = num + 1;
}
else
{
this.total_hechizos_lanzados_en_celda.Add((int)hechizo.id, new Dictionary <int, int>
{
{
(int)celda_id,
1
}
});
}
}
public void actualizar_Hechizos(string paquete)
{
hechizos.Clear();
string[] limitador = paquete.Split(';'), separador;
short hechizo_id;
byte nivel;
for (int i = 0; i < limitador.Length - 1; ++i)
{
separador = limitador[i].Split('~');
hechizo_id = short.Parse(separador[0]);
nivel = byte.Parse(separador[1]);
hechizos.Add(Hechizo.get_Hechizo(hechizo_id, nivel));
}
hechizos_actualizados.Invoke();
}
private void btnAceptar_Click(object sender, EventArgs e)
{
Hechizo hAgregar = (Hechizo)cmbHechizos.SelectedItem;
List <Hechizo> hechizosAsociados = new List <Hechizo>();
hechizosAsociados = negocio.listarHechizosXMago(magoLocal);
foreach (Hechizo h in hechizosAsociados)
{
if (h.Nombre == hAgregar.Nombre)
{
MessageBox.Show("Este hechizo ya está asociado al mago.", "Cuidado!");
return;
}
}
negocio.agregarHechizo(magoLocal, hAgregar);
MessageBox.Show("Hechizo '" + hAgregar.Nombre + "' asociado al mago '" + magoLocal.Nombre + "'.");
this.Close();
}
void AtaqueHechizo()
{
//buscamos el estado actual del jugador con la informacion del animador
AnimatorStateInfo stateInfo = anim.GetCurrentAnimatorStateInfo(0);
bool loading = stateInfo.IsName("Player_Hechizo"); //comprueba si esta esta animacion
//detectamos el ataque va abajo de todo por la prioridad
if (Input.GetKeyDown(KeyCode.LeftShift)) //comprueba si apreto la tecla y si no estoy atacando ya
{
anim.SetTrigger("Loading"); //seteo el trigger a true
aura.AuraStart(); //pone la animacion del aura a funcionar
}
else if (Input.GetKeyUp(KeyCode.LeftShift))
{
anim.SetTrigger("Idle");
if (aura.IsLoaded()) //si esta cargada el aura crea la instancia del hechizo
//conseguir rotacion de un vector
{
float angle = Mathf.Atan2(anim.GetFloat("movY"), anim.GetFloat("movX")) * Mathf.Rad2Deg; //siempre eje Y primero y la ultima funcion pasa de radianes a grados
//instanciamos el hechizo pasamos prefab la pos del jugador el angulo o direccion vector forward siemore es hacia adelante
GameObject hechizoObj = Instantiate(hechizoPrefab, transform.position, Quaternion.AngleAxis(angle, Vector3.forward));
//le damos movimiento llamando a su funcion de hechizo.cs le seteamos al vector 2 los valores almacenados en el blend tree de walking
Hechizo hechizo = hechizoObj.GetComponent <Hechizo> ();
hechizo.mov.x = anim.GetFloat("movX");
hechizo.mov.y = anim.GetFloat("movY");
}
aura.AuraStop(); //detiene la animacion del aura
//esperamos un poco antes de darle movimiento otra vez
StartCoroutine(EnableMovAfter(0.4f));
}
//privamos el movimiento al estar cargando
if (loading)
{
movePrevent = true;
}
}
public void agregarHechizo(Mago mago, Hechizo hechizo)
{
AccesoDatosManager accesoDatos = new AccesoDatosManager();
try
{
accesoDatos.setearConsulta("INSERT INTO HECHIZOSMAGOS (IDMAGO, IDHECHIZO) VALUES (" + mago.ID + ", " + hechizo.ID + ")");
accesoDatos.abrirConexion();
accesoDatos.ejecutarAccion();
}
catch (Exception ex)
{
throw ex;
}
finally
{
accesoDatos.cerrarConexion();
}
}
// Token: 0x060001A0 RID: 416 RVA: 0x000075A8 File Offset: 0x000059A8
private async Task <ResultadoLanzandoHechizo> lanzar_Hechizo_Celda_Vacia(HechizoPelea hechizo_pelea)
{
bool flag = this.pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id) > FallosLanzandoHechizo.NINGUNO;
ResultadoLanzandoHechizo result;
if (flag)
{
result = ResultadoLanzandoHechizo.NO_LANZADO;
}
else
{
bool flag2 = hechizo_pelea.focus == HechizoFocus.CELL_VIDE && this.pelea.get_Cuerpo_A_Cuerpo_Enemigo(null).Count <Luchadores>() == 4;
if (flag2)
{
result = ResultadoLanzandoHechizo.NO_LANZADO;
}
else
{
Hechizo hechizo = this.cuenta.juego.personaje.get_Hechizo(hechizo_pelea.id);
HechizoStats datos_hechizo = hechizo.get_Stats();
List <short> rangos_disponibles = this.pelea.get_Rango_hechizo(this.pelea.jugador_luchador.celda, datos_hechizo, this.mapa);
foreach (short rango in rangos_disponibles)
{
bool flag3 = this.pelea.get_Puede_Lanzar_hechizo(hechizo_pelea.id, this.pelea.jugador_luchador.celda, this.mapa.get_Celda_Id(rango), this.mapa) == FallosLanzandoHechizo.NINGUNO;
if (flag3)
{
bool flag4 = hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.CAC || (hechizo_pelea.metodo_lanzamiento == MetodoLanzamiento.CAC_ET_DISTANCE && this.mapa.get_Celda_Id(rango).get_Distancia_Entre_Dos_Casillas(this.pelea.jugador_luchador.celda) != 1);
if (!flag4)
{
await this.pelea.get_Lanzar_Hechizo(hechizo_pelea.id, rango);
return(ResultadoLanzandoHechizo.LANZADO);
}
}
}
List <short> .Enumerator enumerator = default(List <short> .Enumerator);
result = ResultadoLanzandoHechizo.NO_LANZADO;
}
}
return(result);
}