Scripts/VoA: Update remaining scripts to new model (#26372)

Co-authored-by: offl <offl@users.noreply.github.com>
(cherry picked from commit 3ece1ee87cd4f17725c4cdd975707dbab065a292)

3 files changed, 350 insertions, 444 deletions

diff --git a/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
index eaefeabf71c..d0fbe767f12 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/boss_archavon.cpp
@@ -55,134 +55,112 @@ enum Events
     EVENT_BERSERK           = 5,    // 300s cd
 };
 
-class boss_archavon : public CreatureScript
+struct boss_archavon : public BossAI
 {
-    public:
-        boss_archavon() : CreatureScript("boss_archavon") { }
+    boss_archavon(Creature* creature) : BossAI(creature, DATA_ARCHAVON)
+    {
+    }
 
-        struct boss_archavonAI : public BossAI
-        {
-            boss_archavonAI(Creature* creature) : BossAI(creature, DATA_ARCHAVON)
-            {
-            }
+    void JustEngagedWith(Unit* who) override
+    {
+        events.ScheduleEvent(EVENT_ROCK_SHARDS, 15s);
+        events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30s);
+        events.ScheduleEvent(EVENT_STOMP, 45s);
+        events.ScheduleEvent(EVENT_BERSERK, 5min);
 
-            void JustEngagedWith(Unit* who) override
-            {
-                events.ScheduleEvent(EVENT_ROCK_SHARDS, 15s);
-                events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30s);
-                events.ScheduleEvent(EVENT_STOMP, 45s);
-                events.ScheduleEvent(EVENT_BERSERK, 5min);
+        BossAI::JustEngagedWith(who);
+    }
 
-                BossAI::JustEngagedWith(who);
-            }
-
-            // Below UpdateAI may need review/debug.
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
+    // Below UpdateAI may need review/debug.
+    void UpdateAI(uint32 diff) override
+    {
+        if (!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_ROCK_SHARDS:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                        DoCast(target, SPELL_ROCK_SHARDS);
+                    events.ScheduleEvent(EVENT_ROCK_SHARDS, 15s);
+                    break;
+                case EVENT_CHOKING_CLOUD:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, -10.0f, true))
                     {
-                        case EVENT_ROCK_SHARDS:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                                DoCast(target, SPELL_ROCK_SHARDS);
-                            events.ScheduleEvent(EVENT_ROCK_SHARDS, 15s);
-                            break;
-                        case EVENT_CHOKING_CLOUD:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, -10.0f, true))
-                            {
-                                DoCast(target, SPELL_CRUSHING_LEAP, true); //10y~80y, ignore range
-                                Talk(EMOTE_LEAP, target);
-                            }
-                            events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30s);
-                            break;
-                        case EVENT_STOMP:
-                            DoCastVictim(SPELL_STOMP);
-                            events.ScheduleEvent(EVENT_IMPALE, 3s);
-                            events.ScheduleEvent(EVENT_STOMP, 45s);
-                            break;
-                        case EVENT_IMPALE:
-                            DoCastVictim(SPELL_IMPALE);
-                            break;
-                        case EVENT_BERSERK:
-                            DoCast(me, SPELL_BERSERK);
-                            Talk(EMOTE_BERSERK);
-                            break;
-                        default:
-                            break;
+                        DoCast(target, SPELL_CRUSHING_LEAP, true); //10y~80y, ignore range
+                        Talk(EMOTE_LEAP, target);
                     }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+                    events.ScheduleEvent(EVENT_CHOKING_CLOUD, 30s);
+                    break;
+                case EVENT_STOMP:
+                    DoCastVictim(SPELL_STOMP);
+                    events.ScheduleEvent(EVENT_IMPALE, 3s);
+                    events.ScheduleEvent(EVENT_STOMP, 45s);
+                    break;
+                case EVENT_IMPALE:
+                    DoCastVictim(SPELL_IMPALE);
+                    break;
+                case EVENT_BERSERK:
+                    DoCast(me, SPELL_BERSERK);
+                    Talk(EMOTE_BERSERK);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetVaultOfArchavonAI<boss_archavonAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
 // 58941 - Rock Shards
-class spell_archavon_rock_shards : public SpellScriptLoader
+class spell_archavon_rock_shards : public SpellScript
 {
-    public:
-        spell_archavon_rock_shards() : SpellScriptLoader("spell_archavon_rock_shards") { }
+    PrepareSpellScript(spell_archavon_rock_shards);
 
-        class spell_archavon_rock_shards_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo(
         {
-            PrepareSpellScript(spell_archavon_rock_shards_SpellScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo(
-                {
-                    SPELL_ROCK_SHARDS_VISUAL_L,
-                    SPELL_ROCK_SHARDS_VISUAL_R,
-                    SPELL_ROCK_SHARDS_DAMAGE_L,
-                    SPELL_ROCK_SHARDS_DAMAGE_R
-                });
-            }
-
-            void HandleScript(SpellEffIndex /*effIndex*/)
-            {
-                Unit* caster = GetCaster();
-
-                for (uint8 i = 0; i < 3; ++i)
-                {
-                    caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_VISUAL_L, true);
-                    caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_VISUAL_R, true);
-                }
-
-                caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_DAMAGE_L, true);
-                caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_DAMAGE_R, true);
-            }
-
-            void Register() override
-            {
-                OnEffectHit += SpellEffectFn(spell_archavon_rock_shards_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
-            }
-        };
-
-        SpellScript* GetSpellScript() const override
+            SPELL_ROCK_SHARDS_VISUAL_L,
+            SPELL_ROCK_SHARDS_VISUAL_R,
+            SPELL_ROCK_SHARDS_DAMAGE_L,
+            SPELL_ROCK_SHARDS_DAMAGE_R
+        });
+    }
+
+    void HandleScript(SpellEffIndex /*effIndex*/)
+    {
+        Unit* caster = GetCaster();
+
+        for (uint8 i = 0; i < 3; ++i)
         {
-            return new spell_archavon_rock_shards_SpellScript();
+            caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_VISUAL_L, true);
+            caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_VISUAL_R, true);
         }
+
+        caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_DAMAGE_L, true);
+        caster->CastSpell(nullptr, SPELL_ROCK_SHARDS_DAMAGE_R, true);
+    }
+
+    void Register() override
+    {
+        OnEffectHit += SpellEffectFn(spell_archavon_rock_shards::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+    }
 };
 
 void AddSC_boss_archavon()
 {
-    new boss_archavon();
-    new spell_archavon_rock_shards();
+    RegisterVaultOfArchavonCreatureAI(boss_archavon);
+    RegisterSpellScript(spell_archavon_rock_shards);
 }
diff --git a/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
index 4d5936f8ed3..5438cf29b70 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/boss_emalon.cpp
@@ -68,223 +68,195 @@ Position const TempestMinions[MAX_TEMPEST_MINIONS] =
     {-203.842529f, -297.097015f, 91.745163f, 1.598807f}
 };
 
-/*######
-##  Emalon the Storm Watcher
-######*/
-class boss_emalon : public CreatureScript
+struct boss_emalon : public BossAI
 {
-    public:
-        boss_emalon() : CreatureScript("boss_emalon") { }
-
-        struct boss_emalonAI : public BossAI
+    boss_emalon(Creature* creature) : BossAI(creature, DATA_EMALON)
+    {
+    }
+
+    void Reset() override
+    {
+        _Reset();
+
+        for (uint8 i = 0; i < MAX_TEMPEST_MINIONS; ++i)
+            me->SummonCreature(NPC_TEMPEST_MINION, TempestMinions[i], TEMPSUMMON_CORPSE_DESPAWN);
+    }
+
+    void JustSummoned(Creature* summoned) override
+    {
+        BossAI::JustSummoned(summoned);
+
+        // AttackStart has nullptr-check for victim
+        if (summoned->AI())
+            summoned->AI()->AttackStart(me->GetVictim());
+    }
+
+    void JustEngagedWith(Unit* who) override
+    {
+        if (!summons.empty())
         {
-            boss_emalonAI(Creature* creature) : BossAI(creature, DATA_EMALON)
-            {
-            }
-
-            void Reset() override
+            for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
             {
-                _Reset();
-
-                for (uint8 i = 0; i < MAX_TEMPEST_MINIONS; ++i)
-                    me->SummonCreature(NPC_TEMPEST_MINION, TempestMinions[i], TEMPSUMMON_CORPSE_DESPAWN);
+                Creature* minion = ObjectAccessor::GetCreature(*me, *itr);
+                if (minion && minion->IsAlive() && !minion->GetVictim() && minion->AI())
+                    minion->AI()->AttackStart(who);
             }
+        }
 
-            void JustSummoned(Creature* summoned) override
-            {
-                BossAI::JustSummoned(summoned);
+        events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 5s);
+        events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40s);
+        events.ScheduleEvent(EVENT_BERSERK, 6min);
+        events.ScheduleEvent(EVENT_OVERCHARGE, 45s);
 
-                // AttackStart has nullptr-check for victim
-                if (summoned->AI())
-                    summoned->AI()->AttackStart(me->GetVictim());
-            }
+        BossAI::JustEngagedWith(who);
+    }
 
-            void JustEngagedWith(Unit* who) override
-            {
-                if (!summons.empty())
-                {
-                    for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
-                    {
-                        Creature* minion = ObjectAccessor::GetCreature(*me, *itr);
-                        if (minion && minion->IsAlive() && !minion->GetVictim() && minion->AI())
-                            minion->AI()->AttackStart(who);
-                    }
-                }
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-                events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 5s);
-                events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40s);
-                events.ScheduleEvent(EVENT_BERSERK, 6min);
-                events.ScheduleEvent(EVENT_OVERCHARGE, 45s);
+        events.Update(diff);
 
-                BossAI::JustEngagedWith(who);
-            }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-            void UpdateAI(uint32 diff) override
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                if (!UpdateVictim())
-                    return;
-
-                events.Update(diff);
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
+                case EVENT_CHAIN_LIGHTNING:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                        DoCast(target, SPELL_CHAIN_LIGHTNING);
+                    events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25s);
+                    break;
+                case EVENT_LIGHTNING_NOVA:
+                    DoCastAOE(SPELL_LIGHTNING_NOVA);
+                    events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40s);
+                    break;
+                case EVENT_OVERCHARGE:
+                    if (!summons.empty())
                     {
-                        case EVENT_CHAIN_LIGHTNING:
-                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                                DoCast(target, SPELL_CHAIN_LIGHTNING);
-                            events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25s);
-                            break;
-                        case EVENT_LIGHTNING_NOVA:
-                            DoCastAOE(SPELL_LIGHTNING_NOVA);
-                            events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40s);
-                            break;
-                        case EVENT_OVERCHARGE:
-                            if (!summons.empty())
-                            {
-                                Creature* minion = ObjectAccessor::GetCreature(*me, Trinity::Containers::SelectRandomContainerElement(summons));
-                                if (minion && minion->IsAlive())
-                                {
-                                    minion->CastSpell(me, SPELL_OVERCHARGED, true);
-                                    minion->SetFullHealth();
-                                    Talk(EMOTE_OVERCHARGE);
-                                    events.ScheduleEvent(EVENT_OVERCHARGE, 45s);
-                                }
-                            }
-                            break;
-                        case EVENT_BERSERK:
-                            DoCast(me, SPELL_BERSERK);
-                            Talk(EMOTE_BERSERK);
-                            break;
-                        default:
-                            break;
+                        Creature* minion = ObjectAccessor::GetCreature(*me, Trinity::Containers::SelectRandomContainerElement(summons));
+                        if (minion && minion->IsAlive())
+                        {
+                            minion->CastSpell(me, SPELL_OVERCHARGED, true);
+                            minion->SetFullHealth();
+                            Talk(EMOTE_OVERCHARGE);
+                            events.ScheduleEvent(EVENT_OVERCHARGE, 45s);
+                        }
                     }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+                    break;
+                case EVENT_BERSERK:
+                    DoCast(me, SPELL_BERSERK);
+                    Talk(EMOTE_BERSERK);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetVaultOfArchavonAI<boss_emalonAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
-/*######
-##  Tempest Minion
-######*/
-class npc_tempest_minion : public CreatureScript
+struct npc_tempest_minion : public ScriptedAI
 {
-    public:
-        npc_tempest_minion() : CreatureScript("npc_tempest_minion") { }
-
-        struct npc_tempest_minionAI : public ScriptedAI
+    npc_tempest_minion(Creature* creature) : ScriptedAI(creature)
+    {
+        Initialize();
+        instance = creature->GetInstanceScript();
+    }
+
+    void Initialize()
+    {
+        OverchargedTimer = 0;
+    }
+
+    void Reset() override
+    {
+        events.Reset();
+        Initialize();
+    }
+
+    void JustDied(Unit* /*killer*/) override
+    {
+        if (Creature* emalon = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_EMALON)))
         {
-            npc_tempest_minionAI(Creature* creature) : ScriptedAI(creature)
+            if (emalon->IsAlive())
             {
-                Initialize();
-                instance = creature->GetInstanceScript();
+                emalon->SummonCreature(NPC_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN);
+                Talk(EMOTE_MINION_RESPAWN);
             }
+        }
+    }
 
-            void Initialize()
-            {
-                OverchargedTimer = 0;
-            }
+    void JustEngagedWith(Unit* who) override
+    {
+        DoZoneInCombat();
+        events.ScheduleEvent(EVENT_SHOCK, 20s);
 
-            void Reset() override
-            {
-                events.Reset();
-                Initialize();
-            }
+        if (Creature* pEmalon = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_EMALON)))
+        {
+            if (!pEmalon->GetVictim() && pEmalon->AI())
+                pEmalon->AI()->AttackStart(who);
+        }
+    }
 
-            void JustDied(Unit* /*killer*/) override
-            {
-                if (Creature* emalon = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_EMALON)))
-                {
-                    if (emalon->IsAlive())
-                    {
-                        emalon->SummonCreature(NPC_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN);
-                        Talk(EMOTE_MINION_RESPAWN);
-                    }
-                }
-            }
+    void UpdateAI(uint32 diff) override
+    {
+        //Return since we have no target
+        if (!UpdateVictim())
+            return;
 
-            void JustEngagedWith(Unit* who) override
-            {
-                DoZoneInCombat();
-                events.ScheduleEvent(EVENT_SHOCK, 20s);
+        events.Update(diff);
 
-                if (Creature* pEmalon = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_EMALON)))
-                {
-                    if (!pEmalon->GetVictim() && pEmalon->AI())
-                        pEmalon->AI()->AttackStart(who);
-                }
-            }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-            void UpdateAI(uint32 diff) override
+        if (Aura const* overchargedAura = me->GetAura(SPELL_OVERCHARGED))
+        {
+            if (overchargedAura->GetStackAmount() < 10)
             {
-                //Return since we have no target
-                if (!UpdateVictim())
-                    return;
-
-                events.Update(diff);
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-
-                if (Aura const* overchargedAura = me->GetAura(SPELL_OVERCHARGED))
+                if (OverchargedTimer <= diff)
                 {
-                    if (overchargedAura->GetStackAmount() < 10)
-                    {
-                        if (OverchargedTimer <= diff)
-                        {
-                            DoCast(me, SPELL_OVERCHARGED);
-                            OverchargedTimer = 2000; // ms
-                        }
-                        else
-                            OverchargedTimer -= diff;
-                    }
-                    else
-                    {
-                        if (overchargedAura->GetStackAmount() == 10)
-                        {
-                            DoCast(me, SPELL_OVERCHARGED_BLAST);
-                            me->DespawnOrUnsummon();
-                            Talk(EMOTE_MINION_RESPAWN);
-                        }
-                    }
+                    DoCast(me, SPELL_OVERCHARGED);
+                    OverchargedTimer = 2000; // ms
                 }
-
-                if (events.ExecuteEvent() == EVENT_SHOCK)
+                else
+                    OverchargedTimer -= diff;
+            }
+            else
+            {
+                if (overchargedAura->GetStackAmount() == 10)
                 {
-                    DoCastVictim(SPELL_SHOCK);
-                    events.ScheduleEvent(EVENT_SHOCK, 20s);
+                    DoCast(me, SPELL_OVERCHARGED_BLAST);
+                    me->DespawnOrUnsummon();
+                    Talk(EMOTE_MINION_RESPAWN);
                 }
-
-                DoMeleeAttackIfReady();
             }
+        }
 
-        private:
-            InstanceScript* instance;
-            EventMap events;
-            uint32 OverchargedTimer;
-        };
-
-        CreatureAI* GetAI(Creature* creature) const override
+        if (events.ExecuteEvent() == EVENT_SHOCK)
         {
-            return GetVaultOfArchavonAI<npc_tempest_minionAI>(creature);
+            DoCastVictim(SPELL_SHOCK);
+            events.ScheduleEvent(EVENT_SHOCK, 20s);
         }
+
+        DoMeleeAttackIfReady();
+    }
+
+private:
+    InstanceScript* instance;
+    EventMap events;
+    uint32 OverchargedTimer;
 };
 
 void AddSC_boss_emalon()
 {
-    new boss_emalon();
-    new npc_tempest_minion();
+    RegisterVaultOfArchavonCreatureAI(boss_emalon);
+    RegisterVaultOfArchavonCreatureAI(npc_tempest_minion);
 }
diff --git a/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp b/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
index fc20b287973..9d437fecbd9 100644
--- a/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
+++ b/src/server/scripts/Northrend/VaultOfArchavon/boss_koralon.cpp
@@ -43,188 +43,144 @@ enum Spells
     SPELL_FW_METEOR_FISTS_DAMAGE                = 66809
 };
 
-class boss_koralon : public CreatureScript
+struct boss_koralon : public BossAI
 {
-    public:
-        boss_koralon() : CreatureScript("boss_koralon") { }
+    boss_koralon(Creature* creature) : BossAI(creature, DATA_KORALON)
+    {
+    }
 
-        struct boss_koralonAI : public BossAI
-        {
-            boss_koralonAI(Creature* creature) : BossAI(creature, DATA_KORALON)
-            {
-            }
+    void JustEngagedWith(Unit* who) override
+    {
+        DoCast(me, SPELL_BURNING_FURY);
 
-            void JustEngagedWith(Unit* who) override
-            {
-                DoCast(me, SPELL_BURNING_FURY);
+        events.ScheduleEvent(EVENT_BURNING_FURY, 20s);    /// @todo check timer
+        events.ScheduleEvent(EVENT_BURNING_BREATH, 15s);  // 1st after 15sec, then every 45sec
+        events.ScheduleEvent(EVENT_METEOR_FISTS, 75s);    // 1st after 75sec, then every 45sec
+        events.ScheduleEvent(EVENT_FLAME_CINDER, 30s);    /// @todo check timer
 
-                events.ScheduleEvent(EVENT_BURNING_FURY, 20s);    /// @todo check timer
-                events.ScheduleEvent(EVENT_BURNING_BREATH, 15s);  // 1st after 15sec, then every 45sec
-                events.ScheduleEvent(EVENT_METEOR_FISTS, 75s);    // 1st after 75sec, then every 45sec
-                events.ScheduleEvent(EVENT_FLAME_CINDER, 30s);    /// @todo check timer
+        BossAI::JustEngagedWith(who);
+    }
 
-                BossAI::JustEngagedWith(who);
-            }
-
-            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_BURNING_FURY:
-                            DoCast(me, SPELL_BURNING_FURY);
-                            events.ScheduleEvent(EVENT_BURNING_FURY, 20s);
-                            break;
-                        case EVENT_BURNING_BREATH:
-                            DoCast(me, SPELL_BURNING_BREATH);
-                            events.ScheduleEvent(EVENT_BURNING_BREATH, 45s);
-                            break;
-                        case EVENT_METEOR_FISTS:
-                            DoCast(me, SPELL_METEOR_FISTS);
-                            events.ScheduleEvent(EVENT_METEOR_FISTS, 45s);
-                            break;
-                        case EVENT_FLAME_CINDER:
-                            DoCast(me, SPELL_FLAME_CINDER_A);
-                            events.ScheduleEvent(EVENT_FLAME_CINDER, 30s);
-                            break;
-                        default:
-                            break;
-                    }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
-            }
-        };
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetVaultOfArchavonAI<boss_koralonAI>(creature);
-        }
-};
+        events.Update(diff);
 
-class spell_koralon_meteor_fists : public SpellScriptLoader
-{
-    public:
-        spell_koralon_meteor_fists() : SpellScriptLoader("spell_koralon_meteor_fists") { }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-        class spell_koralon_meteor_fists_AuraScript : public AuraScript
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            PrepareAuraScript(spell_koralon_meteor_fists_AuraScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
+            switch (eventId)
             {
-                return ValidateSpellInfo({ SPELL_METEOR_FISTS_DAMAGE });
+                case EVENT_BURNING_FURY:
+                    DoCast(me, SPELL_BURNING_FURY);
+                    events.ScheduleEvent(EVENT_BURNING_FURY, 20s);
+                    break;
+                case EVENT_BURNING_BREATH:
+                    DoCast(me, SPELL_BURNING_BREATH);
+                    events.ScheduleEvent(EVENT_BURNING_BREATH, 45s);
+                    break;
+                case EVENT_METEOR_FISTS:
+                    DoCast(me, SPELL_METEOR_FISTS);
+                    events.ScheduleEvent(EVENT_METEOR_FISTS, 45s);
+                    break;
+                case EVENT_FLAME_CINDER:
+                    DoCast(me, SPELL_FLAME_CINDER_A);
+                    events.ScheduleEvent(EVENT_FLAME_CINDER, 30s);
+                    break;
+                default:
+                    break;
             }
 
-            void TriggerFists(AuraEffect* aurEff, ProcEventInfo& eventInfo)
-            {
-                PreventDefaultAction();
-                GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_METEOR_FISTS_DAMAGE, aurEff);
-            }
-
-            void Register() override
-            {
-                OnEffectProc += AuraEffectProcFn(spell_koralon_meteor_fists_AuraScript::TriggerFists, EFFECT_0, SPELL_AURA_DUMMY);
-            }
-        };
-
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_koralon_meteor_fists_AuraScript();
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
-class spell_koralon_meteor_fists_damage : public SpellScriptLoader
+class spell_koralon_meteor_fists : public AuraScript
 {
-    public:
-        spell_koralon_meteor_fists_damage() : SpellScriptLoader("spell_koralon_meteor_fists_damage") { }
-
-        class spell_koralon_meteor_fists_damage_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_koralon_meteor_fists_damage_SpellScript);
-
-        public:
-            spell_koralon_meteor_fists_damage_SpellScript()
-            {
-                _chainTargets = 0;
-            }
-
-        private:
-            void FilterTargets(std::list<WorldObject*>& targets)
-            {
-                _chainTargets = uint8(targets.size());
-            }
-
-            void CalculateSplitDamage()
-            {
-                if (_chainTargets)
-                    SetHitDamage(GetHitDamage() / (_chainTargets + 1));
-            }
-
-            void Register() override
-            {
-                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_koralon_meteor_fists_damage_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_TARGET_ENEMY);
-                OnHit += SpellHitFn(spell_koralon_meteor_fists_damage_SpellScript::CalculateSplitDamage);
-            }
-
-        private:
-            uint8 _chainTargets;
-        };
-
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_koralon_meteor_fists_damage_SpellScript();
-        }
+    PrepareAuraScript(spell_koralon_meteor_fists);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_METEOR_FISTS_DAMAGE });
+    }
+
+    void TriggerFists(AuraEffect* aurEff, ProcEventInfo& eventInfo)
+    {
+        PreventDefaultAction();
+        GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_METEOR_FISTS_DAMAGE, aurEff);
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_koralon_meteor_fists::TriggerFists, EFFECT_0, SPELL_AURA_DUMMY);
+    }
 };
 
-class spell_flame_warder_meteor_fists : public SpellScriptLoader
+class spell_koralon_meteor_fists_damage : public SpellScript
 {
-    public:
-        spell_flame_warder_meteor_fists() : SpellScriptLoader("spell_flame_warder_meteor_fists") { }
-
-        class spell_flame_warder_meteor_fists_AuraScript : public AuraScript
-        {
-            PrepareAuraScript(spell_flame_warder_meteor_fists_AuraScript);
-
-            bool Validate(SpellInfo const* /*spellInfo*/) override
-            {
-                return ValidateSpellInfo({ SPELL_FW_METEOR_FISTS_DAMAGE });
-            }
-
-            void TriggerFists(AuraEffect* aurEff, ProcEventInfo& eventInfo)
-            {
-                PreventDefaultAction();
-                GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_FW_METEOR_FISTS_DAMAGE, aurEff);
-            }
-
-            void Register() override
-            {
-                OnEffectProc += AuraEffectProcFn(spell_flame_warder_meteor_fists_AuraScript::TriggerFists, EFFECT_0, SPELL_AURA_DUMMY);
-            }
-        };
+    PrepareSpellScript(spell_koralon_meteor_fists_damage);
+
+public:
+    spell_koralon_meteor_fists_damage()
+    {
+        _chainTargets = 0;
+    }
+
+private:
+    void FilterTargets(std::list<WorldObject*>& targets)
+    {
+        _chainTargets = uint8(targets.size());
+    }
+
+    void CalculateSplitDamage()
+    {
+        if (_chainTargets)
+            SetHitDamage(GetHitDamage() / (_chainTargets + 1));
+    }
+
+    void Register() override
+    {
+        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_koralon_meteor_fists_damage::FilterTargets, EFFECT_0, TARGET_UNIT_TARGET_ENEMY);
+        OnHit += SpellHitFn(spell_koralon_meteor_fists_damage::CalculateSplitDamage);
+    }
+
+private:
+    uint8 _chainTargets;
+};
 
-        AuraScript* GetAuraScript() const override
-        {
-            return new spell_flame_warder_meteor_fists_AuraScript();
-        }
+class spell_flame_warder_meteor_fists : public AuraScript
+{
+    PrepareAuraScript(spell_flame_warder_meteor_fists);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_FW_METEOR_FISTS_DAMAGE });
+    }
+
+    void TriggerFists(AuraEffect* aurEff, ProcEventInfo& eventInfo)
+    {
+        PreventDefaultAction();
+        GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_FW_METEOR_FISTS_DAMAGE, aurEff);
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_flame_warder_meteor_fists::TriggerFists, EFFECT_0, SPELL_AURA_DUMMY);
+    }
 };
 
 void AddSC_boss_koralon()
 {
-    new boss_koralon();
-    new spell_koralon_meteor_fists();
-    new spell_koralon_meteor_fists_damage();
-    new spell_flame_warder_meteor_fists();
+    RegisterVaultOfArchavonCreatureAI(boss_koralon);
+    RegisterSpellScript(spell_koralon_meteor_fists);
+    RegisterSpellScript(spell_koralon_meteor_fists_damage);
+    RegisterSpellScript(spell_flame_warder_meteor_fists);
 }