Scripts/ML: Update Magtheridon to new model (#26420)

2 files changed, 333 insertions, 409 deletions

diff --git a/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/boss_magtheridon.cpp b/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/boss_magtheridon.cpp
index 77b097cde57..758f0c1fd5a 100644
--- a/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/boss_magtheridon.cpp
+++ b/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/boss_magtheridon.cpp
@@ -117,502 +117,423 @@ enum Misc
     ACTION_START_CHANNELERS_EVENT = 2
 };
 
-class boss_magtheridon : public CreatureScript
+struct boss_magtheridon : public BossAI
 {
-    public:
+    boss_magtheridon(Creature* creature) : BossAI(creature, DATA_MAGTHERIDON), _channelersCount(5) { }
 
-        boss_magtheridon() : CreatureScript("boss_magtheridon") { }
-
-        struct boss_magtheridonAI : public BossAI
-        {
-            boss_magtheridonAI(Creature* creature) : BossAI(creature, DATA_MAGTHERIDON), _channelersCount(5) { }
-
-            void Reset() override
-            {
-                _Reset();
-                DoCastSelf(SPELL_SHADOW_CAGE_C);
-                me->SummonCreatureGroup(SUMMON_GROUP_CHANNELERS);
-                events.SetPhase(PHASE_BANISH);
-                _channelersCount = 5;
-                events.ScheduleEvent(EVENT_TAUNT, Minutes(4), Minutes(5));
-            }
+    void Reset() override
+    {
+        _Reset();
+        DoCastSelf(SPELL_SHADOW_CAGE_C);
+        me->SummonCreatureGroup(SUMMON_GROUP_CHANNELERS);
+        events.SetPhase(PHASE_BANISH);
+        _channelersCount = 5;
+        events.ScheduleEvent(EVENT_TAUNT, Minutes(4), Minutes(5));
+    }
 
-            void CombatStart()
-            {
-                events.CancelEvent(EVENT_START_FIGHT);
-                events.CancelEvent(EVENT_NEARLY_EMOTE);
-                events.ScheduleEvent(EVENT_RELEASED, 6s);
-                Talk(EMOTE_BREAKS_FREE, me);
-                Talk(SAY_FREE);
-                me->RemoveAurasDueToSpell(SPELL_SHADOW_CAGE_C);
-            }
+    void CombatStart()
+    {
+        events.CancelEvent(EVENT_START_FIGHT);
+        events.CancelEvent(EVENT_NEARLY_EMOTE);
+        events.ScheduleEvent(EVENT_RELEASED, 6s);
+        Talk(EMOTE_BREAKS_FREE, me);
+        Talk(SAY_FREE);
+        me->RemoveAurasDueToSpell(SPELL_SHADOW_CAGE_C);
+    }
 
-            void EnterEvadeMode(EvadeReason /*why*/) override
-            {
-                summons.DespawnAll();
-                events.Reset();
-                instance->SetData(DATA_MANTICRON_CUBE, ACTION_DISABLE);
-                instance->SetData(DATA_COLLAPSE, ACTION_DISABLE);
-                instance->SetData(DATA_COLLAPSE_2, ACTION_DISABLE);
+    void EnterEvadeMode(EvadeReason /*why*/) override
+    {
+        summons.DespawnAll();
+        events.Reset();
+        instance->SetData(DATA_MANTICRON_CUBE, ACTION_DISABLE);
+        instance->SetData(DATA_COLLAPSE, ACTION_DISABLE);
+        instance->SetData(DATA_COLLAPSE_2, ACTION_DISABLE);
 
-                _DespawnAtEvade();
-            }
+        _DespawnAtEvade();
+    }
 
-            void SummonedCreatureDies(Creature* summon, Unit* /*killer*/) override
-            {
-                if (summon->GetEntry() == NPC_HELLFIRE_CHANNELLER && events.IsInPhase(PHASE_1))
-                {
-                    _channelersCount--;
+    void SummonedCreatureDies(Creature* summon, Unit* /*killer*/) override
+    {
+        if (summon->GetEntry() == NPC_HELLFIRE_CHANNELLER && events.IsInPhase(PHASE_1))
+        {
+            _channelersCount--;
 
-                    if (_channelersCount == 0)
-                        CombatStart();
-                }
-            }
+            if (_channelersCount == 0)
+                CombatStart();
+        }
+    }
 
-            void DoAction(int32 action) override
-            {
-                if (action == ACTION_START_CHANNELERS_EVENT && events.IsInPhase(PHASE_BANISH))
-                {
-                    events.SetPhase(PHASE_1);
-                    Talk(EMOTE_WEAKEN, me);
-                    summons.DoZoneInCombat(NPC_HELLFIRE_CHANNELLER);
-                    events.ScheduleEvent(EVENT_START_FIGHT, 2min);
-                    events.ScheduleEvent(EVENT_NEARLY_EMOTE, 1min);
-                    events.CancelEvent(EVENT_TAUNT);
-                    instance->SetBossState(DATA_MAGTHERIDON, IN_PROGRESS);
-                    instance->SetData(DATA_CALL_WARDERS, ACTION_ENABLE);
-                }
-            }
+    void DoAction(int32 action) override
+    {
+        if (action == ACTION_START_CHANNELERS_EVENT && events.IsInPhase(PHASE_BANISH))
+        {
+            events.SetPhase(PHASE_1);
+            Talk(EMOTE_WEAKEN, me);
+            summons.DoZoneInCombat(NPC_HELLFIRE_CHANNELLER);
+            events.ScheduleEvent(EVENT_START_FIGHT, 2min);
+            events.ScheduleEvent(EVENT_NEARLY_EMOTE, 1min);
+            events.CancelEvent(EVENT_TAUNT);
+            instance->SetBossState(DATA_MAGTHERIDON, IN_PROGRESS);
+            instance->SetData(DATA_CALL_WARDERS, ACTION_ENABLE);
+        }
+    }
 
-            void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
-            {
-                if (spellInfo->Id == SPELL_SHADOW_CAGE)
-                    Talk(SAY_BANISHED);
-            }
+    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
+    {
+        if (spellInfo->Id == SPELL_SHADOW_CAGE)
+            Talk(SAY_BANISHED);
+    }
 
-            void DamageTaken(Unit* /*who*/, uint32& damage) override
-            {
-                if (me->HealthBelowPctDamaged(30, damage) && !events.IsInPhase(PHASE_3))
-                {
-                    events.SetPhase(PHASE_3);
-                    me->SetReactState(REACT_PASSIVE);
-                    me->AttackStop();
-                    Talk(SAY_COLLAPSE);
-                    instance->SetData(DATA_COLLAPSE, ACTION_ENABLE);
-                    DoCastAOE(SPELL_CAMERA_SHAKE);
-                    events.ScheduleEvent(EVENT_COLLAPSE, 6s);
-                }
-            }
+    void DamageTaken(Unit* /*who*/, uint32& damage) override
+    {
+        if (me->HealthBelowPctDamaged(30, damage) && !events.IsInPhase(PHASE_3))
+        {
+            events.SetPhase(PHASE_3);
+            me->SetReactState(REACT_PASSIVE);
+            me->AttackStop();
+            Talk(SAY_COLLAPSE);
+            instance->SetData(DATA_COLLAPSE, ACTION_ENABLE);
+            DoCastAOE(SPELL_CAMERA_SHAKE);
+            events.ScheduleEvent(EVENT_COLLAPSE, 6s);
+        }
+    }
 
-            void JustDied(Unit* /*killer*/) override
-            {
-                Talk(SAY_DEATH);
-                _JustDied();
-                instance->SetData(DATA_MANTICRON_CUBE, ACTION_DISABLE);
-            }
+    void JustDied(Unit* /*killer*/) override
+    {
+        Talk(SAY_DEATH);
+        _JustDied();
+        instance->SetData(DATA_MANTICRON_CUBE, ACTION_DISABLE);
+    }
 
-            void KilledUnit(Unit* who) override
-            {
-                if (who->GetTypeId() == TYPEID_PLAYER)
-                    Talk(SAY_SLAY);
-            }
+    void KilledUnit(Unit* who) override
+    {
+        if (who->GetTypeId() == TYPEID_PLAYER)
+            Talk(SAY_SLAY);
+    }
 
-            void UpdateAI(uint32 diff) override
-            {
-                if (!events.IsInPhase(PHASE_BANISH) && !events.IsInPhase(PHASE_1) && !UpdateVictim())
-                    return;
+    void UpdateAI(uint32 diff) override
+    {
+        if (!events.IsInPhase(PHASE_BANISH) && !events.IsInPhase(PHASE_1) && !UpdateVictim())
+            return;
 
-                events.Update(diff);
+        events.Update(diff);
 
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
+            {
+                case EVENT_BERSERK:
+                    DoCastSelf(SPELL_BERSERK);
+                    break;
+                case EVENT_CLEAVE:
+                    DoCastVictim(SPELL_CLEAVE);
+                    events.Repeat(Seconds(10));
+                    break;
+                case EVENT_BLAZE:
+                    DoCastAOE(SPELL_BLAZE_TARGET, { SPELLVALUE_MAX_TARGETS, 1 });
+                    events.Repeat(Seconds(20));
+                    break;
+                case EVENT_QUAKE:
+                    DoCastAOE(SPELL_QUAKE, { SPELLVALUE_MAX_TARGETS, 5 });
+                    events.Repeat(Seconds(60));
+                    break;
+                case EVENT_START_FIGHT:
+                    CombatStart();
+                    break;
+                case EVENT_RELEASED:
+                    me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+                    me->SetImmuneToPC(false);
+                    DoZoneInCombat();
+                    events.SetPhase(PHASE_2);
+                    instance->SetData(DATA_MANTICRON_CUBE, ACTION_ENABLE);
+                    events.ScheduleEvent(EVENT_CLEAVE, 10s);
+                    events.ScheduleEvent(EVENT_BLAST_NOVA, 1min);
+                    events.ScheduleEvent(EVENT_BLAZE, 20s);
+                    events.ScheduleEvent(EVENT_QUAKE, 35s);
+                    events.ScheduleEvent(EVENT_BERSERK, 20min);
+                    break;
+                case EVENT_COLLAPSE:
+                    instance->SetData(DATA_COLLAPSE_2, ACTION_ENABLE);
+                    events.ScheduleEvent(EVENT_DEBRIS_KNOCKDOWN, 4s);
+                    break;
+                case EVENT_DEBRIS_KNOCKDOWN:
+                    if (Creature* trigger = instance->GetCreature(DATA_WORLD_TRIGGER))
                     {
-                        case EVENT_BERSERK:
-                            DoCastSelf(SPELL_BERSERK);
-                            break;
-                        case EVENT_CLEAVE:
-                            DoCastVictim(SPELL_CLEAVE);
-                            events.Repeat(Seconds(10));
-                            break;
-                        case EVENT_BLAZE:
-                            DoCastAOE(SPELL_BLAZE_TARGET, { SPELLVALUE_MAX_TARGETS, 1 });
-                            events.Repeat(Seconds(20));
-                            break;
-                        case EVENT_QUAKE:
-                            DoCastAOE(SPELL_QUAKE, { SPELLVALUE_MAX_TARGETS, 5 });
-                            events.Repeat(Seconds(60));
-                            break;
-                        case EVENT_START_FIGHT:
-                            CombatStart();
-                            break;
-                        case EVENT_RELEASED:
-                            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-                            me->SetImmuneToPC(false);
-                            DoZoneInCombat();
-                            events.SetPhase(PHASE_2);
-                            instance->SetData(DATA_MANTICRON_CUBE, ACTION_ENABLE);
-                            events.ScheduleEvent(EVENT_CLEAVE, 10s);
-                            events.ScheduleEvent(EVENT_BLAST_NOVA, 1min);
-                            events.ScheduleEvent(EVENT_BLAZE, 20s);
-                            events.ScheduleEvent(EVENT_QUAKE, 35s);
-                            events.ScheduleEvent(EVENT_BERSERK, 20min);
-                            break;
-                        case EVENT_COLLAPSE:
-                            instance->SetData(DATA_COLLAPSE_2, ACTION_ENABLE);
-                            events.ScheduleEvent(EVENT_DEBRIS_KNOCKDOWN, 4s);
-                            break;
-                        case EVENT_DEBRIS_KNOCKDOWN:
-                            if (Creature* trigger = instance->GetCreature(DATA_WORLD_TRIGGER))
-                            {
-                                trigger->CastSpell(trigger, SPELL_DEBRIS_KNOCKDOWN, true);
-                                me->SetReactState(REACT_AGGRESSIVE);
-                                events.ScheduleEvent(EVENT_DEBRIS, 20s);
-                            }
-                            break;
-                        case EVENT_DEBRIS:
-                            DoCastAOE(SPELL_DEBRIS_SERVERSIDE);
-                            events.Repeat(Seconds(20));
-                            break;
-                        case EVENT_NEARLY_EMOTE:
-                            Talk(EMOTE_NEARLY_FREE, me);
-                            break;
-                        case EVENT_BLAST_NOVA:
-                            Talk(EMOTE_BLAST_NOVA, me);
-                            DoCastAOE(SPELL_BLAST_NOVA);
-                            events.Repeat(Seconds(55));
-                            break;
-                        case EVENT_TAUNT:
-                            Talk(SAY_TAUNT);
-                            events.Repeat(Minutes(4), Minutes(5));
-                            break;
-                        default:
-                            break;
+                        trigger->CastSpell(trigger, SPELL_DEBRIS_KNOCKDOWN, true);
+                        me->SetReactState(REACT_AGGRESSIVE);
+                        events.ScheduleEvent(EVENT_DEBRIS, 20s);
                     }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+                    break;
+                case EVENT_DEBRIS:
+                    DoCastAOE(SPELL_DEBRIS_SERVERSIDE);
+                    events.Repeat(Seconds(20));
+                    break;
+                case EVENT_NEARLY_EMOTE:
+                    Talk(EMOTE_NEARLY_FREE, me);
+                    break;
+                case EVENT_BLAST_NOVA:
+                    Talk(EMOTE_BLAST_NOVA, me);
+                    DoCastAOE(SPELL_BLAST_NOVA);
+                    events.Repeat(Seconds(55));
+                    break;
+                case EVENT_TAUNT:
+                    Talk(SAY_TAUNT);
+                    events.Repeat(Minutes(4), Minutes(5));
+                    break;
+                default:
+                    break;
             }
 
-        private:
-            uint8 _channelersCount;
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
+        }
 
-        };
+        DoMeleeAttackIfReady();
+    }
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetMagtheridonsLairAI<boss_magtheridonAI>(creature);
-        }
+private:
+    uint8 _channelersCount;
 };
 
-class npc_hellfire_channeler : public CreatureScript
+struct npc_hellfire_channeler : public ScriptedAI
 {
-    public:
-        npc_hellfire_channeler() : CreatureScript("npc_hellfire_channeler") { }
-
-        struct npc_hellfire_channelerAI : public ScriptedAI
-        {
-            npc_hellfire_channelerAI(Creature* creature) : ScriptedAI(creature), _instance(me->GetInstanceScript()), _canCastDarkMending(true)
-            {
-                SetBoundary(_instance->GetBossBoundary(DATA_MAGTHERIDON));
-            }
+    npc_hellfire_channeler(Creature* creature) : ScriptedAI(creature), _instance(me->GetInstanceScript()), _canCastDarkMending(true)
+    {
+        SetBoundary(_instance->GetBossBoundary(DATA_MAGTHERIDON));
+    }
 
-            void Reset() override
-            {
-                _events.Reset();
-                DoCastSelf(SPELL_SHADOW_GRASP_C);
-                me->SetReactState(REACT_DEFENSIVE);
-            }
+    void Reset() override
+    {
+        _events.Reset();
+        DoCastSelf(SPELL_SHADOW_GRASP_C);
+        me->SetReactState(REACT_DEFENSIVE);
+    }
 
-            void JustEngagedWith(Unit* /*who*/) override
-            {
-                me->InterruptNonMeleeSpells(false);
+    void JustEngagedWith(Unit* /*who*/) override
+    {
+        me->InterruptNonMeleeSpells(false);
 
-                if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
-                    magtheridon->AI()->DoAction(ACTION_START_CHANNELERS_EVENT);
+        if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
+            magtheridon->AI()->DoAction(ACTION_START_CHANNELERS_EVENT);
 
-                _events.ScheduleEvent(EVENT_SHADOWBOLT, 20s);
-                _events.ScheduleEvent(EVENT_CHECK_FRIEND, 1s);
-                _events.ScheduleEvent(EVENT_ABYSSAL, 30s);
-                _events.ScheduleEvent(EVENT_FEAR, 15s, 20s);
+        _events.ScheduleEvent(EVENT_SHADOWBOLT, 20s);
+        _events.ScheduleEvent(EVENT_CHECK_FRIEND, 1s);
+        _events.ScheduleEvent(EVENT_ABYSSAL, 30s);
+        _events.ScheduleEvent(EVENT_FEAR, 15s, 20s);
 
-            }
+    }
 
-            void JustDied(Unit* /*killer*/) override
-            {
-                DoCastAOE(SPELL_SOUL_TRANSFER);
+    void JustDied(Unit* /*killer*/) override
+    {
+        DoCastAOE(SPELL_SOUL_TRANSFER);
 
-                // Channelers killed by "Hit Kill" need trigger combat event too. It's needed for Cata+
-                if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
-                    magtheridon->AI()->DoAction(ACTION_START_CHANNELERS_EVENT);
-            }
+        // Channelers killed by "Hit Kill" need trigger combat event too. It's needed for Cata+
+        if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
+            magtheridon->AI()->DoAction(ACTION_START_CHANNELERS_EVENT);
+    }
 
-            void JustSummoned(Creature* summon) override
-            {
-                if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
-                    magtheridon->AI()->JustSummoned(summon);
+    void JustSummoned(Creature* summon) override
+    {
+        if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
+            magtheridon->AI()->JustSummoned(summon);
 
-                DoZoneInCombat(summon);
-            }
+        DoZoneInCombat(summon);
+    }
 
-            void EnterEvadeMode(EvadeReason /*why*/) override
-            {
-                if (_instance->GetBossState(DATA_MAGTHERIDON) == IN_PROGRESS)
-                    if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
-                        magtheridon->AI()->EnterEvadeMode(EVADE_REASON_OTHER);
-            }
+    void EnterEvadeMode(EvadeReason /*why*/) override
+    {
+        if (_instance->GetBossState(DATA_MAGTHERIDON) == IN_PROGRESS)
+            if (Creature* magtheridon = _instance->GetCreature(DATA_MAGTHERIDON))
+                magtheridon->AI()->EnterEvadeMode(EVADE_REASON_OTHER);
+    }
 
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-                _events.Update(diff);
+        _events.Update(diff);
 
-                while (uint32 eventId = _events.ExecuteEvent())
-                {
-                    switch (eventId)
+        while (uint32 eventId = _events.ExecuteEvent())
+        {
+            switch (eventId)
+            {
+                case EVENT_SHADOWBOLT:
+                    DoCastAOE(SPELL_SHADOW_BOLT_VOLLEY);
+                    _events.Repeat(Seconds(15), Seconds(20));
+                    break;
+                case EVENT_FEAR:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1))
+                        DoCast(target, SPELL_FEAR);
+                    _events.Repeat(Seconds(25), Seconds(40));
+                    break;
+                case EVENT_CHECK_FRIEND:
+                    if (_canCastDarkMending)
                     {
-                        case EVENT_SHADOWBOLT:
-                            DoCastAOE(SPELL_SHADOW_BOLT_VOLLEY);
-                            _events.Repeat(Seconds(15), Seconds(20));
-                            break;
-                        case EVENT_FEAR:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1))
-                                DoCast(target, SPELL_FEAR);
-                            _events.Repeat(Seconds(25), Seconds(40));
-                            break;
-                        case EVENT_CHECK_FRIEND:
-                            if (_canCastDarkMending)
-                            {
-                                if (Unit* target = DoSelectBelowHpPctFriendlyWithEntry(NPC_HELLFIRE_CHANNELLER, 30.0f, 51, false))
-                                {
-                                    DoCast(target, SPELL_DARK_MENDING);
-                                    _canCastDarkMending = false;
-                                    _events.ScheduleEvent(EVENT_DARK_MENDING, 10s, 20s);
-                                }
-                            }
-                            _events.Repeat(Seconds(1));
-                            break;
-                        case EVENT_DARK_MENDING:
-                            _canCastDarkMending = true;
-                            break;
-                        case EVENT_ABYSSAL:
-                            DoCastVictim(SPELL_BURNING_ABYSSAL);
-                            _events.Repeat(Seconds(60));
-                            break;
-                        default:
-                            break;
+                        if (Unit* target = DoSelectBelowHpPctFriendlyWithEntry(NPC_HELLFIRE_CHANNELLER, 30.0f, 51, false))
+                        {
+                            DoCast(target, SPELL_DARK_MENDING);
+                            _canCastDarkMending = false;
+                            _events.ScheduleEvent(EVENT_DARK_MENDING, 10s, 20s);
+                        }
                     }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+                    _events.Repeat(Seconds(1));
+                    break;
+                case EVENT_DARK_MENDING:
+                    _canCastDarkMending = true;
+                    break;
+                case EVENT_ABYSSAL:
+                    DoCastVictim(SPELL_BURNING_ABYSSAL);
+                    _events.Repeat(Seconds(60));
+                    break;
+                default:
+                    break;
             }
 
-        private:
-            InstanceScript* _instance;
-            EventMap _events;
-            bool _canCastDarkMending;
-        };
-
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetMagtheridonsLairAI<npc_hellfire_channelerAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
+
+private:
+    InstanceScript* _instance;
+    EventMap _events;
+    bool _canCastDarkMending;
 };
 
-class npc_magtheridon_room : public CreatureScript
+struct npc_magtheridon_room : public PassiveAI
 {
-public:
-    npc_magtheridon_room() : CreatureScript("npc_magtheridon_room") { }
-    struct npc_magtheridon_roomAI : public PassiveAI
-    {
-        npc_magtheridon_roomAI(Creature* creature) : PassiveAI(creature) { }
+    npc_magtheridon_room(Creature* creature) : PassiveAI(creature) { }
 
-        void Reset() override
-        {
-            DoCastSelf(SPELL_DEBRIS_VISUAL);
-
-            _scheduler.Schedule(Seconds(5), [this](TaskContext /*context*/)
-            {
-                DoCastAOE(SPELL_DEBRIS_DAMAGE);
-            });
-        }
+    void Reset() override
+    {
+        DoCastSelf(SPELL_DEBRIS_VISUAL);
 
-        void UpdateAI(uint32 diff) override
+        _scheduler.Schedule(Seconds(5), [this](TaskContext /*context*/)
         {
-            _scheduler.Update(diff);
-        }
-
-    private:
-        TaskScheduler _scheduler;
-    };
+            DoCastAOE(SPELL_DEBRIS_DAMAGE);
+        });
+    }
 
-    CreatureAI* GetAI(Creature* creature) const override
+    void UpdateAI(uint32 diff) override
     {
-        return GetMagtheridonsLairAI<npc_magtheridon_roomAI>(creature);
+        _scheduler.Update(diff);
     }
+
+private:
+    TaskScheduler _scheduler;
 };
 
-class go_manticron_cube : public GameObjectScript
+struct go_manticron_cube : public GameObjectAI
 {
-public:
-    go_manticron_cube() : GameObjectScript("go_manticron_cube") { }
+    go_manticron_cube(GameObject* go) : GameObjectAI(go) { }
 
-    struct go_manticron_cubeAI : public GameObjectAI
+    bool OnGossipHello(Player* player) override
     {
-        go_manticron_cubeAI(GameObject* go) : GameObjectAI(go) { }
-
-        bool OnGossipHello(Player* player) override
-        {
-            if (player->HasAura(SPELL_MIND_EXHAUSTION) || player->HasAura(SPELL_SHADOW_GRASP))
-                return true;
-
-            if (Creature* trigger = player->FindNearestCreature(NPC_HELFIRE_RAID_TRIGGER, 10.0f))
-                trigger->CastSpell(nullptr, SPELL_SHADOW_GRASP_VISUAL);
-
-            player->CastSpell(nullptr, SPELL_SHADOW_GRASP, true);
+        if (player->HasAura(SPELL_MIND_EXHAUSTION) || player->HasAura(SPELL_SHADOW_GRASP))
             return true;
-        }
-    };
 
-    GameObjectAI* GetAI(GameObject* go) const override
-    {
-        return GetMagtheridonsLairAI<go_manticron_cubeAI>(go);
+        if (Creature* trigger = player->FindNearestCreature(NPC_HELFIRE_RAID_TRIGGER, 10.0f))
+            trigger->CastSpell(nullptr, SPELL_SHADOW_GRASP_VISUAL);
+
+        player->CastSpell(nullptr, SPELL_SHADOW_GRASP, true);
+        return true;
     }
 };
 
 // 30541 - Blaze
-class spell_magtheridon_blaze_target : public SpellScriptLoader
+class spell_magtheridon_blaze_target : public SpellScript
 {
-    public:
-        spell_magtheridon_blaze_target() : SpellScriptLoader("spell_magtheridon_blaze_target") { }
-
-        class spell_magtheridon_blaze_target_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_magtheridon_blaze_target_SpellScript);
-
-            bool Validate(SpellInfo const* /*spell*/) override
-            {
-                return ValidateSpellInfo({ SPELL_BLAZE });
-            }
+    PrepareSpellScript(spell_magtheridon_blaze_target);
 
-            void HandleAura()
-            {
-                GetHitUnit()->CastSpell(GetHitUnit(), SPELL_BLAZE);
-            }
-
-            void Register() override
-            {
-                OnHit += SpellHitFn(spell_magtheridon_blaze_target_SpellScript::HandleAura);
-            }
+    bool Validate(SpellInfo const* /*spell*/) override
+    {
+        return ValidateSpellInfo({ SPELL_BLAZE });
+    }
 
-        };
+    void HandleAura()
+    {
+        GetHitUnit()->CastSpell(GetHitUnit(), SPELL_BLAZE);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_magtheridon_blaze_target_SpellScript();
-        }
+    void Register() override
+    {
+        OnHit += SpellHitFn(spell_magtheridon_blaze_target::HandleAura);
+    }
 };
 
 // 30410 - Shadow Grasp
-class spell_magtheridon_shadow_grasp : public SpellScriptLoader
+class spell_magtheridon_shadow_grasp : public AuraScript
 {
-    public:
-        spell_magtheridon_shadow_grasp() : SpellScriptLoader("spell_magtheridon_shadow_grasp") { }
-
-        class spell_magtheridon_shadow_grasp_AuraScript : public AuraScript
-        {
-            PrepareAuraScript(spell_magtheridon_shadow_grasp_AuraScript);
+    PrepareAuraScript(spell_magtheridon_shadow_grasp);
 
-            bool Validate(SpellInfo const* /*spell*/) override
-            {
-                return ValidateSpellInfo({ SPELL_MIND_EXHAUSTION });
-            }
-
-            void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
-            {
-                GetTarget()->InterruptNonMeleeSpells(false);
-                if (Unit* caster = GetCaster())
-                    caster->CastSpell(caster, SPELL_MIND_EXHAUSTION, true);
-            }
+    bool Validate(SpellInfo const* /*spell*/) override
+    {
+        return ValidateSpellInfo({ SPELL_MIND_EXHAUSTION });
+    }
 
-            void Register() override
-            {
-                AfterEffectRemove += AuraEffectRemoveFn(spell_magtheridon_shadow_grasp_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
-            }
-        };
+    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        GetTarget()->InterruptNonMeleeSpells(false);
+        if (Unit* caster = GetCaster())
+            caster->CastSpell(caster, SPELL_MIND_EXHAUSTION, true);
+    }
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_magtheridon_shadow_grasp_AuraScript();
-        }
+    void Register() override
+    {
+        AfterEffectRemove += AuraEffectRemoveFn(spell_magtheridon_shadow_grasp::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
+    }
 };
 
 // 30166 - Shadow Grasp (Visual Effect)
-class spell_magtheridon_shadow_grasp_visual : public SpellScriptLoader
+class spell_magtheridon_shadow_grasp_visual : public AuraScript
 {
-    public:
-        spell_magtheridon_shadow_grasp_visual() : SpellScriptLoader("spell_magtheridon_shadow_grasp_visual") { }
+    PrepareAuraScript(spell_magtheridon_shadow_grasp_visual);
 
-        class spell_magtheridon_shadow_grasp_visual_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spell*/) override
+    {
+        return ValidateSpellInfo(
         {
-            PrepareAuraScript(spell_magtheridon_shadow_grasp_visual_AuraScript);
-
-            bool Validate(SpellInfo const* /*spell*/) override
-            {
-                return ValidateSpellInfo(
-                {
-                    SPELL_SHADOW_CAGE,
-                    SPELL_SHADOW_GRASP_VISUAL
-                });
-            }
-
-            void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
-            {
-                Unit* target = GetTarget();
+            SPELL_SHADOW_CAGE,
+            SPELL_SHADOW_GRASP_VISUAL
+        });
+    }
 
-                if (target->GetAuraCount(SPELL_SHADOW_GRASP_VISUAL) == 5)
-                    target->CastSpell(target, SPELL_SHADOW_CAGE, true);
-            }
+    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        Unit* target = GetTarget();
 
-            void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
-            {
-                GetTarget()->RemoveAurasDueToSpell(SPELL_SHADOW_CAGE);
-            }
+        if (target->GetAuraCount(SPELL_SHADOW_GRASP_VISUAL) == 5)
+            target->CastSpell(target, SPELL_SHADOW_CAGE, true);
+    }
 
-            void Register() override
-            {
-                AfterEffectApply += AuraEffectApplyFn(spell_magtheridon_shadow_grasp_visual_AuraScript::OnApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
-                AfterEffectRemove += AuraEffectRemoveFn(spell_magtheridon_shadow_grasp_visual_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
-            }
-        };
+    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        GetTarget()->RemoveAurasDueToSpell(SPELL_SHADOW_CAGE);
+    }
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_magtheridon_shadow_grasp_visual_AuraScript();
-        }
+    void Register() override
+    {
+        AfterEffectApply += AuraEffectApplyFn(spell_magtheridon_shadow_grasp_visual::OnApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
+        AfterEffectRemove += AuraEffectRemoveFn(spell_magtheridon_shadow_grasp_visual::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
+    }
 };
 
 void AddSC_boss_magtheridon()
 {
-    new boss_magtheridon();
-    new npc_hellfire_channeler();
-    new npc_magtheridon_room();
-    new go_manticron_cube();
-    new spell_magtheridon_blaze_target();
-    new spell_magtheridon_shadow_grasp();
-    new spell_magtheridon_shadow_grasp_visual();
+    RegisterMagtheridonsLairCreatureAI(boss_magtheridon);
+    RegisterMagtheridonsLairCreatureAI(npc_hellfire_channeler);
+    RegisterMagtheridonsLairCreatureAI(npc_magtheridon_room);
+    RegisterMagtheridonsLairGameObjectAI(go_manticron_cube);
+    RegisterSpellScript(spell_magtheridon_blaze_target);
+    RegisterSpellScript(spell_magtheridon_shadow_grasp);
+    RegisterSpellScript(spell_magtheridon_shadow_grasp_visual);
 }
diff --git a/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/magtheridons_lair.h b/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/magtheridons_lair.h
index cd0b441fada..3e90f04825b 100644
--- a/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/magtheridons_lair.h
+++ b/src/server/scripts/Outland/HellfireCitadel/MagtheridonsLair/magtheridons_lair.h
@@ -80,4 +80,7 @@ inline AI* GetMagtheridonsLairAI(T* obj)
     return GetInstanceAI<AI>(obj, MLScriptName);
 }
 
+#define RegisterMagtheridonsLairCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetMagtheridonsLairAI)
+#define RegisterMagtheridonsLairGameObjectAI(ai_name) RegisterGameObjectAIWithFactory(ai_name, GetMagtheridonsLairAI)
+
 #endif