Core/Misc: Changed some SpellMgr::GetSpellInfo calls

src/server/scripts/EasternKingdoms/Karazhan/boss_shade_of_aran.cpp

@@ -506,26 +506,24 @@ public:
                 DrinkInturrupted = true;
         }
 
-        void SpellHit(Unit* /*pAttacker*/, const SpellInfo* Spell) override
+        void SpellHit(Unit* /*caster*/, SpellInfo const* spellInfo) override
         {
-            //We only care about interrupt effects and only if they are durring a spell currently being cast
-            for (SpellEffectInfo const* effect : Spell->GetEffectsForDifficulty(me->GetMap()->GetDifficultyID()))
-                if (effect && effect->Effect == SPELL_EFFECT_INTERRUPT_CAST && me->IsNonMeleeSpellCast(false))
+            // We only care about interrupt effects and only if they are durring a spell currently being cast
+            if (spellInfo->HasEffect(SPELL_EFFECT_INTERRUPT_CAST) && me->IsNonMeleeSpellCast(false))
+            {
+                // Interrupt effect
+                me->InterruptNonMeleeSpells(false);
+
+                // Normally we would set the cooldown equal to the spell duration
+                // but we do not have access to the DurationStore
+
+                switch (CurrentNormalSpell)
                 {
-                    //Interrupt effect
-                    me->InterruptNonMeleeSpells(false);
-
-                    //Normally we would set the cooldown equal to the spell duration
-                    //but we do not have access to the DurationStore
-
-                    switch (CurrentNormalSpell)
-                    {
                     case SPELL_ARCMISSLE: ArcaneCooldown = 5000; break;
                     case SPELL_FIREBALL: FireCooldown = 5000; break;
                     case SPELL_FROSTBOLT: FrostCooldown = 5000; break;
-                    }
-                    return;
                 }
+            }
         }
 
         void MoveInLineOfSight(Unit* who) override

src/server/scripts/EasternKingdoms/Uldaman/boss_archaedas.cpp

@@ -31,7 +31,7 @@ EndScriptData */
 #include "ObjectAccessor.h"
 #include "Player.h"
 #include "ScriptedCreature.h"
-#include "SpellMgr.h"
+#include "SpellInfo.h"
 #include "uldaman.h"
 
 enum Says
@@ -127,10 +127,10 @@ class boss_archaedas : public CreatureScript
                 me->SetControlled(false, UNIT_STATE_ROOT);
             }
 
-            void SpellHit(Unit* /*caster*/, const SpellInfo* spell) override
+            void SpellHit(Unit* /*caster*/, SpellInfo const* spellInfo) override
             {
                 // Being woken up from the altar, start the awaken sequence
-                if (spell == sSpellMgr->GetSpellInfo(SPELL_ARCHAEDAS_AWAKEN))
+                if (spellInfo->Id == SPELL_ARCHAEDAS_AWAKEN)
                 {
                     Talk(SAY_AGGRO);
                     iAwakenTimer = 4000;
@@ -278,10 +278,10 @@ class npc_archaedas_minions : public CreatureScript
                 bAmIAwake = true;
             }
 
-            void SpellHit(Unit * /*caster*/, const SpellInfo* spell) override
+            void SpellHit(Unit* /*caster*/, SpellInfo const* spellInfo) override
             {
                 // time to wake up, start animation
-                if (spell == sSpellMgr->GetSpellInfo(SPELL_ARCHAEDAS_AWAKEN))
+                if (spellInfo->Id == SPELL_ARCHAEDAS_AWAKEN)
                 {
                     iAwakenTimer = 5000;
                     bWakingUp = true;

src/server/scripts/Kalimdor/HallsOfOrigination/boss_temple_guardian_anhuur.cpp

@@ -387,7 +387,7 @@ public:
             {
                 CustomSpellValues values;
                 values.AddSpellMod(SPELLVALUE_BASE_POINT0, aurEff->GetAmount());
-                caster->CastCustomSpell(GetSpellInfo()->GetEffect(caster->GetMap()->GetDifficultyID(), EFFECT_0)->TriggerSpell, values, GetTarget());
+                caster->CastCustomSpell(aurEff->GetSpellEffectInfo()->TriggerSpell, values, GetTarget());
             }
         }
 

src/server/scripts/Spells/spell_item.cpp

@@ -209,11 +209,12 @@ class spell_item_anger_capacitor : public SpellScriptLoader
 
             bool Validate(SpellInfo const* /*spellInfo*/) override
             {
-                if (!sSpellMgr->GetSpellInfo(SPELL_MOTE_OF_ANGER) ||
-                    !sSpellMgr->GetSpellInfo(SPELL_MANIFEST_ANGER_MAIN_HAND) ||
-                    !sSpellMgr->GetSpellInfo(SPELL_MANIFEST_ANGER_OFF_HAND))
-                    return false;
-                return true;
+                return ValidateSpellInfo(
+                {
+                    SPELL_MOTE_OF_ANGER,
+                    SPELL_MANIFEST_ANGER_MAIN_HAND,
+                    SPELL_MANIFEST_ANGER_OFF_HAND
+                });
             }
 
             void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
@@ -564,13 +565,14 @@ class spell_item_deathbringers_will : public SpellScriptLoader
 
             bool Validate(SpellInfo const* /*spellInfo*/) override
             {
-                if (!sSpellMgr->GetSpellInfo(Strength) ||
-                    !sSpellMgr->GetSpellInfo(Agility) ||
-                    !sSpellMgr->GetSpellInfo(AttackPower) ||
-                    !sSpellMgr->GetSpellInfo(Critical) ||
-                    !sSpellMgr->GetSpellInfo(Haste))
-                    return false;
-                return true;
+                return ValidateSpellInfo(
+                {
+                    Strength,
+                    Agility,
+                    AttackPower,
+                    Critical,
+                    Haste
+                });
             }
 
             void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
@@ -1128,12 +1130,13 @@ class spell_item_heartpierce : public SpellScriptLoader
 
             bool Validate(SpellInfo const* /*spellInfo*/) override
             {
-                if (!sSpellMgr->GetSpellInfo(Energy) ||
-                    !sSpellMgr->GetSpellInfo(Mana) ||
-                    !sSpellMgr->GetSpellInfo(Rage) ||
-                    !sSpellMgr->GetSpellInfo(RunicPower))
-                    return false;
-                return true;
+                return ValidateSpellInfo(
+                {
+                    Energy,
+                    Mana,
+                    Rage,
+                    RunicPower
+                });
             }
 
             void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
@@ -3611,10 +3614,7 @@ class spell_item_shard_of_the_scale : public SpellScriptLoader
 
             bool Validate(SpellInfo const* /*spellInfo*/) override
             {
-                if (!sSpellMgr->GetSpellInfo(HealProc) ||
-                    !sSpellMgr->GetSpellInfo(DamageProc))
-                    return false;
-                return true;
+                return ValidateSpellInfo({ HealProc, DamageProc });
             }
 
             void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
@@ -3750,11 +3750,13 @@ class spell_item_sunwell_neck : public SpellScriptLoader
             bool Validate(SpellInfo const* /*spellInfo*/) override
             {
                 if (!sFactionStore.LookupEntry(FACTION_ALDOR) ||
-                    !sFactionStore.LookupEntry(FACTION_SCRYERS) ||
-                    !sSpellMgr->GetSpellInfo(Aldors) ||
-                    !sSpellMgr->GetSpellInfo(Scryers))
+                    !sFactionStore.LookupEntry(FACTION_SCRYERS))
                     return false;
-                return true;
+                return ValidateSpellInfo(
+                {
+                    Aldors,
+                    Scryers
+                });
             }
 
             bool CheckProc(ProcEventInfo& eventInfo)

src/server/scripts/Spells/spell_monk.cpp

@@ -42,157 +42,126 @@ enum MonkSpells
 };
 
 // 117952 - Crackling Jade Lightning
-class spell_monk_crackling_jade_lightning : public SpellScriptLoader
+class spell_monk_crackling_jade_lightning : public AuraScript
 {
-public:
-    spell_monk_crackling_jade_lightning() : SpellScriptLoader("spell_monk_crackling_jade_lightning") { }
+    PrepareAuraScript(spell_monk_crackling_jade_lightning);
 
-    class spell_monk_crackling_jade_lightning_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_monk_crackling_jade_lightning_AuraScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
+        return ValidateSpellInfo(
         {
-            if (!sSpellMgr->GetSpellInfo(SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHI_PROC))
-                return false;
-            return true;
-        }
+            SPELL_MONK_STANCE_OF_THE_SPIRITED_CRANE,
+            SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHI_PROC
+        });
+    }
 
-        void OnTick(AuraEffect const* /*aurEff*/)
-        {
-            if (Unit* caster = GetCaster())
-                if (caster->HasAura(SPELL_MONK_STANCE_OF_THE_SPIRITED_CRANE))
-                    caster->CastSpell(caster, SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHI_PROC, TRIGGERED_FULL_MASK);
-        }
-
-        void Register() override
-        {
-            OnEffectPeriodic += AuraEffectPeriodicFn(spell_monk_crackling_jade_lightning_AuraScript::OnTick, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
-        }
-    };
-
-    AuraScript* GetAuraScript() const override
+    void OnTick(AuraEffect const* /*aurEff*/)
     {
-        return new spell_monk_crackling_jade_lightning_AuraScript();
+        if (Unit* caster = GetCaster())
+            if (caster->HasAura(SPELL_MONK_STANCE_OF_THE_SPIRITED_CRANE))
+                caster->CastSpell(caster, SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHI_PROC, TRIGGERED_FULL_MASK);
+    }
+
+    void Register() override
+    {
+        OnEffectPeriodic += AuraEffectPeriodicFn(spell_monk_crackling_jade_lightning::OnTick, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
     }
 };
 
 // 117959 - Crackling Jade Lightning
-class spell_monk_crackling_jade_lightning_knockback_proc_aura : public SpellScriptLoader
+class spell_monk_crackling_jade_lightning_knockback_proc_aura : public AuraScript
 {
-public:
-    spell_monk_crackling_jade_lightning_knockback_proc_aura() : SpellScriptLoader("spell_monk_crackling_jade_lightning_knockback_proc_aura") { }
+    PrepareAuraScript(spell_monk_crackling_jade_lightning_knockback_proc_aura);
 
-    class spell_monk_crackling_jade_lightning_aura_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_monk_crackling_jade_lightning_aura_AuraScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
+        return ValidateSpellInfo(
         {
-            if (!sSpellMgr->GetSpellInfo(SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK))
-                return false;
-            if (!sSpellMgr->GetSpellInfo(SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK_CD))
-                return false;
-            return true;
-        }
+            SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK,
+            SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK_CD
+        });
+    }
 
-        bool CheckProc(ProcEventInfo& eventInfo)
-        {
-            if (GetTarget()->HasAura(SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK_CD))
-                return false;
-
-            if (eventInfo.GetActor()->HasAura(SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHANNEL, GetTarget()->GetGUID()))
-                return false;
-
-            Spell* currentChanneledSpell = GetTarget()->GetCurrentSpell(CURRENT_CHANNELED_SPELL);
-            if (!currentChanneledSpell || currentChanneledSpell->GetSpellInfo()->Id != SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHANNEL)
-                return false;
-
-            return true;
-        }
-
-        void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
-        {
-            GetTarget()->CastSpell(eventInfo.GetActor(), SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK, TRIGGERED_FULL_MASK);
-            GetTarget()->CastSpell(GetTarget(), SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK_CD, TRIGGERED_FULL_MASK);
-        }
-
-        void Register() override
-        {
-            DoCheckProc += AuraCheckProcFn(spell_monk_crackling_jade_lightning_aura_AuraScript::CheckProc);
-            OnEffectProc += AuraEffectProcFn(spell_monk_crackling_jade_lightning_aura_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
-        }
-    };
-
-    AuraScript* GetAuraScript() const override
+    bool CheckProc(ProcEventInfo& eventInfo)
     {
-        return new spell_monk_crackling_jade_lightning_aura_AuraScript();
+        if (GetTarget()->HasAura(SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK_CD))
+            return false;
+
+        if (eventInfo.GetActor()->HasAura(SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHANNEL, GetTarget()->GetGUID()))
+            return false;
+
+        Spell* currentChanneledSpell = GetTarget()->GetCurrentSpell(CURRENT_CHANNELED_SPELL);
+        if (!currentChanneledSpell || currentChanneledSpell->GetSpellInfo()->Id != SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHANNEL)
+            return false;
+
+        return true;
+    }
+
+    void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
+    {
+        GetTarget()->CastSpell(eventInfo.GetActor(), SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK, TRIGGERED_FULL_MASK);
+        GetTarget()->CastSpell(GetTarget(), SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK_CD, TRIGGERED_FULL_MASK);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_monk_crackling_jade_lightning_knockback_proc_aura::CheckProc);
+        OnEffectProc += AuraEffectProcFn(spell_monk_crackling_jade_lightning_knockback_proc_aura::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
     }
 };
 
 // 115546 - Provoke
-class spell_monk_provoke : public SpellScriptLoader
+class spell_monk_provoke : public SpellScript
 {
-public:
-    spell_monk_provoke() : SpellScriptLoader("spell_monk_provoke") { }
+    PrepareSpellScript(spell_monk_provoke);
 
-    class spell_monk_provoke_SpellScript : public SpellScript
+    static uint32 const BlackOxStatusEntry = 61146;
+
+    bool Validate(SpellInfo const* spellInfo) override
     {
-        PrepareSpellScript(spell_monk_provoke_SpellScript);
-
-        static uint32 const BlackOxStatusEntry = 61146;
-
-        bool Validate(SpellInfo const* spellInfo) override
+        if (!(spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT_MASK)) // ensure GetExplTargetUnit() will return something meaningful during CheckCast
+            return false;
+        return ValidateSpellInfo(
         {
-            if (!(spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT_MASK)) // ensure GetExplTargetUnit() will return something meaningful during CheckCast
-                return false;
-            if (!sSpellMgr->GetSpellInfo(SPELL_MONK_PROVOKE_SINGLE_TARGET))
-                return false;
-            if (!sSpellMgr->GetSpellInfo(SPELL_MONK_PROVOKE_AOE))
-                return false;
-            return true;
-        }
+            SPELL_MONK_PROVOKE_SINGLE_TARGET,
+            SPELL_MONK_PROVOKE_AOE
+        });
+    }
 
-        SpellCastResult CheckExplicitTarget()
-        {
-            if (GetExplTargetUnit()->GetEntry() != BlackOxStatusEntry)
-            {
-                SpellInfo const* singleTarget = sSpellMgr->AssertSpellInfo(SPELL_MONK_PROVOKE_SINGLE_TARGET);
-                SpellCastResult singleTargetExplicitResult = singleTarget->CheckExplicitTarget(GetCaster(), GetExplTargetUnit());
-                if (singleTargetExplicitResult != SPELL_CAST_OK)
-                    return singleTargetExplicitResult;
-            }
-            else if (GetExplTargetUnit()->GetOwnerGUID() != GetCaster()->GetGUID())
-                return SPELL_FAILED_BAD_TARGETS;
-
-            return SPELL_CAST_OK;
-        }
-
-        void HandleDummy(SpellEffIndex effIndex)
-        {
-            PreventHitDefaultEffect(effIndex);
-            if (GetHitUnit()->GetEntry() != BlackOxStatusEntry)
-                GetCaster()->CastSpell(GetHitUnit(), SPELL_MONK_PROVOKE_SINGLE_TARGET, true);
-            else
-                GetCaster()->CastSpell(GetHitUnit(), SPELL_MONK_PROVOKE_AOE, true);
-        }
-
-        void Register() override
-        {
-            OnCheckCast += SpellCheckCastFn(spell_monk_provoke_SpellScript::CheckExplicitTarget);
-            OnEffectHitTarget += SpellEffectFn(spell_monk_provoke_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
-        }
-    };
-
-    SpellScript* GetSpellScript() const override
+    SpellCastResult CheckExplicitTarget()
     {
-        return new spell_monk_provoke_SpellScript();
+        if (GetExplTargetUnit()->GetEntry() != BlackOxStatusEntry)
+        {
+            SpellInfo const* singleTarget = sSpellMgr->AssertSpellInfo(SPELL_MONK_PROVOKE_SINGLE_TARGET);
+            SpellCastResult singleTargetExplicitResult = singleTarget->CheckExplicitTarget(GetCaster(), GetExplTargetUnit());
+            if (singleTargetExplicitResult != SPELL_CAST_OK)
+                return singleTargetExplicitResult;
+        }
+        else if (GetExplTargetUnit()->GetOwnerGUID() != GetCaster()->GetGUID())
+            return SPELL_FAILED_BAD_TARGETS;
+
+        return SPELL_CAST_OK;
+    }
+
+    void HandleDummy(SpellEffIndex effIndex)
+    {
+        PreventHitDefaultEffect(effIndex);
+        if (GetHitUnit()->GetEntry() != BlackOxStatusEntry)
+            GetCaster()->CastSpell(GetHitUnit(), SPELL_MONK_PROVOKE_SINGLE_TARGET, true);
+        else
+            GetCaster()->CastSpell(GetHitUnit(), SPELL_MONK_PROVOKE_AOE, true);
+    }
+
+    void Register() override
+    {
+        OnCheckCast += SpellCheckCastFn(spell_monk_provoke::CheckExplicitTarget);
+        OnEffectHitTarget += SpellEffectFn(spell_monk_provoke::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
     }
 };
 
 void AddSC_monk_spell_scripts()
 {
-    new spell_monk_crackling_jade_lightning();
-    new spell_monk_crackling_jade_lightning_knockback_proc_aura();
-    new spell_monk_provoke();
+    RegisterAuraScript(spell_monk_crackling_jade_lightning);
+    RegisterAuraScript(spell_monk_crackling_jade_lightning_knockback_proc_aura);
+    RegisterSpellScript(spell_monk_provoke);
 }

src/server/scripts/Spells/spell_warlock.cpp

@@ -1380,9 +1380,7 @@ class spell_warl_t4_2p_bonus : public SpellScriptLoader
 
             bool Validate(SpellInfo const* /*spellInfo*/) override
             {
-                if (!sSpellMgr->GetSpellInfo(Trigger))
-                    return false;
-                return true;
+                return ValidateSpellInfo({ Trigger });
             }
 
             void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)