protected override void Apply(WorldObject target)
        {
            var handler = aura.GetHandler(AuraType.PeriodicHeal) as PeriodicHealHandler;

            if (handler == null)
            {
                LogManager.GetCurrentClassLogger().Warn("Aura does not have a ParameterizedPeriodicHealHandler: " + aura);
                return;
            }

            int ticks;

            if (aura.Spell.Line.LineId == SpellLineId.DruidRejuvenation)
            {
                // "amount equal to 12 sec of Rejuvenation"
                ticks = 4;
            }
            else            // if (aura.Spell.Line.LineId == SpellLineId.DruidRegrowth)
            {
                // "or 18 sec. of Regrowth"
                ticks = 6;
            }

            //var maxTicks = aura.MaxTicks;
            // TODO: Add correct heal bonuses
            var amount = handler.EffectValue * ticks;

            ((Unit)target).Heal(amount, m_cast.CasterUnit, Effect);

            aura.Cancel();
        }
Esempio n. 2
0
        protected override void Apply()
        {
            IList <WorldObject> objectsInRadius =
                Owner.GetObjectsInRadius(3f, ObjectTypes.Unit, false, int.MaxValue);
            bool flag = false;

            foreach (WorldObject worldObject in objectsInRadius)
            {
                Unit unit = worldObject as Unit;
                if (unit != null && unit.IsHostileWith(Owner))
                {
                    flag = true;
                    break;
                }
            }

            if (!flag)
            {
                return;
            }
            foreach (WorldObject objectsInRadiu in Owner.GetObjectsInRadius(12f,
                                                                            ObjectTypes.Unit, false, int.MaxValue))
            {
                Unit pos = objectsInRadiu as Unit;
                if (pos != null && pos.IsHostileWith(Owner))
                {
                    if (SpellEffect.MiscValueB == 1)
                    {
                        Spell spell = SpellHandler.Get(775U);
                        pos.Auras.CreateAndStartAura(Owner.SharedReference, spell, false, null);
                    }
                    else if (SpellEffect.MiscValueB == 0)
                    {
                        float dist = pos.GetDist(Owner);
                        float num  = 1f;
                        if (dist >= 3.0)
                        {
                            num /= (float)Math.Pow(dist, 0.600000023841858);
                        }
                        DamageAction damageAction = pos.DealSpellDamage(Owner, SpellEffect,
                                                                        (int)(Owner.RandomDamage * (double)SpellEffect.MiscValue / 100.0 *
                                                                              num), true, true, false, false);
                        if (damageAction != null)
                        {
                            if (m_aura != null)
                            {
                                Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(
                                    m_aura.CasterUnit as Character, objectsInRadiu as Character,
                                    objectsInRadiu as NPC, damageAction.ActualDamage);
                            }
                            damageAction.OnFinished();
                        }
                    }
                }
            }

            Aura.Cancel();
        }
Esempio n. 3
0
 protected override void Remove(bool cancelled)
 {
     if (activeToggleAura != null)
     {
         // remove aura
         activeToggleAura.Cancel();
         activeToggleAura = null;
     }
 }
Esempio n. 4
0
 protected override void Remove(bool cancelled)
 {
     if (activeToggleAura == null)
     {
         return;
     }
     activeToggleAura.Cancel();
     activeToggleAura = null;
 }
        public override void OnAttack(DamageAction action)
        {
            if (action.Spell == null)
            {
                return;
            }
            action.Damage = (int)(action.Damage * 1.5);
            Spell spell = SpellHandler.Get(SpellId.Silence10Rank7FromWindSlasher);

            action.Victim.Auras.CreateAndStartAura(Owner.SharedReference, spell, false, null);
            Aura.Cancel();
        }
        protected override void Apply()
        {
            int dmg   = Owner.Health * SpellEffect.MiscValue / 100;
            NPC owner = Owner as NPC;

            if (owner != null && owner.Entry.IsBoss)
            {
                return;
            }
            DamageAction damageAction =
                Owner.DealSpellDamage(Owner, SpellEffect, dmg, true, true, false, false);

            if (damageAction == null || m_aura == null)
            {
                return;
            }
            Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(m_aura.CasterUnit as Character,
                                                                     Owner as Character, Owner as NPC, damageAction.ActualDamage);
            damageAction.OnFinished();
            Aura.Cancel();
        }
Esempio n. 7
0
        protected override void Apply()
        {
            var dmg = Owner.Health * SpellEffect.MiscValue / 100;
            var npc = Owner as NPC;

            if (npc != null)
            {
                if (npc.Entry.IsBoss)
                {
                    return;
                }
            }
            var action = Owner.DealSpellDamage(Owner, SpellEffect, dmg, true, true, false, false);

            if (action != null && m_aura != null)
            {
                WCell.RealmServer.Handlers.Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(m_aura.CasterUnit as Character, Owner as Character, Owner as NPC, action.ActualDamage);
                action.OnFinished();
                Aura.Cancel();
            }
        }
Esempio n. 8
0
        protected override void Apply()
        {
            var targets = Owner.GetObjectsInRadius(3, ObjectTypes.Unit, false);
            var boom    = false;

            foreach (var worldObject in targets)
            {
                var unit = worldObject as Unit;
                if (unit == null)
                {
                    continue;
                }
                if (!unit.IsHostileWith(Owner))
                {
                    continue;
                }
                boom = true;
                break;
            }
            if (!boom)
            {
                return;
            }
            targets = Owner.GetObjectsInRadius(12, ObjectTypes.Unit, false);
            foreach (var worldObject in targets)
            {
                var unit = worldObject as Unit;
                if (unit == null)
                {
                    continue;
                }
                if (!unit.IsHostileWith(Owner))
                {
                    continue;
                }
                if (SpellEffect.MiscValueB == 1)       //freez trap
                {
                    var spell = SpellHandler.Get(775); //frost 10 sec
                    unit.Auras.CreateAndStartAura(Owner.SharedReference, spell, false);
                }
                else if (SpellEffect.MiscValueB == 0) //damage trap
                {
                    var range = unit.GetDist(Owner);
                    var mult  = 1f;
                    if (range >= 3)
                    {
                        mult = (float)(mult / System.Math.Pow(range, 0.6f));
                    }
                    var action = unit.DealSpellDamage(Owner, SpellEffect,
                                                      (int)(Owner.RandomDamage * SpellEffect.MiscValue / 100 * mult), true,
                                                      true, false, false);
                    if (action == null)
                    {
                        continue;
                    }
                    if (m_aura != null)
                    {
                        WCell.RealmServer.Handlers.Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(
                            m_aura.CasterUnit as Character, worldObject as Character, worldObject as NPC,
                            action.ActualDamage);
                    }

                    action.OnFinished();
                }
            }
            Aura.Cancel();
        }