Example #1
0
 public override void OnApply()
 {
     if (Source.Data.HasSpecialBonus(BonusType.BLEED_STACKS_EXPLODE_AT_MAX))
     {
         List <ActorEffect> statusList = target.GetStatusEffectAll(EffectType.BLEED);
         if (statusList.Count >= MaxStacks)
         {
             InstantEffects.ApplyStatusExplosionEffect(target, Source, EffectType.BLEED, statusList);
         }
     }
 }
Example #2
0
    public virtual void ApplyTriggerEffects(TriggerType triggerType, Actor target)
    {
        Dictionary <ElementType, MinMaxRange> retaliationToEnemy = new Dictionary <ElementType, MinMaxRange>();
        Dictionary <ElementType, MinMaxRange> retaliationToSelf  = new Dictionary <ElementType, MinMaxRange>();

        foreach (TriggeredEffect actorEffect in SourceActor.Data.TriggeredEffects[triggerType].ToArray())
        {
            TriggeredEffectBonusProperty baseEffect = actorEffect.BaseEffect;
            if (baseEffect.effectType == EffectType.RETALIATION_DAMAGE)
            {
                if (baseEffect.effectTargetType == AbilityTargetType.ENEMY)
                {
                    if (!retaliationToEnemy.ContainsKey(baseEffect.effectElement))
                    {
                        retaliationToEnemy.Add(baseEffect.effectElement, new MinMaxRange());
                    }
                    retaliationToEnemy[baseEffect.effectElement].AddToBoth((int)actorEffect.Value);
                }
                else if (baseEffect.effectTargetType == AbilityTargetType.SELF)
                {
                    if (!retaliationToSelf.ContainsKey(baseEffect.effectElement))
                    {
                        retaliationToSelf.Add(baseEffect.effectElement, new MinMaxRange());
                    }
                    retaliationToSelf[baseEffect.effectElement].AddToBoth((int)actorEffect.Value);
                }
                continue;
            }

            actorEffect.OnTrigger(target, SourceActor);
        }
        if (retaliationToEnemy.Count > 0)
        {
            SourceActor.StartCoroutine(InstantEffects.ApplyRetaliationDamageEffect(target, SourceActor, retaliationToEnemy));
        }

        if (retaliationToSelf.Count > 0)
        {
            SourceActor.StartCoroutine(InstantEffects.ApplyRetaliationDamageEffect(SourceActor, SourceActor, retaliationToSelf));
        }
    }
Example #3
0
    public static void ApplyEffectToTarget(Actor target, Actor source, EffectType effectType, float effectPower, float duration, float auraEffectiveness = 1.0f, ElementType element = ElementType.PHYSICAL, string sourceName = "")
    {
        LayerMask mask = target.GetActorType() == ActorType.ALLY ? (LayerMask)LayerMask.GetMask("Hero") : (LayerMask)LayerMask.GetMask("Enemy");

        switch (effectType)
        {
        case EffectType.BLEED:
            target.AddStatusEffect(new BleedEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.BURN:
            target.AddStatusEffect(new BurnEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.CHILL:
            target.AddStatusEffect(new ChillEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.ELECTROCUTE:
            target.AddStatusEffect(new ElectrocuteEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.FRACTURE:
            target.AddStatusEffect(new FractureEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.PACIFY:
            target.AddStatusEffect(new PacifyEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.RADIATION:
            target.AddStatusEffect(new RadiationEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.POISON:
            target.AddStatusEffect(new PoisonEffect(target, source, effectPower * auraEffectiveness, duration));
            break;

        case EffectType.STUN:
            target.AddStatusEffect(new StunEffect(target, source, duration));
            break;

        case EffectType.PLAGUE:
            target.AddStatusEffect(new PlagueEffect(target, source, duration));
            break;

        case EffectType.EXPLODE_MAX_LIFE:
        case EffectType.EXPLODE_OVERKILL:
        case EffectType.EXPLODE_HIT_DAMAGE:
        case EffectType.EXPLODE_BLEED:
        case EffectType.EXPLODE_BURN:
        case EffectType.EXPLODE_ELECTROCUTE:
        case EffectType.EXPLODE_RADIATION:
            source.StartCoroutine(InstantEffects.ApplyExplosionEffect(target, source, effectType, mask, effectPower, element));
            break;

        case EffectType.SPREAD_DAMAGING_STATUSES:
        case EffectType.SPREAD_BLEED:
        case EffectType.SPREAD_BURN:
        case EffectType.SPREAD_RADIATION:
        case EffectType.SPREAD_STATUSES:
            InstantEffects.ApplyStatusSpreadEffect(target, source, effectType, mask);
            break;

        case EffectType.CLEAR_STATUSES:
            InstantEffects.ClearStatusEffects(target, source);
            break;

        case EffectType.BUFF:
            break;

        case EffectType.DEBUFF:
            break;

        case EffectType.BODYGUARD_AURA:
            target.AddStatusEffect(new BodyguardAura(target, source, effectPower, duration, auraEffectiveness));
            break;

        case EffectType.MASS_SHIELD_AURA:
            target.AddStatusEffect(new MassShieldAura(target, source, effectPower, duration, auraEffectiveness));
            break;

        case EffectType.BERSERK:
            target.AddStatusEffect(new BerserkEffect(target, source, effectPower, duration));
            break;

        case EffectType.KNOCKBACK:
            break;

        case EffectType.REPEAT_OFFENDER_BUFF:
            target.AddStatusEffect(new RepeatOffenderBuffEffect(target, source, effectPower, duration));
            break;

        case EffectType.RETALIATION_DAMAGE:
            // Retaliation damage is handled as a special case
            //source.StartCoroutine(InstantEffects.ApplyRetaliationDamageEffect(target, source, mask, effectPower, element));
            break;

        case EffectType.GENERIC_DAMAGE_OVER_TIME:
            break;

        default:
            return;
        }
    }