Scripts/Spells: Convert rogue spell scripts to new script registration syntax (#27752)

src/server/scripts/Spells/spell_rogue.cpp

@@ -126,150 +126,128 @@ class spell_rog_backstab : public SpellScript
 };
 
 // 13877, 33735, (check 51211, 65956) - Blade Flurry
-class spell_rog_blade_flurry : public SpellScriptLoader
+class spell_rog_blade_flurry : public AuraScript
 {
-    public:
-        spell_rog_blade_flurry() : SpellScriptLoader("spell_rog_blade_flurry") { }
+    PrepareAuraScript(spell_rog_blade_flurry);
 
-        class spell_rog_blade_flurry_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK });
+    }
+
+    bool CheckProc(ProcEventInfo& eventInfo)
+    {
+        _procTarget = GetTarget()->SelectNearbyTarget(eventInfo.GetProcTarget());
+        return _procTarget && eventInfo.GetDamageInfo();
+    }
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
+    {
+        PreventDefaultAction();
+
+        if (DamageInfo* damageInfo = eventInfo.GetDamageInfo())
         {
-            PrepareAuraScript(spell_rog_blade_flurry_AuraScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK });
-            }
-
-            bool CheckProc(ProcEventInfo& eventInfo)
-            {
-                _procTarget = GetTarget()->SelectNearbyTarget(eventInfo.GetProcTarget());
-                return _procTarget && eventInfo.GetDamageInfo();
-            }
-
-            void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
-            {
-                PreventDefaultAction();
-
-                if (DamageInfo* damageInfo = eventInfo.GetDamageInfo())
-                {
-                    CastSpellExtraArgs args(aurEff);
-                    args.AddSpellBP0(damageInfo->GetDamage());
-                    GetTarget()->CastSpell(_procTarget, SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK, args);
-                }
-            }
-
-            void Register() override
-            {
-                DoCheckProc += AuraCheckProcFn(spell_rog_blade_flurry_AuraScript::CheckProc);
-                if (m_scriptSpellId == SPELL_ROGUE_BLADE_FLURRY)
-                    OnEffectProc += AuraEffectProcFn(spell_rog_blade_flurry_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_MOD_POWER_REGEN_PERCENT);
-                else
-                    OnEffectProc += AuraEffectProcFn(spell_rog_blade_flurry_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_MOD_MELEE_HASTE);
-            }
-
-            Unit* _procTarget = nullptr;
-        };
-
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_rog_blade_flurry_AuraScript();
+            CastSpellExtraArgs args(aurEff);
+            args.AddSpellBP0(damageInfo->GetDamage());
+            GetTarget()->CastSpell(_procTarget, SPELL_ROGUE_BLADE_FLURRY_EXTRA_ATTACK, args);
         }
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_rog_blade_flurry::CheckProc);
+        if (m_scriptSpellId == SPELL_ROGUE_BLADE_FLURRY)
+            OnEffectProc += AuraEffectProcFn(spell_rog_blade_flurry::HandleProc, EFFECT_0, SPELL_AURA_MOD_POWER_REGEN_PERCENT);
+        else
+            OnEffectProc += AuraEffectProcFn(spell_rog_blade_flurry::HandleProc, EFFECT_0, SPELL_AURA_MOD_MELEE_HASTE);
+    }
+
+    Unit* _procTarget = nullptr;
 };
 
 // 2818 - Deadly Poison
-class spell_rog_deadly_poison : public SpellScriptLoader
+class spell_rog_deadly_poison : public SpellScript
 {
-    public:
-        spell_rog_deadly_poison() : SpellScriptLoader("spell_rog_deadly_poison") { }
+    PrepareSpellScript(spell_rog_deadly_poison);
 
-        class spell_rog_deadly_poison_SpellScript : public SpellScript
+    bool Load() override
+    {
+        // at this point CastItem must already be initialized
+        return GetCaster()->GetTypeId() == TYPEID_PLAYER && GetCastItem();
+    }
+
+    void HandleBeforeHit(SpellMissInfo missInfo)
+    {
+        if (missInfo != SPELL_MISS_NONE)
+            return;
+
+        if (Unit* target = GetHitUnit())
+            // Deadly Poison
+            if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, flag128(0x10000, 0x80000, 0), GetCaster()->GetGUID()))
+                _stackAmount = aurEff->GetBase()->GetStackAmount();
+    }
+
+    void HandleAfterHit()
+    {
+        if (_stackAmount < 5)
+            return;
+
+        Player* player = GetCaster()->ToPlayer();
+
+        if (Unit* target = GetHitUnit())
         {
-            PrepareSpellScript(spell_rog_deadly_poison_SpellScript);
 
-            bool Load() override
+            Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
+
+            if (item == GetCastItem())
+                item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
+
+            if (!item)
+                return;
+
+            // item combat enchantments
+            for (uint8 slot = 0; slot < MAX_ENCHANTMENT_SLOT; ++slot)
             {
-                // at this point CastItem must already be initialized
-                return GetCaster()->GetTypeId() == TYPEID_PLAYER && GetCastItem();
-            }
+                SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(item->GetEnchantmentId(EnchantmentSlot(slot)));
+                if (!enchant)
+                    continue;
 
-            void HandleBeforeHit(SpellMissInfo missInfo)
-            {
-                if (missInfo != SPELL_MISS_NONE)
-                    return;
-
-                if (Unit* target = GetHitUnit())
-                    // Deadly Poison
-                    if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, flag128(0x10000, 0x80000, 0), GetCaster()->GetGUID()))
-                        _stackAmount = aurEff->GetBase()->GetStackAmount();
-            }
-
-            void HandleAfterHit()
-            {
-                if (_stackAmount < 5)
-                    return;
-
-                Player* player = GetCaster()->ToPlayer();
-
-                if (Unit* target = GetHitUnit())
+                for (uint8 s = 0; s < 3; ++s)
                 {
+                    if (enchant->Effect[s] != ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL)
+                        continue;
 
-                    Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND);
-
-                    if (item == GetCastItem())
-                        item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND);
-
-                    if (!item)
-                        return;
-
-                    // item combat enchantments
-                    for (uint8 slot = 0; slot < MAX_ENCHANTMENT_SLOT; ++slot)
+                    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(enchant->EffectArg[s], DIFFICULTY_NONE);
+                    if (!spellInfo)
                     {
-                        SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(item->GetEnchantmentId(EnchantmentSlot(slot)));
-                        if (!enchant)
-                            continue;
-
-                        for (uint8 s = 0; s < 3; ++s)
-                        {
-                            if (enchant->Effect[s] != ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL)
-                                continue;
-
-                            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(enchant->EffectArg[s], DIFFICULTY_NONE);
-                            if (!spellInfo)
-                            {
-                                TC_LOG_ERROR("spells", "Player::CastItemCombatSpell Enchant %i, player (Name: %s, %s) cast unknown spell %i", enchant->ID, player->GetName().c_str(), player->GetGUID().ToString().c_str(), enchant->EffectArg[s]);
-                                continue;
-                            }
-
-                            // Proc only rogue poisons
-                            if (spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || spellInfo->Dispel != DISPEL_POISON)
-                                continue;
-
-                            // Do not reproc deadly
-                            if (spellInfo->SpellFamilyFlags & flag128(0x10000))
-                                continue;
-
-                            if (spellInfo->IsPositive())
-                                player->CastSpell(player, enchant->EffectArg[s], item);
-                            else
-                                player->CastSpell(target, enchant->EffectArg[s], item);
-                        }
+                        TC_LOG_ERROR("spells", "Player::CastItemCombatSpell Enchant %i, player (Name: %s, %s) cast unknown spell %i", enchant->ID, player->GetName().c_str(), player->GetGUID().ToString().c_str(), enchant->EffectArg[s]);
+                        continue;
                     }
+
+                    // Proc only rogue poisons
+                    if (spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || spellInfo->Dispel != DISPEL_POISON)
+                        continue;
+
+                    // Do not reproc deadly
+                    if (spellInfo->SpellFamilyFlags & flag128(0x10000))
+                        continue;
+
+                    if (spellInfo->IsPositive())
+                        player->CastSpell(player, enchant->EffectArg[s], item);
+                    else
+                        player->CastSpell(target, enchant->EffectArg[s], item);
                 }
             }
-
-            void Register() override
-            {
-                BeforeHit += BeforeSpellHitFn(spell_rog_deadly_poison_SpellScript::HandleBeforeHit);
-                AfterHit += SpellHitFn(spell_rog_deadly_poison_SpellScript::HandleAfterHit);
-            }
-
-            uint8 _stackAmount = 0;
-        };
-
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_rog_deadly_poison_SpellScript();
         }
+    }
+
+    void Register() override
+    {
+        BeforeHit += BeforeSpellHitFn(spell_rog_deadly_poison::HandleBeforeHit);
+        AfterHit += SpellHitFn(spell_rog_deadly_poison::HandleAfterHit);
+    }
+
+    uint8 _stackAmount = 0;
 };
 
 // 193358 - Grand Melee
@@ -315,101 +293,85 @@ class spell_rog_grand_melee : public AuraScript
 };
 
 // 51690 - Killing Spree
-class spell_rog_killing_spree : public SpellScriptLoader
+class spell_rog_killing_spree_aura : public AuraScript
 {
-    public:
-        spell_rog_killing_spree() : SpellScriptLoader("spell_rog_killing_spree") { }
+    PrepareAuraScript(spell_rog_killing_spree_aura);
 
-        class spell_rog_killing_spree_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo(
         {
-            PrepareSpellScript(spell_rog_killing_spree_SpellScript);
+            SPELL_ROGUE_KILLING_SPREE_TELEPORT,
+            SPELL_ROGUE_KILLING_SPREE_WEAPON_DMG,
+            SPELL_ROGUE_KILLING_SPREE_DMG_BUFF
+        });
+    }
 
-            void FilterTargets(std::list<WorldObject*>& targets)
-            {
-                if (targets.empty() || GetCaster()->GetVehicleBase())
-                    FinishCast(SPELL_FAILED_OUT_OF_RANGE);
-            }
+    void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        GetTarget()->CastSpell(GetTarget(), SPELL_ROGUE_KILLING_SPREE_DMG_BUFF, true);
+    }
 
-            void HandleDummy(SpellEffIndex /*effIndex*/)
-            {
-                if (Aura* aura = GetCaster()->GetAura(SPELL_ROGUE_KILLING_SPREE))
-                    if (spell_rog_killing_spree_AuraScript* script = aura->GetScript<spell_rog_killing_spree_AuraScript>())
-                        script->AddTarget(GetHitUnit());
-            }
-
-            void Register() override
-            {
-                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_rog_killing_spree_SpellScript::FilterTargets, EFFECT_1, TARGET_UNIT_DEST_AREA_ENEMY);
-                OnEffectHitTarget += SpellEffectFn(spell_rog_killing_spree_SpellScript::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY);
-            }
-        };
-
-        SpellScript* GetSpellScript() const override
+    void HandleEffectPeriodic(AuraEffect const* /*aurEff*/)
+    {
+        while (!_targets.empty())
         {
-            return new spell_rog_killing_spree_SpellScript();
+            ObjectGuid guid = Trinity::Containers::SelectRandomContainerElement(_targets);
+            if (Unit* target = ObjectAccessor::GetUnit(*GetTarget(), guid))
+            {
+                GetTarget()->CastSpell(target, SPELL_ROGUE_KILLING_SPREE_TELEPORT, true);
+                GetTarget()->CastSpell(target, SPELL_ROGUE_KILLING_SPREE_WEAPON_DMG, true);
+                break;
+            }
+            else
+                _targets.remove(guid);
         }
+    }
 
-        class spell_rog_killing_spree_AuraScript : public AuraScript
-        {
-            PrepareAuraScript(spell_rog_killing_spree_AuraScript);
+    void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        GetTarget()->RemoveAurasDueToSpell(SPELL_ROGUE_KILLING_SPREE_DMG_BUFF);
+    }
 
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo(
-                {
-                    SPELL_ROGUE_KILLING_SPREE_TELEPORT,
-                    SPELL_ROGUE_KILLING_SPREE_WEAPON_DMG,
-                    SPELL_ROGUE_KILLING_SPREE_DMG_BUFF
-                });
-            }
+    void Register() override
+    {
+        AfterEffectApply += AuraEffectApplyFn(spell_rog_killing_spree_aura::HandleApply, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
+        OnEffectPeriodic += AuraEffectPeriodicFn(spell_rog_killing_spree_aura::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+        AfterEffectRemove += AuraEffectRemoveFn(spell_rog_killing_spree_aura::HandleRemove, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
+    }
 
-            void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
-            {
-                GetTarget()->CastSpell(GetTarget(), SPELL_ROGUE_KILLING_SPREE_DMG_BUFF, true);
-            }
+public:
+    void AddTarget(Unit* target)
+    {
+        _targets.push_back(target->GetGUID());
+    }
 
-            void HandleEffectPeriodic(AuraEffect const* /*aurEff*/)
-            {
-                while (!_targets.empty())
-                {
-                    ObjectGuid guid = Trinity::Containers::SelectRandomContainerElement(_targets);
-                    if (Unit* target = ObjectAccessor::GetUnit(*GetTarget(), guid))
-                    {
-                        GetTarget()->CastSpell(target, SPELL_ROGUE_KILLING_SPREE_TELEPORT, true);
-                        GetTarget()->CastSpell(target, SPELL_ROGUE_KILLING_SPREE_WEAPON_DMG, true);
-                        break;
-                    }
-                    else
-                        _targets.remove(guid);
-                }
-            }
+private:
+    GuidList _targets;
+};
 
-            void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
-            {
-                GetTarget()->RemoveAurasDueToSpell(SPELL_ROGUE_KILLING_SPREE_DMG_BUFF);
-            }
+class spell_rog_killing_spree : public SpellScript
+{
+    PrepareSpellScript(spell_rog_killing_spree);
 
-            void Register() override
-            {
-                AfterEffectApply += AuraEffectApplyFn(spell_rog_killing_spree_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
-                OnEffectPeriodic += AuraEffectPeriodicFn(spell_rog_killing_spree_AuraScript::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
-                AfterEffectRemove += AuraEffectRemoveFn(spell_rog_killing_spree_AuraScript::HandleRemove, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
-            }
+    void FilterTargets(std::list<WorldObject*>& targets)
+    {
+        if (targets.empty() || GetCaster()->GetVehicleBase())
+            FinishCast(SPELL_FAILED_OUT_OF_RANGE);
+    }
 
-        public:
-            void AddTarget(Unit* target)
-            {
-                _targets.push_back(target->GetGUID());
-            }
+    void HandleDummy(SpellEffIndex /*effIndex*/)
+    {
+        if (Aura* aura = GetCaster()->GetAura(SPELL_ROGUE_KILLING_SPREE))
+            if (spell_rog_killing_spree_aura* script = aura->GetScript<spell_rog_killing_spree_aura>())
+                script->AddTarget(GetHitUnit());
+    }
 
-        private:
-            GuidList _targets;
-        };
-
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_rog_killing_spree_AuraScript();
-        }
+    void Register() override
+    {
+        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_rog_killing_spree::FilterTargets, EFFECT_1, TARGET_UNIT_DEST_AREA_ENEMY);
+        OnEffectHitTarget += SpellEffectFn(spell_rog_killing_spree::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY);
+    }
 };
 
 // 76806 - Mastery: Main Gauche
@@ -527,79 +489,68 @@ class spell_rog_roll_the_bones : public SpellScript
 };
 
 // 1943 - Rupture
-class spell_rog_rupture : public SpellScriptLoader
+class spell_rog_rupture : public AuraScript
 {
-    public:
-        spell_rog_rupture() : SpellScriptLoader("spell_rog_rupture") { }
+    PrepareAuraScript(spell_rog_rupture);
 
-        class spell_rog_rupture_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_ROGUE_VENOMOUS_WOUNDS });
+    }
+
+    void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& canBeRecalculated)
+    {
+        if (Unit* caster = GetCaster())
         {
-            PrepareAuraScript(spell_rog_rupture_AuraScript);
+            canBeRecalculated = false;
 
-            bool Validate(SpellInfo const* /*spellInfo*/) override
+            float const attackpowerPerCombo[6] =
             {
-                return ValidateSpellInfo({ SPELL_ROGUE_VENOMOUS_WOUNDS });
-            }
+                0.0f,
+                0.015f,         // 1 point:  ${($m1 + $b1*1 + 0.015 * $AP) * 4} damage over 8 secs
+                0.024f,         // 2 points: ${($m1 + $b1*2 + 0.024 * $AP) * 5} damage over 10 secs
+                0.03f,          // 3 points: ${($m1 + $b1*3 + 0.03 * $AP) * 6} damage over 12 secs
+                0.03428571f,    // 4 points: ${($m1 + $b1*4 + 0.03428571 * $AP) * 7} damage over 14 secs
+                0.0375f         // 5 points: ${($m1 + $b1*5 + 0.0375 * $AP) * 8} damage over 16 secs
+            };
 
-            void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& canBeRecalculated)
-            {
-                if (Unit* caster = GetCaster())
-                {
-                    canBeRecalculated = false;
+            uint32 cp = caster->GetComboPoints();
+            if (cp > 5)
+                cp = 5;
 
-                    float const attackpowerPerCombo[6] =
-                    {
-                        0.0f,
-                        0.015f,         // 1 point:  ${($m1 + $b1*1 + 0.015 * $AP) * 4} damage over 8 secs
-                        0.024f,         // 2 points: ${($m1 + $b1*2 + 0.024 * $AP) * 5} damage over 10 secs
-                        0.03f,          // 3 points: ${($m1 + $b1*3 + 0.03 * $AP) * 6} damage over 12 secs
-                        0.03428571f,    // 4 points: ${($m1 + $b1*4 + 0.03428571 * $AP) * 7} damage over 14 secs
-                        0.0375f         // 5 points: ${($m1 + $b1*5 + 0.0375 * $AP) * 8} damage over 16 secs
-                    };
-
-                    uint32 cp = caster->GetComboPoints();
-                    if (cp > 5)
-                        cp = 5;
-
-                    amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * attackpowerPerCombo[cp]);
-                }
-            }
-
-            void OnEffectRemoved(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
-            {
-                if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_DEATH)
-                    return;
-
-                Aura* aura = GetAura();
-                Unit* caster = aura->GetCaster();
-                if (!caster)
-                    return;
-
-                Aura* auraVenomousWounds = caster->GetAura(SPELL_ROGUE_VENOMOUS_WOUNDS);
-                if (!auraVenomousWounds)
-                    return;
-
-                // Venomous Wounds: if unit dies while being affected by rupture, regain energy based on remaining duration
-                Optional<SpellPowerCost> cost = GetSpellInfo()->CalcPowerCost(POWER_ENERGY, false, caster, GetSpellInfo()->GetSchoolMask(), nullptr);
-                if (!cost)
-                    return;
-
-                float pct = float(aura->GetDuration()) / float(aura->GetMaxDuration());
-                int32 extraAmount = float(cost->Amount) * pct;
-                caster->ModifyPower(POWER_ENERGY, extraAmount);
-            }
-
-            void Register() override
-            {
-                DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_rupture_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
-                OnEffectRemove += AuraEffectRemoveFn(spell_rog_rupture_AuraScript::OnEffectRemoved, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
-            }
-        };
-
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_rog_rupture_AuraScript();
+            amount += int32(caster->GetTotalAttackPowerValue(BASE_ATTACK) * attackpowerPerCombo[cp]);
         }
+    }
+
+    void OnEffectRemoved(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_DEATH)
+            return;
+
+        Aura* aura = GetAura();
+        Unit* caster = aura->GetCaster();
+        if (!caster)
+            return;
+
+        Aura* auraVenomousWounds = caster->GetAura(SPELL_ROGUE_VENOMOUS_WOUNDS);
+        if (!auraVenomousWounds)
+            return;
+
+        // Venomous Wounds: if unit dies while being affected by rupture, regain energy based on remaining duration
+        Optional<SpellPowerCost> cost = GetSpellInfo()->CalcPowerCost(POWER_ENERGY, false, caster, GetSpellInfo()->GetSchoolMask(), nullptr);
+        if (!cost)
+            return;
+
+        float pct = float(aura->GetDuration()) / float(aura->GetMaxDuration());
+        int32 extraAmount = float(cost->Amount) * pct;
+        caster->ModifyPower(POWER_ENERGY, extraAmount);
+    }
+
+    void Register() override
+    {
+        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_rupture::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
+        OnEffectRemove += AuraEffectRemoveFn(spell_rog_rupture::OnEffectRemoved, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
+    }
 };
 
 // 14161 - Ruthlessness
@@ -924,111 +875,78 @@ class spell_rog_tricks_of_the_trade_proc : public AuraScript
 
 // 198031 - Honor Among Thieves
 /// 7.1.5
-class spell_rog_honor_among_thieves : public SpellScriptLoader
+class spell_rog_honor_among_thieves : public AuraScript
 {
-public:
-    spell_rog_honor_among_thieves() : SpellScriptLoader("spell_rog_honor_among_thieves") { }
+    PrepareAuraScript(spell_rog_honor_among_thieves);
 
-    class spell_rog_honor_among_thieves_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_rog_honor_among_thieves_AuraScript);
+        return ValidateSpellInfo({ SPELL_ROGUE_HONOR_AMONG_THIEVES_ENERGIZE });
+    }
 
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_ROGUE_HONOR_AMONG_THIEVES_ENERGIZE });
-        }
-
-        void HandleProc(AuraEffect* aurEff, ProcEventInfo& /*eventInfo*/)
-        {
-            PreventDefaultAction();
-
-            Unit* target = GetTarget();
-            target->CastSpell(target, SPELL_ROGUE_HONOR_AMONG_THIEVES_ENERGIZE, aurEff);
-        }
-
-        void Register() override
-        {
-            OnEffectProc += AuraEffectProcFn(spell_rog_honor_among_thieves_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
-        }
-    };
-
-    AuraScript* GetAuraScript() const override
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& /*eventInfo*/)
     {
-        return new spell_rog_honor_among_thieves_AuraScript();
+        PreventDefaultAction();
+
+        Unit* target = GetTarget();
+        target->CastSpell(target, SPELL_ROGUE_HONOR_AMONG_THIEVES_ENERGIZE, aurEff);
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_rog_honor_among_thieves::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
     }
 };
 
 // 196819 - Eviscerate
-class spell_rog_eviscerate : public SpellScriptLoader
+class spell_rog_eviscerate : public SpellScript
 {
-public:
-    spell_rog_eviscerate() : SpellScriptLoader("spell_rog_eviscerate") { }
+    PrepareSpellScript(spell_rog_eviscerate);
 
-    class spell_rog_eviscerate_SpellScript : public SpellScript
+    void CalculateDamage(SpellEffIndex /*effIndex*/)
     {
-        PrepareSpellScript(spell_rog_eviscerate_SpellScript);
+        int32 damagePerCombo = GetHitDamage();
+        if (AuraEffect const* t5 = GetCaster()->GetAuraEffect(SPELL_ROGUE_T5_2P_SET_BONUS, EFFECT_0))
+            damagePerCombo += t5->GetAmount();
 
-        void CalculateDamage(SpellEffIndex /*effIndex*/)
-        {
-            int32 damagePerCombo = GetHitDamage();
-            if (AuraEffect const* t5 = GetCaster()->GetAuraEffect(SPELL_ROGUE_T5_2P_SET_BONUS, EFFECT_0))
-                damagePerCombo += t5->GetAmount();
+        int32 finalDamage = damagePerCombo;
+        std::vector<SpellPowerCost> const& costs = GetSpell()->GetPowerCost();
+        auto c = std::find_if(costs.begin(), costs.end(), [](SpellPowerCost const& cost) { return cost.Power == POWER_COMBO_POINTS; });
+        if (c != costs.end())
+            finalDamage *= c->Amount;
 
-            int32 finalDamage = damagePerCombo;
-            std::vector<SpellPowerCost> const& costs = GetSpell()->GetPowerCost();
-            auto c = std::find_if(costs.begin(), costs.end(), [](SpellPowerCost const& cost) { return cost.Power == POWER_COMBO_POINTS; });
-            if (c != costs.end())
-                finalDamage *= c->Amount;
+        SetHitDamage(finalDamage);
+    }
 
-            SetHitDamage(finalDamage);
-        }
-
-        void Register() override
-        {
-            OnEffectHitTarget += SpellEffectFn(spell_rog_eviscerate_SpellScript::CalculateDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
-        }
-    };
-
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_rog_eviscerate_SpellScript();
+        OnEffectHitTarget += SpellEffectFn(spell_rog_eviscerate::CalculateDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
     }
 };
 
 // 32645 - Envenom
-class spell_rog_envenom : public SpellScriptLoader
+class spell_rog_envenom : public SpellScript
 {
-public:
-    spell_rog_envenom() : SpellScriptLoader("spell_rog_envenom") { }
+    PrepareSpellScript(spell_rog_envenom);
 
-    class spell_rog_envenom_SpellScript : public SpellScript
+    void CalculateDamage(SpellEffIndex /*effIndex*/)
     {
-        PrepareSpellScript(spell_rog_envenom_SpellScript);
+        int32 damagePerCombo = GetHitDamage();
+        if (AuraEffect const* t5 = GetCaster()->GetAuraEffect(SPELL_ROGUE_T5_2P_SET_BONUS, EFFECT_0))
+            damagePerCombo += t5->GetAmount();
 
-        void CalculateDamage(SpellEffIndex /*effIndex*/)
-        {
-            int32 damagePerCombo = GetHitDamage();
-            if (AuraEffect const* t5 = GetCaster()->GetAuraEffect(SPELL_ROGUE_T5_2P_SET_BONUS, EFFECT_0))
-                damagePerCombo += t5->GetAmount();
+        int32 finalDamage = damagePerCombo;
+        std::vector<SpellPowerCost> const& costs = GetSpell()->GetPowerCost();
+        auto c = std::find_if(costs.begin(), costs.end(), [](SpellPowerCost const& cost) { return cost.Power == POWER_COMBO_POINTS; });
+        if (c != costs.end())
+            finalDamage *= c->Amount;
 
-            int32 finalDamage = damagePerCombo;
-            std::vector<SpellPowerCost> const& costs = GetSpell()->GetPowerCost();
-            auto c = std::find_if(costs.begin(), costs.end(), [](SpellPowerCost const& cost) { return cost.Power == POWER_COMBO_POINTS; });
-            if (c != costs.end())
-                finalDamage *= c->Amount;
+        SetHitDamage(finalDamage);
+    }
 
-            SetHitDamage(finalDamage);
-        }
-
-        void Register() override
-        {
-            OnEffectHitTarget += SpellEffectFn(spell_rog_envenom_SpellScript::CalculateDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
-        }
-    };
-
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_rog_envenom_SpellScript();
+        OnEffectHitTarget += SpellEffectFn(spell_rog_envenom::CalculateDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
     }
 };
 
@@ -1052,14 +970,14 @@ class spell_rog_venomous_wounds : public AuraScript
 void AddSC_rogue_spell_scripts()
 {
     RegisterSpellScript(spell_rog_backstab);
-    new spell_rog_blade_flurry();
-    new spell_rog_deadly_poison();
+    RegisterSpellScript(spell_rog_blade_flurry);
+    RegisterSpellScript(spell_rog_deadly_poison);
     RegisterSpellScript(spell_rog_grand_melee);
-    new spell_rog_killing_spree();
+    RegisterSpellAndAuraScriptPair(spell_rog_killing_spree, spell_rog_killing_spree_aura);
     RegisterSpellScript(spell_rog_mastery_main_gauche);
     RegisterSpellScript(spell_rog_restless_blades);
     RegisterSpellScript(spell_rog_roll_the_bones);
-    new spell_rog_rupture();
+    RegisterSpellScript(spell_rog_rupture);
     RegisterSpellScript(spell_rog_ruthlessness);
     RegisterSpellScript(spell_rog_shadowstrike);
     RegisterSpellScript(spell_rog_sinister_strike);
@@ -1069,8 +987,8 @@ void AddSC_rogue_spell_scripts()
     RegisterSpellScript(spell_rog_vanish_aura);
     RegisterSpellAndAuraScriptPair(spell_rog_tricks_of_the_trade, spell_rog_tricks_of_the_trade_aura);
     RegisterSpellScript(spell_rog_tricks_of_the_trade_proc);
-    new spell_rog_honor_among_thieves();
-    new spell_rog_eviscerate();
-    new spell_rog_envenom();
+    RegisterSpellScript(spell_rog_honor_among_thieves);
+    RegisterSpellScript(spell_rog_eviscerate);
+    RegisterSpellScript(spell_rog_envenom);
     RegisterSpellScript(spell_rog_venomous_wounds);
 }