Scripts/Scholomance: Modernize scripts (#30920)

14 files changed, 1028 insertions, 1267 deletions

diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_darkmaster_gandling.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_darkmaster_gandling.cpp
index f8c7b97cb47..e4ca9095ca4 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_darkmaster_gandling.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_darkmaster_gandling.cpp
@@ -15,13 +15,6 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/*
-Name: Boss_Darkmaster_Gandling
-%Complete: 90
-Comment: Doors Not yet reopening.
-Category: Scholomance
-*/
-
 #include "ScriptMgr.h"
 #include "GameObject.h"
 #include "InstanceScript.h"
@@ -33,115 +26,106 @@ Category: Scholomance
 #include "SpellScript.h"
 #include "TemporarySummon.h"
 
-enum Says
+enum GandlingTexts
 {
-   YELL_SUMMONED                = 0
+    SAY_SUMMONED                 = 0
 };
 
-enum Spells
+enum GandlingSpells
 {
-    SPELL_ARCANEMISSILES        = 15790,
-    SPELL_SHADOWSHIELD          = 12040,
+    SPELL_ARCANE_MISSILES       = 15790,
+    SPELL_SHADOW_SHIELD         = 12040,
     SPELL_CURSE                 = 18702,
     SPELL_SHADOW_PORTAL         = 17950
 };
 
-enum Events
+enum GandlingEvents
 {
-    EVENT_ARCANEMISSILES        = 1,
-    EVENT_SHADOWSHIELD          = 2,
-    EVENT_CURSE                 = 3,
-    EVENT_SHADOW_PORTAL         = 4
+    EVENT_ARCANE_MISSILES = 1,
+    EVENT_SHADOW_SHIELD,
+    EVENT_CURSE,
+    EVENT_SHADOW_PORTAL
 };
 
-class boss_darkmaster_gandling : public CreatureScript
+// 1853 - Darkmaster Gandling
+struct boss_darkmaster_gandling : public BossAI
 {
-    public: boss_darkmaster_gandling() : CreatureScript("boss_darkmaster_gandling") { }
-
-        struct boss_darkmaster_gandlingAI : public BossAI
+    boss_darkmaster_gandling(Creature* creature) : BossAI(creature, DATA_DARKMASTER_GANDLING) { }
+
+    void Reset() override
+    {
+        _Reset();
+        if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
+            gate->SetGoState(GO_STATE_ACTIVE);
+    }
+
+    void JustDied(Unit* /*killer*/) override
+    {
+        _JustDied();
+        if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
+            gate->SetGoState(GO_STATE_ACTIVE);
+    }
+
+    void JustEngagedWith(Unit* who) override
+    {
+        BossAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_ARCANE_MISSILES, 4500ms);
+        events.ScheduleEvent(EVENT_SHADOW_SHIELD, 12s);
+        events.ScheduleEvent(EVENT_CURSE, 2s);
+        events.ScheduleEvent(EVENT_SHADOW_PORTAL, 15s);
+
+        if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
+            gate->SetGoState(GO_STATE_READY);
+    }
+
+    void IsSummonedBy(WorldObject* /*summoner*/) override
+    {
+        Talk(SAY_SUMMONED);
+        me->GetMotionMaster()->MoveRandom(5);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        events.Update(diff);
+
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
+
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            boss_darkmaster_gandlingAI(Creature* creature) : BossAI(creature, DATA_DARKMASTER_GANDLING) { }
-
-            void Reset() override
-            {
-                _Reset();
-                if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
-                    gate->SetGoState(GO_STATE_ACTIVE);
-            }
-
-            void JustDied(Unit* /*killer*/) override
-            {
-                _JustDied();
-                if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
-                    gate->SetGoState(GO_STATE_ACTIVE);
-            }
-
-            void JustEngagedWith(Unit* who) override
-            {
-                BossAI::JustEngagedWith(who);
-                events.ScheduleEvent(EVENT_ARCANEMISSILES, 4500ms);
-                events.ScheduleEvent(EVENT_SHADOWSHIELD, 12s);
-                events.ScheduleEvent(EVENT_CURSE, 2s);
-                events.ScheduleEvent(EVENT_SHADOW_PORTAL, 15s);
-
-                if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_GANDLING)))
-                    gate->SetGoState(GO_STATE_READY);
-            }
-
-            void IsSummonedBy(WorldObject* /*summoner*/) override
-            {
-                Talk(YELL_SUMMONED);
-                me->GetMotionMaster()->MoveRandom(5);
-            }
-
-            void UpdateAI(uint32 diff) override
+            switch (eventId)
             {
-                if (!UpdateVictim())
-                    return;
-
-                events.Update(diff);
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
+                case EVENT_ARCANE_MISSILES:
+                    DoCastVictim(SPELL_ARCANE_MISSILES);
+                    events.Repeat(8s);
+                    break;
+                case EVENT_SHADOW_SHIELD:
+                    DoCastSelf(SPELL_SHADOW_SHIELD);
+                    events.Repeat(14s, 28s);
+                    break;
+                case EVENT_CURSE:
+                    DoCastVictim(SPELL_CURSE);
+                    events.Repeat(15s, 27s);
+                    break;
+                case EVENT_SHADOW_PORTAL:
+                    if (HealthAbovePct(3))
                     {
-                        case EVENT_ARCANEMISSILES:
-                            DoCastVictim(SPELL_ARCANEMISSILES, true);
-                            events.ScheduleEvent(EVENT_ARCANEMISSILES, 8s);
-                            break;
-                        case EVENT_SHADOWSHIELD:
-                            DoCast(me, SPELL_SHADOWSHIELD);
-                            events.ScheduleEvent(EVENT_SHADOWSHIELD, 14s, 28s);
-                            break;
-                        case EVENT_CURSE:
-                            DoCastVictim(SPELL_CURSE, true);
-                            events.ScheduleEvent(EVENT_CURSE, 15s, 27s);
-                            break;
-                        case EVENT_SHADOW_PORTAL:
-                            if (HealthAbovePct(3))
-                            {
-                                DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOW_PORTAL, true);
-                                events.ScheduleEvent(EVENT_SHADOW_PORTAL, 17s, 27s);
-                            }
+                        DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOW_PORTAL);
+                        events.Repeat(17s, 27s);
                     }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-                DoMeleeAttackIfReady();
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_darkmaster_gandlingAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
-// Script for Shadow Portal spell 17950
 enum Rooms
 {
     ROOM_HALL_OF_SECRETS        = 0,
@@ -163,82 +147,71 @@ enum SPSpells
 };
 
 // 17950 - Shadow Portal
-class spell_shadow_portal : public SpellScriptLoader
+class spell_shadow_portal : public SpellScript
 {
-    public:
-        spell_shadow_portal() : SpellScriptLoader("spell_shadow_portal") { }
-
-        class spell_shadow_portal_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_shadow_portal_SpellScript);
-
-            bool Load() override
-            {
-                _instance = GetCaster()->GetInstanceScript();
-                return InstanceHasScript(GetCaster(), ScholomanceScriptName);
-            }
-
-            void HandleCast(SpellEffIndex /*effIndex*/)
-            {
-                Unit* caster = GetCaster();
-                uint8 attempts = 0;
-                uint32 spellId = 0;
+    PrepareSpellScript(spell_shadow_portal);
 
-                while (!spellId)
-                {
-                    if (attempts++ >= 6) break;
+    bool Load() override
+    {
+        _instance = GetCaster()->GetInstanceScript();
+        return InstanceHasScript(GetCaster(), ScholomanceScriptName);
+    }
 
-                    switch (urand(0, 5))
-                    {
-                        case ROOM_HALL_OF_SECRETS:
-                            if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_RAVENIAN)))
-                                if (go->GetGoState() == GO_STATE_ACTIVE)
-                                    spellId = SPELL_SHADOW_PORTAL_HALLOFSECRETS;
-                            break;
-                        case ROOM_HALL_OF_THE_DAMNED:
-                            if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_THEOLEN)))
-                                if (go->GetGoState() == GO_STATE_ACTIVE)
-                                    spellId = SPELL_SHADOW_PORTAL_HALLOFTHEDAMNED;
-                            break;
-                        case ROOM_THE_COVEN:
-                            if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_MALICIA)))
-                                if (go->GetGoState() == GO_STATE_ACTIVE)
-                                    spellId = SPELL_SHADOW_PORTAL_THECOVEN;
-                            break;
-                        case ROOM_THE_SHADOW_VAULT:
-                            if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_ILLUCIA)))
-                                if (go->GetGoState() == GO_STATE_ACTIVE)
-                                    spellId = SPELL_SHADOW_PORTAL_THESHADOWVAULT;
-                            break;
-                        case ROOM_BAROV_FAMILY_VAULT:
-                            if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_BAROV)))
-                                if (go->GetGoState() == GO_STATE_ACTIVE)
-                                    spellId = SPELL_SHADOW_PORTAL_BAROVFAMILYVAULT;
-                            break;
-                        case ROOM_VAULT_OF_THE_RAVENIAN:
-                            if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_POLKELT)))
-                                if (go->GetGoState() == GO_STATE_ACTIVE)
-                                    spellId = SPELL_SHADOW_PORTAL_VAULTOFTHERAVENIAN;
-                            break;
-                    }
+    void HandleCast(SpellEffIndex /*effIndex*/)
+    {
+        Unit* caster = GetCaster();
+        uint8 attempts = 0;
+        uint32 spellId = 0;
 
-                    if (spellId)
-                        GetHitUnit()->CastSpell(GetHitUnit(), spellId);
-                }
-            }
+        while (!spellId)
+        {
+            if (attempts++ >= 6) break;
 
-            void Register() override
+            switch (urand(0, 5))
             {
-                OnEffectHitTarget += SpellEffectFn(spell_shadow_portal_SpellScript::HandleCast, EFFECT_0, SPELL_EFFECT_DUMMY);
+                case ROOM_HALL_OF_SECRETS:
+                    if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_RAVENIAN)))
+                        if (go->GetGoState() == GO_STATE_ACTIVE)
+                            spellId = SPELL_SHADOW_PORTAL_HALLOFSECRETS;
+                    break;
+                case ROOM_HALL_OF_THE_DAMNED:
+                    if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_THEOLEN)))
+                        if (go->GetGoState() == GO_STATE_ACTIVE)
+                            spellId = SPELL_SHADOW_PORTAL_HALLOFTHEDAMNED;
+                    break;
+                case ROOM_THE_COVEN:
+                    if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_MALICIA)))
+                        if (go->GetGoState() == GO_STATE_ACTIVE)
+                            spellId = SPELL_SHADOW_PORTAL_THECOVEN;
+                    break;
+                case ROOM_THE_SHADOW_VAULT:
+                    if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_ILLUCIA)))
+                        if (go->GetGoState() == GO_STATE_ACTIVE)
+                            spellId = SPELL_SHADOW_PORTAL_THESHADOWVAULT;
+                    break;
+                case ROOM_BAROV_FAMILY_VAULT:
+                    if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_BAROV)))
+                        if (go->GetGoState() == GO_STATE_ACTIVE)
+                            spellId = SPELL_SHADOW_PORTAL_BAROVFAMILYVAULT;
+                    break;
+                case ROOM_VAULT_OF_THE_RAVENIAN:
+                    if (GameObject* go = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(GO_GATE_POLKELT)))
+                        if (go->GetGoState() == GO_STATE_ACTIVE)
+                            spellId = SPELL_SHADOW_PORTAL_VAULTOFTHERAVENIAN;
+                    break;
             }
 
-            InstanceScript* _instance = nullptr;
-        };
-
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_shadow_portal_SpellScript();
+            if (spellId)
+                GetHitUnit()->CastSpell(GetHitUnit(), spellId);
         }
+    }
+
+    void Register() override
+    {
+        OnEffectHitTarget += SpellEffectFn(spell_shadow_portal::HandleCast, EFFECT_0, SPELL_EFFECT_DUMMY);
+    }
+
+    InstanceScript* _instance = nullptr;
 };
 
 // Script for Shadow Portal spells 17863, 17939, 17943, 17944, 17946, 17948
@@ -282,100 +255,89 @@ enum ScriptEventId
 };
 
 // 17863, 17939, 17943, 17944, 17946, 17948 - Shadow Portal
-class spell_shadow_portal_rooms : public SpellScriptLoader
+class spell_shadow_portal_rooms : public SpellScript
 {
-    public:
-        spell_shadow_portal_rooms() : SpellScriptLoader("spell_shadow_portal_rooms") { }
+    PrepareSpellScript(spell_shadow_portal_rooms);
 
-        class spell_shadow_portal_rooms_SpellScript : public SpellScript
-        {
-            PrepareSpellScript(spell_shadow_portal_rooms_SpellScript);
-
-            bool Load() override
-            {
-                _instance = GetCaster()->GetInstanceScript();
-                return InstanceHasScript(GetCaster(), ScholomanceScriptName);
-            }
+    bool Load() override
+    {
+        _instance = GetCaster()->GetInstanceScript();
+        return InstanceHasScript(GetCaster(), ScholomanceScriptName);
+    }
 
-            void HandleSendEvent(SpellEffIndex /*effIndex*/)
-            {
-                // If only one player in threat list fail spell
+    void HandleSendEvent(SpellEffIndex /*effIndex*/)
+    {
+        // If only one player in threat list fail spell
 
-                Unit* caster = GetCaster();
+        Unit* caster = GetCaster();
 
-                int8 pos_to_summon = 0;
-                int8 phase_to_set = 0;
-                int32 gate_to_close = 0;
+        int8 pos_to_summon = 0;
+        int8 phase_to_set = 0;
+        int32 gate_to_close = 0;
 
-                switch (GetEffectInfo().MiscValue)
-                {
-                    case SPELL_EVENT_HALLOFSECRETS:
-                        pos_to_summon = 0; // Not yet spawned
-                        phase_to_set = 1;
-                        gate_to_close = GO_GATE_RAVENIAN;
-                        break;
-                    case SPELL_EVENT_HALLOFTHEDAMNED:
-                        pos_to_summon = 0;
-                        phase_to_set = 2;
-                        gate_to_close = GO_GATE_THEOLEN;
-                        break;
-                    case SPELL_EVENT_THECOVEN:
-                        pos_to_summon = 3;
-                        phase_to_set = 3;
-                        gate_to_close = GO_GATE_MALICIA;
-                        break;
-                    case SPELL_EVENT_THESHADOWVAULT:
-                        pos_to_summon = 6;
-                        phase_to_set = 4;
-                        gate_to_close = GO_GATE_ILLUCIA;
-                        break;
-                    case SPELL_EVENT_BAROVFAMILYVAULT:
-                        pos_to_summon = 9;
-                        phase_to_set = 5;
-                        gate_to_close = GO_GATE_BAROV;
-                        break;
-                    case SPELL_EVENT_VAULTOFTHERAVENIAN:
-                        pos_to_summon = 0; // Not yet spawned
-                        phase_to_set = 6;
-                        gate_to_close = GO_GATE_POLKELT;
-                        break;
-                    default:
-                        break;
-                }
+        switch (GetEffectInfo().MiscValue)
+        {
+            case SPELL_EVENT_HALLOFSECRETS:
+                pos_to_summon = 0; // Not yet spawned
+                phase_to_set = 1;
+                gate_to_close = GO_GATE_RAVENIAN;
+                break;
+            case SPELL_EVENT_HALLOFTHEDAMNED:
+                pos_to_summon = 0;
+                phase_to_set = 2;
+                gate_to_close = GO_GATE_THEOLEN;
+                break;
+            case SPELL_EVENT_THECOVEN:
+                pos_to_summon = 3;
+                phase_to_set = 3;
+                gate_to_close = GO_GATE_MALICIA;
+                break;
+            case SPELL_EVENT_THESHADOWVAULT:
+                pos_to_summon = 6;
+                phase_to_set = 4;
+                gate_to_close = GO_GATE_ILLUCIA;
+                break;
+            case SPELL_EVENT_BAROVFAMILYVAULT:
+                pos_to_summon = 9;
+                phase_to_set = 5;
+                gate_to_close = GO_GATE_BAROV;
+                break;
+            case SPELL_EVENT_VAULTOFTHERAVENIAN:
+                pos_to_summon = 0; // Not yet spawned
+                phase_to_set = 6;
+                gate_to_close = GO_GATE_POLKELT;
+                break;
+            default:
+                break;
+        }
 
-                if (gate_to_close)
+        if (gate_to_close)
+        {
+            for (uint8 i = 0; i < 3; ++i)
+            {
+                if (Creature* Summoned = caster->SummonCreature(NPC_RISEN_GUARDIAN, SummonPos[pos_to_summon++], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 2min))
                 {
-                    for (uint8 i = 0; i < 3; ++i)
-                    {
-                        if (Creature* Summoned = caster->SummonCreature(NPC_RISEN_GUARDIAN, SummonPos[pos_to_summon++], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 2min))
-                        {
-                            Summoned->GetMotionMaster()->MoveRandom(5);
-                            Summoned->AI()->SetData(0, phase_to_set);
-                        }
-                    }
-
-                    if (GameObject* gate = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(gate_to_close)))
-                        gate->SetGoState(GO_STATE_READY);
+                    Summoned->GetMotionMaster()->MoveRandom(5);
+                    Summoned->AI()->SetData(0, phase_to_set);
                 }
             }
 
-            void Register() override
-            {
-                OnEffectHit += SpellEffectFn(spell_shadow_portal_rooms_SpellScript::HandleSendEvent, EFFECT_1, SPELL_EFFECT_SEND_EVENT);
-            }
+            if (GameObject* gate = ObjectAccessor::GetGameObject(*caster, _instance->GetGuidData(gate_to_close)))
+                gate->SetGoState(GO_STATE_READY);
+        }
+    }
 
-            InstanceScript* _instance = nullptr;
-        };
+    void Register() override
+    {
+        OnEffectHit += SpellEffectFn(spell_shadow_portal_rooms::HandleSendEvent, EFFECT_1, SPELL_EFFECT_SEND_EVENT);
+    }
 
-        SpellScript* GetSpellScript() const override
-        {
-            return new spell_shadow_portal_rooms_SpellScript();
-        }
+    InstanceScript* _instance = nullptr;
 };
 
 void AddSC_boss_darkmaster_gandling()
 {
-    new boss_darkmaster_gandling();
-    new spell_shadow_portal();
-    new spell_shadow_portal_rooms();
+    RegisterScholomanceCreatureAI(boss_darkmaster_gandling);
+    RegisterSpellScript(spell_shadow_portal);
+    RegisterSpellScript(spell_shadow_portal_rooms);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_death_knight_darkreaver.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_death_knight_darkreaver.cpp
index 3672bf89ff4..af62380ba0e 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_death_knight_darkreaver.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_death_knight_darkreaver.cpp
@@ -15,49 +15,35 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* ScriptData
-SDName: Boss_Death_knight_darkreaver
-SD%Complete: 100
-SDComment:
-SDCategory: Scholomance
-EndScriptData */
-
 #include "ScriptMgr.h"
 #include "scholomance.h"
 #include "ScriptedCreature.h"
 
-class boss_death_knight_darkreaver : public CreatureScript
+enum DarkreaverSpells
 {
-public:
-    boss_death_knight_darkreaver() : CreatureScript("boss_death_knight_darkreaver") { }
+    SUMMON_FALLEN_CHARGER       = 23261
+};
 
-    CreatureAI* GetAI(Creature* creature) const override
+// 14516 - Death Knight Darkreaver
+struct boss_death_knight_darkreaver : public ScriptedAI
+{
+    boss_death_knight_darkreaver(Creature* creature) : ScriptedAI(creature) { }
+
+    void Reset() override
     {
-        return GetScholomanceAI<boss_death_knight_darkreaverAI>(creature);
     }
 
-    struct boss_death_knight_darkreaverAI : public ScriptedAI
+    void JustDied(Unit* /*killer*/) override
     {
-        boss_death_knight_darkreaverAI(Creature* creature) : ScriptedAI(creature) { }
-
-        void Reset() override
-        {
-        }
-
-        void DamageTaken(Unit* /*done_by*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
-        {
-            if (me->GetHealth() <= damage)
-                DoCast(me, 23261, true);   //Summon Darkreaver's Fallen Charger
-        }
-
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-        }
-    };
+        DoCastSelf(SUMMON_FALLEN_CHARGER, true);
+    }
 
+    void JustEngagedWith(Unit* /*who*/) override
+    {
+    }
 };
 
 void AddSC_boss_death_knight_darkreaver()
 {
-    new boss_death_knight_darkreaver();
+    RegisterScholomanceCreatureAI(boss_death_knight_darkreaver);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_doctor_theolen_krastinov.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_doctor_theolen_krastinov.cpp
index 56c78aa4162..74879b5dbd4 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_doctor_theolen_krastinov.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_doctor_theolen_krastinov.cpp
@@ -15,99 +15,82 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/*
-Name: Boss_Doctor_Theolen_Krastinov
-%Complete: 100
-Comment:
-Category: Scholomance
-*/
-
 #include "ScriptMgr.h"
 #include "scholomance.h"
 #include "ScriptedCreature.h"
 
-enum Say
+enum TheolenTexts
 {
-    EMOTE_FRENZY_KILL           = 0,
+    EMOTE_FRENZY_KILL           = 0
 };
 
-enum Spells
+enum TheolenSpells
 {
     SPELL_REND                  = 16509,
     SPELL_BACKHAND              = 18103,
     SPELL_FRENZY                = 8269
 };
 
-enum Events
+enum TheolenEvents
 {
-    EVENT_REND                  = 1,
-    EVENT_BACKHAND              = 2,
-    EVENT_FRENZY                = 3
+    EVENT_REND = 1,
+    EVENT_BACKHAND,
+    EVENT_FRENZY
 };
 
-class boss_doctor_theolen_krastinov : public CreatureScript
+// 11261 - Doctor Theolen Krastinov
+struct boss_doctor_theolen_krastinov : public BossAI
 {
-    public: boss_doctor_theolen_krastinov() : CreatureScript("boss_doctor_theolen_krastinov") { }
-
-        struct boss_theolenkrastinovAI : public BossAI
-        {
-            boss_theolenkrastinovAI(Creature* creature) : BossAI(creature, DATA_DOCTOR_THEOLEN_KRASTINOV) { }
-
-            void JustEngagedWith(Unit* who) override
-            {
-                BossAI::JustEngagedWith(who);
-                events.ScheduleEvent(EVENT_REND, 8s);
-                events.ScheduleEvent(EVENT_BACKHAND, 9s);
-                events.ScheduleEvent(EVENT_FRENZY, 1s);
-            }
-
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
+    boss_doctor_theolen_krastinov(Creature* creature) : BossAI(creature, DATA_DOCTOR_THEOLEN_KRASTINOV) { }
 
-                events.Update(diff);
+    void JustEngagedWith(Unit* who) override
+    {
+        BossAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_REND, 8s);
+        events.ScheduleEvent(EVENT_BACKHAND, 9s);
+        events.ScheduleEvent(EVENT_FRENZY, 1s);
+    }
 
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
-                    {
-                        case EVENT_REND:
-                            DoCastVictim(SPELL_REND, true);
-                            events.ScheduleEvent(EVENT_REND, 10s);
-                            break;
-                        case EVENT_BACKHAND:
-                            DoCastVictim(SPELL_BACKHAND, true);
-                            events.ScheduleEvent(EVENT_BACKHAND, 10s);
-                            break;
-                        case EVENT_FRENZY:
-                            DoCast(me, SPELL_FRENZY, true);
-                            Talk(EMOTE_FRENZY_KILL);
-                            events.ScheduleEvent(EVENT_FRENZY, 120s);
-                            break;
-                        default:
-                            break;
-                    }
+        events.Update(diff);
 
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-                DoMeleeAttackIfReady();
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
+            {
+                case EVENT_REND:
+                    DoCastVictim(SPELL_REND);
+                    events.Repeat(10s);
+                    break;
+                case EVENT_BACKHAND:
+                    DoCastVictim(SPELL_BACKHAND);
+                    events.Repeat(10s);
+                    break;
+                case EVENT_FRENZY:
+                    DoCastSelf(SPELL_FRENZY);
+                    Talk(EMOTE_FRENZY_KILL);
+                    events.Repeat(120s);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_theolenkrastinovAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
 
+        DoMeleeAttackIfReady();
+    }
 };
 
 void AddSC_boss_theolenkrastinov()
 {
-    new boss_doctor_theolen_krastinov();
+    RegisterScholomanceCreatureAI(boss_doctor_theolen_krastinov);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp
index 28e7529fa54..b9b40ee9aae 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp
@@ -15,100 +15,84 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/*
-Name: Boss_Illucia_Barov
-%Complete: 100
-Comment:
-Category: Scholomance
-*/
-
 #include "ScriptMgr.h"
 #include "scholomance.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum IlluciaSpells
 {
-    SPELL_CURSEOFAGONY          = 18671,
+    SPELL_CURSE_OF_AGONY        = 18671,
     SPELL_DOMINATE              = 7645, // UNUSED YET added for documentation
     SPELL_FEAR                  = 12542,
-    SPELL_SHADOWSHOCK           = 17234,
+    SPELL_SHADOW_SHOCK          = 17234,
     SPELL_SILENCE               = 12528
 };
 
-enum Events
+enum IlluciaEvents
 {
-    EVENT_CURSEOFAGONY          = 1,
-    EVENT_SHADOWSHOCK           = 2,
-    EVENT_SILENCE               = 3,
-    EVENT_FEAR                  = 4
+    EVENT_CURSE_OF_AGONY = 1,
+    EVENT_SHADOW_SHOCK,
+    EVENT_SILENCE,
+    EVENT_FEAR
 };
 
-class boss_illucia_barov : public CreatureScript
+// 10502 - Lady Illucia Barov
+struct boss_illucia_barov : public BossAI
 {
-    public: boss_illucia_barov() : CreatureScript("boss_illucia_barov") { }
+    boss_illucia_barov(Creature* creature) : BossAI(creature, DATA_LADY_ILLUCIA_BAROV) { }
 
-        struct boss_illuciabarovAI : public BossAI
-        {
-            boss_illuciabarovAI(Creature* creature) : BossAI(creature, DATA_LADY_ILLUCIA_BAROV) { }
+    void JustEngagedWith(Unit* who) override
+    {
+        BossAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_CURSE_OF_AGONY, 18s);
+        events.ScheduleEvent(EVENT_SHADOW_SHOCK, 9s);
+        events.ScheduleEvent(EVENT_SILENCE, 5s);
+        events.ScheduleEvent(EVENT_FEAR, 30s);
+    }
 
-            void JustEngagedWith(Unit* who) override
-            {
-                BossAI::JustEngagedWith(who);
-                events.ScheduleEvent(EVENT_CURSEOFAGONY, 18s);
-                events.ScheduleEvent(EVENT_SHADOWSHOCK, 9s);
-                events.ScheduleEvent(EVENT_SILENCE, 5s);
-                events.ScheduleEvent(EVENT_FEAR, 30s);
-            }
-
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
+    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)
-                    {
-                        case EVENT_CURSEOFAGONY:
-                            DoCastVictim(SPELL_CURSEOFAGONY, true);
-                            events.ScheduleEvent(EVENT_CURSEOFAGONY, 30s);
-                            break;
-                        case EVENT_SHADOWSHOCK:
-                            DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOWSHOCK, true);
-                            events.ScheduleEvent(EVENT_SHADOWSHOCK, 12s);
-                            break;
-                        case EVENT_SILENCE:
-                            DoCastVictim(SPELL_SILENCE, true);
-                            events.ScheduleEvent(EVENT_SILENCE, 14s);
-                            break;
-                        case EVENT_FEAR:
-                            DoCastVictim(SPELL_FEAR, true);
-                            events.ScheduleEvent(EVENT_FEAR, 30s);
-                            break;
-                        default:
-                            break;
-                    }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
+            {
+                case EVENT_CURSE_OF_AGONY:
+                    DoCastVictim(SPELL_CURSE_OF_AGONY);
+                    events.Repeat(30s);
+                    break;
+                case EVENT_SHADOW_SHOCK:
+                    DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_SHADOW_SHOCK);
+                    events.Repeat(12s);
+                    break;
+                case EVENT_SILENCE:
+                    DoCastSelf(SPELL_SILENCE);
+                    events.Repeat(14s);
+                    break;
+                case EVENT_FEAR:
+                    DoCastVictim(SPELL_FEAR);
+                    events.Repeat(30s);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_illuciabarovAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
 void AddSC_boss_illuciabarov()
 {
-    new boss_illucia_barov();
+    RegisterScholomanceCreatureAI(boss_illucia_barov);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp
index 9a8002b070f..df70433bfeb 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp
@@ -15,145 +15,128 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* ScriptData
-SDName: Boss_instructormalicia
-SD%Complete: 100
-SDComment:
-SDCategory: Scholomance
-EndScriptData */
-
 #include "ScriptMgr.h"
 #include "scholomance.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum MaliciaSpells
 {
-    SPELL_CALLOFGRAVES          = 17831,
+    SPELL_CALL_OF_GRAVES        = 17831,
     SPELL_CORRUPTION            = 11672,
-    SPELL_FLASHHEAL             = 10917,
+    SPELL_FLASH_HEAL            = 10917,
     SPELL_RENEW                 = 10929,
-    SPELL_HEALINGTOUCH          = 9889
+    SPELL_HEALING_TOUCH         = 9889
 };
 
-enum Events
+enum MaliciaEvents
 {
-    EVENT_CALLOFGRAVES          = 1,
-    EVENT_CORRUPTION            = 2,
-    EVENT_FLASHHEAL             = 3,
-    EVENT_RENEW                 = 4,
-    EVENT_HEALINGTOUCH          = 5
+    EVENT_CALL_OF_GRAVES = 1,
+    EVENT_CORRUPTION,
+    EVENT_FLASH_HEAL,
+    EVENT_RENEW,
+    EVENT_HEALING_TOUCH
 };
 
-class boss_instructor_malicia : public CreatureScript
+// 10505 - Instructor Malicia
+struct boss_instructor_malicia : public BossAI
 {
-    public: boss_instructor_malicia() : CreatureScript("boss_instructor_malicia") { }
-
-        struct boss_instructormaliciaAI : public BossAI
+    boss_instructor_malicia(Creature* creature) : BossAI(creature, DATA_INSTRUCTOR_MALICIA)
+    {
+        Initialize();
+    }
+
+    void Initialize()
+    {
+        FlashCounter = 0;
+        TouchCounter = 0;
+    }
+
+    uint32 FlashCounter;
+    uint32 TouchCounter;
+
+    void Reset() override
+    {
+        _Reset();
+        Initialize();
+    }
+
+    void JustEngagedWith(Unit* who) override
+    {
+        BossAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_CALL_OF_GRAVES, 4s);
+        events.ScheduleEvent(EVENT_CORRUPTION, 8s);
+        events.ScheduleEvent(EVENT_RENEW, 32s);
+        events.ScheduleEvent(EVENT_FLASH_HEAL, 38s);
+        events.ScheduleEvent(EVENT_HEALING_TOUCH, 45s);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        events.Update(diff);
+
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
+
+        while (uint32 eventId = events.ExecuteEvent())
         {
-            boss_instructormaliciaAI(Creature* creature) : BossAI(creature, DATA_INSTRUCTOR_MALICIA)
-            {
-                Initialize();
-            }
-
-            void Initialize()
-            {
-                FlashCounter = 0;
-                TouchCounter = 0;
-            }
-
-            uint32 FlashCounter;
-            uint32 TouchCounter;
-
-            void Reset() override
+            switch (eventId)
             {
-                _Reset();
-                Initialize();
-            }
-
-            void JustEngagedWith(Unit* who) override
-            {
-                BossAI::JustEngagedWith(who);
-                events.ScheduleEvent(EVENT_CALLOFGRAVES, 4s);
-                events.ScheduleEvent(EVENT_CORRUPTION, 8s);
-                events.ScheduleEvent(EVENT_RENEW, 32s);
-                events.ScheduleEvent(EVENT_FLASHHEAL, 38s);
-                events.ScheduleEvent(EVENT_HEALINGTOUCH, 45s);
-            }
-
-            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_CALL_OF_GRAVES:
+                    DoCastSelf(SPELL_CALL_OF_GRAVES);
+                    events.Repeat(65s);
+                    break;
+                case EVENT_CORRUPTION:
+                    DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_CORRUPTION);
+                    events.Repeat(24s);
+                    break;
+                case EVENT_RENEW:
+                    DoCastSelf(SPELL_RENEW);
+                    events.Repeat(10s);
+                    break;
+                case EVENT_FLASH_HEAL:
+                    // 5 Flash Heal will be cast
+                    DoCastSelf(SPELL_FLASH_HEAL);
+                    if (FlashCounter < 2)
                     {
-                        case EVENT_CALLOFGRAVES:
-                            DoCastVictim(SPELL_CALLOFGRAVES, true);
-                            events.ScheduleEvent(EVENT_CALLOFGRAVES, 65s);
-                            break;
-                        case EVENT_CORRUPTION:
-                            DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_CORRUPTION, true);
-                            events.ScheduleEvent(EVENT_CORRUPTION, 24s);
-                            break;
-                        case EVENT_RENEW:
-                            DoCast(me, SPELL_RENEW);
-                            events.ScheduleEvent(EVENT_RENEW, 10s);
-                            break;
-                        case EVENT_FLASHHEAL:
-                            //5 Flashheals will be cast
-                            DoCast(me, SPELL_FLASHHEAL);
-                            if (FlashCounter < 2)
-                            {
-                                events.ScheduleEvent(EVENT_FLASHHEAL, 5s);
-                                ++FlashCounter;
-                            }
-                            else
-                            {
-                                FlashCounter=0;
-                                events.ScheduleEvent(EVENT_FLASHHEAL, 30s);
-                            }
-                            break;
-                        case EVENT_HEALINGTOUCH:
-                            //3 Healing Touch will be cast
-                            DoCast(me, SPELL_HEALINGTOUCH);
-                            if (TouchCounter < 2)
-                            {
-                                events.ScheduleEvent(EVENT_HEALINGTOUCH, 5500ms);
-                                ++TouchCounter;
-                            }
-                            else
-                            {
-                                TouchCounter=0;
-                                events.ScheduleEvent(EVENT_HEALINGTOUCH, 30s);
-                            }
-                            break;
-                        default:
-                            break;
+                        events.ScheduleEvent(EVENT_FLASH_HEAL, 5s);
+                        ++FlashCounter;
                     }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+                    else
+                    {
+                        FlashCounter=0;
+                        events.ScheduleEvent(EVENT_FLASH_HEAL, 30s);
+                    }
+                    break;
+                case EVENT_HEALING_TOUCH:
+                    // 3 Healing Touch will be cast
+                    DoCastSelf(SPELL_HEALING_TOUCH);
+                    if (TouchCounter < 2)
+                    {
+                        events.ScheduleEvent(EVENT_HEALING_TOUCH, 5500ms);
+                        ++TouchCounter;
+                    }
+                    else
+                    {
+                        TouchCounter=0;
+                        events.ScheduleEvent(EVENT_HEALING_TOUCH, 30s);
+                    }
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_instructormaliciaAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
 
+        DoMeleeAttackIfReady();
+    }
 };
 
 void AddSC_boss_instructormalicia()
 {
-    new boss_instructor_malicia();
+    RegisterScholomanceCreatureAI(boss_instructor_malicia);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_jandice_barov.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_jandice_barov.cpp
index 97a0d1fa435..32f7e0cd2cb 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_jandice_barov.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_jandice_barov.cpp
@@ -19,14 +19,14 @@
 #include "scholomance.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum JandiceSpells
 {
     SPELL_CURSE_OF_BLOOD        = 24673,
     SPELL_ILLUSION              = 17773,
     SPELL_DROP_JOURNAL          = 26096
 };
 
-enum Events
+enum JandiceEvents
 {
     EVENT_CURSE_OF_BLOOD = 1,
     EVENT_ILLUSION,
@@ -34,95 +34,85 @@ enum Events
     EVENT_SET_VISIBILITY
 };
 
-class boss_jandice_barov : public CreatureScript
+// 10503 - Jandice Barov
+struct boss_jandice_barov : public ScriptedAI
 {
-public:
-    boss_jandice_barov() : CreatureScript("boss_jandice_barov") { }
+    boss_jandice_barov(Creature* creature) : ScriptedAI(creature), _summons(me) { }
 
-    struct boss_jandicebarovAI : public ScriptedAI
+    void Reset() override
     {
-        boss_jandicebarovAI(Creature* creature) : ScriptedAI(creature), Summons(me) { }
-
-        void Reset() override
-        {
-            events.Reset();
-            Summons.DespawnAll();
-        }
+        _events.Reset();
+        _summons.DespawnAll();
+    }
 
-        void JustSummoned(Creature* summoned) override
-        {
-            // Illusions should attack a random target.
-            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                summoned->AI()->AttackStart(target);
+    void JustSummoned(Creature* summoned) override
+    {
+        // Illusions should attack a random target.
+        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+            summoned->AI()->AttackStart(target);
 
-            Summons.Summon(summoned);
-        }
+        _summons.Summon(summoned);
+    }
 
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-            events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 15s);
-            events.ScheduleEvent(EVENT_ILLUSION, 30s);
-        }
+    void JustEngagedWith(Unit* /*who*/) override
+    {
+        _events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 15s);
+        _events.ScheduleEvent(EVENT_ILLUSION, 30s);
+    }
 
-        void JustDied(Unit* /*killer*/) override
-        {
-            Summons.DespawnAll();
-            DoCastSelf(SPELL_DROP_JOURNAL, true);
-        }
+    void JustDied(Unit* /*killer*/) override
+    {
+        _summons.DespawnAll();
+        DoCastSelf(SPELL_DROP_JOURNAL, true);
+    }
 
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
+    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())
+        while (uint32 eventId = _events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_CURSE_OF_BLOOD:
-                        DoCastVictim(SPELL_CURSE_OF_BLOOD);
-                        events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 30s);
-                        break;
-                    case EVENT_ILLUSION:
-                        DoCast(SPELL_ILLUSION);
-                        me->SetUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
-                        me->SetDisplayId(11686);  // Invisible Model
-                        ModifyThreatByPercent(me->GetVictim(), -99);
-                        events.ScheduleEvent(EVENT_SET_VISIBILITY, 3s);
-                        events.ScheduleEvent(EVENT_ILLUSION, 25s);
-                        break;
-                    case EVENT_SET_VISIBILITY:
-                        me->RemoveUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
-                        me->SetDisplayId(11073);     //Jandice Model
-                        break;
-                    default:
-                        break;
-                }
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
+                case EVENT_CURSE_OF_BLOOD:
+                    DoCastVictim(SPELL_CURSE_OF_BLOOD);
+                    _events.Repeat(30s);
+                    break;
+                case EVENT_ILLUSION:
+                    DoCast(SPELL_ILLUSION);
+                    me->SetUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
+                    me->SetDisplayId(11686);  // Invisible Model
+                    ModifyThreatByPercent(me->GetVictim(), -99);
+                    _events.ScheduleEvent(EVENT_SET_VISIBILITY, 3s);
+                    _events.Repeat(25s);
+                    break;
+                case EVENT_SET_VISIBILITY:
+                    me->RemoveUnitFlag(UNIT_FLAG_UNINTERACTIBLE);
+                    me->SetDisplayId(11073);     // Jandice Model
+                    break;
+                default:
+                    break;
             }
 
-            DoMeleeAttackIfReady();
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
 
-    private:
-        EventMap events;
-        SummonList Summons;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetScholomanceAI<boss_jandicebarovAI>(creature);
+        DoMeleeAttackIfReady();
     }
+
+private:
+    EventMap _events;
+    SummonList _summons;
 };
 
 void AddSC_boss_jandicebarov()
 {
-    new boss_jandice_barov();
+    RegisterScholomanceCreatureAI(boss_jandice_barov);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_kirtonos_the_herald.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_kirtonos_the_herald.cpp
index 05ec449e8d1..7e2640da7c3 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_kirtonos_the_herald.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_kirtonos_the_herald.cpp
@@ -26,12 +26,12 @@
 #include "scholomance.h"
 #include "ScriptedCreature.h"
 
-enum Says
+enum KirtonosTexts
 {
    EMOTE_SUMMONED                     = 0
 };
 
-enum Spells
+enum KirtonosSpells
 {
     SPELL_SWOOP                       = 18144,
     SPELL_WING_FLAP                   = 12882,
@@ -43,7 +43,7 @@ enum Spells
     SPELL_DOMINATE_MIND               = 14515
 };
 
-enum Events
+enum KirtonosEvents
 {
     INTRO_1                           = 1,
     INTRO_2                           = 2,
@@ -61,7 +61,7 @@ enum Events
     EVENT_KIRTONOS_TRANSFORM          = 14
 };
 
-enum Misc
+enum KirtonosMisc
 {
     WEAPON_KIRTONOS_STAFF             = 11365,
     POINT_KIRTONOS_LAND               = 13,
@@ -74,197 +74,184 @@ Position const PosMove[2] =
     { 314.8673f, 90.30210f, 101.6459f, 0.0f }
 };
 
-class boss_kirtonos_the_herald : public CreatureScript
+// 10506 - Kirtonos the Herald
+struct boss_kirtonos_the_herald : public BossAI
 {
-    public: boss_kirtonos_the_herald() : CreatureScript("boss_kirtonos_the_herald") { }
+    boss_kirtonos_the_herald(Creature* creature) : BossAI(creature, DATA_KIRTONOS) { }
 
-        struct boss_kirtonos_the_heraldAI : public BossAI
+    void Reset() override
+    {
+        _Reset();
+    }
+
+    void JustEngagedWith(Unit* who) override
+    {
+        events.ScheduleEvent(EVENT_SWOOP, 8s, 8s);
+        events.ScheduleEvent(EVENT_WING_FLAP, 15s, 15s);
+        events.ScheduleEvent(EVENT_PIERCE_ARMOR, 18s, 18s);
+        events.ScheduleEvent(EVENT_DISARM, 22s, 22s);
+        events.ScheduleEvent(EVENT_SHADOW_BOLT, 42s, 42s);
+        events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 53s, 53s);
+        events.ScheduleEvent(EVENT_DOMINATE_MIND, 34s, 48s);
+        events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 20s, 20s);
+        BossAI::JustEngagedWith(who);
+    }
+
+    void JustDied(Unit* /*killer*/) override
+    {
+        if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
+            gate->SetGoState(GO_STATE_ACTIVE);
+        if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
         {
-            boss_kirtonos_the_heraldAI(Creature* creature) : BossAI(creature, DATA_KIRTONOS) { }
+            brazier->ResetDoorOrButton();
+            brazier->SetGoState(GO_STATE_READY);
+        }
+        _JustDied();
+    }
 
-            void Reset() override
-            {
-                _Reset();
-            }
+    void EnterEvadeMode(EvadeReason /*why*/) override
+    {
+        if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
+            gate->SetGoState(GO_STATE_ACTIVE);
+        if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
+        {
+            brazier->ResetDoorOrButton();
+            brazier->SetGoState(GO_STATE_READY);
+        }
+        me->DespawnOrUnsummon(5s);
+    }
 
-            void JustEngagedWith(Unit* who) override
-            {
-                events.ScheduleEvent(EVENT_SWOOP, 8s, 8s);
-                events.ScheduleEvent(EVENT_WING_FLAP, 15s, 15s);
-                events.ScheduleEvent(EVENT_PIERCE_ARMOR, 18s, 18s);
-                events.ScheduleEvent(EVENT_DISARM, 22s, 22s);
-                events.ScheduleEvent(EVENT_SHADOW_BOLT, 42s, 42s);
-                events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 53s, 53s);
-                events.ScheduleEvent(EVENT_DOMINATE_MIND, 34s, 48s);
-                events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 20s, 20s);
-                BossAI::JustEngagedWith(who);
-            }
+    void IsSummonedBy(WorldObject* /*summoner*/) override
+    {
+        events.ScheduleEvent(INTRO_1, 500ms);
+        me->SetDisableGravity(true);
+        me->SetReactState(REACT_PASSIVE);
+        me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
+        Talk(EMOTE_SUMMONED);
+    }
 
-            void JustDied(Unit* /*killer*/) override
-            {
-                if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
-                    gate->SetGoState(GO_STATE_ACTIVE);
-                if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
-                {
-                    brazier->ResetDoorOrButton();
-                    brazier->SetGoState(GO_STATE_READY);
-                }
-                _JustDied();
-            }
+    void JustSummoned(Creature* summon) override
+    {
+        BossAI::JustSummoned(summon);
+    }
+
+    void MovementInform(uint32 type, uint32 id) override
+    {
+        if (type == WAYPOINT_MOTION_TYPE && id == POINT_KIRTONOS_LAND)
+            events.ScheduleEvent(INTRO_2, 1500ms);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        events.Update(diff);
 
-            void EnterEvadeMode(EvadeReason /*why*/) override
+        if (!UpdateVictim())
+        {
+            while (uint32 eventId = events.ExecuteEvent())
             {
-                if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
-                    gate->SetGoState(GO_STATE_ACTIVE);
-                if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
+                switch (eventId)
                 {
-                    brazier->ResetDoorOrButton();
-                    brazier->SetGoState(GO_STATE_READY);
+                    case INTRO_1:
+                        me->GetMotionMaster()->MovePath(KIRTONOS_PATH, false);
+                        break;
+                    case INTRO_2:
+                        me->GetMotionMaster()->MovePoint(0, PosMove[0]);
+                        events.ScheduleEvent(INTRO_3, 1s);
+                        break;
+                    case INTRO_3:
+                        if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
+                            gate->SetGoState(GO_STATE_READY);
+                        me->SetFacingTo(0.01745329f);
+                        events.ScheduleEvent(INTRO_4, 3s);
+                        break;
+                    case INTRO_4:
+                        if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
+                            brazier->SetGoState(GO_STATE_READY);
+                        me->SetWalk(true);
+                        me->SetDisableGravity(false);
+                        DoCast(me, SPELL_KIRTONOS_TRANSFORM);
+                        me->SetCanFly(false);
+                        events.ScheduleEvent(INTRO_5, 1s);
+                        break;
+                    case INTRO_5:
+                        me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
+                        me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
+                        me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
+                        me->SetReactState(REACT_AGGRESSIVE);
+                        events.ScheduleEvent(INTRO_6, 5s);
+                        break;
+                    case INTRO_6:
+                        me->GetMotionMaster()->MovePoint(0, PosMove[1]);
+                        break;
+                    default:
+                        break;
                 }
-                me->DespawnOrUnsummon(5s);
             }
 
-            void IsSummonedBy(WorldObject* /*summoner*/) override
-            {
-                events.ScheduleEvent(INTRO_1, 500ms);
-                me->SetDisableGravity(true);
-                me->SetReactState(REACT_PASSIVE);
-                me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
-                Talk(EMOTE_SUMMONED);
-            }
+            return;
+        }
 
-            void JustSummoned(Creature* summon) override
-            {
-                BossAI::JustSummoned(summon);
-            }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-            void MovementInform(uint32 type, uint32 id) override
-            {
-                if (type == WAYPOINT_MOTION_TYPE && id == POINT_KIRTONOS_LAND)
-                    events.ScheduleEvent(INTRO_2, 1500ms);
-            }
-
-            void UpdateAI(uint32 diff) override
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                events.Update(diff);
-
-                if (!UpdateVictim())
-                {
-                    while (uint32 eventId = events.ExecuteEvent())
+                case EVENT_SWOOP:
+                    DoCastVictim(SPELL_SWOOP);
+                    events.Repeat(15s);
+                    break;
+                case EVENT_WING_FLAP:
+                    DoCastSelf(SPELL_WING_FLAP);
+                    events.Repeat(13s);
+                    break;
+                case EVENT_PIERCE_ARMOR:
+                    DoCastVictim(SPELL_PIERCE_ARMOR);
+                    events.Repeat(12s);
+                    break;
+                case EVENT_DISARM:
+                    DoCastVictim(SPELL_DISARM);
+                    events.Repeat(11s);
+                    break;
+                case EVENT_SHADOW_BOLT:
+                    DoCastVictim(SPELL_SHADOW_BOLT);
+                    events.Repeat(42s);
+                    break;
+                case EVENT_CURSE_OF_TONGUES:
+                    DoCastVictim(SPELL_CURSE_OF_TONGUES);
+                    events.Repeat(35s);
+                    break;
+                case EVENT_DOMINATE_MIND:
+                    DoCastVictim(SPELL_DOMINATE_MIND);
+                    events.Repeat(44s, 48s);
+                    break;
+                case EVENT_KIRTONOS_TRANSFORM:
+                    if (me->HasAura(SPELL_KIRTONOS_TRANSFORM))
                     {
-                        switch (eventId)
-                        {
-                            case INTRO_1:
-                                me->GetMotionMaster()->MovePath(KIRTONOS_PATH, false);
-                                break;
-                            case INTRO_2:
-                                me->GetMotionMaster()->MovePoint(0, PosMove[0]);
-                                events.ScheduleEvent(INTRO_3, 1s);
-                                break;
-                            case INTRO_3:
-                                if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
-                                    gate->SetGoState(GO_STATE_READY);
-                                me->SetFacingTo(0.01745329f);
-                                events.ScheduleEvent(INTRO_4, 3s);
-                                break;
-                            case INTRO_4:
-                                if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
-                                    brazier->SetGoState(GO_STATE_READY);
-                                me->SetWalk(true);
-                                me->SetDisableGravity(false);
-                                DoCast(me, SPELL_KIRTONOS_TRANSFORM);
-                                me->SetCanFly(false);
-                                events.ScheduleEvent(INTRO_5, 1s);
-                                break;
-                            case INTRO_5:
-                                me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
-                                me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
-                                me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_UNINTERACTIBLE);
-                                me->SetReactState(REACT_AGGRESSIVE);
-                                events.ScheduleEvent(INTRO_6, 5s);
-                                break;
-                            case INTRO_6:
-                                me->GetMotionMaster()->MovePoint(0, PosMove[1]);
-                                break;
-                            default:
-                                break;
-                        }
+                        me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
+                        me->SetVirtualItem(0, uint32(0));
+                        me->SetCanFly(false);
                     }
-
-                    return;
-                }
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
+                    else
                     {
-                        case EVENT_SWOOP:
-                            DoCast(me, SPELL_SWOOP);
-                            events.ScheduleEvent(EVENT_SWOOP, 15s);
-                            break;
-                        case EVENT_WING_FLAP:
-                            DoCast(me, SPELL_WING_FLAP);
-                            events.ScheduleEvent(EVENT_WING_FLAP, 13s);
-                            break;
-                        case EVENT_PIERCE_ARMOR:
-                            DoCastVictim(SPELL_PIERCE_ARMOR, true);
-                            events.ScheduleEvent(EVENT_PIERCE_ARMOR, 12s);
-                            break;
-                        case EVENT_DISARM:
-                            DoCastVictim(SPELL_DISARM, true);
-                            events.ScheduleEvent(EVENT_DISARM, 11s);
-                            break;
-                        case EVENT_SHADOW_BOLT:
-                            DoCastVictim(SPELL_SHADOW_BOLT, true);
-                            events.ScheduleEvent(EVENT_SHADOW_BOLT, 42s);
-                            break;
-                        case EVENT_CURSE_OF_TONGUES:
-                            DoCastVictim(SPELL_CURSE_OF_TONGUES, true);
-                            events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 35s);
-                            break;
-                        case EVENT_DOMINATE_MIND:
-                            DoCastVictim(SPELL_DOMINATE_MIND, true);
-                            events.ScheduleEvent(EVENT_DOMINATE_MIND, 44s, 48s);
-                            break;
-                        case EVENT_KIRTONOS_TRANSFORM:
-                            if (me->HasAura(SPELL_KIRTONOS_TRANSFORM))
-                            {
-                                me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
-                                me->SetVirtualItem(0, uint32(0));
-                                me->SetCanFly(false);
-                            }
-                            else
-                            {
-                                DoCast(me, SPELL_KIRTONOS_TRANSFORM);
-                                me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
-                                me->SetCanFly(true);
-                            }
-                            events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 16s, 18s);
-                            break;
-                        default:
-                            break;
+                        DoCast(me, SPELL_KIRTONOS_TRANSFORM);
+                        me->SetVirtualItem(0, uint32(WEAPON_KIRTONOS_STAFF));
+                        me->SetCanFly(true);
                     }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+                    events.Repeat(16s, 18s);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_kirtonos_the_heraldAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
-};
 
-/*######
-## go_brazier_of_the_herald
-######*/
+        DoMeleeAttackIfReady();
+    }
+};
 
 enum Brazier_Of_The_Herald
 {
@@ -277,32 +264,21 @@ Position const PosSummon[1] =
     { 315.028f, 70.53845f, 102.1496f, 0.3859715f }
 };
 
-class go_brazier_of_the_herald : public GameObjectScript
+struct go_brazier_of_the_herald : public GameObjectAI
 {
-    public:
-        go_brazier_of_the_herald() : GameObjectScript("go_brazier_of_the_herald") { }
-
-        struct go_brazier_of_the_heraldAI : public GameObjectAI
-        {
-            go_brazier_of_the_heraldAI(GameObject* go) : GameObjectAI(go) { }
+    go_brazier_of_the_herald(GameObject* go) : GameObjectAI(go) { }
 
-            bool OnGossipHello(Player* player) override
-            {
-                me->UseDoorOrButton();
-                me->PlayDirectSound(SOUND_SCREECH, 0);
-                player->SummonCreature(NPC_KIRTONOS, PosSummon[0], TEMPSUMMON_DEAD_DESPAWN, 15min);
-                return true;
-            }
-        };
-
-        GameObjectAI* GetAI(GameObject* go) const override
-        {
-            return GetScholomanceAI<go_brazier_of_the_heraldAI>(go);
-        }
+    bool OnGossipHello(Player* player) override
+    {
+        me->UseDoorOrButton();
+        me->PlayDirectSound(SOUND_SCREECH, 0);
+        player->SummonCreature(NPC_KIRTONOS, PosSummon[0], TEMPSUMMON_DEAD_DESPAWN, 15min);
+        return true;
+    }
 };
 
 void AddSC_boss_kirtonos_the_herald()
 {
-    new boss_kirtonos_the_herald();
-    new go_brazier_of_the_herald;
+    RegisterScholomanceCreatureAI(boss_kirtonos_the_herald);
+    RegisterScholomanceGameObjectAI(go_brazier_of_the_herald);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_kormok.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_kormok.cpp
index b5fd8141e25..e9f35b087fb 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_kormok.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_kormok.cpp
@@ -20,201 +20,167 @@
 #include "ScriptedCreature.h"
 #include "SpellScript.h"
 
-enum Spells
+enum KormokSpells
 {
     SPELL_SHADOWBOLT_VOLLEY             = 20741,
     SPELL_BONE_SHIELD                   = 27688,
 
     SPELL_SUMMON_BONE_MAGES             = 27695,
-
     SPELL_SUMMON_BONE_MAGE_FRONT_LEFT   = 27696,
     SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT  = 27697,
     SPELL_SUMMON_BONE_MAGE_BACK_RIGHT   = 27698,
     SPELL_SUMMON_BONE_MAGE_BACK_LEFT    = 27699,
 
-    SPELL_SUMMON_BONE_MINIONS           = 27687
+    SPELL_SUMMON_BONE_MINIONS           = 27687,
+    SPELL_SUMMON_BONE_MINION_FRONT      = 27690,
+    SPELL_SUMMON_BONE_MINION_BACK       = 27691,
+    SPELL_SUMMON_BONE_MINION_LEFT       = 27692,
+    SPELL_SUMMON_BONE_MINION_RIGHT      = 27693
 };
 
-enum Events
+enum KormokEvents
 {
     EVENT_SHADOWBOLT_VOLLEY = 1,
     EVENT_BONE_SHIELD,
+    EVENT_SUMMON_MAGES,
     EVENT_SUMMON_MINIONS
 };
 
-class boss_kormok : public CreatureScript
+// 16118 - Kormok
+struct boss_kormok : public ScriptedAI
 {
-public:
-    boss_kormok() : CreatureScript("boss_kormok") { }
+    boss_kormok(Creature* creature) : ScriptedAI(creature) { }
 
-    struct boss_kormokAI : public ScriptedAI
+    void Reset() override
     {
-        boss_kormokAI(Creature* creature) : ScriptedAI(creature)
-        {
-            Initialize();
-        }
+        _events.Reset();
+    }
 
-        void Initialize()
-        {
-            Mages = false;
-        }
+    void JustEngagedWith(Unit* /*who*/) override
+    {
+        _events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, 10s);
+        _events.ScheduleEvent(EVENT_BONE_SHIELD, 2s);
+        _events.ScheduleEvent(EVENT_SUMMON_MAGES, 10s, 15s);
+        _events.ScheduleEvent(EVENT_SUMMON_MINIONS, 5s, 10s);
+    }
 
-        void Reset() override
-        {
-            Initialize();
-            events.Reset();
-        }
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-            events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, 10s);
-            events.ScheduleEvent(EVENT_BONE_SHIELD, 2s);
-            events.ScheduleEvent(EVENT_SUMMON_MINIONS, 15s);
-        }
+        _events.Update(diff);
 
-        void JustSummoned(Creature* summoned) override
-        {
-            summoned->AI()->AttackStart(me->GetVictim());
-        }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-        void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
+        while (uint32 eventId = _events.ExecuteEvent())
         {
-            if (me->HealthBelowPctDamaged(25, damage) && !Mages)
+            switch (eventId)
             {
-                DoCast(SPELL_SUMMON_BONE_MAGES);
-                Mages = true;
+                case EVENT_SHADOWBOLT_VOLLEY:
+                    DoCastSelf(SPELL_SHADOWBOLT_VOLLEY);
+                    _events.Repeat(15s);
+                    break;
+                case EVENT_BONE_SHIELD:
+                    DoCastSelf(SPELL_BONE_SHIELD);
+                    _events.Repeat(45s);
+                    break;
+                case EVENT_SUMMON_MAGES:
+                    DoCastSelf(SPELL_SUMMON_BONE_MAGES);
+                    _events.Repeat(10s, 15s);
+                    break;
+                case EVENT_SUMMON_MINIONS:
+                    DoCastSelf(SPELL_SUMMON_BONE_MINIONS);
+                    _events.Repeat(20s, 25s);
+                    break;
+                default:
+                    break;
             }
-        }
-
-        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_SHADOWBOLT_VOLLEY:
-                        DoCastVictim(SPELL_SHADOWBOLT_VOLLEY);
-                        events.ScheduleEvent(EVENT_SHADOWBOLT_VOLLEY, 15s);
-                        break;
-                    case EVENT_BONE_SHIELD:
-                        DoCastVictim(SPELL_BONE_SHIELD);
-                        events.ScheduleEvent(EVENT_BONE_SHIELD, 45s);
-                        break;
-                    case EVENT_SUMMON_MINIONS:
-                        DoCast(SPELL_SUMMON_BONE_MINIONS);
-                        events.ScheduleEvent(EVENT_SUMMON_MINIONS, 12s);
-                        break;
-                    default:
-                        break;
-                }
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
-            }
-
-            DoMeleeAttackIfReady();
         }
 
-        private:
-            EventMap events;
-            bool Mages;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetScholomanceAI<boss_kormokAI>(creature);
+        DoMeleeAttackIfReady();
     }
-};
 
-uint32 const SummonMageSpells[4] =
-{
-    SPELL_SUMMON_BONE_MAGE_FRONT_LEFT,
-    SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT,
-    SPELL_SUMMON_BONE_MAGE_BACK_RIGHT,
-    SPELL_SUMMON_BONE_MAGE_BACK_LEFT,
+private:
+    EventMap _events;
 };
 
 // 27695 - Summon Bone Mages
-class spell_kormok_summon_bone_mages : SpellScriptLoader
+class spell_kormok_summon_bone_mages : public SpellScript
 {
-    public:
-        spell_kormok_summon_bone_mages() : SpellScriptLoader("spell_kormok_summon_bone_mages") { }
+    PrepareSpellScript(spell_kormok_summon_bone_mages);
 
-        class spell_kormok_summon_bone_magesSpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spell*/) override
+    {
+        return ValidateSpellInfo(
         {
-            PrepareSpellScript(spell_kormok_summon_bone_magesSpellScript);
-
-            bool Validate(SpellInfo const* /*spell*/) override
-            {
-                return ValidateSpellInfo(SummonMageSpells);
-            }
-
-            void HandleScript(SpellEffIndex effIndex)
-            {
-                PreventHitDefaultEffect(effIndex);
-                for (uint32 i = 0; i < 2; ++i)
-                    GetCaster()->CastSpell(GetCaster(), SummonMageSpells[urand(0, 3)], true);
-            }
-
-            void Register() override
-            {
-                OnEffectHitTarget += SpellEffectFn(spell_kormok_summon_bone_magesSpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
-            }
-        };
+            SPELL_SUMMON_BONE_MAGE_FRONT_LEFT,
+            SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT,
+            SPELL_SUMMON_BONE_MAGE_BACK_RIGHT,
+            SPELL_SUMMON_BONE_MAGE_BACK_LEFT
+        });
+    }
 
-        SpellScript* GetSpellScript() const override
+    void HandleScript(SpellEffIndex /*effIndex*/)
+    {
+        Unit* caster = GetCaster();
+        switch (urand(0, 1))
         {
-            return new spell_kormok_summon_bone_magesSpellScript();
+            case 0:
+                caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_FRONT_LEFT);
+                caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_FRONT_RIGHT);
+                break;
+            case 1:
+                caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_BACK_RIGHT);
+                caster->CastSpell(caster, SPELL_SUMMON_BONE_MAGE_BACK_LEFT);
+                break;
         }
+    }
+
+    void Register() override
+    {
+        OnEffectHit += SpellEffectFn(spell_kormok_summon_bone_mages::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+    }
 };
 
 // 27687 - Summon Bone Minions
-class spell_kormok_summon_bone_minions : SpellScriptLoader
+class spell_kormok_summon_bone_minions : public SpellScript
 {
-    public:
-       spell_kormok_summon_bone_minions() : SpellScriptLoader("spell_kormok_summon_bone_minions") { }
+    PrepareSpellScript(spell_kormok_summon_bone_minions);
 
-    class spell_kormok_summon_bone_minionsSpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spell*/) override
     {
-        PrepareSpellScript(spell_kormok_summon_bone_minionsSpellScript);
-
-        bool Validate(SpellInfo const* /*spell*/) override
+        return ValidateSpellInfo(
         {
-            return ValidateSpellInfo({ SPELL_SUMMON_BONE_MINIONS });
-        }
-
-        void HandleScript(SpellEffIndex effIndex)
-        {
-            PreventHitDefaultEffect(effIndex);
-
-            // Possible spells to handle this not found.
-            for (uint32 i = 0; i < 4; ++i)
-                GetCaster()->SummonCreature(NPC_BONE_MINION, GetCaster()->GetPositionX() + float(irand(-7, 7)), GetCaster()->GetPositionY() + float(irand(-7, 7)), GetCaster()->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 2min);
-        }
+            SPELL_SUMMON_BONE_MINION_FRONT,
+            SPELL_SUMMON_BONE_MINION_BACK,
+            SPELL_SUMMON_BONE_MINION_LEFT,
+            SPELL_SUMMON_BONE_MINION_RIGHT
+        });
+    }
 
-        void Register() override
-        {
-            OnEffectHitTarget += SpellEffectFn(spell_kormok_summon_bone_minionsSpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
-        }
-    };
+    void HandleScript(SpellEffIndex /*effIndex*/)
+    {
+        Unit* caster = GetCaster();
+        caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_FRONT);
+        caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_BACK);
+        caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_LEFT);
+        caster->CastSpell(caster, SPELL_SUMMON_BONE_MINION_RIGHT);
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_kormok_summon_bone_minionsSpellScript();
+        OnEffectHit += SpellEffectFn(spell_kormok_summon_bone_minions::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
     }
 };
 
 void AddSC_boss_kormok()
 {
-    new boss_kormok();
-    new spell_kormok_summon_bone_mages();
-    new spell_kormok_summon_bone_minions();
+    RegisterScholomanceCreatureAI(boss_kormok);
+    RegisterSpellScript(spell_kormok_summon_bone_mages);
+    RegisterSpellScript(spell_kormok_summon_bone_minions);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_lord_alexei_barov.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_lord_alexei_barov.cpp
index 22ed088934c..bd678b8e71a 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_lord_alexei_barov.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_lord_alexei_barov.cpp
@@ -15,94 +15,78 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/* ScriptData
-SDName: Boss_Lord_Alexei_Barov
-SD%Complete: 100
-SDComment: aura applied/defined in database
-SDCategory: Scholomance
-EndScriptData */
-
 #include "scholomance.h"
 #include "ScriptMgr.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum AlexeiSpells
 {
     SPELL_IMMOLATE                  = 20294,
-    SPELL_VEILOFSHADOW              = 17820,
+    SPELL_VEIL_OF_SHADOW            = 17820,
     SPELL_UNHOLY_AURA               = 17467
 };
 
-enum Events
+enum AlexeiEvents
 {
-    EVENT_IMMOLATE                  = 1,
-    EVENT_VEILOFSHADOW              = 2
+    EVENT_IMMOLATE = 1,
+    EVENT_VEIL_OF_SHADOW
 };
 
-class boss_lord_alexei_barov : public CreatureScript
+// 10504 - Lord Alexei Barov
+struct boss_lord_alexei_barov : public BossAI
 {
-    public: boss_lord_alexei_barov() : CreatureScript("boss_lord_alexei_barov") { }
-
-        struct boss_lordalexeibarovAI : public BossAI
-        {
-            boss_lordalexeibarovAI(Creature* creature) : BossAI(creature, DATA_LORD_ALEXEI_BAROV) { }
-
-            void Reset() override
-            {
-                _Reset();
-
-                if (!me->HasAura(SPELL_UNHOLY_AURA))
-                    DoCast(me, SPELL_UNHOLY_AURA);
-            }
+    boss_lord_alexei_barov(Creature* creature) : BossAI(creature, DATA_LORD_ALEXEI_BAROV) { }
 
-            void JustEngagedWith(Unit* who) override
-            {
-                BossAI::JustEngagedWith(who);
-                events.ScheduleEvent(EVENT_IMMOLATE, 7s);
-                events.ScheduleEvent(EVENT_VEILOFSHADOW, 15s);
-            }
+    void Reset() override
+    {
+        _Reset();
 
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
+        if (!me->HasAura(SPELL_UNHOLY_AURA))
+            DoCastSelf(SPELL_UNHOLY_AURA);
+    }
 
-                events.Update(diff);
+    void JustEngagedWith(Unit* who) override
+    {
+        BossAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_IMMOLATE, 7s);
+        events.ScheduleEvent(EVENT_VEIL_OF_SHADOW, 15s);
+    }
 
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
 
-                while (uint32 eventId = events.ExecuteEvent())
-                {
-                    switch (eventId)
-                    {
-                        case EVENT_IMMOLATE:
-                            DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_IMMOLATE, true);
-                            events.ScheduleEvent(EVENT_IMMOLATE, 12s);
-                            break;
-                        case EVENT_VEILOFSHADOW:
-                            DoCastVictim(SPELL_VEILOFSHADOW, true);
-                            events.ScheduleEvent(EVENT_VEILOFSHADOW, 20s);
-                            break;
-                        default:
-                            break;
-                    }
+        events.Update(diff);
 
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
+        if (me->HasUnitState(UNIT_STATE_CASTING))
+            return;
 
-                DoMeleeAttackIfReady();
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
+            {
+                case EVENT_IMMOLATE:
+                    DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_IMMOLATE);
+                    events.Repeat(12s);
+                    break;
+                case EVENT_VEIL_OF_SHADOW:
+                    DoCastVictim(SPELL_VEIL_OF_SHADOW);
+                    events.Repeat(20s);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_lordalexeibarovAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
 void AddSC_boss_lordalexeibarov()
 {
-    new boss_lord_alexei_barov();
+    RegisterScholomanceCreatureAI(boss_lord_alexei_barov);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp
index 07615837321..4accabc4746 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp
@@ -15,99 +15,83 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/*
-Name: Boss_Lorekeeper_Polkelt
-%Complete: 100
-Comment:
-Category: Scholomance
-*/
-
 #include "scholomance.h"
 #include "ScriptMgr.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum PolkeltSpells
 {
-    SPELL_VOLATILEINFECTION     = 24928,
-    SPELL_DARKPLAGUE            = 18270,
-    SPELL_CORROSIVEACID         = 23313,
-    SPELL_NOXIOUSCATALYST       = 18151
+    SPELL_VOLATILE_INFECTION    = 24928,
+    SPELL_DARK_PLAGUE           = 18270,
+    SPELL_CORROSIVE_ACID        = 23313,
+    SPELL_NOXIOUS_CATALYST      = 18151
 };
 
-enum Events
+enum PolkeltEvents
 {
-    EVENT_VOLATILEINFECTION     = 1,
-    EVENT_DARKPLAGUE            = 2,
-    EVENT_CORROSIVEACID         = 3,
-    EVENT_NOXIOUSCATALYST       = 4
+    EVENT_VOLATILE_INFECTION = 1,
+    EVENT_DARK_PLAGUE,
+    EVENT_CORROSIVE_ACID,
+    EVENT_NOXIOUS_CATALYST
 };
 
-class boss_lorekeeper_polkelt : public CreatureScript
+// 10901 - Lorekeeper Polkelt
+struct boss_lorekeeper_polkelt : public BossAI
 {
-    public: boss_lorekeeper_polkelt() : CreatureScript("boss_lorekeeper_polkelt") { }
+    boss_lorekeeper_polkelt(Creature* creature) : BossAI(creature, DATA_LOREKEEPER_POLKELT) { }
 
-        struct boss_lorekeeperpolkeltAI : public BossAI
-        {
-            boss_lorekeeperpolkeltAI(Creature* creature) : BossAI(creature, DATA_LOREKEEPER_POLKELT) { }
+    void JustEngagedWith(Unit* who) override
+    {
+        BossAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_VOLATILE_INFECTION, 38s);
+        events.ScheduleEvent(EVENT_DARK_PLAGUE, 8s);
+        events.ScheduleEvent(EVENT_CORROSIVE_ACID, 45s);
+        events.ScheduleEvent(EVENT_NOXIOUS_CATALYST, 35s);
+    }
 
-            void JustEngagedWith(Unit* who) override
-            {
-                BossAI::JustEngagedWith(who);
-                events.ScheduleEvent(EVENT_VOLATILEINFECTION, 38s);
-                events.ScheduleEvent(EVENT_DARKPLAGUE, 8s);
-                events.ScheduleEvent(EVENT_CORROSIVEACID, 45s);
-                events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 35s);
-            }
-
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
+    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)
-                    {
-                        case EVENT_VOLATILEINFECTION:
-                            DoCastVictim(SPELL_VOLATILEINFECTION, true);
-                            events.ScheduleEvent(EVENT_VOLATILEINFECTION, 32s);
-                            break;
-                        case EVENT_DARKPLAGUE:
-                            DoCastVictim(SPELL_DARKPLAGUE, true);
-                            events.ScheduleEvent(EVENT_DARKPLAGUE, 8s);
-                            break;
-                        case EVENT_CORROSIVEACID:
-                            DoCastVictim(SPELL_CORROSIVEACID, true);
-                            events.ScheduleEvent(EVENT_CORROSIVEACID, 25s);
-                            break;
-                        case EVENT_NOXIOUSCATALYST:
-                            DoCastVictim(SPELL_NOXIOUSCATALYST, true);
-                            events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 38s);
-                            break;
-                        default:
-                            break;
-                    }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
+            {
+                case EVENT_VOLATILE_INFECTION:
+                    DoCastVictim(SPELL_VOLATILE_INFECTION);
+                    events.Repeat(32s);
+                    break;
+                case EVENT_DARK_PLAGUE:
+                    DoCastVictim(SPELL_DARK_PLAGUE);
+                    events.Repeat(8s);
+                    break;
+                case EVENT_CORROSIVE_ACID:
+                    DoCastSelf(SPELL_CORROSIVE_ACID);
+                    events.Repeat(25s);
+                    break;
+                case EVENT_NOXIOUS_CATALYST:
+                    DoCastVictim(SPELL_NOXIOUS_CATALYST);
+                    events.Repeat(38s);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_lorekeeperpolkeltAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
 void AddSC_boss_lorekeeperpolkelt()
 {
-    new boss_lorekeeper_polkelt();
+    RegisterScholomanceCreatureAI(boss_lorekeeper_polkelt);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_ras_frostwhisper.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_ras_frostwhisper.cpp
index 6aa017d5174..8581e5f66aa 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_ras_frostwhisper.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_ras_frostwhisper.cpp
@@ -19,17 +19,17 @@
 #include "ScriptMgr.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum RasSpells
 {
     SPELL_FROSTBOLT         = 21369,
     SPELL_ICE_ARMOR         = 18100, // This is actually a buff he gives himself
     SPELL_FREEZE            = 18763,
     SPELL_FEAR              = 26070,
     SPELL_CHILL_NOVA        = 18099,
-    SPELL_FROSTVOLLEY       = 8398
+    SPELL_FROSTBOLT_VOLLEY  = 8398
 };
 
-enum Events
+enum RasEvents
 {
     EVENT_FROSTBOLT = 1,
     EVENT_ICE_ARMOR,
@@ -39,91 +39,81 @@ enum Events
     EVENT_FROSTVOLLEY
 };
 
-class boss_boss_ras_frostwhisper : public CreatureScript
+// 10508 - Ras Frostwhisper
+struct boss_boss_ras_frostwhisper : public ScriptedAI
 {
-public:
-    boss_boss_ras_frostwhisper() : CreatureScript("boss_boss_ras_frostwhisper") { }
+    boss_boss_ras_frostwhisper(Creature* creature) : ScriptedAI(creature) { }
 
-    struct boss_rasfrostAI : public ScriptedAI
+    void Reset() override
     {
-        boss_rasfrostAI(Creature* creature) : ScriptedAI(creature) { }
-
-        void Reset() override
-        {
-            events.Reset();
-            DoCast(me, SPELL_ICE_ARMOR);
-        }
+        _events.Reset();
+        DoCastSelf(SPELL_ICE_ARMOR);
+    }
 
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-            events.ScheduleEvent(EVENT_ICE_ARMOR, 2s);
-            events.ScheduleEvent(EVENT_FROSTBOLT, 8s);
-            events.ScheduleEvent(EVENT_CHILL_NOVA, 12s);
-            events.ScheduleEvent(EVENT_FREEZE, 18s);
-            events.ScheduleEvent(EVENT_FEAR, 45s);
-        }
+    void JustEngagedWith(Unit* /*who*/) override
+    {
+        _events.ScheduleEvent(EVENT_ICE_ARMOR, 2s);
+        _events.ScheduleEvent(EVENT_FROSTBOLT, 8s);
+        _events.ScheduleEvent(EVENT_CHILL_NOVA, 12s);
+        _events.ScheduleEvent(EVENT_FREEZE, 18s);
+        _events.ScheduleEvent(EVENT_FEAR, 45s);
+    }
 
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
+    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())
+        while (uint32 eventId = _events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_ICE_ARMOR:
-                        DoCast(me, SPELL_ICE_ARMOR);
-                        events.ScheduleEvent(EVENT_ICE_ARMOR, 3min);
-                        break;
-                    case EVENT_FROSTBOLT:
-                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 40.0f, true))
-                            DoCast(target, SPELL_FROSTBOLT);
-                        events.ScheduleEvent(EVENT_FROSTBOLT, 8s);
-                        break;
-                    case EVENT_FREEZE:
-                        DoCastVictim(SPELL_FREEZE);
-                        events.ScheduleEvent(EVENT_FREEZE, 24s);
-                        break;
-                    case EVENT_FEAR:
-                        DoCastVictim(SPELL_FEAR);
-                        events.ScheduleEvent(EVENT_FEAR, 30s);
-                        break;
-                    case EVENT_CHILL_NOVA:
-                        DoCastVictim(SPELL_CHILL_NOVA);
-                        events.ScheduleEvent(EVENT_CHILL_NOVA, 14s);
-                        break;
-                    case EVENT_FROSTVOLLEY:
-                        DoCastVictim(SPELL_FROSTVOLLEY);
-                        events.ScheduleEvent(EVENT_FROSTVOLLEY, 15s);
-                        break;
-                    default:
-                        break;
-                }
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
+                case EVENT_ICE_ARMOR:
+                    DoCastSelf(SPELL_ICE_ARMOR);
+                    _events.Repeat(3min);
+                    break;
+                case EVENT_FROSTBOLT:
+                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 40.0f, true))
+                        DoCast(target, SPELL_FROSTBOLT);
+                    _events.Repeat(8s);
+                    break;
+                case EVENT_FREEZE:
+                    DoCastVictim(SPELL_FREEZE);
+                    _events.Repeat(24s);
+                    break;
+                case EVENT_FEAR:
+                    DoCastSelf(SPELL_FEAR);
+                    _events.Repeat(30s);
+                    break;
+                case EVENT_CHILL_NOVA:
+                    DoCastSelf(SPELL_CHILL_NOVA);
+                    _events.Repeat(14s);
+                    break;
+                case EVENT_FROSTVOLLEY:
+                    DoCastVictim(SPELL_FROSTBOLT_VOLLEY);
+                    _events.Repeat(15s);
+                    break;
+                default:
+                    break;
             }
 
-            DoMeleeAttackIfReady();
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
 
-        private:
-            EventMap events;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetScholomanceAI<boss_rasfrostAI>(creature);
+        DoMeleeAttackIfReady();
     }
+
+private:
+    EventMap _events;
 };
 
 void AddSC_boss_rasfrost()
 {
-    new boss_boss_ras_frostwhisper();
+    RegisterScholomanceCreatureAI(boss_boss_ras_frostwhisper);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp
index 3b6965f7582..5965e8bf9d3 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp
@@ -15,99 +15,83 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/*
-Name: Boss_the_ravenian
-%Complete: 100
-Comment:
-Category: Scholomance
-*/
-
 #include "scholomance.h"
 #include "ScriptMgr.h"
 #include "ScriptedCreature.h"
 
-enum Spells
+enum RavenianSpells
 {
     SPELL_TRAMPLE                   = 15550,
     SPELL_CLEAVE                    = 20691,
-    SPELL_SUNDERINCLEAVE            = 25174,
-    SPELL_KNOCKAWAY                 = 10101
+    SPELL_SUNDERING_CLEAVE          = 25174,
+    SPELL_KNOCK_AWAY                = 10101
 };
 
-enum Events
+enum RavenianEvents
 {
-    EVENT_TRAMPLE                   = 1,
-    EVENT_CLEAVE                    = 2,
-    EVENT_SUNDERINCLEAVE            = 3,
-    EVENT_KNOCKAWAY                 = 4
+    EVENT_TRAMPLE = 1,
+    EVENT_CLEAVE,
+    EVENT_SUNDERING_CLEAVE,
+    EVENT_KNOCK_AWAY
 };
 
-class boss_the_ravenian : public CreatureScript
+// 10507 - The Ravenian
+struct boss_the_ravenian : public BossAI
 {
-    public: boss_the_ravenian() : CreatureScript("boss_the_ravenian") { }
+    boss_the_ravenian(Creature* creature) : BossAI(creature, DATA_THE_RAVENIAN) { }
 
-        struct boss_theravenianAI : public BossAI
-        {
-            boss_theravenianAI(Creature* creature) : BossAI(creature, DATA_THE_RAVENIAN) { }
+    void JustEngagedWith(Unit* who) override
+    {
+        BossAI::JustEngagedWith(who);
+        events.ScheduleEvent(EVENT_TRAMPLE, 24s);
+        events.ScheduleEvent(EVENT_CLEAVE, 15s);
+        events.ScheduleEvent(EVENT_SUNDERING_CLEAVE, 40s);
+        events.ScheduleEvent(EVENT_KNOCK_AWAY, 32s);
+    }
 
-            void JustEngagedWith(Unit* who) override
-            {
-                BossAI::JustEngagedWith(who);
-                events.ScheduleEvent(EVENT_TRAMPLE, 24s);
-                events.ScheduleEvent(EVENT_CLEAVE, 15s);
-                events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 40s);
-                events.ScheduleEvent(EVENT_KNOCKAWAY, 32s);
-            }
-
-            void UpdateAI(uint32 diff) override
-            {
-                if (!UpdateVictim())
-                    return;
+    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)
-                    {
-                        case EVENT_TRAMPLE:
-                            DoCastVictim(SPELL_TRAMPLE, true);
-                            events.ScheduleEvent(EVENT_TRAMPLE, 10s);
-                            break;
-                        case EVENT_CLEAVE:
-                            DoCastVictim(SPELL_CLEAVE, true);
-                            events.ScheduleEvent(EVENT_CLEAVE, 7s);
-                            break;
-                        case EVENT_SUNDERINCLEAVE:
-                            DoCastVictim(SPELL_SUNDERINCLEAVE, true);
-                            events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 20s);
-                            break;
-                        case EVENT_KNOCKAWAY:
-                            DoCastVictim(SPELL_KNOCKAWAY, true);
-                            events.ScheduleEvent(EVENT_KNOCKAWAY, 12s);
-                            break;
-                        default:
-                            break;
-                    }
-
-                    if (me->HasUnitState(UNIT_STATE_CASTING))
-                        return;
-                }
-
-                DoMeleeAttackIfReady();
+        while (uint32 eventId = events.ExecuteEvent())
+        {
+            switch (eventId)
+            {
+                case EVENT_TRAMPLE:
+                    DoCastSelf(SPELL_TRAMPLE);
+                    events.Repeat(10s);
+                    break;
+                case EVENT_CLEAVE:
+                    DoCastVictim(SPELL_CLEAVE);
+                    events.Repeat(7s);
+                    break;
+                case EVENT_SUNDERING_CLEAVE:
+                    DoCastVictim(SPELL_SUNDERING_CLEAVE);
+                    events.Repeat(20s);
+                    break;
+                case EVENT_KNOCK_AWAY:
+                    DoCastVictim(SPELL_KNOCK_AWAY);
+                    events.Repeat(12s);
+                    break;
+                default:
+                    break;
             }
-        };
 
-        CreatureAI* GetAI(Creature* creature) const override
-        {
-            return GetScholomanceAI<boss_theravenianAI>(creature);
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
+
+        DoMeleeAttackIfReady();
+    }
 };
 
 void AddSC_boss_theravenian()
 {
-    new boss_the_ravenian();
+    RegisterScholomanceCreatureAI(boss_the_ravenian);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_vectus.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_vectus.cpp
index 6558325f19d..768e96b3c8a 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_vectus.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_vectus.cpp
@@ -19,12 +19,12 @@
 #include "ScriptMgr.h"
 #include "ScriptedCreature.h"
 
-enum Emotes
+enum VectusTexts
 {
     EMOTE_FRENZY                 = 0
 };
 
-enum Spells
+enum VectusSpells
 {
     SPELL_FLAMESTRIKE            = 18399,
     SPELL_BLAST_WAVE             = 16046,
@@ -32,92 +32,78 @@ enum Spells
     SPELL_FRENZY                 = 8269  // 28371
 };
 
-enum Events
+enum VectusEvents
 {
     EVENT_FIRE_SHIELD = 1,
     EVENT_BLAST_WAVE,
     EVENT_FRENZY
 };
 
-class boss_vectus : public CreatureScript
+// 10432 - Vectus
+struct boss_vectus : public ScriptedAI
 {
-public:
-    boss_vectus() : CreatureScript("boss_vectus") { }
+    boss_vectus(Creature* creature) : ScriptedAI(creature) { }
 
-    struct boss_vectusAI : public ScriptedAI
+    void Reset() override
     {
-        boss_vectusAI(Creature* creature) : ScriptedAI(creature) { }
-
-        void Reset() override
-        {
-            events.Reset();
-        }
+        _events.Reset();
+    }
 
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-            events.ScheduleEvent(EVENT_FIRE_SHIELD, 2s);
-            events.ScheduleEvent(EVENT_BLAST_WAVE, 14s);
-        }
+    void JustEngagedWith(Unit* /*who*/) override
+    {
+        _events.ScheduleEvent(EVENT_FIRE_SHIELD, 2s);
+        _events.ScheduleEvent(EVENT_BLAST_WAVE, 14s);
+    }
 
-        void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
-        {
-            if (me->HealthBelowPctDamaged(25, damage))
-            {
-                DoCast(me, SPELL_FRENZY);
-                Talk(EMOTE_FRENZY);
-                events.ScheduleEvent(EVENT_FRENZY, 24s);
-            }
-        }
+    void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
+    {
+        if (!me->HasAura(SPELL_FRENZY) && me->HealthBelowPctDamaged(25, damage))
+            _events.ScheduleEvent(EVENT_FRENZY, 0s);
+    }
 
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
+    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())
+        while (uint32 eventId = _events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_FIRE_SHIELD:
-                        DoCast(me, SPELL_FIRE_SHIELD);
-                        events.ScheduleEvent(EVENT_FIRE_SHIELD, 90s);
-                        break;
-                    case EVENT_BLAST_WAVE:
-                        DoCast(me, SPELL_BLAST_WAVE);
-                        events.ScheduleEvent(EVENT_BLAST_WAVE, 12s);
-                        break;
-                    case EVENT_FRENZY:
-                        DoCast(me, SPELL_FRENZY);
-                        Talk(EMOTE_FRENZY);
-                        events.ScheduleEvent(EVENT_FRENZY, 24s);
-                        break;
-                    default:
-                        break;
-                }
-
-                if (me->HasUnitState(UNIT_STATE_CASTING))
-                    return;
+                case EVENT_FIRE_SHIELD:
+                    DoCastSelf(SPELL_FIRE_SHIELD);
+                    _events.Repeat(90s);
+                    break;
+                case EVENT_BLAST_WAVE:
+                    DoCastSelf(SPELL_BLAST_WAVE);
+                    _events.Repeat(12s);
+                    break;
+                case EVENT_FRENZY:
+                    DoCastSelf(SPELL_FRENZY);
+                    Talk(EMOTE_FRENZY);
+                    _events.Repeat(24s);
+                    break;
+                default:
+                    break;
             }
 
-            DoMeleeAttackIfReady();
+            if (me->HasUnitState(UNIT_STATE_CASTING))
+                return;
         }
 
-        private:
-            EventMap events;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetScholomanceAI<boss_vectusAI>(creature);
+        DoMeleeAttackIfReady();
     }
+
+private:
+    EventMap _events;
 };
 
 void AddSC_boss_vectus()
 {
-    new boss_vectus();
+    RegisterScholomanceCreatureAI(boss_vectus);
 }
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h b/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h
index 42b075eb4b5..a4a8aa58631 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h
+++ b/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h
@@ -62,4 +62,7 @@ inline AI* GetScholomanceAI(T* obj)
     return GetInstanceAI<AI>(obj, ScholomanceScriptName);
 }
 
+#define RegisterScholomanceCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetScholomanceAI)
+#define RegisterScholomanceGameObjectAI(ai_name) RegisterGameObjectAIWithFactory(ai_name, GetScholomanceAI)
+
 #endif