Scripts/Spells: Moved all special target filtering cases to scripts

4 files changed, 610 insertions, 497 deletions

diff --git a/src/server/scripts/Spells/spell_dk.cpp b/src/server/scripts/Spells/spell_dk.cpp
index f94a1bcf4de..6c2c0c30fe9 100644
--- a/src/server/scripts/Spells/spell_dk.cpp
+++ b/src/server/scripts/Spells/spell_dk.cpp
@@ -26,407 +26,446 @@
 
 enum DeathKnightSpells
 {
-    DK_SPELL_SUMMON_GARGOYLE                = 50514,
-    DK_SPELL_CORPSE_EXPLOSION_TRIGGERED     = 43999,
-    DISPLAY_GHOUL_CORPSE                    = 25537,
-    DK_SPELL_SCOURGE_STRIKE_TRIGGERED       = 70890,
+    DK_SPELL_RUNIC_POWER_ENERGIZE               = 49088,
+    DK_SPELL_ANTI_MAGIC_SHELL_TALENT            = 51052,
+    DK_SPELL_SUMMON_GARGOYLE                    = 50514,
+    DK_SPELL_CORPSE_EXPLOSION_TRIGGERED         = 43999,
+    DISPLAY_GHOUL_CORPSE                        = 25537,
+    DK_SPELL_SCOURGE_STRIKE_TRIGGERED           = 70890,
+    DK_SPELL_WILL_OF_THE_NECROPOLIS_TALENT_R1   = 49189,
+    DK_SPELL_WILL_OF_THE_NECROPOLIS_AURA_R1     = 52284,
 };
 
 // 50462 - Anti-Magic Shell (on raid member)
 class spell_dk_anti_magic_shell_raid : public SpellScriptLoader
 {
-public:
-    spell_dk_anti_magic_shell_raid() : SpellScriptLoader("spell_dk_anti_magic_shell_raid") { }
+    public:
+        spell_dk_anti_magic_shell_raid() : SpellScriptLoader("spell_dk_anti_magic_shell_raid") { }
 
-    class spell_dk_anti_magic_shell_raid_AuraScript : public AuraScript
-    {
-        PrepareAuraScript(spell_dk_anti_magic_shell_raid_AuraScript);
+        class spell_dk_anti_magic_shell_raid_AuraScript : public AuraScript
+        {
+            PrepareAuraScript(spell_dk_anti_magic_shell_raid_AuraScript);
 
-        uint32 absorbPct;
+            uint32 absorbPct;
 
-        bool Load()
-        {
-            absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
-            return true;
-        }
+            bool Load()
+            {
+                absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
+                return true;
+            }
 
-        void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
-        {
-            // TODO: this should absorb limited amount of damage, but no info on calculation formula
-            amount = -1;
-        }
+            void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
+            {
+                // TODO: this should absorb limited amount of damage, but no info on calculation formula
+                amount = -1;
+            }
 
-        void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
-        {
-             absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
-        }
+            void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
+            {
+                 absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
+            }
+
+            void Register()
+            {
+                 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_anti_magic_shell_raid_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
+                 OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_shell_raid_AuraScript::Absorb, EFFECT_0);
+            }
+        };
 
-        void Register()
+        AuraScript *GetAuraScript() const
         {
-             DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_anti_magic_shell_raid_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
-             OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_shell_raid_AuraScript::Absorb, EFFECT_0);
+            return new spell_dk_anti_magic_shell_raid_AuraScript();
         }
-    };
-
-    AuraScript *GetAuraScript() const
-    {
-        return new spell_dk_anti_magic_shell_raid_AuraScript();
-    }
 };
 
 // 48707 - Anti-Magic Shell (on self)
 class spell_dk_anti_magic_shell_self : public SpellScriptLoader
 {
-public:
-    spell_dk_anti_magic_shell_self() : SpellScriptLoader("spell_dk_anti_magic_shell_self") { }
+    public:
+        spell_dk_anti_magic_shell_self() : SpellScriptLoader("spell_dk_anti_magic_shell_self") { }
 
-    class spell_dk_anti_magic_shell_self_AuraScript : public AuraScript
-    {
-        PrepareAuraScript(spell_dk_anti_magic_shell_self_AuraScript);
-
-        enum Spells
+        class spell_dk_anti_magic_shell_self_AuraScript : public AuraScript
         {
-            DK_SPELL_RUNIC_POWER_ENERGIZE = 49088,
-        };
+            PrepareAuraScript(spell_dk_anti_magic_shell_self_AuraScript);
 
-        uint32 absorbPct, hpPct;
-        bool Load()
-        {
-            absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
-            hpPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_1, GetCaster());
-            return true;
-        }
+            uint32 absorbPct, hpPct;
+            bool Load()
+            {
+                absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
+                hpPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_1, GetCaster());
+                return true;
+            }
 
-        bool Validate(SpellEntry const * /*spellEntry*/)
-        {
-            return sSpellStore.LookupEntry(DK_SPELL_RUNIC_POWER_ENERGIZE);
-        }
+            bool Validate(SpellEntry const * /*spellEntry*/)
+            {
+                return sSpellStore.LookupEntry(DK_SPELL_RUNIC_POWER_ENERGIZE);
+            }
 
-        void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
-        {
-            // Set absorbtion amount to unlimited
-            amount = -1;
-        }
+            void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
+            {
+                // Set absorbtion amount to unlimited
+                amount = -1;
+            }
 
-        void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
-        {
-            absorbAmount = std::min(CalculatePctN(dmgInfo.GetDamage(), absorbPct), GetTarget()->CountPctFromMaxHealth(hpPct));
-        }
+            void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
+            {
+                absorbAmount = std::min(CalculatePctN(dmgInfo.GetDamage(), absorbPct), GetTarget()->CountPctFromMaxHealth(hpPct));
+            }
 
-        void Trigger(AuraEffect * aurEff, DamageInfo & /*dmgInfo*/, uint32 & absorbAmount)
-        {
-            Unit * target = GetTarget();
-            // damage absorbed by Anti-Magic Shell energizes the DK with additional runic power.
-            // This, if I'm not mistaken, shows that we get back ~20% of the absorbed damage as runic power.
-            int32 bp = absorbAmount * 2 / 10;
-            target->CastCustomSpell(target, DK_SPELL_RUNIC_POWER_ENERGIZE, &bp, NULL, NULL, true, NULL, aurEff);
-        }
+            void Trigger(AuraEffect * aurEff, DamageInfo & /*dmgInfo*/, uint32 & absorbAmount)
+            {
+                Unit * target = GetTarget();
+                // damage absorbed by Anti-Magic Shell energizes the DK with additional runic power.
+                // This, if I'm not mistaken, shows that we get back ~20% of the absorbed damage as runic power.
+                int32 bp = absorbAmount * 2 / 10;
+                target->CastCustomSpell(target, DK_SPELL_RUNIC_POWER_ENERGIZE, &bp, NULL, NULL, true, NULL, aurEff);
+            }
+
+            void Register()
+            {
+                 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_anti_magic_shell_self_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
+                 OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_shell_self_AuraScript::Absorb, EFFECT_0);
+                 AfterEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_shell_self_AuraScript::Trigger, EFFECT_0);
+            }
+        };
 
-        void Register()
+        AuraScript *GetAuraScript() const
         {
-             DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_anti_magic_shell_self_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
-             OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_shell_self_AuraScript::Absorb, EFFECT_0);
-             AfterEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_shell_self_AuraScript::Trigger, EFFECT_0);
+            return new spell_dk_anti_magic_shell_self_AuraScript();
         }
-    };
-
-    AuraScript *GetAuraScript() const
-    {
-        return new spell_dk_anti_magic_shell_self_AuraScript();
-    }
 };
 
 // 50461 - Anti-Magic Zone
 class spell_dk_anti_magic_zone : public SpellScriptLoader
 {
-public:
-    spell_dk_anti_magic_zone() : SpellScriptLoader("spell_dk_anti_magic_zone") { }
-
-    class spell_dk_anti_magic_zone_AuraScript : public AuraScript
-    {
-        PrepareAuraScript(spell_dk_anti_magic_zone_AuraScript);
+    public:
+        spell_dk_anti_magic_zone() : SpellScriptLoader("spell_dk_anti_magic_zone") { }
 
-        enum Spells
+        class spell_dk_anti_magic_zone_AuraScript : public AuraScript
         {
-            DK_SPELL_ANTI_MAGIC_SHELL_TALENT = 51052,
-        };
+            PrepareAuraScript(spell_dk_anti_magic_zone_AuraScript);
 
-        uint32 absorbPct;
+            uint32 absorbPct;
 
-        bool Load()
-        {
-            absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
-            return true;
-        }
+            bool Load()
+            {
+                absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
+                return true;
+            }
 
-        bool Validate(SpellEntry const * /*spellEntry*/)
-        {
-            return sSpellStore.LookupEntry(DK_SPELL_ANTI_MAGIC_SHELL_TALENT);
-        }
+            bool Validate(SpellEntry const * /*spellEntry*/)
+            {
+                return sSpellStore.LookupEntry(DK_SPELL_ANTI_MAGIC_SHELL_TALENT);
+            }
 
-        void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
-        {
-            SpellEntry const * talentSpell = sSpellStore.LookupEntry(DK_SPELL_ANTI_MAGIC_SHELL_TALENT);
-            amount = SpellMgr::CalculateSpellEffectAmount(talentSpell, EFFECT_0, GetCaster());
-            // assume caster is a player here
-            if (Unit * caster = GetCaster())
-                 amount += int32(2 * caster->ToPlayer()->GetTotalAttackPowerValue(BASE_ATTACK));
-        }
+            void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
+            {
+                SpellEntry const * talentSpell = sSpellStore.LookupEntry(DK_SPELL_ANTI_MAGIC_SHELL_TALENT);
+                amount = SpellMgr::CalculateSpellEffectAmount(talentSpell, EFFECT_0, GetCaster());
+                // assume caster is a player here
+                if (Unit * caster = GetCaster())
+                     amount += int32(2 * caster->ToPlayer()->GetTotalAttackPowerValue(BASE_ATTACK));
+            }
 
-        void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
-        {
-             absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
-        }
+            void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
+            {
+                 absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
+            }
+
+            void Register()
+            {
+                 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_anti_magic_zone_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
+                 OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_zone_AuraScript::Absorb, EFFECT_0);
+            }
+        };
 
-        void Register()
+        AuraScript *GetAuraScript() const
         {
-             DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_anti_magic_zone_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
-             OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_zone_AuraScript::Absorb, EFFECT_0);
+            return new spell_dk_anti_magic_zone_AuraScript();
         }
-    };
-
-    AuraScript *GetAuraScript() const
-    {
-        return new spell_dk_anti_magic_zone_AuraScript();
-    }
 };
 
 // 49158 Corpse Explosion (51325, 51326, 51327, 51328)
 class spell_dk_corpse_explosion : public SpellScriptLoader
 {
-public:
-    spell_dk_corpse_explosion() : SpellScriptLoader("spell_dk_corpse_explosion") { }
+    public:
+        spell_dk_corpse_explosion() : SpellScriptLoader("spell_dk_corpse_explosion") { }
 
-    class spell_dk_corpse_explosion_SpellScript : public SpellScript
-    {
-        PrepareSpellScript(spell_dk_corpse_explosion_SpellScript)
-        bool Validate(SpellEntry const * /*spellEntry*/)
+        class spell_dk_corpse_explosion_SpellScript : public SpellScript
         {
-            if (!sSpellStore.LookupEntry(DK_SPELL_CORPSE_EXPLOSION_TRIGGERED))
-                return false;
-            return true;
+            PrepareSpellScript(spell_dk_corpse_explosion_SpellScript);
+
+            bool Validate(SpellEntry const * /*spellEntry*/)
+            {
+                if (!sSpellStore.LookupEntry(DK_SPELL_CORPSE_EXPLOSION_TRIGGERED))
+                    return false;
+                return true;
+            }
+
+            void HandleDummy(SpellEffIndex /*effIndex*/)
+            {
+                if (Unit* unitTarget = GetHitUnit())
+                {
+                    int32 bp = 0;
+                    // Living ghoul as a target
+                    if (unitTarget->isAlive())
+                        bp = int32(unitTarget->CountPctFromMaxHealth(25));
+                    // Some corpse
+                    else
+                        bp = GetEffectValue();
+                    GetCaster()->CastCustomSpell(unitTarget, SpellMgr::CalculateSpellEffectAmount(GetSpellInfo(), 1), &bp, NULL, NULL, true);
+                    // Corpse Explosion (Suicide)
+                    unitTarget->CastCustomSpell(unitTarget, DK_SPELL_CORPSE_EXPLOSION_TRIGGERED, &bp, NULL, NULL, true);
+                    // Set corpse look
+                    unitTarget->SetDisplayId(DISPLAY_GHOUL_CORPSE + urand(0, 3));
+                }
+            }
+
+            void Register()
+            {
+                OnEffect += SpellEffectFn(spell_dk_corpse_explosion_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
+        {
+            return new spell_dk_corpse_explosion_SpellScript();
         }
+};
+
+class spell_dk_death_pact : public SpellScriptLoader
+{
+    public:
+        spell_dk_death_pact() : SpellScriptLoader("spell_dk_death_pact") { }
 
-        void HandleDummy(SpellEffIndex /*effIndex*/)
+        class spell_dk_death_pact_SpellScript : public SpellScript
         {
-            if (Unit* unitTarget = GetHitUnit())
+            PrepareSpellScript(spell_dk_death_pact_SpellScript);
+
+            void FilterTargets(std::list<Unit*>& unitList)
             {
-                int32 bp = 0;
-                // Living ghoul as a target
-                if (unitTarget->isAlive())
-                    bp = int32(unitTarget->CountPctFromMaxHealth(25));
-                // Some corpse
+                Unit* unit_to_add = NULL;
+                for (std::list<Unit*>::iterator itr = unitList.begin() ; itr != unitList.end(); ++itr)
+                {
+                    if ((*itr)->GetTypeId() == TYPEID_UNIT
+                        && (*itr)->GetOwnerGUID() == GetCaster()->GetGUID()
+                        && (*itr)->ToCreature()->GetCreatureInfo()->type == CREATURE_TYPE_UNDEAD)
+                    {
+                        unit_to_add = (*itr);
+                        break;
+                    }
+                }
+
+                unitList.clear();
+                if (unit_to_add)
+                    unitList.push_back(unit_to_add);
                 else
-                    bp = GetEffectValue();
-                GetCaster()->CastCustomSpell(unitTarget, SpellMgr::CalculateSpellEffectAmount(GetSpellInfo(), 1), &bp, NULL, NULL, true);
-                // Corpse Explosion (Suicide)
-                unitTarget->CastCustomSpell(unitTarget, DK_SPELL_CORPSE_EXPLOSION_TRIGGERED, &bp, NULL, NULL, true);
-                // Set corpse look
-                unitTarget->SetDisplayId(DISPLAY_GHOUL_CORPSE + urand(0, 3));
+                {
+                    // Pet not found - remove cooldown
+                    if (Player* modOwner = GetCaster()->GetSpellModOwner())
+                        modOwner->RemoveSpellCooldown(GetSpellInfo()->Id, true);
+                    FinishCast(SPELL_FAILED_NO_PET);
+                }
             }
-        }
 
-        void Register()
+            void Register()
+            {
+                OnUnitTargetSelect += SpellUnitTargetFn(spell_dk_death_pact_SpellScript::FilterTargets, EFFECT_1, TARGET_UNIT_AREA_ALLY_DST);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
         {
-            OnEffect += SpellEffectFn(spell_dk_corpse_explosion_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
+            return new spell_dk_death_pact_SpellScript();
         }
-    };
-
-    SpellScript* GetSpellScript() const
-    {
-        return new spell_dk_corpse_explosion_SpellScript();
-    }
 };
 
 // 50524 Runic Power Feed (keeping Gargoyle alive)
 class spell_dk_runic_power_feed : public SpellScriptLoader
 {
-public:
-    spell_dk_runic_power_feed() : SpellScriptLoader("spell_dk_runic_power_feed") { }
+    public:
+        spell_dk_runic_power_feed() : SpellScriptLoader("spell_dk_runic_power_feed") { }
 
-    class spell_dk_runic_power_feed_SpellScript : public SpellScript
-    {
-        PrepareSpellScript(spell_dk_runic_power_feed_SpellScript)
-        bool Validate(SpellEntry const * /*spellEntry*/)
+        class spell_dk_runic_power_feed_SpellScript : public SpellScript
         {
-            if (!sSpellStore.LookupEntry(DK_SPELL_SUMMON_GARGOYLE))
-                return false;
-            return true;
-        }
+            PrepareSpellScript(spell_dk_runic_power_feed_SpellScript);
 
-        void HandleDummy(SpellEffIndex /*effIndex*/)
-        {
-            if (Unit* caster = GetCaster())
+            bool Validate(SpellEntry const * /*spellEntry*/)
             {
-                // No power, dismiss Gargoyle
-                if (caster->GetPower(POWER_RUNIC_POWER) < 30)
-                    caster->RemoveAurasDueToSpell(DK_SPELL_SUMMON_GARGOYLE, caster->GetGUID());
-                else
-                    caster->ModifyPower(POWER_RUNIC_POWER, -30);
+                if (!sSpellStore.LookupEntry(DK_SPELL_SUMMON_GARGOYLE))
+                    return false;
+                return true;
             }
-        }
 
-        void Register()
+            void HandleDummy(SpellEffIndex /*effIndex*/)
+            {
+                if (Unit* caster = GetCaster())
+                {
+                    // No power, dismiss Gargoyle
+                    if (caster->GetPower(POWER_RUNIC_POWER) < 30)
+                        caster->RemoveAurasDueToSpell(DK_SPELL_SUMMON_GARGOYLE, caster->GetGUID());
+                    else
+                        caster->ModifyPower(POWER_RUNIC_POWER, -30);
+                }
+            }
+
+            void Register()
+            {
+                OnEffect += SpellEffectFn(spell_dk_runic_power_feed_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
         {
-            OnEffect += SpellEffectFn(spell_dk_runic_power_feed_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
+            return new spell_dk_runic_power_feed_SpellScript();
         }
-    };
-
-    SpellScript* GetSpellScript() const
-    {
-        return new spell_dk_runic_power_feed_SpellScript();
-    }
 };
 
 // 55090 Scourge Strike (55265, 55270, 55271)
 class spell_dk_scourge_strike : public SpellScriptLoader
 {
-public:
-    spell_dk_scourge_strike() : SpellScriptLoader("spell_dk_scourge_strike") { }
+    public:
+        spell_dk_scourge_strike() : SpellScriptLoader("spell_dk_scourge_strike") { }
 
-    class spell_dk_scourge_strike_SpellScript : public SpellScript
-    {
-        PrepareSpellScript(spell_dk_scourge_strike_SpellScript)
-        bool Validate(SpellEntry const * /*spellEntry*/)
+        class spell_dk_scourge_strike_SpellScript : public SpellScript
         {
-            if (!sSpellStore.LookupEntry(DK_SPELL_SCOURGE_STRIKE_TRIGGERED))
-                return false;
-            return true;
-        }
+            PrepareSpellScript(spell_dk_scourge_strike_SpellScript);
 
-        void HandleDummy(SpellEffIndex /*effIndex*/)
-        {
-            Unit* caster = GetCaster();
-            if (Unit* unitTarget = GetHitUnit())
+            bool Validate(SpellEntry const * /*spellEntry*/)
             {
-                int32 bp = CalculatePctN(GetHitDamage(), GetEffectValue() * unitTarget->GetDiseasesByCaster(caster->GetGUID()));
-                caster->CastCustomSpell(unitTarget, DK_SPELL_SCOURGE_STRIKE_TRIGGERED, &bp, NULL, NULL, true);
+                if (!sSpellStore.LookupEntry(DK_SPELL_SCOURGE_STRIKE_TRIGGERED))
+                    return false;
+                return true;
+            }
+
+            void HandleDummy(SpellEffIndex /*effIndex*/)
+            {
+                Unit* caster = GetCaster();
+                if (Unit* unitTarget = GetHitUnit())
+                {
+                    int32 bp = CalculatePctN(GetHitDamage(), GetEffectValue() * unitTarget->GetDiseasesByCaster(caster->GetGUID()));
+                    caster->CastCustomSpell(unitTarget, DK_SPELL_SCOURGE_STRIKE_TRIGGERED, &bp, NULL, NULL, true);
+                }
             }
-        }
 
-        void Register()
+            void Register()
+            {
+                OnEffect += SpellEffectFn(spell_dk_scourge_strike_SpellScript::HandleDummy, EFFECT_2, SPELL_EFFECT_DUMMY);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
         {
-            OnEffect += SpellEffectFn(spell_dk_scourge_strike_SpellScript::HandleDummy, EFFECT_2, SPELL_EFFECT_DUMMY);
+            return new spell_dk_scourge_strike_SpellScript();
         }
-    };
-
-    SpellScript* GetSpellScript() const
-    {
-        return new spell_dk_scourge_strike_SpellScript();
-    }
 };
 
 // 49145 - Spell Deflection
 class spell_dk_spell_deflection : public SpellScriptLoader
 {
-public:
-    spell_dk_spell_deflection() : SpellScriptLoader("spell_dk_spell_deflection") { }
+    public:
+        spell_dk_spell_deflection() : SpellScriptLoader("spell_dk_spell_deflection") { }
 
-    class spell_dk_spell_deflection_AuraScript : public AuraScript
-    {
-        PrepareAuraScript(spell_dk_spell_deflection_AuraScript);
+        class spell_dk_spell_deflection_AuraScript : public AuraScript
+        {
+            PrepareAuraScript(spell_dk_spell_deflection_AuraScript);
 
-        uint32 absorbPct;
+            uint32 absorbPct;
 
-        bool Load()
-        {
-            absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
-            return true;
-        }
+            bool Load()
+            {
+                absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
+                return true;
+            }
 
-        void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
-        {
-            // Set absorbtion amount to unlimited
-            amount = -1;
-        }
+            void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
+            {
+                // Set absorbtion amount to unlimited
+                amount = -1;
+            }
 
-        void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
-        {
-            // You have a chance equal to your Parry chance
-            if ((dmgInfo.GetDamageType() == DIRECT_DAMAGE) && roll_chance_f(GetTarget()->GetUnitParryChance()))
-                absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
-        }
+            void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
+            {
+                // You have a chance equal to your Parry chance
+                if ((dmgInfo.GetDamageType() == DIRECT_DAMAGE) && roll_chance_f(GetTarget()->GetUnitParryChance()))
+                    absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
+            }
 
-        void Register()
+            void Register()
+            {
+                 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_spell_deflection_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
+                 OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_spell_deflection_AuraScript::Absorb, EFFECT_0);
+            }
+        };
+
+        AuraScript *GetAuraScript() const
         {
-             DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_spell_deflection_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
-             OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_spell_deflection_AuraScript::Absorb, EFFECT_0);
+            return new spell_dk_spell_deflection_AuraScript();
         }
-    };
-
-    AuraScript *GetAuraScript() const
-    {
-        return new spell_dk_spell_deflection_AuraScript();
-    }
 };
 
 // 52284 - Will of the Necropolis
 class spell_dk_will_of_the_necropolis : public SpellScriptLoader
 {
-public:
-    spell_dk_will_of_the_necropolis() : SpellScriptLoader("spell_dk_will_of_the_necropolis") { }
-
-    class spell_dk_will_of_the_necropolis_AuraScript : public AuraScript
-    {
-        PrepareAuraScript(spell_dk_will_of_the_necropolis_AuraScript);
+    public:
+        spell_dk_will_of_the_necropolis() : SpellScriptLoader("spell_dk_will_of_the_necropolis") { }
 
-        enum Spells
+        class spell_dk_will_of_the_necropolis_AuraScript : public AuraScript
         {
-            DK_SPELL_WILL_OF_THE_NECROPOLIS_TALENT_R1 = 49189,
-            DK_SPELL_WILL_OF_THE_NECROPOLIS_AURA_R1   = 52284,
-        };
-        bool Validate(SpellEntry const *spellEntry)
-        {
-            // can't use other spell than will of the necropolis due to spell_ranks dependency
-            if (sSpellMgr->GetFirstSpellInChain(DK_SPELL_WILL_OF_THE_NECROPOLIS_AURA_R1) != sSpellMgr->GetFirstSpellInChain(spellEntry->Id))
-                return false;
+            PrepareAuraScript(spell_dk_will_of_the_necropolis_AuraScript);
 
-            uint8 rank = sSpellMgr->GetSpellRank(spellEntry->Id);
-            if (!sSpellMgr->GetSpellWithRank(DK_SPELL_WILL_OF_THE_NECROPOLIS_TALENT_R1, rank, true))
-                return false;
+            bool Validate(SpellEntry const *spellEntry)
+            {
+                // can't use other spell than will of the necropolis due to spell_ranks dependency
+                if (sSpellMgr->GetFirstSpellInChain(DK_SPELL_WILL_OF_THE_NECROPOLIS_AURA_R1) != sSpellMgr->GetFirstSpellInChain(spellEntry->Id))
+                    return false;
 
-            return true;
-        }
+                uint8 rank = sSpellMgr->GetSpellRank(spellEntry->Id);
+                if (!sSpellMgr->GetSpellWithRank(DK_SPELL_WILL_OF_THE_NECROPOLIS_TALENT_R1, rank, true))
+                    return false;
 
-        uint32 absorbPct;
+                return true;
+            }
 
-        bool Load()
-        {
-            absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
-            return true;
-        }
+            uint32 absorbPct;
 
-        void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
-        {
-            // Set absorbtion amount to unlimited
-            amount = -1;
-        }
+            bool Load()
+            {
+                absorbPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_0, GetCaster());
+                return true;
+            }
 
-        void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
-        {
-            // min pct of hp is stored in effect 0 of talent spell
-            uint32 rank = sSpellMgr->GetSpellRank(GetSpellProto()->Id);
-            SpellEntry const * talentProto = sSpellStore.LookupEntry(sSpellMgr->GetSpellWithRank(DK_SPELL_WILL_OF_THE_NECROPOLIS_TALENT_R1, rank));
+            void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
+            {
+                // Set absorbtion amount to unlimited
+                amount = -1;
+            }
 
-            int32 remainingHp = int32(GetTarget()->GetHealth() - dmgInfo.GetDamage());
-            int32 minHp = int32(GetTarget()->CountPctFromMaxHealth(SpellMgr::CalculateSpellEffectAmount(talentProto, EFFECT_0, GetCaster())));
+            void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
+            {
+                // min pct of hp is stored in effect 0 of talent spell
+                uint32 rank = sSpellMgr->GetSpellRank(GetSpellProto()->Id);
+                SpellEntry const * talentProto = sSpellStore.LookupEntry(sSpellMgr->GetSpellWithRank(DK_SPELL_WILL_OF_THE_NECROPOLIS_TALENT_R1, rank));
+
+                int32 remainingHp = int32(GetTarget()->GetHealth() - dmgInfo.GetDamage());
+                int32 minHp = int32(GetTarget()->CountPctFromMaxHealth(SpellMgr::CalculateSpellEffectAmount(talentProto, EFFECT_0, GetCaster())));
             
-            // Damage that would take you below [effect0] health or taken while you are at [effect0]
-            if (remainingHp < minHp)
-                absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
-        }
+                // Damage that would take you below [effect0] health or taken while you are at [effect0]
+                if (remainingHp < minHp)
+                    absorbAmount = CalculatePctN(dmgInfo.GetDamage(), absorbPct);
+            }
 
-        void Register()
+            void Register()
+            {
+                 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_will_of_the_necropolis_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
+                 OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_will_of_the_necropolis_AuraScript::Absorb, EFFECT_0);
+            }
+        };
+
+        AuraScript *GetAuraScript() const
         {
-             DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_will_of_the_necropolis_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
-             OnEffectAbsorb += AuraEffectAbsorbFn(spell_dk_will_of_the_necropolis_AuraScript::Absorb, EFFECT_0);
+            return new spell_dk_will_of_the_necropolis_AuraScript();
         }
-    };
-
-    AuraScript *GetAuraScript() const
-    {
-        return new spell_dk_will_of_the_necropolis_AuraScript();
-    }
 };
 
 void AddSC_deathknight_spell_scripts()
@@ -435,6 +474,7 @@ void AddSC_deathknight_spell_scripts()
     new spell_dk_anti_magic_shell_self();
     new spell_dk_anti_magic_zone();
     new spell_dk_corpse_explosion();
+    new spell_dk_death_pact();
     new spell_dk_runic_power_feed();
     new spell_dk_scourge_strike();
     new spell_dk_spell_deflection();
diff --git a/src/server/scripts/Spells/spell_priest.cpp b/src/server/scripts/Spells/spell_priest.cpp
index c4b6107a9f6..98504899da5 100644
--- a/src/server/scripts/Spells/spell_priest.cpp
+++ b/src/server/scripts/Spells/spell_priest.cpp
@@ -26,69 +26,67 @@
 
 enum PriestSpells
 {
-    PRIEST_SPELL_PENANCE_R1                      = 47540,
-    PRIEST_SPELL_PENANCE_R1_DAMAGE               = 47758,
-    PRIEST_SPELL_PENANCE_R1_HEAL                 = 47757,
+    PRIEST_SPELL_GUARDIAN_SPIRIT_HEAL           = 48153,
+    PRIEST_SPELL_PENANCE_R1                     = 47540,
+    PRIEST_SPELL_PENANCE_R1_DAMAGE              = 47758,
+    PRIEST_SPELL_PENANCE_R1_HEAL                = 47757,
+    PRIEST_SPELL_REFLECTIVE_SHIELD_TRIGGERED    = 33619,
+    PRIEST_SPELL_REFLECTIVE_SHIELD_R1           = 33201,
 };
 
 // Guardian Spirit
 class spell_pri_guardian_spirit : public SpellScriptLoader
 {
-public:
-    spell_pri_guardian_spirit() : SpellScriptLoader("spell_pri_guardian_spirit") { }
+    public:
+        spell_pri_guardian_spirit() : SpellScriptLoader("spell_pri_guardian_spirit") { }
 
-    class spell_pri_guardian_spirit_AuraScript : public AuraScript
-    {
-        PrepareAuraScript(spell_pri_guardian_spirit_AuraScript);
+        class spell_pri_guardian_spirit_AuraScript : public AuraScript
+        {
+            PrepareAuraScript(spell_pri_guardian_spirit_AuraScript);
 
-        uint32 healPct;
+            uint32 healPct;
 
-        enum Spell
-        {
-            PRI_SPELL_GUARDIAN_SPIRIT_HEAL = 48153,
-        };
+            bool Validate(SpellEntry const * /*spellEntry*/)
+            {
+                return sSpellStore.LookupEntry(PRIEST_SPELL_GUARDIAN_SPIRIT_HEAL) != NULL;
+            }
 
-        bool Validate(SpellEntry const * /*spellEntry*/)
-        {
-            return sSpellStore.LookupEntry(PRI_SPELL_GUARDIAN_SPIRIT_HEAL);
-        }
+            bool Load()
+            {
+                healPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_1);
+                return true;
+            }
 
-        bool Load()
-        {
-            healPct = SpellMgr::CalculateSpellEffectAmount(GetSpellProto(), EFFECT_1);
-            return true;
-        }
+            void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
+            {
+                // Set absorbtion amount to unlimited
+                amount = -1;
+            }
 
-        void CalculateAmount(AuraEffect const * /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
-        {
-            // Set absorbtion amount to unlimited
-            amount = -1;
-        }
+            void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
+            {
+                Unit * target = GetTarget();
+                if (dmgInfo.GetDamage() < target->GetHealth())
+                    return;
 
-        void Absorb(AuraEffect * /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount)
-        {
-            Unit * target = GetTarget();
-            if (dmgInfo.GetDamage() < target->GetHealth())
-                return;
-
-            int32 healAmount = int32(target->CountPctFromMaxHealth(healPct));
-            // remove the aura now, we don't want 40% healing bonus
-            Remove(AURA_REMOVE_BY_ENEMY_SPELL);
-            target->CastCustomSpell(target, PRI_SPELL_GUARDIAN_SPIRIT_HEAL, &healAmount, NULL, NULL, true);
-            absorbAmount = dmgInfo.GetDamage();
-        }
+                int32 healAmount = int32(target->CountPctFromMaxHealth(healPct));
+                // remove the aura now, we don't want 40% healing bonus
+                Remove(AURA_REMOVE_BY_ENEMY_SPELL);
+                target->CastCustomSpell(target, PRIEST_SPELL_GUARDIAN_SPIRIT_HEAL, &healAmount, NULL, NULL, true);
+                absorbAmount = dmgInfo.GetDamage();
+            }
+
+            void Register()
+            {
+                DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_guardian_spirit_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_SCHOOL_ABSORB);
+                OnEffectAbsorb += AuraEffectAbsorbFn(spell_pri_guardian_spirit_AuraScript::Absorb, EFFECT_1);
+            }
+        };
 
-        void Register()
+        AuraScript *GetAuraScript() const
         {
-            DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_guardian_spirit_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_SCHOOL_ABSORB);
-            OnEffectAbsorb += AuraEffectAbsorbFn(spell_pri_guardian_spirit_AuraScript::Absorb, EFFECT_1);
+            return new spell_pri_guardian_spirit_AuraScript();
         }
-    };
-
-    AuraScript *GetAuraScript() const
-    {
-        return new spell_pri_guardian_spirit_AuraScript();
-    }
 };
 
 class spell_pri_mana_burn : public SpellScriptLoader
@@ -98,15 +96,11 @@ class spell_pri_mana_burn : public SpellScriptLoader
 
         class spell_pri_mana_burn_SpellScript : public SpellScript
         {
-            PrepareSpellScript(spell_pri_mana_burn_SpellScript)
-            bool Validate(SpellEntry const * /*spellEntry*/)
-            {
-                return true;
-            }
+            PrepareSpellScript(spell_pri_mana_burn_SpellScript);
 
             void HandleAfterHit()
             {
-                Unit * unitTarget = GetHitUnit();
+                Unit* unitTarget = GetHitUnit();
                 if (!unitTarget)
                     return;
 
@@ -125,6 +119,32 @@ class spell_pri_mana_burn : public SpellScriptLoader
         }
 };
 
+class spell_pri_mind_sear : public SpellScriptLoader
+{
+    public:
+        spell_pri_mind_sear() : SpellScriptLoader("spell_pri_mind_sear") { }
+
+        class spell_pri_mind_sear_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_pri_mind_sear_SpellScript);
+
+            void FilterTargets(std::list<Unit*>& unitList)
+            {
+                unitList.remove(GetTargetUnit());
+            }
+
+            void Register()
+            {
+                OnUnitTargetSelect += SpellUnitTargetFn(spell_pri_mind_sear_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_AREA_ENEMY_DST);
+            }
+        };
+
+        SpellScript *GetSpellScript() const
+        {
+            return new spell_pri_mind_sear_SpellScript();
+        }
+};
+
 class spell_pri_pain_and_suffering_proc : public SpellScriptLoader
 {
     public:
@@ -133,7 +153,8 @@ class spell_pri_pain_and_suffering_proc : public SpellScriptLoader
         // 47948 Pain and Suffering (proc)
         class spell_pri_pain_and_suffering_proc_SpellScript : public SpellScript
         {
-            PrepareSpellScript(spell_pri_pain_and_suffering_proc_SpellScript)
+            PrepareSpellScript(spell_pri_pain_and_suffering_proc_SpellScript);
+
             void HandleEffectScriptEffect(SpellEffIndex /*effIndex*/)
             {
                 // Refresh Shadow Word: Pain on target
@@ -161,7 +182,8 @@ class spell_pri_penance : public SpellScriptLoader
 
         class spell_pri_penance_SpellScript : public SpellScript
         {
-            PrepareSpellScript(spell_pri_penance_SpellScript)
+            PrepareSpellScript(spell_pri_penance_SpellScript);
+
             bool Validate(SpellEntry const * spellEntry)
             {
                 if (!sSpellStore.LookupEntry(PRIEST_SPELL_PENANCE_R1))
@@ -211,49 +233,43 @@ class spell_pri_penance : public SpellScriptLoader
 // Reflective Shield
 class spell_pri_reflective_shield_trigger : public SpellScriptLoader
 {
-public:
-    spell_pri_reflective_shield_trigger() : SpellScriptLoader("spell_pri_reflective_shield_trigger") { }
-
-    class spell_pri_reflective_shield_trigger_AuraScript : public AuraScript
-    {
-        PrepareAuraScript(spell_pri_reflective_shield_trigger_AuraScript);
+    public:
+        spell_pri_reflective_shield_trigger() : SpellScriptLoader("spell_pri_reflective_shield_trigger") { }
 
-        enum Spells
+        class spell_pri_reflective_shield_trigger_AuraScript : public AuraScript
         {
-            SPELL_PRI_REFLECTIVE_SHIELD_TRIGGERED = 33619,
-            SPELL_PRI_REFLECTIVE_SHIELD_R1 = 33201,
-        };
+            PrepareAuraScript(spell_pri_reflective_shield_trigger_AuraScript);
 
-        bool Validate(SpellEntry const * /*spellEntry*/)
-        {
-            return sSpellStore.LookupEntry(SPELL_PRI_REFLECTIVE_SHIELD_TRIGGERED) && sSpellStore.LookupEntry(SPELL_PRI_REFLECTIVE_SHIELD_R1);
-        }
+            bool Validate(SpellEntry const * /*spellEntry*/)
+            {
+                return sSpellStore.LookupEntry(PRIEST_SPELL_REFLECTIVE_SHIELD_TRIGGERED) && sSpellStore.LookupEntry(PRIEST_SPELL_REFLECTIVE_SHIELD_R1);
+            }
 
-        void Trigger(AuraEffect * aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount)
-        {
-            Unit * target = GetTarget();
-            if (dmgInfo.GetAttacker() == target)
-                return;
-            Unit * caster = GetCaster();
-            if (!caster)
-                return;
-            if (AuraEffect * talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_PRI_REFLECTIVE_SHIELD_R1, EFFECT_0))
+            void Trigger(AuraEffect * aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount)
             {
-                int32 bp = CalculatePctN(absorbAmount, talentAurEff->GetAmount());
-                target->CastCustomSpell(dmgInfo.GetAttacker(), SPELL_PRI_REFLECTIVE_SHIELD_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff);
+                Unit * target = GetTarget();
+                if (dmgInfo.GetAttacker() == target)
+                    return;
+                Unit * caster = GetCaster();
+                if (!caster)
+                    return;
+                if (AuraEffect * talentAurEff = target->GetAuraEffectOfRankedSpell(PRIEST_SPELL_REFLECTIVE_SHIELD_R1, EFFECT_0))
+                {
+                    int32 bp = CalculatePctN(absorbAmount, talentAurEff->GetAmount());
+                    target->CastCustomSpell(dmgInfo.GetAttacker(), PRIEST_SPELL_REFLECTIVE_SHIELD_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff);
+                }
             }
-        }
 
-        void Register()
+            void Register()
+            {
+                 AfterEffectAbsorb += AuraEffectAbsorbFn(spell_pri_reflective_shield_trigger_AuraScript::Trigger, EFFECT_0);
+            }
+        };
+
+        AuraScript *GetAuraScript() const
         {
-             AfterEffectAbsorb += AuraEffectAbsorbFn(spell_pri_reflective_shield_trigger_AuraScript::Trigger, EFFECT_0);
+            return new spell_pri_reflective_shield_trigger_AuraScript();
         }
-    };
-
-    AuraScript *GetAuraScript() const
-    {
-        return new spell_pri_reflective_shield_trigger_AuraScript();
-    }
 };
 
 void AddSC_priest_spell_scripts()
@@ -263,4 +279,5 @@ void AddSC_priest_spell_scripts()
     new spell_pri_pain_and_suffering_proc;
     new spell_pri_penance;
     new spell_pri_reflective_shield_trigger();
+    new spell_pri_mind_sear();
 }
diff --git a/src/server/scripts/Spells/spell_warlock.cpp b/src/server/scripts/Spells/spell_warlock.cpp
index 55a7bb00630..31d35db5edd 100644
--- a/src/server/scripts/Spells/spell_warlock.cpp
+++ b/src/server/scripts/Spells/spell_warlock.cpp
@@ -39,155 +39,128 @@ enum WarlockSpells
 // 47193 Demonic Empowerment
 class spell_warl_demonic_empowerment : public SpellScriptLoader
 {
-public:
-    spell_warl_demonic_empowerment() : SpellScriptLoader("spell_warl_demonic_empowerment") { }
+    public:
+        spell_warl_demonic_empowerment() : SpellScriptLoader("spell_warl_demonic_empowerment") { }
 
-    class spell_warl_demonic_empowerment_SpellScript : public SpellScript
-    {
-        PrepareSpellScript(spell_warl_demonic_empowerment_SpellScript)
-        bool Validate(SpellEntry const * /*spellEntry*/)
+        class spell_warl_demonic_empowerment_SpellScript : public SpellScript
         {
-            if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS))
-                return false;
-            if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER))
-                return false;
-            if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD))
-                return false;
-            if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER))
-                return false;
-            if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_IMP))
-                return false;
-            return true;
-        }
+            PrepareSpellScript(spell_warl_demonic_empowerment_SpellScript);
 
-        void HandleScriptEffect(SpellEffIndex /*effIndex*/)
-        {
-            if (Creature* targetCreature = GetHitCreature())
+            bool Validate(SpellEntry const * /*spellEntry*/)
+            {
+                if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS))
+                    return false;
+                if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER))
+                    return false;
+                if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD))
+                    return false;
+                if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER))
+                    return false;
+                if (!sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_IMP))
+                    return false;
+                return true;
+            }
+
+            void HandleScriptEffect(SpellEffIndex /*effIndex*/)
             {
-                if (targetCreature->isPet())
+                if (Creature* targetCreature = GetHitCreature())
                 {
-                    CreatureInfo const * ci = ObjectMgr::GetCreatureTemplate(targetCreature->GetEntry());
-                    switch (ci->family)
+                    if (targetCreature->isPet())
                     {
-                    case CREATURE_FAMILY_SUCCUBUS:
-                        targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS, true);
-                        break;
-                    case CREATURE_FAMILY_VOIDWALKER:
-                    {
-                        SpellEntry const* spellInfo = sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER);
-                        int32 hp = int32(targetCreature->CountPctFromMaxHealth(GetCaster()->CalculateSpellDamage(targetCreature, spellInfo, 0)));
-                        targetCreature->CastCustomSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER, &hp, NULL, NULL, true);
-                        //unitTarget->CastSpell(unitTarget, 54441, true);
-                        break;
-                    }
-                    case CREATURE_FAMILY_FELGUARD:
-                        targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD, true);
-                        break;
-                    case CREATURE_FAMILY_FELHUNTER:
-                        targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER, true);
-                        break;
-                    case CREATURE_FAMILY_IMP:
-                        targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_IMP, true);
-                        break;
+                        CreatureInfo const * ci = ObjectMgr::GetCreatureTemplate(targetCreature->GetEntry());
+                        switch (ci->family)
+                        {
+                        case CREATURE_FAMILY_SUCCUBUS:
+                            targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS, true);
+                            break;
+                        case CREATURE_FAMILY_VOIDWALKER:
+                        {
+                            SpellEntry const* spellInfo = sSpellStore.LookupEntry(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER);
+                            int32 hp = int32(targetCreature->CountPctFromMaxHealth(GetCaster()->CalculateSpellDamage(targetCreature, spellInfo, 0)));
+                            targetCreature->CastCustomSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER, &hp, NULL, NULL, true);
+                            //unitTarget->CastSpell(unitTarget, 54441, true);
+                            break;
+                        }
+                        case CREATURE_FAMILY_FELGUARD:
+                            targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD, true);
+                            break;
+                        case CREATURE_FAMILY_FELHUNTER:
+                            targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER, true);
+                            break;
+                        case CREATURE_FAMILY_IMP:
+                            targetCreature->CastSpell(targetCreature, WARLOCK_DEMONIC_EMPOWERMENT_IMP, true);
+                            break;
+                        }
                     }
                 }
             }
-        }
-
-        void Register()
-        {
-            OnEffect += SpellEffectFn(spell_warl_demonic_empowerment_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
-        }
-    };
-
-    SpellScript* GetSpellScript() const
-    {
-        return new spell_warl_demonic_empowerment_SpellScript();
-    }
-};
 
-// 47422 Everlasting Affliction
-class spell_warl_everlasting_affliction : public SpellScriptLoader
-{
-public:
-    spell_warl_everlasting_affliction() : SpellScriptLoader("spell_warl_everlasting_affliction") { }
-
-    class spell_warl_everlasting_affliction_SpellScript : public SpellScript
-    {
-        PrepareSpellScript(spell_warl_everlasting_affliction_SpellScript)
-        void HandleScriptEffect(SpellEffIndex /*effIndex*/)
-        {
-            if (Unit* unitTarget = GetHitUnit())
-                // Refresh corruption on target
-                if (AuraEffect* aur = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_WARLOCK, 0x2, 0, 0, GetCaster()->GetGUID()))
-                    aur->GetBase()->RefreshDuration();
-        }
+            void Register()
+            {
+                OnEffect += SpellEffectFn(spell_warl_demonic_empowerment_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+            }
+        };
 
-        void Register()
+        SpellScript* GetSpellScript() const
         {
-            OnEffect += SpellEffectFn(spell_warl_everlasting_affliction_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+            return new spell_warl_demonic_empowerment_SpellScript();
         }
-    };
-
-    SpellScript* GetSpellScript() const
-    {
-        return new spell_warl_everlasting_affliction_SpellScript();
-    }
 };
 
 // 6201 Create Healthstone (and ranks)
 class spell_warl_create_healthstone : public SpellScriptLoader
 {
-public:
-    spell_warl_create_healthstone() : SpellScriptLoader("spell_warl_create_healthstone") { }
+    public:
+        spell_warl_create_healthstone() : SpellScriptLoader("spell_warl_create_healthstone") { }
 
-    class spell_warl_create_healthstone_SpellScript : public SpellScript
-    {
-        PrepareSpellScript(spell_warl_create_healthstone_SpellScript)
-        static uint32 const iTypes[8][3];
-
-        bool Validate(SpellEntry const * /*spellEntry*/)
+        class spell_warl_create_healthstone_SpellScript : public SpellScript
         {
-            if (!sSpellStore.LookupEntry(WARLOCK_IMPROVED_HEALTHSTONE_R1))
-                return false;
-            if (!sSpellStore.LookupEntry(WARLOCK_IMPROVED_HEALTHSTONE_R2))
-                return false;
-            return true;
-        }
+            PrepareSpellScript(spell_warl_create_healthstone_SpellScript);
 
-        void HandleScriptEffect(SpellEffIndex effIndex)
-        {
-            if (Unit* unitTarget = GetHitUnit())
+            static uint32 const iTypes[8][3];
+
+            bool Validate(SpellEntry const * /*spellEntry*/)
             {
-                uint32 rank = 0;
-                // Improved Healthstone
-                if (AuraEffect const * aurEff = unitTarget->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, 284, 0))
+                if (!sSpellStore.LookupEntry(WARLOCK_IMPROVED_HEALTHSTONE_R1))
+                    return false;
+                if (!sSpellStore.LookupEntry(WARLOCK_IMPROVED_HEALTHSTONE_R2))
+                    return false;
+                return true;
+            }
+
+            void HandleScriptEffect(SpellEffIndex effIndex)
+            {
+                if (Unit* unitTarget = GetHitUnit())
                 {
-                    switch (aurEff->GetId())
+                    uint32 rank = 0;
+                    // Improved Healthstone
+                    if (AuraEffect const * aurEff = unitTarget->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, 284, 0))
                     {
-                        case WARLOCK_IMPROVED_HEALTHSTONE_R1: rank = 1; break;
-                        case WARLOCK_IMPROVED_HEALTHSTONE_R2: rank = 2; break;
-                        default:
-                            sLog->outError("Unknown rank of Improved Healthstone id: %d", aurEff->GetId());
-                            break;
+                        switch (aurEff->GetId())
+                        {
+                            case WARLOCK_IMPROVED_HEALTHSTONE_R1: rank = 1; break;
+                            case WARLOCK_IMPROVED_HEALTHSTONE_R2: rank = 2; break;
+                            default:
+                                sLog->outError("Unknown rank of Improved Healthstone id: %d", aurEff->GetId());
+                                break;
+                        }
                     }
+                    uint8 spellRank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
+                    if (spellRank > 0 && spellRank <= 8)
+                        CreateItem(effIndex, iTypes[spellRank - 1][rank]);
                 }
-                uint8 spellRank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
-                if (spellRank > 0 && spellRank <= 8)
-                    CreateItem(effIndex, iTypes[spellRank - 1][rank]);
             }
-        }
 
-        void Register()
+            void Register()
+            {
+                OnEffect += SpellEffectFn(spell_warl_create_healthstone_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
         {
-            OnEffect += SpellEffectFn(spell_warl_create_healthstone_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+            return new spell_warl_create_healthstone_SpellScript();
         }
-    };
-
-    SpellScript* GetSpellScript() const
-    {
-        return new spell_warl_create_healthstone_SpellScript();
-    }
 };
 
 uint32 const spell_warl_create_healthstone::spell_warl_create_healthstone_SpellScript::iTypes[8][3] = {
@@ -201,10 +174,66 @@ uint32 const spell_warl_create_healthstone::spell_warl_create_healthstone_SpellS
     {36892, 36893, 36894}               // Fel Healthstone
 };
 
+// 47422 Everlasting Affliction
+class spell_warl_everlasting_affliction : public SpellScriptLoader
+{
+    public:
+        spell_warl_everlasting_affliction() : SpellScriptLoader("spell_warl_everlasting_affliction") { }
+
+        class spell_warl_everlasting_affliction_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_warl_everlasting_affliction_SpellScript);
+
+            void HandleScriptEffect(SpellEffIndex /*effIndex*/)
+            {
+                if (Unit* unitTarget = GetHitUnit())
+                    // Refresh corruption on target
+                    if (AuraEffect* aur = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_WARLOCK, 0x2, 0, 0, GetCaster()->GetGUID()))
+                        aur->GetBase()->RefreshDuration();
+            }
+
+            void Register()
+            {
+                OnEffect += SpellEffectFn(spell_warl_everlasting_affliction_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+            }
+        };
+
+        SpellScript* GetSpellScript() const
+        {
+            return new spell_warl_everlasting_affliction_SpellScript();
+        }
+};
+
+class spell_warl_seed_of_corruption : public SpellScriptLoader
+{
+    public:
+        spell_warl_seed_of_corruption() : SpellScriptLoader("spell_warl_seed_of_corruption") { }
+
+        class spell_warl_seed_of_corruption_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_warl_seed_of_corruption_SpellScript);
+
+            void FilterTargets(std::list<Unit*>& unitList)
+            {
+                unitList.remove(GetTargetUnit());
+            }
+
+            void Register()
+            {
+                OnUnitTargetSelect += SpellUnitTargetFn(spell_warl_seed_of_corruption_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_AREA_ENEMY_DST);
+            }
+        };
+
+        SpellScript *GetSpellScript() const
+        {
+            return new spell_warl_seed_of_corruption_SpellScript();
+        }
+};
 
 void AddSC_warlock_spell_scripts()
 {
     new spell_warl_demonic_empowerment();
-    new spell_warl_everlasting_affliction();
     new spell_warl_create_healthstone();
+    new spell_warl_everlasting_affliction();
+    new spell_warl_seed_of_corruption();
 }
diff --git a/src/server/scripts/Spells/spell_warrior.cpp b/src/server/scripts/Spells/spell_warrior.cpp
index 833a2802320..83c3d9c137c 100644
--- a/src/server/scripts/Spells/spell_warrior.cpp
+++ b/src/server/scripts/Spells/spell_warrior.cpp
@@ -35,7 +35,7 @@ class spell_warr_last_stand : public SpellScriptLoader
 
         class spell_warr_last_stand_SpellScript : public SpellScript
         {
-            PrepareSpellScript(spell_warr_last_stand_SpellScript)
+            PrepareSpellScript(spell_warr_last_stand_SpellScript);
 
             bool Validate(SpellEntry const * /*spellEntry*/)
             {
@@ -63,7 +63,34 @@ class spell_warr_last_stand : public SpellScriptLoader
         }
 };
 
+class spell_warr_improved_spell_reflection : public SpellScriptLoader
+{
+    public:
+        spell_warr_improved_spell_reflection() : SpellScriptLoader("spell_warr_improved_spell_reflection") { }
+
+        class spell_warr_improved_spell_reflection_SpellScript : public SpellScript
+        {
+            PrepareSpellScript(spell_warr_improved_spell_reflection_SpellScript);
+
+            void FilterTargets(std::list<Unit*>& unitList)
+            {
+                unitList.remove(GetCaster());
+            }
+
+            void Register()
+            {
+                OnUnitTargetSelect += SpellUnitTargetFn(spell_warr_improved_spell_reflection_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_PARTY_CASTER);
+            }
+        };
+
+        SpellScript *GetSpellScript() const
+        {
+            return new spell_warr_improved_spell_reflection_SpellScript();
+        }
+};
+
 void AddSC_warrior_spell_scripts()
 {
-    new spell_warr_last_stand;
+    new spell_warr_last_stand();
+    new spell_warr_improved_spell_reflection();
 }