Scripts/Spells: Update warrior spells to modern standards

1 files changed, 386 insertions, 607 deletions

diff --git a/src/server/scripts/Spells/spell_warrior.cpp b/src/server/scripts/Spells/spell_warrior.cpp
index d008fec0db8..f65dba95093 100644
--- a/src/server/scripts/Spells/spell_warrior.cpp
+++ b/src/server/scripts/Spells/spell_warrior.cpp
@@ -72,527 +72,378 @@ enum WarriorMisc
 };
 
 // 23881 - Bloodthirst
-class spell_warr_bloodthirst : public SpellScriptLoader
+class spell_warr_bloodthirst : public SpellScript
 {
-public:
-    spell_warr_bloodthirst() : SpellScriptLoader("spell_warr_bloodthirst") { }
+    PrepareSpellScript(spell_warr_bloodthirst);
 
-    class spell_warr_bloodthirst_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareSpellScript(spell_warr_bloodthirst_SpellScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_WARRIOR_BLOODTHIRST_HEAL });
-        }
-
-        void HandleDummy(SpellEffIndex /*effIndex*/)
-        {
-            GetCaster()->CastSpell(GetCaster(), SPELL_WARRIOR_BLOODTHIRST_HEAL, true);
-        }
+        return ValidateSpellInfo({ SPELL_WARRIOR_BLOODTHIRST_HEAL });
+    }
 
-        void Register() override
-        {
-            OnEffectHit += SpellEffectFn(spell_warr_bloodthirst_SpellScript::HandleDummy, EFFECT_3, SPELL_EFFECT_DUMMY);
-        }
-    };
+    void HandleDummy(SpellEffIndex /*effIndex*/)
+    {
+        GetCaster()->CastSpell(GetCaster(), SPELL_WARRIOR_BLOODTHIRST_HEAL, true);
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_warr_bloodthirst_SpellScript();
+        OnEffectHit += SpellEffectFn(spell_warr_bloodthirst::HandleDummy, EFFECT_3, SPELL_EFFECT_DUMMY);
     }
 };
 
 // 100 - Charge
-class spell_warr_charge : public SpellScriptLoader
+class spell_warr_charge : public SpellScript
 {
-    public:
-        spell_warr_charge() : SpellScriptLoader("spell_warr_charge") { }
-
-        class spell_warr_charge_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_charge_SpellScript);
+    PrepareSpellScript(spell_warr_charge);
 
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo
-                ({
-                    SPELL_WARRIOR_CHARGE_EFFECT,
-                    SPELL_WARRIOR_CHARGE_EFFECT_BLAZING_TRAIL
-                });
-            }
-
-            void HandleDummy(SpellEffIndex /*effIndex*/)
-            {
-                uint32 spellId = SPELL_WARRIOR_CHARGE_EFFECT;
-                if (GetCaster()->HasAura(SPELL_WARRIOR_GLYPH_OF_THE_BLAZING_TRAIL))
-                    spellId = SPELL_WARRIOR_CHARGE_EFFECT_BLAZING_TRAIL;
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo
+        ({
+            SPELL_WARRIOR_CHARGE_EFFECT,
+            SPELL_WARRIOR_CHARGE_EFFECT_BLAZING_TRAIL
+        });
+    }
 
-                GetCaster()->CastSpell(GetHitUnit(), spellId, true);
-            }
+    void HandleDummy(SpellEffIndex /*effIndex*/)
+    {
+        uint32 spellId = SPELL_WARRIOR_CHARGE_EFFECT;
+        if (GetCaster()->HasAura(SPELL_WARRIOR_GLYPH_OF_THE_BLAZING_TRAIL))
+            spellId = SPELL_WARRIOR_CHARGE_EFFECT_BLAZING_TRAIL;
 
-            void Register() override
-            {
-                OnEffectHitTarget += SpellEffectFn(spell_warr_charge_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
-            }
-        };
+        GetCaster()->CastSpell(GetHitUnit(), spellId, true);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_charge_SpellScript();
-        }
+    void Register() override
+    {
+        OnEffectHitTarget += SpellEffectFn(spell_warr_charge::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
+    }
 };
 
 // 126661 - Warrior Charge Drop Fire Periodic
-class spell_warr_charge_drop_fire_periodic : public SpellScriptLoader
+class spell_warr_charge_drop_fire_periodic : public AuraScript
 {
-    public:
-        spell_warr_charge_drop_fire_periodic() : SpellScriptLoader("spell_warr_charge_drop_fire_periodic") { }
+    PrepareAuraScript(spell_warr_charge_drop_fire_periodic);
 
-        class spell_warr_charge_drop_fire_periodic_AuraScript : public AuraScript
+    void DropFireVisual(AuraEffect const* aurEff)
+    {
+        PreventDefaultAction();
+        if (GetTarget()->IsSplineEnabled())
         {
-            PrepareAuraScript(spell_warr_charge_drop_fire_periodic_AuraScript);
-
-            void DropFireVisual(AuraEffect const* aurEff)
-            {
-                PreventDefaultAction();
-                if (GetTarget()->IsSplineEnabled())
-                {
-                    for (uint32 i = 0; i < 5; ++i)
-                    {
-                        int32 timeOffset = 6 * i * aurEff->GetPeriod() / 25;
-                        Movement::Location loc = GetTarget()->movespline->ComputePosition(timeOffset);
-                        GetTarget()->SendPlaySpellVisual(Position(loc.x, loc.y, loc.z), 0.f, SPELL_VISUAL_BLAZING_CHARGE, 0, 0, 1.f, true);
-                    }
-                }
-            }
-
-            void Register() override
+            for (uint32 i = 0; i < 5; ++i)
             {
-                OnEffectPeriodic += AuraEffectPeriodicFn(spell_warr_charge_drop_fire_periodic_AuraScript::DropFireVisual, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
+                int32 timeOffset = 6 * i * aurEff->GetPeriod() / 25;
+                Movement::Location loc = GetTarget()->movespline->ComputePosition(timeOffset);
+                GetTarget()->SendPlaySpellVisual(Position(loc.x, loc.y, loc.z), 0.f, SPELL_VISUAL_BLAZING_CHARGE, 0, 0, 1.f, true);
             }
-        };
-
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_warr_charge_drop_fire_periodic_AuraScript();
         }
+    }
+
+    void Register() override
+    {
+        OnEffectPeriodic += AuraEffectPeriodicFn(spell_warr_charge_drop_fire_periodic::DropFireVisual, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
+    }
 };
 
 // 198337 - Charge Effect (dropping Blazing Trail)
 // 218104 - Charge Effect
-class spell_warr_charge_effect : public SpellScriptLoader
+class spell_warr_charge_effect : public SpellScript
 {
-    public:
-        spell_warr_charge_effect() : SpellScriptLoader("spell_warr_charge_effect") { }
-
-        class spell_warr_charge_effect_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_charge_effect_SpellScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo
-                ({
-                    SPELL_WARRIOR_CHARGE_PAUSE_RAGE_DECAY,
-                    SPELL_WARRIOR_CHARGE_ROOT_EFFECT,
-                    SPELL_WARRIOR_CHARGE_SLOW_EFFECT
-                });
-            }
+    PrepareSpellScript(spell_warr_charge_effect);
 
-            void HandleCharge(SpellEffIndex /*effIndex*/)
-            {
-                Unit* caster = GetCaster();
-                Unit* target = GetHitUnit();
-                caster->CastSpell(caster, SPELL_WARRIOR_CHARGE_PAUSE_RAGE_DECAY, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_BASE_POINT0, 0));
-                caster->CastSpell(target, SPELL_WARRIOR_CHARGE_ROOT_EFFECT, true);
-                caster->CastSpell(target, SPELL_WARRIOR_CHARGE_SLOW_EFFECT, true);
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo
+        ({
+            SPELL_WARRIOR_CHARGE_PAUSE_RAGE_DECAY,
+            SPELL_WARRIOR_CHARGE_ROOT_EFFECT,
+            SPELL_WARRIOR_CHARGE_SLOW_EFFECT
+        });
+    }
 
-            void Register() override
-            {
-                OnEffectLaunchTarget += SpellEffectFn(spell_warr_charge_effect_SpellScript::HandleCharge, EFFECT_0, SPELL_EFFECT_CHARGE);
-            }
-        };
+    void HandleCharge(SpellEffIndex /*effIndex*/)
+    {
+        Unit* caster = GetCaster();
+        Unit* target = GetHitUnit();
+        caster->CastSpell(caster, SPELL_WARRIOR_CHARGE_PAUSE_RAGE_DECAY, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_BASE_POINT0, 0));
+        caster->CastSpell(target, SPELL_WARRIOR_CHARGE_ROOT_EFFECT, true);
+        caster->CastSpell(target, SPELL_WARRIOR_CHARGE_SLOW_EFFECT, true);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_charge_effect_SpellScript();
-        }
+    void Register() override
+    {
+        OnEffectLaunchTarget += SpellEffectFn(spell_warr_charge_effect::HandleCharge, EFFECT_0, SPELL_EFFECT_CHARGE);
+    }
 };
 
 // 167105 - Colossus Smash 7.1.5
-class spell_warr_colossus_smash : public SpellScriptLoader
+class spell_warr_colossus_smash : public SpellScript
 {
-    public:
-        spell_warr_colossus_smash() : SpellScriptLoader("spell_warr_colossus_smash") { }
-
-        class spell_warr_colossus_smash_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_colossus_smash_SpellScript);
+    PrepareSpellScript(spell_warr_colossus_smash);
 
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_COLOSSUS_SMASH_EFFECT });
-            }
-
-            void HandleOnHit()
-            {
-                if (Unit* target = GetHitUnit())
-                    GetCaster()->CastSpell(target, SPELL_WARRIOR_COLOSSUS_SMASH_EFFECT, true);
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_COLOSSUS_SMASH_EFFECT });
+    }
 
-            void Register() override
-            {
-                OnHit += SpellHitFn(spell_warr_colossus_smash_SpellScript::HandleOnHit);
-            }
-        };
+    void HandleOnHit()
+    {
+        if (Unit* target = GetHitUnit())
+            GetCaster()->CastSpell(target, SPELL_WARRIOR_COLOSSUS_SMASH_EFFECT, true);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_colossus_smash_SpellScript();
-        }
+    void Register() override
+    {
+        OnHit += SpellHitFn(spell_warr_colossus_smash::HandleOnHit);
+    }
 };
 
 // 6544 - Heroic leap
-class spell_warr_heroic_leap : public SpellScriptLoader
+class spell_warr_heroic_leap : public SpellScript
 {
-public:
-    spell_warr_heroic_leap() : SpellScriptLoader("spell_warr_heroic_leap") { }
+    PrepareSpellScript(spell_warr_heroic_leap);
 
-    class spell_warr_heroic_leap_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareSpellScript(spell_warr_heroic_leap_SpellScript);
+        return ValidateSpellInfo({ SPELL_WARRIOR_HEROIC_LEAP_JUMP });
+    }
 
-        bool Validate(SpellInfo const* /*spellInfo*/) override
+    SpellCastResult CheckElevation()
+    {
+        if (WorldLocation const* dest = GetExplTargetDest())
         {
-            return ValidateSpellInfo({ SPELL_WARRIOR_HEROIC_LEAP_JUMP });
-        }
+            if (GetCaster()->HasUnitMovementFlag(MOVEMENTFLAG_ROOT))
+                return SPELL_FAILED_ROOTED;
 
-        SpellCastResult CheckElevation()
-        {
-            if (WorldLocation const* dest = GetExplTargetDest())
+            if (GetCaster()->GetMap()->Instanceable())
             {
-                if (GetCaster()->HasUnitMovementFlag(MOVEMENTFLAG_ROOT))
-                    return SPELL_FAILED_ROOTED;
-
-                if (GetCaster()->GetMap()->Instanceable())
-                {
-                    float range = GetSpellInfo()->GetMaxRange(true, GetCaster()) * 1.5f;
-
-                    PathGenerator generatedPath(GetCaster());
-                    generatedPath.SetPathLengthLimit(range);
-
-                    bool result = generatedPath.CalculatePath(dest->GetPositionX(), dest->GetPositionY(), dest->GetPositionZ(), false);
-                    if (generatedPath.GetPathType() & PATHFIND_SHORT)
-                        return SPELL_FAILED_OUT_OF_RANGE;
-                    else if (!result || generatedPath.GetPathType() & PATHFIND_NOPATH)
-                        return SPELL_FAILED_NOPATH;
-                }
-                else if (dest->GetPositionZ() > GetCaster()->GetPositionZ() + 4.0f)
-                    return SPELL_FAILED_NOPATH;
+                float range = GetSpellInfo()->GetMaxRange(true, GetCaster()) * 1.5f;
+
+                PathGenerator generatedPath(GetCaster());
+                generatedPath.SetPathLengthLimit(range);
 
-                return SPELL_CAST_OK;
+                bool result = generatedPath.CalculatePath(dest->GetPositionX(), dest->GetPositionY(), dest->GetPositionZ(), false);
+                if (generatedPath.GetPathType() & PATHFIND_SHORT)
+                    return SPELL_FAILED_OUT_OF_RANGE;
+                else if (!result || generatedPath.GetPathType() & PATHFIND_NOPATH)
+                    return SPELL_FAILED_NOPATH;
             }
+            else if (dest->GetPositionZ() > GetCaster()->GetPositionZ() + 4.0f)
+                return SPELL_FAILED_NOPATH;
 
-            return SPELL_FAILED_NO_VALID_TARGETS;
+            return SPELL_CAST_OK;
         }
 
-        void HandleDummy(SpellEffIndex /*effIndex*/)
-        {
-            if (WorldLocation* dest = GetHitDest())
-                GetCaster()->CastSpell(*dest, SPELL_WARRIOR_HEROIC_LEAP_JUMP, true);
-        }
+        return SPELL_FAILED_NO_VALID_TARGETS;
+    }
 
-        void Register() override
-        {
-            OnCheckCast += SpellCheckCastFn(spell_warr_heroic_leap_SpellScript::CheckElevation);
-            OnEffectHit += SpellEffectFn(spell_warr_heroic_leap_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
-        }
-    };
+    void HandleDummy(SpellEffIndex /*effIndex*/)
+    {
+        if (WorldLocation* dest = GetHitDest())
+            GetCaster()->CastSpell(*dest, SPELL_WARRIOR_HEROIC_LEAP_JUMP, true);
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_warr_heroic_leap_SpellScript();
+        OnCheckCast += SpellCheckCastFn(spell_warr_heroic_leap::CheckElevation);
+        OnEffectHit += SpellEffectFn(spell_warr_heroic_leap::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
     }
 };
 
 // Heroic Leap (triggered by Heroic Leap (6544)) - 178368
-class spell_warr_heroic_leap_jump : public SpellScriptLoader
+class spell_warr_heroic_leap_jump : public SpellScript
 {
-public:
-    spell_warr_heroic_leap_jump() : SpellScriptLoader("spell_warr_heroic_leap_jump") { }
+    PrepareSpellScript(spell_warr_heroic_leap_jump);
 
-    class spell_warr_heroic_leap_jump_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareSpellScript(spell_warr_heroic_leap_jump_SpellScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo(
-            {
-                SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP,
-                SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP_BUFF,
-                SPELL_WARRIOR_IMPROVED_HEROIC_LEAP,
-                SPELL_WARRIOR_TAUNT
-            });
-        }
-
-        void AfterJump(SpellEffIndex /*effIndex*/)
+        return ValidateSpellInfo(
         {
-            if (GetCaster()->HasAura(SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP))
-                GetCaster()->CastSpell(GetCaster(), SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP_BUFF, true);
-            if (GetCaster()->HasAura(SPELL_WARRIOR_IMPROVED_HEROIC_LEAP))
-                GetCaster()->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_TAUNT, true);
-        }
+            SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP,
+            SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP_BUFF,
+            SPELL_WARRIOR_IMPROVED_HEROIC_LEAP,
+            SPELL_WARRIOR_TAUNT
+        });
+    }
 
-        void Register() override
-        {
-            OnEffectHit += SpellEffectFn(spell_warr_heroic_leap_jump_SpellScript::AfterJump, EFFECT_1, SPELL_EFFECT_JUMP_DEST);
-        }
-    };
+    void AfterJump(SpellEffIndex /*effIndex*/)
+    {
+        if (GetCaster()->HasAura(SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP))
+            GetCaster()->CastSpell(GetCaster(), SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP_BUFF, true);
+        if (GetCaster()->HasAura(SPELL_WARRIOR_IMPROVED_HEROIC_LEAP))
+            GetCaster()->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_TAUNT, true);
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_warr_heroic_leap_jump_SpellScript();
+        OnEffectHit += SpellEffectFn(spell_warr_heroic_leap_jump::AfterJump, EFFECT_1, SPELL_EFFECT_JUMP_DEST);
     }
 };
 
 // 202168 - Impending Victory
-class spell_warr_impending_victory : public SpellScriptLoader
+class spell_warr_impending_victory : public SpellScript
 {
-    public:
-        spell_warr_impending_victory() : SpellScriptLoader("spell_warr_impending_victory") { }
-
-        class spell_warr_impending_victory_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_impending_victory_SpellScript);
+    PrepareSpellScript(spell_warr_impending_victory);
 
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_IMPENDING_VICTORY_HEAL });
-            }
-
-            void HandleAfterCast()
-            {
-                Unit* caster = GetCaster();
-                caster->CastSpell(caster, SPELL_WARRIOR_IMPENDING_VICTORY_HEAL, true);
-                caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VICTORIOUS);
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_IMPENDING_VICTORY_HEAL });
+    }
 
-            void Register() override
-            {
-                AfterCast += SpellCastFn(spell_warr_impending_victory_SpellScript::HandleAfterCast);
-            }
-        };
+    void HandleAfterCast()
+    {
+        Unit* caster = GetCaster();
+        caster->CastSpell(caster, SPELL_WARRIOR_IMPENDING_VICTORY_HEAL, true);
+        caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VICTORIOUS);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_impending_victory_SpellScript();
-        }
+    void Register() override
+    {
+        AfterCast += SpellCastFn(spell_warr_impending_victory::HandleAfterCast);
+    }
 };
 
 // 5246 - Intimidating Shout
-class spell_warr_intimidating_shout : public SpellScriptLoader
+class spell_warr_intimidating_shout : public SpellScript
 {
-    public:
-        spell_warr_intimidating_shout() : SpellScriptLoader("spell_warr_intimidating_shout") { }
-
-        class spell_warr_intimidating_shout_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_intimidating_shout_SpellScript);
-
-            void FilterTargets(std::list<WorldObject*>& unitList)
-            {
-                unitList.remove(GetExplTargetWorldObject());
-            }
+    PrepareSpellScript(spell_warr_intimidating_shout);
 
-            void Register() override
-            {
-                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout_SpellScript::FilterTargets, EFFECT_1, TARGET_UNIT_SRC_AREA_ENEMY);
-                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout_SpellScript::FilterTargets, EFFECT_2, TARGET_UNIT_SRC_AREA_ENEMY);
-            }
-        };
+    void FilterTargets(std::list<WorldObject*>& unitList)
+    {
+        unitList.remove(GetExplTargetWorldObject());
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_intimidating_shout_SpellScript();
-        }
+    void Register() override
+    {
+        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout::FilterTargets, EFFECT_1, TARGET_UNIT_SRC_AREA_ENEMY);
+        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout::FilterTargets, EFFECT_2, TARGET_UNIT_SRC_AREA_ENEMY);
+    }
 };
 
 // 70844 - Item - Warrior T10 Protection 4P Bonus
-/// 7.1.5
-class spell_warr_item_t10_prot_4p_bonus : public SpellScriptLoader
+class spell_warr_item_t10_prot_4p_bonus : public AuraScript
 {
-    public:
-        spell_warr_item_t10_prot_4p_bonus() : SpellScriptLoader("spell_warr_item_t10_prot_4p_bonus") { }
-
-        class spell_warr_item_t10_prot_4p_bonus_AuraScript : public AuraScript
-        {
-            PrepareAuraScript(spell_warr_item_t10_prot_4p_bonus_AuraScript);
+    PrepareAuraScript(spell_warr_item_t10_prot_4p_bonus);
 
-            bool Validate(SpellInfo const* spellInfo) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_STOICISM })
-                    && spellInfo->GetEffects().size() > EFFECT_1;
-            }
-
-            void HandleProc(ProcEventInfo& eventInfo)
-            {
-                PreventDefaultAction();
+    bool Validate(SpellInfo const* spellInfo) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_STOICISM })
+            && spellInfo->GetEffects().size() > EFFECT_1;
+    }
 
-                Unit* target = eventInfo.GetActionTarget();
-                int32 bp0 = CalculatePct(target->GetMaxHealth(), GetEffectInfo(EFFECT_1).CalcValue());
-                CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
-                args.AddSpellBP0(bp0);
-                target->CastSpell(nullptr, SPELL_WARRIOR_STOICISM, args);
-            }
+    void HandleProc(ProcEventInfo& eventInfo)
+    {
+        PreventDefaultAction();
 
-            void Register() override
-            {
-                OnProc += AuraProcFn(spell_warr_item_t10_prot_4p_bonus_AuraScript::HandleProc);
-            }
-        };
+        Unit* target = eventInfo.GetActionTarget();
+        int32 bp0 = CalculatePct(target->GetMaxHealth(), GetEffectInfo(EFFECT_1).CalcValue());
+        CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
+        args.AddSpellBP0(bp0);
+        target->CastSpell(nullptr, SPELL_WARRIOR_STOICISM, args);
+    }
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_warr_item_t10_prot_4p_bonus_AuraScript();
-        }
+    void Register() override
+    {
+        OnProc += AuraProcFn(spell_warr_item_t10_prot_4p_bonus::HandleProc);
+    }
 };
 
 // 12294 - Mortal Strike 7.1.5
-class spell_warr_mortal_strike : public SpellScriptLoader
+class spell_warr_mortal_strike : public SpellScript
 {
-    public:
-        spell_warr_mortal_strike() : SpellScriptLoader("spell_warr_mortal_strike") { }
-
-        class spell_warr_mortal_strike_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_mortal_strike_SpellScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_MORTAL_WOUNDS });
-            }
+    PrepareSpellScript(spell_warr_mortal_strike);
 
-            void HandleDummy(SpellEffIndex /*effIndex*/)
-            {
-                if (Unit* target = GetHitUnit())
-                    GetCaster()->CastSpell(target, SPELL_WARRIOR_MORTAL_WOUNDS, true);
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_MORTAL_WOUNDS });
+    }
 
-            void Register() override
-            {
-                OnEffectHitTarget += SpellEffectFn(spell_warr_mortal_strike_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
-            }
-        };
+    void HandleDummy(SpellEffIndex /*effIndex*/)
+    {
+        if (Unit* target = GetHitUnit())
+            GetCaster()->CastSpell(target, SPELL_WARRIOR_MORTAL_WOUNDS, true);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_mortal_strike_SpellScript();
-        }
+    void Register() override
+    {
+        OnEffectHitTarget += SpellEffectFn(spell_warr_mortal_strike::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
+    }
 };
 
 // 97462 - Rallying Cry
-class spell_warr_rallying_cry : public SpellScriptLoader
+class spell_warr_rallying_cry : public SpellScript
 {
-    public:
-        spell_warr_rallying_cry() : SpellScriptLoader("spell_warr_rallying_cry") { }
-
-        class spell_warr_rallying_cry_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_rallying_cry_SpellScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_RALLYING_CRY });
-            }
+    PrepareSpellScript(spell_warr_rallying_cry);
 
-            bool Load() override
-            {
-                return GetCaster()->GetTypeId() ==  TYPEID_PLAYER;
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_RALLYING_CRY });
+    }
 
-            void HandleScript(SpellEffIndex /*effIndex*/)
-            {
-                CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
-                args.AddSpellMod(SPELLVALUE_BASE_POINT0, int32(GetHitUnit()->CountPctFromMaxHealth(GetEffectValue())));
+    bool Load() override
+    {
+        return GetCaster()->GetTypeId() ==  TYPEID_PLAYER;
+    }
 
-                GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_RALLYING_CRY, args);
-            }
+    void HandleScript(SpellEffIndex /*effIndex*/)
+    {
+        CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
+        args.AddSpellMod(SPELLVALUE_BASE_POINT0, int32(GetHitUnit()->CountPctFromMaxHealth(GetEffectValue())));
 
-            void Register() override
-            {
-                OnEffectHitTarget += SpellEffectFn(spell_warr_rallying_cry_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
-            }
-        };
+        GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_RALLYING_CRY, args);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_rallying_cry_SpellScript();
-        }
+    void Register() override
+    {
+        OnEffectHitTarget += SpellEffectFn(spell_warr_rallying_cry::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
+    }
 };
 
 // 46968 - Shockwave
-class spell_warr_shockwave : public SpellScriptLoader
+class spell_warr_shockwave : public SpellScript
 {
-public:
-    spell_warr_shockwave() : SpellScriptLoader("spell_warr_shockwave") { }
+    PrepareSpellScript(spell_warr_shockwave);
 
-    class spell_warr_shockwave_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* spellInfo) override
     {
-        PrepareSpellScript(spell_warr_shockwave_SpellScript);
-
-        bool Validate(SpellInfo const* spellInfo) override
-        {
-            if (!ValidateSpellInfo({ SPELL_WARRIOR_SHOCKWAVE, SPELL_WARRIOR_SHOCKWAVE_STUN }))
-                return false;
-
-            return spellInfo->GetEffects().size() > EFFECT_3;
-        }
-
-        bool Load() override
-        {
-            return GetCaster()->GetTypeId() == TYPEID_PLAYER;
-        }
+        if (!ValidateSpellInfo({ SPELL_WARRIOR_SHOCKWAVE, SPELL_WARRIOR_SHOCKWAVE_STUN }))
+            return false;
 
-        void HandleStun(SpellEffIndex /*effIndex*/)
-        {
-            GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_SHOCKWAVE_STUN, true);
-            ++_targetCount;
-        }
+        return spellInfo->GetEffects().size() > EFFECT_3;
+    }
 
-        // Cooldown reduced by 20 sec if it strikes at least 3 targets.
-        void HandleAfterCast()
-        {
-            if (_targetCount >= uint32(GetEffectInfo(EFFECT_0).CalcValue()))
-                GetCaster()->ToPlayer()->GetSpellHistory()->ModifyCooldown(GetSpellInfo()->Id, Seconds(-GetEffectInfo(EFFECT_3).CalcValue()));
-        }
+    bool Load() override
+    {
+        return GetCaster()->GetTypeId() == TYPEID_PLAYER;
+    }
 
-        void Register() override
-        {
-            OnEffectHitTarget += SpellEffectFn(spell_warr_shockwave_SpellScript::HandleStun, EFFECT_0, SPELL_EFFECT_DUMMY);
-            AfterCast += SpellCastFn(spell_warr_shockwave_SpellScript::HandleAfterCast);
-        }
+    void HandleStun(SpellEffIndex /*effIndex*/)
+    {
+        GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_SHOCKWAVE_STUN, true);
+        ++_targetCount;
+    }
 
-        uint32 _targetCount = 0;
-    };
+    // Cooldown reduced by 20 sec if it strikes at least 3 targets.
+    void HandleAfterCast()
+    {
+        if (_targetCount >= uint32(GetEffectInfo(EFFECT_0).CalcValue()))
+            GetCaster()->ToPlayer()->GetSpellHistory()->ModifyCooldown(GetSpellInfo()->Id, Seconds(-GetEffectInfo(EFFECT_3).CalcValue()));
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_warr_shockwave_SpellScript();
+        OnEffectHitTarget += SpellEffectFn(spell_warr_shockwave::HandleStun, EFFECT_0, SPELL_EFFECT_DUMMY);
+        AfterCast += SpellCastFn(spell_warr_shockwave::HandleAfterCast);
     }
+
+    uint32 _targetCount = 0;
 };
 
 // 107570 - Storm Bolt
-class spell_warr_storm_bolt : public SpellScriptLoader
-{
-public:
-    spell_warr_storm_bolt() : SpellScriptLoader("spell_warr_storm_bolt") { }
-
-    class spell_warr_storm_bolt_SpellScript : public SpellScript
+    class spell_warr_storm_bolt : public SpellScript
     {
-        PrepareSpellScript(spell_warr_storm_bolt_SpellScript);
+        PrepareSpellScript(spell_warr_storm_bolt);
 
         bool Validate(SpellInfo const* /*spellInfo*/) override
         {
@@ -609,271 +460,199 @@ public:
 
         void Register() override
         {
-            OnEffectHitTarget += SpellEffectFn(spell_warr_storm_bolt_SpellScript::HandleOnHit, EFFECT_1, SPELL_EFFECT_DUMMY);
+            OnEffectHitTarget += SpellEffectFn(spell_warr_storm_bolt::HandleOnHit, EFFECT_1, SPELL_EFFECT_DUMMY);
         }
     };
 
-    SpellScript* GetSpellScript() const override
-    {
-        return new spell_warr_storm_bolt_SpellScript();
-    }
-};
-
 // 52437 - Sudden Death
-class spell_warr_sudden_death : public SpellScriptLoader
+class spell_warr_sudden_death : public AuraScript
 {
-    public:
-        spell_warr_sudden_death() : SpellScriptLoader("spell_warr_sudden_death") { }
-
-        class spell_warr_sudden_death_AuraScript : public AuraScript
-        {
-            PrepareAuraScript(spell_warr_sudden_death_AuraScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_COLOSSUS_SMASH });
-            }
+    PrepareAuraScript(spell_warr_sudden_death);
 
-            void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
-            {
-                // Remove cooldown on Colossus Smash
-                if (Player* player = GetTarget()->ToPlayer())
-                    player->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_COLOSSUS_SMASH, true);
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_COLOSSUS_SMASH });
+    }
 
-            void Register() override
-            {
-                AfterEffectApply += AuraEffectRemoveFn(spell_warr_sudden_death_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); // correct?
-            }
-        };
+    void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        // Remove cooldown on Colossus Smash
+        if (Player* player = GetTarget()->ToPlayer())
+            player->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_COLOSSUS_SMASH, true);
+    }
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_warr_sudden_death_AuraScript();
-        }
+    void Register() override
+    {
+        AfterEffectApply += AuraEffectRemoveFn(spell_warr_sudden_death::HandleApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); // correct?
+    }
 };
 
 // 12328, 18765, 35429 - Sweeping Strikes
-class spell_warr_sweeping_strikes : public SpellScriptLoader
+class spell_warr_sweeping_strikes : public AuraScript
 {
-    public:
-        spell_warr_sweeping_strikes() : SpellScriptLoader("spell_warr_sweeping_strikes") { }
+    PrepareAuraScript(spell_warr_sweeping_strikes);
 
-        class spell_warr_sweeping_strikes_AuraScript : public AuraScript
-        {
-            PrepareAuraScript(spell_warr_sweeping_strikes_AuraScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2 });
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2 });
+    }
 
-            bool CheckProc(ProcEventInfo& eventInfo)
-            {
-                _procTarget = eventInfo.GetActor()->SelectNearbyTarget(eventInfo.GetProcTarget());
-                return _procTarget != nullptr;
-            }
+    bool CheckProc(ProcEventInfo& eventInfo)
+    {
+        _procTarget = eventInfo.GetActor()->SelectNearbyTarget(eventInfo.GetProcTarget());
+        return _procTarget != nullptr;
+    }
 
-            void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
+    {
+        PreventDefaultAction();
+        if (DamageInfo* damageInfo = eventInfo.GetDamageInfo())
+        {
+            SpellInfo const* spellInfo = damageInfo->GetSpellInfo();
+            if (spellInfo && (spellInfo->Id == SPELL_WARRIOR_BLADESTORM_PERIODIC_WHIRLWIND || (spellInfo->Id == SPELL_WARRIOR_EXECUTE && !_procTarget->HasAuraState(AURA_STATE_WOUNDED_20_PERCENT))))
             {
-                PreventDefaultAction();
-                if (DamageInfo* damageInfo = eventInfo.GetDamageInfo())
-                {
-                    SpellInfo const* spellInfo = damageInfo->GetSpellInfo();
-                    if (spellInfo && (spellInfo->Id == SPELL_WARRIOR_BLADESTORM_PERIODIC_WHIRLWIND || (spellInfo->Id == SPELL_WARRIOR_EXECUTE && !_procTarget->HasAuraState(AURA_STATE_WOUNDED_20_PERCENT))))
-                    {
-                        // If triggered by Execute (while target is not under 20% hp) or Bladestorm deals normalized weapon damage
-                        GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2, aurEff);
-                    }
-                    else
-                    {
-                        CastSpellExtraArgs args(aurEff);
-                        args.AddSpellMod(SPELLVALUE_BASE_POINT0, damageInfo->GetDamage());
-                        GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, args);
-                    }
-                }
+                // If triggered by Execute (while target is not under 20% hp) or Bladestorm deals normalized weapon damage
+                GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2, aurEff);
             }
-
-            void Register() override
+            else
             {
-                DoCheckProc += AuraCheckProcFn(spell_warr_sweeping_strikes_AuraScript::CheckProc);
-                OnEffectProc += AuraEffectProcFn(spell_warr_sweeping_strikes_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
+                CastSpellExtraArgs args(aurEff);
+                args.AddSpellMod(SPELLVALUE_BASE_POINT0, damageInfo->GetDamage());
+                GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, args);
             }
+        }
+    }
 
-            Unit* _procTarget = nullptr;
-        };
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_warr_sweeping_strikes::CheckProc);
+        OnEffectProc += AuraEffectProcFn(spell_warr_sweeping_strikes::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
+    }
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_warr_sweeping_strikes_AuraScript();
-        }
+    Unit* _procTarget = nullptr;
 };
 
 // 215538 - Trauma
-class spell_warr_trauma : public SpellScriptLoader
+class spell_warr_trauma : public AuraScript
 {
-public:
-    spell_warr_trauma() : SpellScriptLoader("spell_warr_trauma") { }
+    PrepareAuraScript(spell_warr_trauma);
 
-    class spell_warr_trauma_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_warr_trauma_AuraScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_WARRIOR_TRAUMA_EFFECT });
-        }
-
-        void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
-        {
-            Unit* target = eventInfo.GetActionTarget();
-            //Get 25% of damage from the spell casted (Slam & Whirlwind) plus Remaining Damage from Aura
-            int32 damage = int32(CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetAmount()) / sSpellMgr->AssertSpellInfo(SPELL_WARRIOR_TRAUMA_EFFECT, GetCastDifficulty())->GetMaxTicks());
-            CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
-            args.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
-            GetCaster()->CastSpell(target, SPELL_WARRIOR_TRAUMA_EFFECT, args);
-        }
+        return ValidateSpellInfo({ SPELL_WARRIOR_TRAUMA_EFFECT });
+    }
 
-        void Register() override
-        {
-            OnEffectProc += AuraEffectProcFn(spell_warr_trauma_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
-        }
-    };
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
+    {
+        Unit* target = eventInfo.GetActionTarget();
+        //Get 25% of damage from the spell casted (Slam & Whirlwind) plus Remaining Damage from Aura
+        int32 damage = int32(CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetAmount()) / sSpellMgr->AssertSpellInfo(SPELL_WARRIOR_TRAUMA_EFFECT, GetCastDifficulty())->GetMaxTicks());
+        CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
+        args.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
+        GetCaster()->CastSpell(target, SPELL_WARRIOR_TRAUMA_EFFECT, args);
+    }
 
-    AuraScript* GetAuraScript() const override
+    void Register() override
     {
-        return new spell_warr_trauma_AuraScript();
+        OnEffectProc += AuraEffectProcFn(spell_warr_trauma::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
     }
 };
 
 // 28845 - Cheat Death
-class spell_warr_t3_prot_8p_bonus : public SpellScriptLoader
+class spell_warr_t3_prot_8p_bonus : public AuraScript
 {
-    public:
-        spell_warr_t3_prot_8p_bonus() : SpellScriptLoader("spell_warr_t3_prot_8p_bonus") { }
-
-        class spell_warr_t3_prot_8p_bonus_AuraScript : public AuraScript
-        {
-            PrepareAuraScript(spell_warr_t3_prot_8p_bonus_AuraScript);
-
-            bool CheckProc(ProcEventInfo& eventInfo)
-            {
-                if (eventInfo.GetActionTarget()->HealthBelowPct(20))
-                    return true;
+    PrepareAuraScript(spell_warr_t3_prot_8p_bonus);
 
-                DamageInfo* damageInfo = eventInfo.GetDamageInfo();
-                if (damageInfo && damageInfo->GetDamage())
-                    if (GetTarget()->HealthBelowPctDamaged(20, damageInfo->GetDamage()))
-                        return true;
+    bool CheckProc(ProcEventInfo& eventInfo)
+    {
+        if (eventInfo.GetActionTarget()->HealthBelowPct(20))
+            return true;
 
-                return false;
-            }
+        DamageInfo* damageInfo = eventInfo.GetDamageInfo();
+        if (damageInfo && damageInfo->GetDamage())
+            if (GetTarget()->HealthBelowPctDamaged(20, damageInfo->GetDamage()))
+                return true;
 
-            void Register() override
-            {
-                DoCheckProc += AuraCheckProcFn(spell_warr_t3_prot_8p_bonus_AuraScript::CheckProc);
-            }
-        };
+        return false;
+    }
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_warr_t3_prot_8p_bonus_AuraScript();
-        }
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_warr_t3_prot_8p_bonus::CheckProc);
+    }
 };
 
 // 32215 - Victorious State
-class spell_warr_victorious_state : public SpellScriptLoader
+class spell_warr_victorious_state : public AuraScript
 {
-    public:
-        spell_warr_victorious_state() : SpellScriptLoader("spell_warr_victorious_state") { }
-
-        class spell_warr_victorious_state_Aurascript : public AuraScript
-        {
-            PrepareAuraScript(spell_warr_victorious_state_Aurascript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_WARRIOR_IMPENDING_VICTORY });
-            }
+    PrepareAuraScript(spell_warr_victorious_state);
 
-            void HandleOnProc(AuraEffect* /*aurEff*/, ProcEventInfo& procInfo)
-            {
-                if (procInfo.GetActor()->GetTypeId() == TYPEID_PLAYER && procInfo.GetActor()->ToPlayer()->GetPrimarySpecialization() == TALENT_SPEC_WARRIOR_FURY)
-                    PreventDefaultAction();
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_WARRIOR_IMPENDING_VICTORY });
+    }
 
-                procInfo.GetActor()->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_IMPENDING_VICTORY, true);
-            }
+    void HandleOnProc(AuraEffect* /*aurEff*/, ProcEventInfo& procInfo)
+    {
+        if (procInfo.GetActor()->GetTypeId() == TYPEID_PLAYER && procInfo.GetActor()->ToPlayer()->GetPrimarySpecialization() == TALENT_SPEC_WARRIOR_FURY)
+            PreventDefaultAction();
 
-            void Register() override
-            {
-                OnEffectProc += AuraEffectProcFn(spell_warr_victorious_state_Aurascript::HandleOnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
-            }
-        };
+        procInfo.GetActor()->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_IMPENDING_VICTORY, true);
+    }
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_warr_victorious_state_Aurascript();
-        }
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_warr_victorious_state::HandleOnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
 };
 
 // 34428 - Victory Rush
-class spell_warr_victory_rush : public SpellScriptLoader
+class spell_warr_victory_rush : public SpellScript
 {
-    public:
-        spell_warr_victory_rush() : SpellScriptLoader("spell_warr_victory_rush") { }
-
-        class spell_warr_victory_rush_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_warr_victory_rush_SpellScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo
-                ({
-                    SPELL_WARRIOR_VICTORIOUS,
-                    SPELL_WARRIOR_VICTORY_RUSH_HEAL
-                });
-            }
+    PrepareSpellScript(spell_warr_victory_rush);
 
-            void HandleHeal()
-            {
-                Unit* caster = GetCaster();
-                caster->CastSpell(caster, SPELL_WARRIOR_VICTORY_RUSH_HEAL, true);
-                caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VICTORIOUS);
-            }
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo
+        ({
+            SPELL_WARRIOR_VICTORIOUS,
+            SPELL_WARRIOR_VICTORY_RUSH_HEAL
+        });
+    }
 
-            void Register() override
-            {
-                AfterCast += SpellCastFn(spell_warr_victory_rush_SpellScript::HandleHeal);
-            }
-        };
+    void HandleHeal()
+    {
+        Unit* caster = GetCaster();
+        caster->CastSpell(caster, SPELL_WARRIOR_VICTORY_RUSH_HEAL, true);
+        caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VICTORIOUS);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_warr_victory_rush_SpellScript();
-        }
+    void Register() override
+    {
+        AfterCast += SpellCastFn(spell_warr_victory_rush::HandleHeal);
+    }
 };
 
 void AddSC_warrior_spell_scripts()
 {
-    new spell_warr_bloodthirst();
-    new spell_warr_charge();
-    new spell_warr_charge_drop_fire_periodic();
-    new spell_warr_charge_effect();
-    new spell_warr_colossus_smash();
-    new spell_warr_heroic_leap();
-    new spell_warr_heroic_leap_jump();
-    new spell_warr_impending_victory();
-    new spell_warr_intimidating_shout();
-    new spell_warr_item_t10_prot_4p_bonus();
-    new spell_warr_mortal_strike();
-    new spell_warr_rallying_cry();
-    new spell_warr_shockwave();
-    new spell_warr_storm_bolt();
-    new spell_warr_sudden_death();
-    new spell_warr_sweeping_strikes();
-    new spell_warr_trauma();
-    new spell_warr_t3_prot_8p_bonus();
-    new spell_warr_victorious_state();
-    new spell_warr_victory_rush();
+    RegisterSpellScript(spell_warr_bloodthirst);
+    RegisterSpellScript(spell_warr_charge);
+    RegisterSpellScript(spell_warr_charge_drop_fire_periodic);
+    RegisterSpellScript(spell_warr_charge_effect);
+    RegisterSpellScript(spell_warr_colossus_smash);
+    RegisterSpellScript(spell_warr_heroic_leap);
+    RegisterSpellScript(spell_warr_heroic_leap_jump);
+    RegisterSpellScript(spell_warr_impending_victory);
+    RegisterSpellScript(spell_warr_intimidating_shout);
+    RegisterSpellScript(spell_warr_item_t10_prot_4p_bonus);
+    RegisterSpellScript(spell_warr_mortal_strike);
+    RegisterSpellScript(spell_warr_rallying_cry);
+    RegisterSpellScript(spell_warr_shockwave);
+    RegisterSpellScript(spell_warr_storm_bolt);
+    RegisterSpellScript(spell_warr_sudden_death);
+    RegisterSpellScript(spell_warr_sweeping_strikes);
+    RegisterSpellScript(spell_warr_trauma);
+    RegisterSpellScript(spell_warr_t3_prot_8p_bonus);
+    RegisterSpellScript(spell_warr_victorious_state);
+    RegisterSpellScript(spell_warr_victory_rush);
 }