Scripts/Molten Core: Update remaining scripts to new register model (2/2) (#26710)

(cherry picked from commit 863635dbf982394716d13608659ad81aa28812d3)

3 files changed, 432 insertions, 498 deletions

diff --git a/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_ragnaros.cpp b/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_ragnaros.cpp
index 9f1d100f958..726aca9b9c8 100644
--- a/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_ragnaros.cpp
+++ b/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_ragnaros.cpp
@@ -75,284 +75,262 @@ enum Events
     EVENT_INTRO_5               = 12
 };
 
-class boss_ragnaros : public CreatureScript
+struct boss_ragnaros : public BossAI
 {
-    public:
-        boss_ragnaros() : CreatureScript("boss_ragnaros") { }
-
-        struct boss_ragnarosAI : public BossAI
+    boss_ragnaros(Creature* creature) : BossAI(creature, BOSS_RAGNAROS)
+    {
+        Initialize();
+        _introState = 0;
+        me->SetReactState(REACT_PASSIVE);
+        me->AddUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
+        SetCombatMovement(false);
+    }
+
+    void Initialize()
+    {
+        _emergeTimer = 90000;
+        _hasYelledMagmaBurst = false;
+        _hasSubmergedOnce = false;
+        _isBanished = false;
+    }
+
+    void Reset() override
+    {
+        BossAI::Reset();
+        Initialize();
+        me->SetEmoteState(EMOTE_ONESHOT_NONE);
+    }
+
+    void JustEngagedWith(Unit* victim) override
+    {
+        BossAI::JustEngagedWith(victim);
+        events.ScheduleEvent(EVENT_ERUPTION, 15s);
+        events.ScheduleEvent(EVENT_WRATH_OF_RAGNAROS, 30s);
+        events.ScheduleEvent(EVENT_HAND_OF_RAGNAROS, 25s);
+        events.ScheduleEvent(EVENT_LAVA_BURST, 10s);
+        events.ScheduleEvent(EVENT_ELEMENTAL_FIRE, 3s);
+        events.ScheduleEvent(EVENT_MAGMA_BLAST, 2s);
+        events.ScheduleEvent(EVENT_SUBMERGE, 3min);
+    }
+
+    void KilledUnit(Unit* /*victim*/) override
+    {
+        if (urand(0, 99) < 25)
+            Talk(SAY_KILL);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (_introState != 2)
         {
-            boss_ragnarosAI(Creature* creature) : BossAI(creature, BOSS_RAGNAROS)
+            if (!_introState)
             {
-                Initialize();
-                _introState = 0;
-                me->SetReactState(REACT_PASSIVE);
-                me->AddUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
-                SetCombatMovement(false);
+                me->HandleEmoteCommand(EMOTE_ONESHOT_EMERGE);
+                events.ScheduleEvent(EVENT_INTRO_1, 4s);
+                events.ScheduleEvent(EVENT_INTRO_2, 23s);
+                events.ScheduleEvent(EVENT_INTRO_3, 42s);
+                events.ScheduleEvent(EVENT_INTRO_4, 43s);
+                events.ScheduleEvent(EVENT_INTRO_5, 53s);
+                _introState = 1;
             }
 
-            void Initialize()
+            events.Update(diff);
+
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                _emergeTimer = 90000;
-                _hasYelledMagmaBurst = false;
-                _hasSubmergedOnce = false;
-                _isBanished = false;
+                switch (eventId)
+                {
+                case EVENT_INTRO_1:
+                    Talk(SAY_ARRIVAL1_RAG);
+                    break;
+                case EVENT_INTRO_2:
+                    Talk(SAY_ARRIVAL3_RAG);
+                    break;
+                case EVENT_INTRO_3:
+                    me->HandleEmoteCommand(EMOTE_ONESHOT_ATTACK1H);
+                    break;
+                case EVENT_INTRO_4:
+                    Talk(SAY_ARRIVAL5_RAG);
+                    if (Creature* executus = ObjectAccessor::GetCreature(*me, instance->GetGuidData(BOSS_MAJORDOMO_EXECUTUS)))
+                        Unit::Kill(me, executus);
+                    break;
+                case EVENT_INTRO_5:
+                    me->SetReactState(REACT_AGGRESSIVE);
+                    me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
+                    me->SetImmuneToPC(false);
+                    _introState = 2;
+                    break;
+                default:
+                    break;
+                }
             }
-
-            void Reset() override
+        }
+        else
+        {
+            if (_isBanished && ((_emergeTimer <= diff) || (instance->GetData(DATA_RAGNAROS_ADDS)) > 8))
             {
-                BossAI::Reset();
-                Initialize();
+                //Become unbanished again
+                me->SetReactState(REACT_AGGRESSIVE);
+                me->SetFaction(FACTION_MONSTER);
+                me->RemoveUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
                 me->SetEmoteState(EMOTE_ONESHOT_NONE);
-            }
+                me->HandleEmoteCommand(EMOTE_ONESHOT_EMERGE);
+                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                    AttackStart(target);
+                instance->SetData(DATA_RAGNAROS_ADDS, 0);
 
-            void JustEngagedWith(Unit* victim) override
-            {
-                BossAI::JustEngagedWith(victim);
-                events.ScheduleEvent(EVENT_ERUPTION, 15s);
-                events.ScheduleEvent(EVENT_WRATH_OF_RAGNAROS, 30s);
-                events.ScheduleEvent(EVENT_HAND_OF_RAGNAROS, 25s);
-                events.ScheduleEvent(EVENT_LAVA_BURST, 10s);
-                events.ScheduleEvent(EVENT_ELEMENTAL_FIRE, 3s);
-                events.ScheduleEvent(EVENT_MAGMA_BLAST, 2s);
-                events.ScheduleEvent(EVENT_SUBMERGE, 3min);
+                //DoCast(me, SPELL_RAGEMERGE); //"phase spells" didnt worked correctly so Ive commented them and wrote solution witch doesnt need core support
+                _isBanished = false;
             }
-
-            void KilledUnit(Unit* /*victim*/) override
+            else if (_isBanished)
             {
-                if (urand(0, 99) < 25)
-                    Talk(SAY_KILL);
+                _emergeTimer -= diff;
+                //Do nothing while banished
+                return;
             }
 
-            void UpdateAI(uint32 diff) override
-            {
-                if (_introState != 2)
-                {
-                    if (!_introState)
-                    {
-                        me->HandleEmoteCommand(EMOTE_ONESHOT_EMERGE);
-                        events.ScheduleEvent(EVENT_INTRO_1, 4s);
-                        events.ScheduleEvent(EVENT_INTRO_2, 23s);
-                        events.ScheduleEvent(EVENT_INTRO_3, 42s);
-                        events.ScheduleEvent(EVENT_INTRO_4, 43s);
-                        events.ScheduleEvent(EVENT_INTRO_5, 53s);
-                        _introState = 1;
-                    }
+            //Return since we have no target
+            if (!UpdateVictim())
+                return;
 
-                    events.Update(diff);
+            events.Update(diff);
 
-                    while (uint32 eventId = events.ExecuteEvent())
-                    {
-                        switch (eventId)
+            while (uint32 eventId = events.ExecuteEvent())
+            {
+                switch (eventId)
+                {
+                    case EVENT_ERUPTION:
+                        DoCastVictim(SPELL_ERRUPTION);
+                        events.ScheduleEvent(EVENT_ERUPTION, 20s, 45s);
+                        break;
+                    case EVENT_WRATH_OF_RAGNAROS:
+                        DoCastVictim(SPELL_WRATH_OF_RAGNAROS);
+                        if (urand(0, 1))
+                            Talk(SAY_WRATH);
+                        events.ScheduleEvent(EVENT_WRATH_OF_RAGNAROS, 25s);
+                        break;
+                    case EVENT_HAND_OF_RAGNAROS:
+                        DoCast(me, SPELL_HAND_OF_RAGNAROS);
+                        if (urand(0, 1))
+                            Talk(SAY_HAND);
+                        events.ScheduleEvent(EVENT_HAND_OF_RAGNAROS, 20s);
+                        break;
+                    case EVENT_LAVA_BURST:
+                        DoCastVictim(SPELL_LAVA_BURST);
+                        events.ScheduleEvent(EVENT_LAVA_BURST, 10s);
+                        break;
+                    case EVENT_ELEMENTAL_FIRE:
+                        DoCastVictim(SPELL_ELEMENTAL_FIRE);
+                        events.ScheduleEvent(EVENT_ELEMENTAL_FIRE, 10s, 14s);
+                        break;
+                    case EVENT_MAGMA_BLAST:
+                        if (!me->IsWithinMeleeRange(me->GetVictim()))
                         {
-                        case EVENT_INTRO_1:
-                            Talk(SAY_ARRIVAL1_RAG);
-                            break;
-                        case EVENT_INTRO_2:
-                            Talk(SAY_ARRIVAL3_RAG);
-                            break;
-                        case EVENT_INTRO_3:
-                            me->HandleEmoteCommand(EMOTE_ONESHOT_ATTACK1H);
-                            break;
-                        case EVENT_INTRO_4:
-                            Talk(SAY_ARRIVAL5_RAG);
-                            if (Creature* executus = ObjectAccessor::GetCreature(*me, instance->GetGuidData(BOSS_MAJORDOMO_EXECUTUS)))
-                                Unit::Kill(me, executus);
-                            break;
-                        case EVENT_INTRO_5:
-                            me->SetReactState(REACT_AGGRESSIVE);
-                            me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
-                            me->SetImmuneToPC(false);
-                            _introState = 2;
-                            break;
-                        default:
-                            break;
+                            DoCastVictim(SPELL_MAGMA_BLAST);
+                            if (!_hasYelledMagmaBurst)
+                            {
+                                //Say our dialog
+                                Talk(SAY_MAGMABURST);
+                                _hasYelledMagmaBurst = true;
+                            }
                         }
-                    }
-                }
-                else
-                {
-                    if (_isBanished && ((_emergeTimer <= diff) || (instance->GetData(DATA_RAGNAROS_ADDS)) > 8))
-                    {
-                        //Become unbanished again
-                        me->SetReactState(REACT_AGGRESSIVE);
-                        me->SetFaction(FACTION_MONSTER);
-                        me->RemoveUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
-                        me->SetEmoteState(EMOTE_ONESHOT_NONE);
-                        me->HandleEmoteCommand(EMOTE_ONESHOT_EMERGE);
-                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                            AttackStart(target);
-                        instance->SetData(DATA_RAGNAROS_ADDS, 0);
-
-                        //DoCast(me, SPELL_RAGEMERGE); //"phase spells" didnt worked correctly so Ive commented them and wrote solution witch doesnt need core support
-                        _isBanished = false;
-                    }
-                    else if (_isBanished)
+                        events.ScheduleEvent(EVENT_MAGMA_BLAST, 2500ms);
+                        break;
+                    case EVENT_SUBMERGE:
                     {
-                        _emergeTimer -= diff;
-                        //Do nothing while banished
-                        return;
-                    }
+                        if (!_isBanished)
+                        {
+                            //Creature spawning and ragnaros becomming unattackable
+                            //is not very well supported in the core //no it really isnt
+                            //so added normaly spawning and banish workaround and attack again after 90 secs.
+                            me->AttackStop();
+                            ResetThreatList();
+                            me->SetReactState(REACT_PASSIVE);
+                            me->InterruptNonMeleeSpells(false);
+                            //Root self
+                            //DoCast(me, 23973);
+                            me->SetFaction(FACTION_FRIENDLY);
+                            me->AddUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
+                            me->SetEmoteState(EMOTE_STATE_SUBMERGED);
+                            me->HandleEmoteCommand(EMOTE_ONESHOT_SUBMERGE);
+                            instance->SetData(DATA_RAGNAROS_ADDS, 0);
+
+                            if (!_hasSubmergedOnce)
+                            {
+                                Talk(SAY_REINFORCEMENTS1);
 
-                    //Return since we have no target
-                    if (!UpdateVictim())
-                        return;
+                                // summon 8 elementals
+                                for (uint8 i = 0; i < 8; ++i)
+                                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                                        if (Creature* summoned = me->SummonCreature(12143, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 15min))
+                                            summoned->AI()->AttackStart(target);
 
-                    events.Update(diff);
+                                _hasSubmergedOnce = true;
+                                _isBanished = true;
+                                //DoCast(me, SPELL_RAGSUBMERGE);
+                                _emergeTimer = 90000;
 
-                    while (uint32 eventId = events.ExecuteEvent())
-                    {
-                        switch (eventId)
-                        {
-                            case EVENT_ERUPTION:
-                                DoCastVictim(SPELL_ERRUPTION);
-                                events.ScheduleEvent(EVENT_ERUPTION, 20s, 45s);
-                                break;
-                            case EVENT_WRATH_OF_RAGNAROS:
-                                DoCastVictim(SPELL_WRATH_OF_RAGNAROS);
-                                if (urand(0, 1))
-                                    Talk(SAY_WRATH);
-                                events.ScheduleEvent(EVENT_WRATH_OF_RAGNAROS, 25s);
-                                break;
-                            case EVENT_HAND_OF_RAGNAROS:
-                                DoCast(me, SPELL_HAND_OF_RAGNAROS);
-                                if (urand(0, 1))
-                                    Talk(SAY_HAND);
-                                events.ScheduleEvent(EVENT_HAND_OF_RAGNAROS, 20s);
-                                break;
-                            case EVENT_LAVA_BURST:
-                                DoCastVictim(SPELL_LAVA_BURST);
-                                events.ScheduleEvent(EVENT_LAVA_BURST, 10s);
-                                break;
-                            case EVENT_ELEMENTAL_FIRE:
-                                DoCastVictim(SPELL_ELEMENTAL_FIRE);
-                                events.ScheduleEvent(EVENT_ELEMENTAL_FIRE, 10s, 14s);
-                                break;
-                            case EVENT_MAGMA_BLAST:
-                                if (!me->IsWithinMeleeRange(me->GetVictim()))
-                                {
-                                    DoCastVictim(SPELL_MAGMA_BLAST);
-                                    if (!_hasYelledMagmaBurst)
-                                    {
-                                        //Say our dialog
-                                        Talk(SAY_MAGMABURST);
-                                        _hasYelledMagmaBurst = true;
-                                    }
-                                }
-                                events.ScheduleEvent(EVENT_MAGMA_BLAST, 2500ms);
-                                break;
-                            case EVENT_SUBMERGE:
+                            }
+                            else
                             {
-                                if (!_isBanished)
-                                {
-                                    //Creature spawning and ragnaros becomming unattackable
-                                    //is not very well supported in the core //no it really isnt
-                                    //so added normaly spawning and banish workaround and attack again after 90 secs.
-                                    me->AttackStop();
-                                    ResetThreatList();
-                                    me->SetReactState(REACT_PASSIVE);
-                                    me->InterruptNonMeleeSpells(false);
-                                    //Root self
-                                    //DoCast(me, 23973);
-                                    me->SetFaction(FACTION_FRIENDLY);
-                                    me->AddUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
-                                    me->SetEmoteState(EMOTE_STATE_SUBMERGED);
-                                    me->HandleEmoteCommand(EMOTE_ONESHOT_SUBMERGE);
-                                    instance->SetData(DATA_RAGNAROS_ADDS, 0);
-
-                                    if (!_hasSubmergedOnce)
-                                    {
-                                        Talk(SAY_REINFORCEMENTS1);
-
-                                        // summon 8 elementals
-                                        for (uint8 i = 0; i < 8; ++i)
-                                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                                                if (Creature* summoned = me->SummonCreature(12143, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 15min))
-                                                    summoned->AI()->AttackStart(target);
-
-                                        _hasSubmergedOnce = true;
-                                        _isBanished = true;
-                                        //DoCast(me, SPELL_RAGSUBMERGE);
-                                        _emergeTimer = 90000;
-
-                                    }
-                                    else
-                                    {
-                                        Talk(SAY_REINFORCEMENTS2);
-
-                                        for (uint8 i = 0; i < 8; ++i)
-                                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                                                if (Creature* summoned = me->SummonCreature(12143, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 15min))
-                                                    summoned->AI()->AttackStart(target);
-
-                                        _isBanished = true;
-                                        //DoCast(me, SPELL_RAGSUBMERGE);
-                                        _emergeTimer = 90000;
-                                    }
-                                }
-                                events.ScheduleEvent(EVENT_SUBMERGE, 3min);
-                                break;
+                                Talk(SAY_REINFORCEMENTS2);
+
+                                for (uint8 i = 0; i < 8; ++i)
+                                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                                        if (Creature* summoned = me->SummonCreature(12143, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 15min))
+                                            summoned->AI()->AttackStart(target);
+
+                                _isBanished = true;
+                                //DoCast(me, SPELL_RAGSUBMERGE);
+                                _emergeTimer = 90000;
                             }
-                            default:
-                                break;
                         }
+                        events.ScheduleEvent(EVENT_SUBMERGE, 3min);
+                        break;
                     }
-
-                    DoMeleeAttackIfReady();
+                    default:
+                        break;
                 }
             }
 
-        private:
-            uint32 _emergeTimer;
-            uint8 _introState;
-            bool _hasYelledMagmaBurst;
-            bool _hasSubmergedOnce;
-            bool _isBanished;
-        };
-
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetMoltenCoreAI<boss_ragnarosAI>(creature);
+            DoMeleeAttackIfReady();
         }
+    }
+
+private:
+    uint32 _emergeTimer;
+    uint8 _introState;
+    bool _hasYelledMagmaBurst;
+    bool _hasSubmergedOnce;
+    bool _isBanished;
 };
 
-class npc_son_of_flame : public CreatureScript
+struct npc_son_of_flame : public ScriptedAI //didnt work correctly in EAI for me...
 {
-    public:
-        npc_son_of_flame() : CreatureScript("npc_SonOfFlame") { }
-
-        struct npc_son_of_flameAI : public ScriptedAI //didnt work correctly in EAI for me...
-        {
-            npc_son_of_flameAI(Creature* creature) : ScriptedAI(creature)
-            {
-                instance = me->GetInstanceScript();
-            }
-
-            void JustDied(Unit* /*killer*/) override
-            {
-                instance->SetData(DATA_RAGNAROS_ADDS, 1);
-            }
-
-            void UpdateAI(uint32 /*diff*/) override
-            {
-                if (!UpdateVictim())
-                    return;
-
-                DoMeleeAttackIfReady();
-            }
-
-        private:
-            InstanceScript* instance;
-        };
-
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetMoltenCoreAI<npc_son_of_flameAI>(creature);
-        }
+    npc_son_of_flame(Creature* creature) : ScriptedAI(creature)
+    {
+        instance = me->GetInstanceScript();
+    }
+
+    void JustDied(Unit* /*killer*/) override
+    {
+        instance->SetData(DATA_RAGNAROS_ADDS, 1);
+    }
+
+    void UpdateAI(uint32 /*diff*/) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        DoMeleeAttackIfReady();
+    }
+
+private:
+    InstanceScript* instance;
 };
 
 void AddSC_boss_ragnaros()
 {
-    new boss_ragnaros();
-    new npc_son_of_flame();
+    RegisterMoltenCoreCreatureAI(boss_ragnaros);
+    RegisterMoltenCoreCreatureAI(npc_son_of_flame);
 }
diff --git a/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_shazzrah.cpp b/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_shazzrah.cpp
index cf1156e3299..941813f36c8 100644
--- a/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_shazzrah.cpp
+++ b/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_shazzrah.cpp
@@ -40,135 +40,113 @@ enum Events
     EVENT_SHAZZRAH_GATE                 = 6,
 };
 
-class boss_shazzrah : public CreatureScript
+struct boss_shazzrah : public BossAI
 {
-    public:
-        boss_shazzrah() : CreatureScript("boss_shazzrah") { }
+    boss_shazzrah(Creature* creature) : BossAI(creature, BOSS_SHAZZRAH) { }
 
-        struct boss_shazzrahAI : public BossAI
-        {
-            boss_shazzrahAI(Creature* creature) : BossAI(creature, BOSS_SHAZZRAH) { }
+    void JustEngagedWith(Unit* target) override
+    {
+        BossAI::JustEngagedWith(target);
+        events.ScheduleEvent(EVENT_ARCANE_EXPLOSION, 6s);
+        events.ScheduleEvent(EVENT_SHAZZRAH_CURSE, 10s);
+        events.ScheduleEvent(EVENT_MAGIC_GROUNDING, 24s);
+        events.ScheduleEvent(EVENT_COUNTERSPELL, 15s);
+        events.ScheduleEvent(EVENT_SHAZZRAH_GATE, 45s);
+    }
 
-            void JustEngagedWith(Unit* target) override
-            {
-                BossAI::JustEngagedWith(target);
-                events.ScheduleEvent(EVENT_ARCANE_EXPLOSION, 6s);
-                events.ScheduleEvent(EVENT_SHAZZRAH_CURSE, 10s);
-                events.ScheduleEvent(EVENT_MAGIC_GROUNDING, 24s);
-                events.ScheduleEvent(EVENT_COUNTERSPELL, 15s);
-                events.ScheduleEvent(EVENT_SHAZZRAH_GATE, 45s);
-            }
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
-
-                events.Update(diff);
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
-                    {
-                        case EVENT_ARCANE_EXPLOSION:
-                            DoCastVictim(SPELL_ARCANE_EXPLOSION);
-                            events.ScheduleEvent(EVENT_ARCANE_EXPLOSION, 4s, 7s);
-                            break;
-                        // Triggered subsequent to using "Gate of Shazzrah".
-                        case EVENT_ARCANE_EXPLOSION_TRIGGERED:
-                            DoCastVictim(SPELL_ARCANE_EXPLOSION);
-                            break;
-                        case EVENT_SHAZZRAH_CURSE:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true, true, -SPELL_SHAZZRAH_CURSE))
-                                DoCast(target, SPELL_SHAZZRAH_CURSE);
-                            events.ScheduleEvent(EVENT_SHAZZRAH_CURSE, 25s, 30s);
-                            break;
-                        case EVENT_MAGIC_GROUNDING:
-                            DoCast(me, SPELL_MAGIC_GROUNDING);
-                            events.ScheduleEvent(EVENT_MAGIC_GROUNDING, 35s);
-                            break;
-                        case EVENT_COUNTERSPELL:
-                            DoCastVictim(SPELL_COUNTERSPELL);
-                            events.ScheduleEvent(EVENT_COUNTERSPELL, 16s, 20s);
-                            break;
-                        case EVENT_SHAZZRAH_GATE:
-                            ResetThreatList();
-                            DoCastAOE(SPELL_SHAZZRAH_GATE_DUMMY);
-                            events.ScheduleEvent(EVENT_ARCANE_EXPLOSION_TRIGGERED, 2s);
-                            events.RescheduleEvent(EVENT_ARCANE_EXPLOSION, 3s, 6s);
-                            events.ScheduleEvent(EVENT_SHAZZRAH_GATE, 45s);
-                            break;
-                        default:
-                            break;
-                    }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
-            }
-        };
+        events.Update(diff);
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetMoltenCoreAI<boss_shazzrahAI>(creature);
-        }
-};
-
-// 23138 - Gate of Shazzrah
-class spell_shazzrah_gate_dummy : public SpellScriptLoader
-{
-    public:
-        spell_shazzrah_gate_dummy() : SpellScriptLoader("spell_shazzrah_gate_dummy") { }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-        class spell_shazzrah_gate_dummy_SpellScript : public SpellScript
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            PrepareSpellScript(spell_shazzrah_gate_dummy_SpellScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
+            switch (eventId)
             {
-                return ValidateSpellInfo({ SPELL_SHAZZRAH_GATE });
+                case EVENT_ARCANE_EXPLOSION:
+                    DoCastVictim(SPELL_ARCANE_EXPLOSION);
+                    events.ScheduleEvent(EVENT_ARCANE_EXPLOSION, 4s, 7s);
+                    break;
+                // Triggered subsequent to using "Gate of Shazzrah".
+                case EVENT_ARCANE_EXPLOSION_TRIGGERED:
+                    DoCastVictim(SPELL_ARCANE_EXPLOSION);
+                    break;
+                case EVENT_SHAZZRAH_CURSE:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true, true, -SPELL_SHAZZRAH_CURSE))
+                        DoCast(target, SPELL_SHAZZRAH_CURSE);
+                    events.ScheduleEvent(EVENT_SHAZZRAH_CURSE, 25s, 30s);
+                    break;
+                case EVENT_MAGIC_GROUNDING:
+                    DoCast(me, SPELL_MAGIC_GROUNDING);
+                    events.ScheduleEvent(EVENT_MAGIC_GROUNDING, 35s);
+                    break;
+                case EVENT_COUNTERSPELL:
+                    DoCastVictim(SPELL_COUNTERSPELL);
+                    events.ScheduleEvent(EVENT_COUNTERSPELL, 16s, 20s);
+                    break;
+                case EVENT_SHAZZRAH_GATE:
+                    ResetThreatList();
+                    DoCastAOE(SPELL_SHAZZRAH_GATE_DUMMY);
+                    events.ScheduleEvent(EVENT_ARCANE_EXPLOSION_TRIGGERED, 2s);
+                    events.RescheduleEvent(EVENT_ARCANE_EXPLOSION, 3s, 6s);
+                    events.ScheduleEvent(EVENT_SHAZZRAH_GATE, 45s);
+                    break;
+                default:
+                    break;
             }
 
-            void FilterTargets(std::list<WorldObject*>& targets)
-            {
-                if (targets.empty())
-                    return;
-
-                WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
-                targets.clear();
-                targets.push_back(target);
-            }
-
-            void HandleScript(SpellEffIndex /*effIndex*/)
-            {
-                if (Unit* target = GetHitUnit())
-                {
-                    target->CastSpell(GetCaster(), SPELL_SHAZZRAH_GATE, true);
-                    if (Creature* creature = GetCaster()->ToCreature())
-                        creature->AI()->AttackStart(target); // Attack the target which caster will teleport to.
-                }
-            }
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
+        }
 
-            void Register() override
-            {
-                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_shazzrah_gate_dummy_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
-                OnEffectHitTarget += SpellEffectFn(spell_shazzrah_gate_dummy_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
-            }
-        };
+        DoMeleeAttackIfReady();
+    }
+};
 
-        SpellScript* GetSpellScript() const override
+// 23138 - Gate of Shazzrah
+class spell_shazzrah_gate_dummy : public SpellScript
+{
+    PrepareSpellScript(spell_shazzrah_gate_dummy);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_SHAZZRAH_GATE });
+    }
+
+    void FilterTargets(std::list<WorldObject*>& targets)
+    {
+        if (targets.empty())
+            return;
+
+        WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
+        targets.clear();
+        targets.push_back(target);
+    }
+
+    void HandleScript(SpellEffIndex /*effIndex*/)
+    {
+        if (Unit* target = GetHitUnit())
         {
-            return new spell_shazzrah_gate_dummy_SpellScript();
+            target->CastSpell(GetCaster(), SPELL_SHAZZRAH_GATE, true);
+            if (Creature* creature = GetCaster()->ToCreature())
+                creature->AI()->AttackStart(target); // Attack the target which caster will teleport to.
         }
+    }
+
+    void Register() override
+    {
+        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_shazzrah_gate_dummy::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
+        OnEffectHitTarget += SpellEffectFn(spell_shazzrah_gate_dummy::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
+    }
 };
 
 void AddSC_boss_shazzrah()
 {
-    new boss_shazzrah();
-    new spell_shazzrah_gate_dummy();
+    RegisterMoltenCoreCreatureAI(boss_shazzrah);
+    RegisterSpellScript(spell_shazzrah_gate_dummy);
 }
diff --git a/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_sulfuron_harbinger.cpp b/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_sulfuron_harbinger.cpp
index 290c6c0811e..4ffdb4501b7 100644
--- a/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_sulfuron_harbinger.cpp
+++ b/src/server/scripts/EasternKingdoms/BlackrockMountain/MoltenCore/boss_sulfuron_harbinger.cpp
@@ -54,167 +54,145 @@ enum Events
     EVENT_IMMOLATE              = 8,
 };
 
-class boss_sulfuron : public CreatureScript
+struct boss_sulfuron : public BossAI
 {
-    public:
-        boss_sulfuron() : CreatureScript("boss_sulfuron") { }
-
-        struct boss_sulfuronAI : public BossAI
+    boss_sulfuron(Creature* creature) : BossAI(creature, BOSS_SULFURON_HARBINGER)
+    {
+    }
+
+    void JustEngagedWith(Unit* victim) override
+    {
+        BossAI::JustEngagedWith(victim);
+        events.ScheduleEvent(EVENT_DARK_STRIKE, 10s);
+        events.ScheduleEvent(EVENT_DEMORALIZING_SHOUT, 15s);
+        events.ScheduleEvent(EVENT_INSPIRE, 13s);
+        events.ScheduleEvent(EVENT_KNOCKDOWN, 6s);
+        events.ScheduleEvent(EVENT_FLAMESPEAR, 2s);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        events.Update(diff);
+
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
+
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            boss_sulfuronAI(Creature* creature) : BossAI(creature, BOSS_SULFURON_HARBINGER)
+            switch (eventId)
             {
-            }
-
-            void JustEngagedWith(Unit* victim) override
-            {
-                BossAI::JustEngagedWith(victim);
-                events.ScheduleEvent(EVENT_DARK_STRIKE, 10s);
-                events.ScheduleEvent(EVENT_DEMORALIZING_SHOUT, 15s);
-                events.ScheduleEvent(EVENT_INSPIRE, 13s);
-                events.ScheduleEvent(EVENT_KNOCKDOWN, 6s);
-                events.ScheduleEvent(EVENT_FLAMESPEAR, 2s);
-            }
-
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
-
-                events.Update(diff);
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-
-                while (uint32 eventId = events.ExecuteEvent())
+                case EVENT_DARK_STRIKE:
+                    DoCast(me, SPELL_DARK_STRIKE);
+                    events.ScheduleEvent(EVENT_DARK_STRIKE, 15s, 18s);
+                    break;
+                case EVENT_DEMORALIZING_SHOUT:
+                    DoCastVictim(SPELL_DEMORALIZING_SHOUT);
+                    events.ScheduleEvent(EVENT_DEMORALIZING_SHOUT, 15s, 20s);
+                    break;
+                case EVENT_INSPIRE:
                 {
-                    switch (eventId)
-                    {
-                        case EVENT_DARK_STRIKE:
-                            DoCast(me, SPELL_DARK_STRIKE);
-                            events.ScheduleEvent(EVENT_DARK_STRIKE, 15s, 18s);
-                            break;
-                        case EVENT_DEMORALIZING_SHOUT:
-                            DoCastVictim(SPELL_DEMORALIZING_SHOUT);
-                            events.ScheduleEvent(EVENT_DEMORALIZING_SHOUT, 15s, 20s);
-                            break;
-                        case EVENT_INSPIRE:
-                        {
-                            std::list<Creature*> healers = DoFindFriendlyMissingBuff(45.0f, SPELL_INSPIRE);
-                            if (!healers.empty())
-                                DoCast(Trinity::Containers::SelectRandomContainerElement(healers), SPELL_INSPIRE);
-
-                            DoCast(me, SPELL_INSPIRE);
-                            events.ScheduleEvent(EVENT_INSPIRE, 20s, 26s);
-                            break;
-                        }
-                        case EVENT_KNOCKDOWN:
-                            DoCastVictim(SPELL_KNOCKDOWN);
-                            events.ScheduleEvent(EVENT_KNOCKDOWN, 12s, 15s);
-                            break;
-                        case EVENT_FLAMESPEAR:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true))
-                                DoCast(target, SPELL_FLAMESPEAR);
-                            events.ScheduleEvent(EVENT_FLAMESPEAR, 12s, 16s);
-                            break;
-                        default:
-                            break;
-                    }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
+                    std::list<Creature*> healers = DoFindFriendlyMissingBuff(45.0f, SPELL_INSPIRE);
+                    if (!healers.empty())
+                        DoCast(Trinity::Containers::SelectRandomContainerElement(healers), SPELL_INSPIRE);
 
-                DoMeleeAttackIfReady();
+                    DoCast(me, SPELL_INSPIRE);
+                    events.ScheduleEvent(EVENT_INSPIRE, 20s, 26s);
+                    break;
+                }
+                case EVENT_KNOCKDOWN:
+                    DoCastVictim(SPELL_KNOCKDOWN);
+                    events.ScheduleEvent(EVENT_KNOCKDOWN, 12s, 15s);
+                    break;
+                case EVENT_FLAMESPEAR:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true))
+                        DoCast(target, SPELL_FLAMESPEAR);
+                    events.ScheduleEvent(EVENT_FLAMESPEAR, 12s, 16s);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetMoltenCoreAI<boss_sulfuronAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
-class npc_flamewaker_priest : public CreatureScript
+struct npc_flamewaker_priest : public ScriptedAI
 {
-    public:
-        npc_flamewaker_priest() : CreatureScript("npc_flamewaker_priest") { }
-
-        struct npc_flamewaker_priestAI : public ScriptedAI
+    npc_flamewaker_priest(Creature* creature) : ScriptedAI(creature)
+    {
+    }
+
+    void Reset() override
+    {
+        events.Reset();
+    }
+
+    void JustDied(Unit* /*killer*/) override
+    {
+        events.Reset();
+    }
+
+    void JustEngagedWith(Unit* victim) override
+    {
+        ScriptedAI::JustEngagedWith(victim);
+        events.ScheduleEvent(EVENT_HEAL, 15s, 30s);
+        events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 2s);
+        events.ScheduleEvent(EVENT_IMMOLATE, 8s);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        events.Update(diff);
+
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
+
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            npc_flamewaker_priestAI(Creature* creature) : ScriptedAI(creature)
-            {
-            }
-
-            void Reset() override
+            switch (eventId)
             {
-                events.Reset();
+                case EVENT_HEAL:
+                    if (Unit* target = DoSelectLowestHpFriendly(60.0f, 1))
+                        DoCast(target, SPELL_HEAL);
+                    events.ScheduleEvent(EVENT_HEAL, 15s, 20s);
+                    break;
+                case EVENT_SHADOW_WORD_PAIN:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true, true, -SPELL_SHADOWWORDPAIN))
+                        DoCast(target, SPELL_SHADOWWORDPAIN);
+                    events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 18s, 26s);
+                    break;
+                case EVENT_IMMOLATE:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true, true, -SPELL_IMMOLATE))
+                        DoCast(target, SPELL_IMMOLATE);
+                    events.ScheduleEvent(EVENT_IMMOLATE, 15s, 25s);
+                    break;
+                default:
+                    break;
             }
 
-            void JustDied(Unit* /*killer*/) override
-            {
-                events.Reset();
-            }
-
-            void JustEngagedWith(Unit* victim) override
-            {
-                ScriptedAI::JustEngagedWith(victim);
-                events.ScheduleEvent(EVENT_HEAL, 15s, 30s);
-                events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 2s);
-                events.ScheduleEvent(EVENT_IMMOLATE, 8s);
-            }
-
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
-
-                events.Update(diff);
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
-                    {
-                        case EVENT_HEAL:
-                            if (Unit* target = DoSelectLowestHpFriendly(60.0f, 1))
-                                DoCast(target, SPELL_HEAL);
-                            events.ScheduleEvent(EVENT_HEAL, 15s, 20s);
-                            break;
-                        case EVENT_SHADOW_WORD_PAIN:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true, true, -SPELL_SHADOWWORDPAIN))
-                                DoCast(target, SPELL_SHADOWWORDPAIN);
-                            events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 18s, 26s);
-                            break;
-                        case EVENT_IMMOLATE:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true, true, -SPELL_IMMOLATE))
-                                DoCast(target, SPELL_IMMOLATE);
-                            events.ScheduleEvent(EVENT_IMMOLATE, 15s, 25s);
-                            break;
-                        default:
-                            break;
-                    }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
-            }
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
+        }
 
-        private:
-            EventMap events;
-        };
+        DoMeleeAttackIfReady();
+    }
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetMoltenCoreAI<npc_flamewaker_priestAI>(creature);
-        }
+private:
+    EventMap events;
 };
 
 void AddSC_boss_sulfuron()
 {
-    new boss_sulfuron();
-    new npc_flamewaker_priest();
+    RegisterMoltenCoreCreatureAI(boss_sulfuron);
+    RegisterMoltenCoreCreatureAI(npc_flamewaker_priest);
 }