Scripts/Obsidian Sanctum: Update instance scripts to new register model (#26680)

(cherry picked from commit 8e0429d6abcdd2a1dc73b0e1d720afa393dfdd80)

2 files changed, 325 insertions, 423 deletions

diff --git a/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.cpp b/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.cpp
index 99129bc2b6b..bd08efa07b8 100644
--- a/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.cpp
+++ b/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.cpp
@@ -411,59 +411,48 @@ struct dummy_dragonAI : public ScriptedAI
 ## Tenebron
 ######*/
 
-class npc_tenebron : public CreatureScript
+struct npc_tenebron : public dummy_dragonAI
 {
-public:
-    npc_tenebron() : CreatureScript("npc_tenebron") { }
+    npc_tenebron(Creature* creature) : dummy_dragonAI(creature) { }
 
-    struct npc_tenebronAI : public dummy_dragonAI
+    void Reset() override
     {
-        npc_tenebronAI(Creature* creature) : dummy_dragonAI(creature) { }
-
-        void Reset() override
-        {
-            dummy_dragonAI::Reset();
-        }
+        dummy_dragonAI::Reset();
+    }
 
-        void JustEngagedWith(Unit* who) override
-        {
-            dummy_dragonAI::JustEngagedWith(who);
+    void JustEngagedWith(Unit* who) override
+    {
+        dummy_dragonAI::JustEngagedWith(who);
 
-            events.ScheduleEvent(EVENT_HATCH_EGGS, 30s);
-        }
+        events.ScheduleEvent(EVENT_HATCH_EGGS, 30s);
+    }
 
-        void UpdateAI(uint32 diff) override
+    void UpdateAI(uint32 diff) override
+    {
+        // if no target, update dummy and return
+        if (!UpdateVictim())
         {
-            // if no target, update dummy and return
-            if (!UpdateVictim())
-            {
-                dummy_dragonAI::UpdateAI(diff);
-                return;
-            }
+            dummy_dragonAI::UpdateAI(diff);
+            return;
+        }
 
-            events.Update(diff);
+        events.Update(diff);
 
-            while (uint32 eventId = events.ExecuteEvent())
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_HATCH_EGGS:
-                        OpenPortal();
-                        events.ScheduleEvent(EVENT_HATCH_EGGS, 30s);
-                        break;
-                    default:
-                        dummy_dragonAI::ExecuteEvent(eventId);
-                        break;
-                }
+                case EVENT_HATCH_EGGS:
+                    OpenPortal();
+                    events.ScheduleEvent(EVENT_HATCH_EGGS, 30s);
+                    break;
+                default:
+                    dummy_dragonAI::ExecuteEvent(eventId);
+                    break;
             }
-
-            DoMeleeAttackIfReady();
         }
-    };
 
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetObsidianSanctumAI<npc_tenebronAI>(creature);
+        DoMeleeAttackIfReady();
     }
 };
 
@@ -471,78 +460,67 @@ public:
 ## Shadron
 ######*/
 
-class npc_shadron : public CreatureScript
+struct npc_shadron : public dummy_dragonAI
 {
-public:
-    npc_shadron() : CreatureScript("npc_shadron") { }
+    npc_shadron(Creature* creature) : dummy_dragonAI(creature) { }
 
-    struct npc_shadronAI : public dummy_dragonAI
+    void Reset() override
     {
-        npc_shadronAI(Creature* creature) : dummy_dragonAI(creature) { }
+        dummy_dragonAI::Reset();
 
-        void Reset() override
-        {
-            dummy_dragonAI::Reset();
+        if (me->HasAura(SPELL_TWILIGHT_TORMENT_VESP))
+            me->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP);
 
-            if (me->HasAura(SPELL_TWILIGHT_TORMENT_VESP))
-                me->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP);
+        if (me->HasAura(SPELL_GIFT_OF_TWILIGTH_SHA))
+            me->RemoveAurasDueToSpell(SPELL_GIFT_OF_TWILIGTH_SHA);
 
-            if (me->HasAura(SPELL_GIFT_OF_TWILIGTH_SHA))
-                me->RemoveAurasDueToSpell(SPELL_GIFT_OF_TWILIGTH_SHA);
+        instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
+    }
 
-            instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
-        }
+    void JustEngagedWith(Unit* who) override
+    {
+        dummy_dragonAI::JustEngagedWith(who);
 
-        void JustEngagedWith(Unit* who) override
-        {
-            dummy_dragonAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_ACOLYTE_SHADRON, 1min);
+    }
 
-            events.ScheduleEvent(EVENT_ACOLYTE_SHADRON, 1min);
+    void UpdateAI(uint32 diff) override
+    {
+        // if no target, update dummy and return
+        if (!UpdateVictim())
+        {
+            dummy_dragonAI::UpdateAI(diff);
+            return;
         }
 
-        void UpdateAI(uint32 diff) override
+        events.Update(diff);
+
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            // if no target, update dummy and return
-            if (!UpdateVictim())
+            switch (eventId)
             {
-                dummy_dragonAI::UpdateAI(diff);
-                return;
-            }
+                case EVENT_ACOLYTE_SHADRON:
+                    if (instance->GetBossState(DATA_PORTAL_OPEN) == NOT_STARTED)
+                        events.ScheduleEvent(EVENT_ACOLYTE_SHADRON, 10s);
+                    else
+                    {
+                        if (me->HasAura(SPELL_GIFT_OF_TWILIGTH_SHA))
+                            return;
 
-            events.Update(diff);
+                        OpenPortal();
 
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch (eventId)
-                {
-                    case EVENT_ACOLYTE_SHADRON:
-                        if (instance->GetBossState(DATA_PORTAL_OPEN) == NOT_STARTED)
-                            events.ScheduleEvent(EVENT_ACOLYTE_SHADRON, 10s);
-                        else
-                        {
-                            if (me->HasAura(SPELL_GIFT_OF_TWILIGTH_SHA))
-                                return;
-
-                            OpenPortal();
-
-                            instance->SetBossState(DATA_PORTAL_OPEN, IN_PROGRESS);
-
-                            events.ScheduleEvent(EVENT_ACOLYTE_SHADRON, 60s, 65s);
-                        }
-                        break;
-                    default:
-                        dummy_dragonAI::ExecuteEvent(eventId);
-                        break;
-                }
-            }
+                        instance->SetBossState(DATA_PORTAL_OPEN, IN_PROGRESS);
 
-            DoMeleeAttackIfReady();
+                        events.ScheduleEvent(EVENT_ACOLYTE_SHADRON, 60s, 65s);
+                    }
+                    break;
+                default:
+                    dummy_dragonAI::ExecuteEvent(eventId);
+                    break;
+            }
         }
-    };
 
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetObsidianSanctumAI<npc_shadronAI>(creature);
+        DoMeleeAttackIfReady();
     }
 };
 
@@ -550,65 +528,54 @@ public:
 ## Vesperon
 ######*/
 
-class npc_vesperon : public CreatureScript
+struct npc_vesperon : public dummy_dragonAI
 {
-public:
-    npc_vesperon() : CreatureScript("npc_vesperon") { }
+    npc_vesperon(Creature* creature) : dummy_dragonAI(creature) { }
 
-    struct npc_vesperonAI : public dummy_dragonAI
+    void Reset() override
     {
-        npc_vesperonAI(Creature* creature) : dummy_dragonAI(creature) { }
-
-        void Reset() override
-        {
-            dummy_dragonAI::Reset();
-        }
+        dummy_dragonAI::Reset();
+    }
 
-        void JustEngagedWith(Unit* who) override
-        {
-            dummy_dragonAI::JustEngagedWith(who);
+    void JustEngagedWith(Unit* who) override
+    {
+        dummy_dragonAI::JustEngagedWith(who);
 
-            events.ScheduleEvent(EVENT_ACOLYTE_VESPERON, 1min);
-        }
+        events.ScheduleEvent(EVENT_ACOLYTE_VESPERON, 1min);
+    }
 
-        void UpdateAI(uint32 diff) override
+    void UpdateAI(uint32 diff) override
+    {
+        // if no target, update dummy and return
+        if (!UpdateVictim())
         {
-            // if no target, update dummy and return
-            if (!UpdateVictim())
-            {
-                dummy_dragonAI::UpdateAI(diff);
-                return;
-            }
+            dummy_dragonAI::UpdateAI(diff);
+            return;
+        }
 
-            events.Update(diff);
+        events.Update(diff);
 
-            while (uint32 eventId = events.ExecuteEvent())
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_ACOLYTE_VESPERON:
-                        if (instance->GetBossState(DATA_PORTAL_OPEN) == IN_PROGRESS)
-                            events.ScheduleEvent(EVENT_ACOLYTE_VESPERON, 10s);
-                        else
-                        {
-                            OpenPortal();
-                            DoCastVictim(SPELL_TWILIGHT_TORMENT_VESP);
-                            events.ScheduleEvent(EVENT_ACOLYTE_VESPERON, 60s, 70s);
-                        }
-                        break;
-                    default:
-                        dummy_dragonAI::ExecuteEvent(eventId);
-                        break;
-                }
+                case EVENT_ACOLYTE_VESPERON:
+                    if (instance->GetBossState(DATA_PORTAL_OPEN) == IN_PROGRESS)
+                        events.ScheduleEvent(EVENT_ACOLYTE_VESPERON, 10s);
+                    else
+                    {
+                        OpenPortal();
+                        DoCastVictim(SPELL_TWILIGHT_TORMENT_VESP);
+                        events.ScheduleEvent(EVENT_ACOLYTE_VESPERON, 60s, 70s);
+                    }
+                    break;
+                default:
+                    dummy_dragonAI::ExecuteEvent(eventId);
+                    break;
             }
-
-            DoMeleeAttackIfReady();
         }
-    };
 
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetObsidianSanctumAI<npc_vesperonAI>(creature);
+        DoMeleeAttackIfReady();
     }
 };
 
@@ -616,157 +583,134 @@ public:
 ## Acolyte of Shadron
 ######*/
 
-class npc_acolyte_of_shadron : public CreatureScript
+struct npc_acolyte_of_shadron : public ScriptedAI
 {
-    public:
-        npc_acolyte_of_shadron() : CreatureScript("npc_acolyte_of_shadron") { }
+    npc_acolyte_of_shadron(Creature* creature) : ScriptedAI(creature)
+    {
+        instance = creature->GetInstanceScript();
+    }
 
-        struct npc_acolyte_of_shadronAI : public ScriptedAI
-        {
-            npc_acolyte_of_shadronAI(Creature* creature) : ScriptedAI(creature)
-            {
-                instance = creature->GetInstanceScript();
-            }
+    void Reset() override
+    {
+        // Despawn the NPC automatically after 28 seconds
+        me->DespawnOrUnsummon(28s);
 
-            void Reset() override
-            {
-                // Despawn the NPC automatically after 28 seconds
-                me->DespawnOrUnsummon(28s);
+        //if not solo fight, buff main boss, else place debuff on mini-boss. both spells TARGET_SCRIPT
+        if (instance->GetBossState(DATA_SARTHARION) == IN_PROGRESS)
+        {
+            if (Creature* sartharion = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SARTHARION)))
+                sartharion->AddAura(SPELL_GIFT_OF_TWILIGTH_SAR, sartharion);
+        }
+        else
+        {
+            if (Creature* shadron = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SHADRON)))
+                shadron->AddAura(SPELL_GIFT_OF_TWILIGTH_SHA, shadron);
+        }
 
-                //if not solo fight, buff main boss, else place debuff on mini-boss. both spells TARGET_SCRIPT
-                if (instance->GetBossState(DATA_SARTHARION) == IN_PROGRESS)
-                {
-                    if (Creature* sartharion = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SARTHARION)))
-                        sartharion->AddAura(SPELL_GIFT_OF_TWILIGTH_SAR, sartharion);
-                }
-                else
-                {
-                    if (Creature* shadron = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SHADRON)))
-                        shadron->AddAura(SPELL_GIFT_OF_TWILIGTH_SHA, shadron);
-                }
+        me->AddAura(SPELL_TWILIGHT_SHIFT_ENTER, me);
+    }
 
-                me->AddAura(SPELL_TWILIGHT_SHIFT_ENTER, me);
-            }
+    void JustDied(Unit* /*killer*/) override
+    {
+        if (ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SHADRON)))
+            instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
 
-            void JustDied(Unit* /*killer*/) override
+        instance->instance->DoOnPlayers([](Player* player)
+        {
+            if (player->IsAlive() && player->HasAura(SPELL_TWILIGHT_SHIFT) && !player->GetVictim())
             {
-                if (ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SHADRON)))
-                    instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
-
-                instance->instance->DoOnPlayers([](Player* player)
-                {
-                    if (player->IsAlive() && player->HasAura(SPELL_TWILIGHT_SHIFT) && !player->GetVictim())
-                    {
-                        player->CastSpell(player, SPELL_TWILIGHT_SHIFT_REMOVAL_ALL, true);
-                        player->CastSpell(player, SPELL_TWILIGHT_RESIDUE, true);
-                        player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT);
-                        player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT_ENTER);
-                    }
-                });
-
-                // not solo fight, so main boss has debuff
-                if (Creature* debuffTarget = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SARTHARION)))
-                    if (debuffTarget->IsAlive() && debuffTarget->HasAura(SPELL_GIFT_OF_TWILIGTH_SAR))
-                        debuffTarget->RemoveAurasDueToSpell(SPELL_GIFT_OF_TWILIGTH_SAR);
-
-                // event not in progress, then solo fight and must remove debuff mini-boss
-                if (Creature* debuffTarget = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SHADRON)))
-                    if (debuffTarget->IsAlive() && debuffTarget->HasAura(SPELL_GIFT_OF_TWILIGTH_SHA))
-                        debuffTarget->RemoveAurasDueToSpell(SPELL_GIFT_OF_TWILIGTH_SHA);
+                player->CastSpell(player, SPELL_TWILIGHT_SHIFT_REMOVAL_ALL, true);
+                player->CastSpell(player, SPELL_TWILIGHT_RESIDUE, true);
+                player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT);
+                player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT_ENTER);
             }
+        });
 
-            void UpdateAI(uint32 /*diff*/) override
-            {
-                if (!UpdateVictim())
-                    return;
+        // not solo fight, so main boss has debuff
+        if (Creature* debuffTarget = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SARTHARION)))
+            if (debuffTarget->IsAlive() && debuffTarget->HasAura(SPELL_GIFT_OF_TWILIGTH_SAR))
+                debuffTarget->RemoveAurasDueToSpell(SPELL_GIFT_OF_TWILIGTH_SAR);
 
-                DoMeleeAttackIfReady();
-            }
+        // event not in progress, then solo fight and must remove debuff mini-boss
+        if (Creature* debuffTarget = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SHADRON)))
+            if (debuffTarget->IsAlive() && debuffTarget->HasAura(SPELL_GIFT_OF_TWILIGTH_SHA))
+                debuffTarget->RemoveAurasDueToSpell(SPELL_GIFT_OF_TWILIGTH_SHA);
+    }
 
-        private:
-            InstanceScript* instance;
-        };
+    void UpdateAI(uint32 /*diff*/) override
+    {
+        if (!UpdateVictim())
+            return;
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetObsidianSanctumAI<npc_acolyte_of_shadronAI>(creature);
-        }
+        DoMeleeAttackIfReady();
+    }
+
+private:
+    InstanceScript* instance;
 };
 
 /*######
 ## Acolyte of Vesperon
 ######*/
 
-class npc_acolyte_of_vesperon : public CreatureScript
+struct npc_acolyte_of_vesperon : public ScriptedAI
 {
-    public:
-        npc_acolyte_of_vesperon() : CreatureScript("npc_acolyte_of_vesperon") { }
-
-        struct npc_acolyte_of_vesperonAI : public ScriptedAI
-        {
-            npc_acolyte_of_vesperonAI(Creature* creature) : ScriptedAI(creature)
-            {
-                instance = creature->GetInstanceScript();
-            }
-
-            void Reset() override
-            {
-                // Despawn the NPC automatically after 28 seconds
-                me->DespawnOrUnsummon(28s);
-
-                me->AddAura(SPELL_TWILIGHT_SHIFT_ENTER, me);
+    npc_acolyte_of_vesperon(Creature* creature) : ScriptedAI(creature)
+    {
+        instance = creature->GetInstanceScript();
+    }
 
-                DoCast(me, SPELL_TWILIGHT_TORMENT_VESP_ACO);
-            }
+    void Reset() override
+    {
+        // Despawn the NPC automatically after 28 seconds
+        me->DespawnOrUnsummon(28s);
 
-            void JustDied(Unit* /*killer*/) override
-            {
-                me->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP_ACO);
+        me->AddAura(SPELL_TWILIGHT_SHIFT_ENTER, me);
 
-                // remove twilight torment on Vesperon
-                if (Creature* vesperon = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_VESPERON)))
-                {
-                    instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
+        DoCast(me, SPELL_TWILIGHT_TORMENT_VESP_ACO);
+    }
 
-                    if (vesperon->IsAlive() && vesperon->HasAura(SPELL_TWILIGHT_TORMENT_VESP))
-                        vesperon->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP);
-                }
+    void JustDied(Unit* /*killer*/) override
+    {
+        me->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP_ACO);
 
-                instance->instance->DoOnPlayers([](Player* player)
-                {
-                    if (player->IsAlive() && player->HasAura(SPELL_TWILIGHT_SHIFT) && !player->GetVictim())
-                    {
-                        player->CastSpell(player, SPELL_TWILIGHT_SHIFT_REMOVAL_ALL, true);
-                        player->CastSpell(player, SPELL_TWILIGHT_RESIDUE, true);
-                        player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT);
-                        player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT_ENTER);
-                    }
+        // remove twilight torment on Vesperon
+        if (Creature* vesperon = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_VESPERON)))
+        {
+            instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
 
-                    if (player->IsAlive() && player->HasAura(SPELL_TWILIGHT_TORMENT_VESP) && !player->GetVictim())
-                        player->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP);
-                });
+            if (vesperon->IsAlive() && vesperon->HasAura(SPELL_TWILIGHT_TORMENT_VESP))
+                vesperon->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP);
+        }
 
-                instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_TWILIGHT_TORMENT_VESP_ACO, true, true);
-                instance->DoRemoveAurasDueToSpellOnPlayers(57935, true, true);
-                instance->DoRemoveAurasDueToSpellOnPlayers(58835, true, true); // Components of spell Twilight Torment
+        instance->instance->DoOnPlayers([](Player* player)
+        {
+            if (player->IsAlive() && player->HasAura(SPELL_TWILIGHT_SHIFT) && !player->GetVictim())
+            {
+                player->CastSpell(player, SPELL_TWILIGHT_SHIFT_REMOVAL_ALL, true);
+                player->CastSpell(player, SPELL_TWILIGHT_RESIDUE, true);
+                player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT);
+                player->RemoveAurasDueToSpell(SPELL_TWILIGHT_SHIFT_ENTER);
             }
+            if (player->IsAlive() && player->HasAura(SPELL_TWILIGHT_TORMENT_VESP) && !player->GetVictim())
+                player->RemoveAurasDueToSpell(SPELL_TWILIGHT_TORMENT_VESP);
+        });
 
-            void UpdateAI(uint32 /*diff*/) override
-            {
-                if (!UpdateVictim())
-                    return;
+        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_TWILIGHT_TORMENT_VESP_ACO, true, true);
+        instance->DoRemoveAurasDueToSpellOnPlayers(57935, true, true);
+        instance->DoRemoveAurasDueToSpellOnPlayers(58835, true, true); // Components of spell Twilight Torment
+    }
 
-                DoMeleeAttackIfReady();
-            }
+    void UpdateAI(uint32 /*diff*/) override
+    {
+        if (!UpdateVictim())
+            return;
 
-        private:
-            InstanceScript* instance;
-        };
+        DoMeleeAttackIfReady();
+    }
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetObsidianSanctumAI<npc_acolyte_of_vesperonAI>(creature);
-        }
+private:
+    InstanceScript* instance;
 };
 
 /*######
@@ -778,64 +722,53 @@ enum TwilightEggs
     EVENT_TWILIGHT_EGGS           = 11
 };
 
-class npc_twilight_eggs : public CreatureScript
+struct npc_twilight_eggs : public ScriptedAI
 {
-public:
-    npc_twilight_eggs() : CreatureScript("npc_twilight_eggs") { }
+    npc_twilight_eggs(Creature* creature) : ScriptedAI(creature)
+    {
+        SetCombatMovement(false);
+        instance = creature->GetInstanceScript();
+    }
 
-    struct npc_twilight_eggsAI : public ScriptedAI
+    void Reset() override
     {
-        npc_twilight_eggsAI(Creature* creature) : ScriptedAI(creature)
-        {
-            SetCombatMovement(false);
-            instance = creature->GetInstanceScript();
-        }
+        me->AddAura(SPELL_TWILIGHT_SHIFT_ENTER, me);
 
-        void Reset() override
-        {
-            me->AddAura(SPELL_TWILIGHT_SHIFT_ENTER, me);
+        events.ScheduleEvent(EVENT_TWILIGHT_EGGS, 20s);
+    }
 
-            events.ScheduleEvent(EVENT_TWILIGHT_EGGS, 20s);
-        }
+    void SpawnWhelps()
+    {
+        me->RemoveAllAuras();
 
-        void SpawnWhelps()
-        {
-            me->RemoveAllAuras();
+        if (instance->GetBossState(DATA_SARTHARION) != IN_PROGRESS)
+            me->SummonCreature(NPC_TWILIGHT_WHELP, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 1min);
+        else
+            me->SummonCreature(NPC_SARTHARION_TWILIGHT_WHELP, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 1min);
+        me->KillSelf();
+    }
 
-            if (instance->GetBossState(DATA_SARTHARION) != IN_PROGRESS)
-                me->SummonCreature(NPC_TWILIGHT_WHELP, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 1min);
-            else
-                me->SummonCreature(NPC_SARTHARION_TWILIGHT_WHELP, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 1min);
-            me->KillSelf();
-        }
+    void JustSummoned(Creature* who) override
+    {
+        DoZoneInCombat(who);
+    }
 
-        void JustSummoned(Creature* who) override
-        {
-            DoZoneInCombat(who);
-        }
+    void UpdateAI(uint32 diff) override
+    {
+        events.Update(diff);
 
-        void UpdateAI(uint32 diff) override
+        if (events.ExecuteEvent() == EVENT_TWILIGHT_EGGS)
         {
-            events.Update(diff);
-
-            if (events.ExecuteEvent() == EVENT_TWILIGHT_EGGS)
-            {
-                if (ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_TENEBRON)))
-                    instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
+            if (ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_TENEBRON)))
+                instance->SetBossState(DATA_PORTAL_OPEN, NOT_STARTED);
 
-                SpawnWhelps();
-            }
+            SpawnWhelps();
         }
-
-    private:
-        InstanceScript* instance;
-        EventMap events;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetObsidianSanctumAI<npc_twilight_eggsAI>(creature);
     }
+
+private:
+    InstanceScript* instance;
+    EventMap events;
 };
 
 /*######
@@ -848,56 +781,45 @@ enum FlameTsunami
     EVENT_TSUNAMI_BUFF            = 13
 };
 
-class npc_flame_tsunami : public CreatureScript
+struct npc_flame_tsunami : public ScriptedAI
 {
-public:
-    npc_flame_tsunami() : CreatureScript("npc_flame_tsunami") { }
+    npc_flame_tsunami(Creature* creature) : ScriptedAI(creature)
+    {
+        me->SetDisplayId(11686);
+        me->AddAura(SPELL_FLAME_TSUNAMI, me);
+    }
 
-    struct npc_flame_tsunamiAI : public ScriptedAI
+    void Reset() override
     {
-        npc_flame_tsunamiAI(Creature* creature) : ScriptedAI(creature)
-        {
-            me->SetDisplayId(11686);
-            me->AddAura(SPELL_FLAME_TSUNAMI, me);
-        }
+        me->SetReactState(REACT_PASSIVE);
+        events.ScheduleEvent(EVENT_TSUNAMI_TIMER, 100ms);
+        events.ScheduleEvent(EVENT_TSUNAMI_BUFF, 1s);
+        me->AddUnitFlag(UnitFlags(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE));
+    }
 
-        void Reset() override
-        {
-            me->SetReactState(REACT_PASSIVE);
-            events.ScheduleEvent(EVENT_TSUNAMI_TIMER, 100ms);
-            events.ScheduleEvent(EVENT_TSUNAMI_BUFF, 1s);
-            me->AddUnitFlag(UnitFlags(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE));
-        }
+    void UpdateAI(uint32 diff) override
+    {
+        events.Update(diff);
 
-        void UpdateAI(uint32 diff) override
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            events.Update(diff);
-
-            while (uint32 eventId = events.ExecuteEvent())
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_TSUNAMI_TIMER:
-                        DoCast(me, SPELL_FLAME_TSUNAMI_DMG_AURA);
-                        events.ScheduleEvent(EVENT_TSUNAMI_TIMER, 500ms);
-                        break;
-                    case EVENT_TSUNAMI_BUFF:
-                        if (Unit* lavaBlaze = GetClosestCreatureWithEntry(me, NPC_LAVA_BLAZE, 10.0f, true))
-                            lavaBlaze->CastSpell(lavaBlaze, SPELL_FLAME_TSUNAMI_BUFF, true);
-                        events.ScheduleEvent(EVENT_TSUNAMI_BUFF, 1s);
-                        break;
-                }
+                case EVENT_TSUNAMI_TIMER:
+                    DoCast(me, SPELL_FLAME_TSUNAMI_DMG_AURA);
+                    events.ScheduleEvent(EVENT_TSUNAMI_TIMER, 500ms);
+                    break;
+                case EVENT_TSUNAMI_BUFF:
+                    if (Unit* lavaBlaze = GetClosestCreatureWithEntry(me, NPC_LAVA_BLAZE, 10.0f, true))
+                        lavaBlaze->CastSpell(lavaBlaze, SPELL_FLAME_TSUNAMI_BUFF, true);
+                    events.ScheduleEvent(EVENT_TSUNAMI_BUFF, 1s);
+                    break;
             }
         }
-
-    private:
-        EventMap events;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetObsidianSanctumAI<npc_flame_tsunamiAI>(creature);
     }
+
+private:
+    EventMap events;
 };
 
 /*######
@@ -909,49 +831,38 @@ enum TwilightFissure
     EVENT_VOID_BLAST              = 14
 };
 
-class npc_twilight_fissure : public CreatureScript
+struct npc_twilight_fissure : public ScriptedAI
 {
-public:
-    npc_twilight_fissure() : CreatureScript("npc_twilight_fissure") { }
+    npc_twilight_fissure(Creature* creature) : ScriptedAI(creature)
+    {
+        SetCombatMovement(false);
+    }
 
-    struct npc_twilight_fissureAI : public ScriptedAI
+    void Reset() override
     {
-        npc_twilight_fissureAI(Creature* creature) : ScriptedAI(creature)
-        {
-            SetCombatMovement(false);
-        }
+        me->AddUnitFlag(UnitFlags(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE));
+        me->AddAura(46265, me); // Wrong, can't find proper visual
+        me->AddAura(69422, me);
+        events.ScheduleEvent(EVENT_VOID_BLAST, 5s);
+    }
 
-        void Reset() override
-        {
-            me->AddUnitFlag(UnitFlags(UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE));
-            me->AddAura(46265, me); // Wrong, can't find proper visual
-            me->AddAura(69422, me);
-            events.ScheduleEvent(EVENT_VOID_BLAST, 5s);
-        }
+    void UpdateAI(uint32 diff) override
+    {
+        events.Update(diff);
 
-        void UpdateAI(uint32 diff) override
+        if (events.ExecuteEvent() == EVENT_VOID_BLAST)
         {
-            events.Update(diff);
-
-            if (events.ExecuteEvent() == EVENT_VOID_BLAST)
-            {
-                DoCastAOE(SPELL_VOID_BLAST);
-                ////twilight realm
-                //DoCastVictim(57620, true);
-                //DoCastVictim(57874, true);
-                me->RemoveAllAuras();
-                me->KillSelf();
-            }
+            DoCastAOE(SPELL_VOID_BLAST);
+            ////twilight realm
+            //DoCastVictim(57620, true);
+            //DoCastVictim(57874, true);
+            me->RemoveAllAuras();
+            me->KillSelf();
         }
-
-    private:
-        EventMap events;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetObsidianSanctumAI<npc_twilight_fissureAI>(creature);
     }
+
+private:
+    EventMap events;
 };
 
 /*######
@@ -963,49 +874,38 @@ enum TwilightWhelps
     EVENT_FADE_ARMOR              = 15
 };
 
-class npc_twilight_whelp : public CreatureScript
+struct npc_twilight_whelp : public ScriptedAI
 {
-public:
-    npc_twilight_whelp() : CreatureScript("npc_twilight_whelp") { }
-
-    struct npc_twilight_whelpAI : public ScriptedAI
+    npc_twilight_whelp(Creature* creature) : ScriptedAI(creature)
     {
-        npc_twilight_whelpAI(Creature* creature) : ScriptedAI(creature)
-        {
-        }
-
-        void Reset() override
-        {
-            me->RemoveAllAuras();
-            DoZoneInCombat();
-            events.ScheduleEvent(EVENT_FADE_ARMOR, 1s);
-        }
+    }
 
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
+    void Reset() override
+    {
+        me->RemoveAllAuras();
+        DoZoneInCombat();
+        events.ScheduleEvent(EVENT_FADE_ARMOR, 1s);
+    }
 
-            // twilight torment
-            events.Update(diff);
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-            if (events.ExecuteEvent() == EVENT_FADE_ARMOR)
-            {
-                DoCastVictim(SPELL_FADE_ARMOR);
-                events.ScheduleEvent(EVENT_FADE_ARMOR, 5s, 10s);
-            }
+        // twilight torment
+        events.Update(diff);
 
-            DoMeleeAttackIfReady();
+        if (events.ExecuteEvent() == EVENT_FADE_ARMOR)
+        {
+            DoCastVictim(SPELL_FADE_ARMOR);
+            events.ScheduleEvent(EVENT_FADE_ARMOR, 5s, 10s);
         }
 
-    private:
-        EventMap events;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetObsidianSanctumAI<npc_twilight_whelpAI>(creature);
+        DoMeleeAttackIfReady();
     }
+
+private:
+    EventMap events;
 };
 
 class achievement_twilight_assist : public AchievementCriteriaScript
@@ -1043,15 +943,15 @@ class achievement_twilight_zone : public AchievementCriteriaScript
 
 void AddSC_obsidian_sanctum()
 {
-    new npc_vesperon();
-    new npc_shadron();
-    new npc_tenebron();
-    new npc_acolyte_of_shadron();
-    new npc_acolyte_of_vesperon();
-    new npc_twilight_eggs();
-    new npc_flame_tsunami();
-    new npc_twilight_fissure();
-    new npc_twilight_whelp();
+    RegisterObsidianSanctumCreatureAI(npc_vesperon);
+    RegisterObsidianSanctumCreatureAI(npc_shadron);
+    RegisterObsidianSanctumCreatureAI(npc_tenebron);
+    RegisterObsidianSanctumCreatureAI(npc_acolyte_of_shadron);
+    RegisterObsidianSanctumCreatureAI(npc_acolyte_of_vesperon);
+    RegisterObsidianSanctumCreatureAI(npc_twilight_eggs);
+    RegisterObsidianSanctumCreatureAI(npc_flame_tsunami);
+    RegisterObsidianSanctumCreatureAI(npc_twilight_fissure);
+    RegisterObsidianSanctumCreatureAI(npc_twilight_whelp);
     new achievement_twilight_assist();
     new achievement_twilight_duo();
     new achievement_twilight_zone();
diff --git a/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.h b/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.h
index 64365ca50b3..cd7e78603a6 100644
--- a/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.h
+++ b/src/server/scripts/Northrend/ChamberOfAspects/ObsidianSanctum/obsidian_sanctum.h
@@ -54,4 +54,6 @@ inline AI* GetObsidianSanctumAI(T* obj)
     return GetInstanceAI<AI>(obj, OSScriptName);
 }
 
+#define RegisterObsidianSanctumCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetObsidianSanctumAI)
+
 #endif // OBSIDIAN_SANCTUM_H_