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