/// <summary>
/// <para>Toma el turno de una unidad</para>
/// </summary>
/// <param name="target">Unidad</param>
/// <returns></returns>
private bool TomarTurno(Unidad target) // Toma el turno de una unidad
{
BaseExcepcion exc = new BaseExcepcion(GetCounter(target) >= turnoActivacion);
target.EnviarNotificacion(CambioTurnoNotificacion, exc);
return(exc.Toggle);
}
/// <summary>
/// <para>Predice el damage de un ataque</para>
/// </summary>
/// <param name="target">Area de ataque</param>
/// <returns></returns>
public override int Predecir(Area target) // Predice el damage de un ataque
{
Unidad atacante = GetComponentInParent <Unidad>();
Unidad defensor = target.contenido.GetComponent <Unidad>();
// Obtener la base de ataque de los atacantes considerando
// los objetos, ayudas, estado y equipo, etc
int ataque = GetStat(atacante, defensor, GetAtaqueNotificacion, 0);
// Obtener la base de defensa de los atacantes considerando
// los objetos, ayudas, estado y equipo, etc
int defensa = GetStat(atacante, defensor, GetDefensaNotificacion, 0);
// Calcular el damage base
int damage = ataque - (defensa / 2);
damage = Mathf.Max(damage, 1);
// Obtener las habilidades de los stats considerando posibles variaciones
int poder = GetStat(atacante, defensor, GetPoderNotificacion, 0);
// Aplicar bonus
damage = poder * damage / 100;
damage = Mathf.Max(damage, 1);
// Ajusta el damage basado en una variedad de otros controles como
// damage elemental, golpes criticos, multiplicadores de damage, etc.
damage = GetStat(atacante, defensor, AjustarDamageNotificacion, damage);
// Comprueba el limite
damage = Mathf.Clamp(damage, minDamage, maxDamage);
return(-damage);
}
/// <summary>
/// <para>Predice el heal de una habilidad</para>
/// </summary>
/// <param name="target">Area de heal</param>
/// <returns></returns>
public override int Predecir(Area target) // Predice el heal de una habilidad
{
Unidad atacante = GetComponentInParent <Unidad>();
Unidad defensor = target.contenido.GetComponent <Unidad>();
return(GetStat(atacante, defensor, GetPoderNotificacion, 0));
}
/// <summary>
/// <para>Selecciona el plan de direccion</para>
/// </summary>
/// <param name="plan"></param>
private void PlanDirectionDependent(PlanDeAtaque plan) // Selecciona el plan de direccion
{
// Obtener datos
Area areaInicial = Unidad.Area;
Direcciones dirInicial = Unidad.dir;
List <OpcionAtaque> list = new List <OpcionAtaque>();
List <Area> opcionesMov = GetOpcionesMovimiento();
// Comprobar las opciones de movimiento
for (int n = 0; n < opcionesMov.Count; n++)
{
Area sigArea = opcionesMov[n];
Unidad.Posicionar(sigArea);
// Comprobar las ocpiones de direccion
for (int i = 0; i < 4; i++)
{
Unidad.dir = (Direcciones)i;
OpcionAtaque opcionAtaq = new OpcionAtaque();
opcionAtaq.objetivo = sigArea;
opcionAtaq.direccion = Unidad.dir;
AnalizarLocalizacionAtaque(plan, opcionAtaq);
opcionAtaq.AddMovimientoObjetivo(sigArea);
list.Add(opcionAtaq);
}
}
// Posicionar unidad
Unidad.Posicionar(areaInicial);
Unidad.dir = dirInicial;
// Elegir la mejor opcion
ElegirMejorOpcion(plan, list);
}
/// <summary>
/// <para>Buscar una unidad cercana</para>
/// </summary>
private void BuscarUnidadCercana() // Buscar una unidad cercana
{
unidadCercana = null;
// Buscar con un criterio
freya.grid.Buscar(Unidad.Area, delegate(Area arg1, Area arg2)
{
if (unidadCercana == null && arg2.contenido != null)
{
Bando bando = arg2.contenido.GetComponentInChildren <Bando>();
if (bando != null && Bando.IsCalculo(bando, Objetivos.Enemigo))
{
// Si la alianza esta
Unidad unidad = bando.GetComponent <Unidad>();
Stats stats = unidad.GetComponent <Stats>();
// Si la unidad no esta KO
if (stats[TipoStats.HP] > 0)
{
// Obtener la unidad cercana
unidadCercana = unidad;
return(true);
}
}
}
return(unidadCercana == null);
});
}
private Unidad unidad; // Unidad
#endregion
#region Metodos
/// <summary>
/// <para>Cuando se activa</para>
/// </summary>
private void OnEnable() // Cuando se activa
{
unidad = GetComponentInParent <Unidad>();
if (unidad)
{
this.AddObservador(OnNewTurno, TurnoController.TurnoComienzoNotificacion, unidad);
}
}
/// <summary>
/// <para>Cuando se comprueba el acierto automatico</para>
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void OnAutomaticAciertoComprueba(object sender, object args) // Cuando se comprueba el acierto automatico
{
Unidad uni = GetComponentInParent <Unidad>();
MatchExcepcion exc = args as MatchExcepcion;
if (uni == exc.objetivo)
{
exc.FlipToggle();
}
}
/// <summary>
/// <para>Devuelve un valor en el rango de 0 a 100 como un porcentaje de probabilidad de que una habilidad tenga exito</para>
/// </summary>
/// <param name="atacante">Atacante</param>
/// <param name="defensor">Defensor</param>
/// <returns></returns>
public override int Calcular(Area target) // Devuelve un valor en el rango de 0 a 100 como un porcentaje de probabilidad de que una habilidad tenga exito
{
Unidad defensor = target.contenido.GetComponent <Unidad>();
if (AutomaticEvasion(defensor))
{
return(Final(100));
}
return(Final(0));
}
/// <summary>
/// <para>Selecciona el plan de direccion</para>
/// </summary>
/// <param name="plan"></param>
private void PlanDireccionIndependiente(PlanDeAtaque plan) // Selecciona el plan de direccion
{
// Obtener datos
Area areaInicial = Unidad.Area;
Dictionary <Area, OpcionAtaque> mapeo = new Dictionary <Area, OpcionAtaque>();
RangoHabilidad rangoHab = plan.habilidad.GetComponent <RangoHabilidad>();
List <Area> opcionesMov = GetOpcionesMovimiento();
// Comprobar las opciones de movimiento
for (int n = 0; n < opcionesMov.Count; n++)
{
// Posicionar la unidad en la siguiente area
Area sigArea = opcionesMov[n];
Unidad.Posicionar(sigArea);
// Obtener las posibles opciones de ataque
List <Area> opcionesAtaq = rangoHab.GetAreasARango(freya.grid);
// Comprobar las opciones de ataques
for (int i = 0; i < opcionesAtaq.Count; i++)
{
Area areaAtaque = opcionesAtaq[i];
OpcionAtaque opcionAtaq = null;
// Comprobar si el area puede ser atacada
if (mapeo.ContainsKey(areaAtaque))
{
opcionAtaq = mapeo[areaAtaque];
}
else
{
// Cambiar la ocpion
opcionAtaq = new OpcionAtaque();
mapeo[areaAtaque] = opcionAtaq;
opcionAtaq.objetivo = areaAtaque;
opcionAtaq.direccion = Unidad.dir;
AnalizarLocalizacionAtaque(plan, opcionAtaq);
}
// Moveer hacia la siguiente area
opcionAtaq.AddMovimientoObjetivo(sigArea);
}
}
// Posicionar unidad
Unidad.Posicionar(areaInicial);
List <OpcionAtaque> list = new List <OpcionAtaque>(mapeo.Values);
// Elegir la mejor opcion
ElegirMejorOpcion(plan, list);
}
/// <summary>
/// <para>Ajusta el franqueo de las unidades</para>
/// </summary>
/// <param name="atacante"></param>
/// <param name="defensor"></param>
/// <param name="porcentaje"></param>
/// <returns></returns>
private int AjustarFranqueo(Unidad defensor, int porcentaje) // Ajusta el franqueo de las unidades
{
switch (atacante.GetFranqueo(defensor))
{
case Franqueo.Delante:
return(porcentaje);
case Franqueo.Lados:
return(porcentaje / 2);
default:
return(porcentaje / 4);
}
}
/// <summary>
/// <para>Comprobar la tasa de exito</para>
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void OnTasaExitoStatusCheck(object sender, object args) // Comprobar la tasa de exito
{
Info <Unidad, Unidad, int> info = args as Info <Unidad, Unidad, int>;
Unidad unidad = GetComponentInParent <Unidad>();
if (unidad == info.arg0)
{
// El atacante es ciego
info.arg2 += 50;
}
else if (unidad == info.arg1)
{
// El defensor es ciego
info.arg2 -= 20;
}
}
/// <summary>
/// <para>Aplica el damage</para>
/// </summary>
/// <param name="target">Area</param>
public override int OnAplicar(Area target)
{
Unidad defensor = target.contenido.GetComponent <Unidad>();
EstadoUnidad estado = defensor.GetComponentInChildren <EstadoUnidad>();
DuracionCondicionEstadoUnidad[] candidatos = estado.GetComponentsInChildren <DuracionCondicionEstadoUnidad>();
for (int i = candidatos.Length - 1; i >= 0; --i)
{
EfectoEstadoUnidad efecto = candidatos[i].GetComponentInParent <EfectoEstadoUnidad>();
if (Tipos.Contains(efecto.GetType()))
{
candidatos[i].Remove();
}
}
return(0);
}
/// <summary>
/// <para>Aplica el damage en un area</para>
/// </summary>
/// <param name="target">Area</param>
public override int OnAplicar(Area target) // Aplica el damage en un area
{
Unidad defensor = target.contenido.GetComponent <Unidad>();
// Predecir el valor
int value = Predecir(target);
// Agregar una variacion
value = Mathf.FloorToInt(value * UnityEngine.Random.Range(0.9f, 1.1f));
// Comprobar el rango
value = Mathf.Clamp(value, minDamage, maxDamage);
// Aplicar el damage
Stats s = defensor.GetComponent <Stats>();
s[TipoStats.HP] += value;
return(value);
}
/// <summary>
/// <para>Devuelve un valor en el rango de 0 a 100 como un porcentaje de probabilidad de que una habilidad tenga exito</para>
/// </summary>
/// <param name="atacante">Atacante</param>
/// <param name="defensor">Defensor</param>
/// <returns></returns>
public override int Calcular(Area target) // Devuelve un valor en el rango de 0 a 100 como un porcentaje de probabilidad de que una habilidad tenga exito
{
Unidad defensor = target.contenido.GetComponent <Unidad>();
if (AutomaticExito(defensor))
{
return(Final(0));
}
if (AutomaticEvasion(defensor))
{
return(Final(100));
}
int evasion = GetEvasion(defensor);
evasion = AjustarFranqueo(defensor, evasion);
evasion = AjustarEfectosStatus(defensor, evasion);
evasion = Mathf.Clamp(evasion, 5, 95);
return(Final(evasion));
}
/// <summary>
/// <para>Evaluar el plan de ataque</para>
/// </summary>
/// <returns></returns>
public PlanDeAtaque Evaluar() // Evaluar el plan de ataque
{
// Obtener el plan de ataque y el patron
PlanDeAtaque plan = new PlanDeAtaque();
PatronAtaque patron = Unidad.GetComponentInChildren <PatronAtaque>();
// Si hay patron, seleccionar plan, sino dar uno por defecto
if (patron)
{
patron.Eleccion(plan);
}
else
{
PatronAtaqueGeneral(plan);
}
// Comprobar la posicion y direccion y preparar la accion
if (IsPosicionIndependiente(plan))
{
PlanPosicionIndependiente(plan);
}
else if (IsDireccionIndependiente(plan))
{
PlanDireccionIndependiente(plan);
}
else
{
PlanDirectionDependent(plan);
}
// Mover hacia el oponente
if (plan.habilidad == null)
{
MoverHaciaOponente(plan);
}
return(plan);
}
/// <summary>
/// <para>Obtiene la defensa base</para>
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public override int GetBaseDefensa(Unidad target) // Obtiene la defensa base
{
return(target.GetComponent <Stats>()[TipoStats.DEF]);
}
/// <summary>
/// <para>Obtener el counter de una unidad</para>
/// </summary>
/// <param name="target">Unidad</param>
/// <returns></returns>
private int GetCounter(Unidad target) // Obtener el counter de una unidad
{
return(target.GetComponent <Stats>()[TipoStats.CTR]);
}
/// <summary>
/// <para>Obtiene la evasion de la unidad</para>
/// </summary>
/// <param name="target">Unidad</param>
/// <returns></returns>
private int GetEvasion(Unidad target) // Obtiene la evasion de la unidad
{
Stats s = target.GetComponentInParent <Stats>();
return(Mathf.Clamp(s[TipoStats.EVD], 0, 100));
}
/// <summary>
/// <para>Inicializador de <see cref="Mana"/></para>
/// </summary>
private void Awake() // Inicializador de Mana
{
stats = GetComponent <Stats>();
unidad = GetComponent <Unidad>();
}
private Stats stats; // Estadisticas
#endregion
#region Inicializaciones
/// <summary>
/// <para>Inicializacion de <see cref="EstadoEfectoKO"/></para>
/// </summary>
private void Awake() // Inicializacion de EstadoEfectoKO
{
unidad = GetComponentInParent <Unidad>();
stats = unidad.GetComponent <Stats>();
}
public readonly Unidad objetivo; // Objetivo
#endregion
#region Constructor
/// <summary>
/// <para>Constructor de <see cref="MatchExcepcion"/></para>
/// </summary>
/// <param name="atacante"></param>
/// <param name="objetivo"></param>
public MatchExcepcion(Unidad atacante, Unidad objetivo) : base(false)
{
this.atacante = atacante;
this.objetivo = objetivo;
}
/// <summary>
/// <para>Obtiene la resistencia de la unidad</para>
/// </summary>
/// <param name="target">Unidad</param>
/// <returns></returns>
private int GetResistencia(Unidad target) // Obtiene la resistencia de la unidad
{
Stats s = target.GetComponentInParent <Stats>();
return(s[TipoStats.RES]);
}
/// <summary>
/// <para>Obtener las areas a rango para el movimiento</para>
/// </summary>
/// <returns></returns>
private List <Area> GetOpcionesMovimiento() // Obtener las areas a rango para el movimiento
{
return(Unidad.GetComponent <Movimiento>().GetAreasInRango(freya.grid));
}
/// <summary>
/// <para>Asigna solo atacar</para>
/// </summary>
/// <param name="plan"></param>
private void PatronAtaqueGeneral(PlanDeAtaque plan) // Asigna solo atacar
{
// Solo obtiene la habilidad de ataque
plan.habilidad = Unidad.GetComponentInChildren <Habilidad>();
plan.objetivo = Objetivos.Enemigo;
}
