Core/Scripting: Update Scholomance Scripts

9 files changed, 469 insertions, 447 deletions

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 dc52ec6c29e..ea60b0ce333 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_doctor_theolen_krastinov.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_doctor_theolen_krastinov.cpp
@@ -27,94 +27,97 @@ EndScriptData */
 #include "ScriptedCreature.h"
 #include "scholomance.h"
 
-enum eEnums
+enum Say
 {
     EMOTE_FRENZY_KILL           = 0,
+};
+
+enum Spells
+{
     SPELL_REND                  = 16509,
     SPELL_BACKHAND              = 18103,
     SPELL_FRENZY                = 8269
 };
 
-class boss_doctor_theolen_krastinov : public CreatureScript
+enum Events
 {
-public:
-    boss_doctor_theolen_krastinov() : CreatureScript("boss_doctor_theolen_krastinov") { }
-
-    CreatureAI* GetAI(Creature* creature) const
-    {
-        return new boss_theolenkrastinovAI (creature);
-    }
-
-    struct boss_theolenkrastinovAI : public ScriptedAI
-    {
-        boss_theolenkrastinovAI(Creature* creature) : ScriptedAI(creature) {}
+    EVENT_REND                  = 1,
+    EVENT_BACKHAND              = 2,
+    EVENT_FRENZY                = 3
+};
 
-        uint32 m_uiRend_Timer;
-        uint32 m_uiBackhand_Timer;
-        uint32 m_uiFrenzy_Timer;
+class boss_doctor_theolen_krastinov : public CreatureScript
+{
+    public: boss_doctor_theolen_krastinov() : CreatureScript("boss_doctor_theolen_krastinov") { }
 
-        void Reset()
+        struct boss_theolenkrastinovAI : public BossAI
         {
-            m_uiRend_Timer = 8000;
-            m_uiBackhand_Timer = 9000;
-            m_uiFrenzy_Timer = 1000;
-        }
+            boss_theolenkrastinovAI(Creature* creature) : BossAI(creature, DATA_DOCTORTHEOLENKRASTINOV) {}
 
-        void JustDied(Unit* /*killer*/)
-        {
-            InstanceScript* instance = me->GetInstanceScript();
-            if (instance)
-            {
-                instance->SetData(DATA_DOCTORTHEOLENKRASTINOV_DEATH, 0);
+            void Reset() {}
 
-                if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+            void JustDied(Unit* /*killer*/)
+            {
+                InstanceScript* instance = me->GetInstanceScript();
+                if (instance)
                 {
-                    instance->SetData(TYPE_GANDLING, IN_PROGRESS);
-                    me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    instance->SetData(DATA_DOCTORTHEOLENKRASTINOV, DONE);
+
+                    if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+                    {
+                        instance->SetData(TYPE_GANDLING, IN_PROGRESS);
+                        me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    }
                 }
             }
-        }
 
-        void UpdateAI(const uint32 uiDiff)
-        {
-            if (!UpdateVictim())
-                return;
-
-            //Rend_Timer
-            if (m_uiRend_Timer <= uiDiff)
+            void EnterCombat(Unit* /*who*/)
             {
-                DoCast(me->getVictim(), SPELL_REND);
-                m_uiRend_Timer = 10000;
+                events.ScheduleEvent(EVENT_REND, 8000);
+                events.ScheduleEvent(EVENT_BACKHAND, 9000);
+                events.ScheduleEvent(EVENT_FRENZY, 1000);
             }
-            else
-                m_uiRend_Timer -= uiDiff;
 
-            //Backhand_Timer
-            if (m_uiBackhand_Timer <= uiDiff)
+            void UpdateAI(uint32 const diff)
             {
-                DoCast(me->getVictim(), SPELL_BACKHAND);
-                m_uiBackhand_Timer = 10000;
-            }
-            else
-                m_uiBackhand_Timer -= uiDiff;
+                if (!UpdateVictim())
+                    return;
 
-            //Frenzy_Timer
-            if (HealthBelowPct(26))
-            {
-                if (m_uiFrenzy_Timer <= uiDiff)
-                {
-                    DoCast(me, SPELL_FRENZY);
-                    Talk(EMOTE_FRENZY_KILL);
+                events.Update(diff);
+
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
 
-                    m_uiFrenzy_Timer = 120000;
+                while (uint32 eventId = events.ExecuteEvent())
+                {
+                    switch (eventId)
+                    {
+                        case EVENT_REND:
+                            DoCastVictim(SPELL_REND, true);
+                            events.ScheduleEvent(EVENT_REND, 10000);
+                            break;
+                        case EVENT_BACKHAND:
+                            DoCastVictim(SPELL_BACKHAND, true);
+                            events.ScheduleEvent(EVENT_BACKHAND, 10000);
+                            break;
+                        case EVENT_FRENZY:
+                            DoCast(me, SPELL_FRENZY, true);
+                            Talk(EMOTE_FRENZY_KILL);
+                            events.ScheduleEvent(EVENT_FRENZY, 120000);
+                            break;
+                        default:
+                            break;
+                    }
                 }
-                else
-                    m_uiFrenzy_Timer -= uiDiff;
+
+                DoMeleeAttackIfReady();
             }
+        };
 
-            DoMeleeAttackIfReady();
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_theolenkrastinovAI (creature);
         }
-    };
 
 };
 
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp
index cc81687c5d1..54fc9e4a17e 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_illucia_barov.cpp
@@ -27,97 +27,98 @@ EndScriptData */
 #include "ScriptedCreature.h"
 #include "scholomance.h"
 
-#define SPELL_CURSEOFAGONY      18671
-#define SPELL_SHADOWSHOCK       20603
-#define SPELL_SILENCE           15487
-#define SPELL_FEAR              6215
-
-class boss_illucia_barov : public CreatureScript
+enum Spells
 {
-public:
-    boss_illucia_barov() : CreatureScript("boss_illucia_barov") { }
-
-    CreatureAI* GetAI(Creature* creature) const
-    {
-        return new boss_illuciabarovAI (creature);
-    }
+    SPELL_CURSEOFAGONY          = 34794,
+    SPELL_SHADOWSHOCK           = 34799,
+    SPELL_SILENCE               = 34803,
+    SPELL_FEAR                  = 34803
+};
 
-    struct boss_illuciabarovAI : public ScriptedAI
-    {
-        boss_illuciabarovAI(Creature* creature) : ScriptedAI(creature) {}
+enum Events
+{
+    EVENT_CURSEOFAGONY          = 1,
+    EVENT_SHADOWSHOCK           = 2,
+    EVENT_SILENCE               = 3,
+    EVENT_FEAR                  = 4
+};
 
-        uint32 CurseOfAgony_Timer;
-        uint32 ShadowShock_Timer;
-        uint32 Silence_Timer;
-        uint32 Fear_Timer;
+class boss_illucia_barov : public CreatureScript
+{
+    public: boss_illucia_barov() : CreatureScript("boss_illucia_barov") { }
 
-        void Reset()
+        struct boss_illuciabarovAI : public BossAI
         {
-            CurseOfAgony_Timer = 18000;
-            ShadowShock_Timer = 9000;
-            Silence_Timer = 5000;
-            Fear_Timer = 30000;
-        }
+            boss_illuciabarovAI(Creature* creature) : BossAI(creature,DATA_LADYILLUCIABAROV) {}
 
-        void JustDied(Unit* /*killer*/)
-        {
-            InstanceScript* instance = me->GetInstanceScript();
-            if (instance)
-            {
-                instance->SetData(DATA_LADYILLUCIABAROV_DEATH, 0);
+            void Reset() {}
 
-                if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+            void JustDied(Unit* /*killer*/)
+            {
+                InstanceScript* instance = me->GetInstanceScript();
+                if (instance)
                 {
-                    instance->SetData(TYPE_GANDLING, IN_PROGRESS);
-                    me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    instance->SetData(DATA_LADYILLUCIABAROV, DONE);
+
+                    if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+                    {
+                        instance->SetData(TYPE_GANDLING, IN_PROGRESS);
+                        me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    }
                 }
             }
-        }
 
-        void EnterCombat(Unit* /*who*/)
-        {
-        }
-
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
-
-            //CurseOfAgony_Timer
-            if (CurseOfAgony_Timer <= diff)
+            void EnterCombat(Unit* /*who*/)
             {
-                DoCast(me->getVictim(), SPELL_CURSEOFAGONY);
-                CurseOfAgony_Timer = 30000;
-            } else CurseOfAgony_Timer -= diff;
+                events.ScheduleEvent(EVENT_CURSEOFAGONY, 18000);
+                events.ScheduleEvent(EVENT_SHADOWSHOCK, 9000);
+                events.ScheduleEvent(EVENT_SILENCE, 5000);
+                events.ScheduleEvent(EVENT_FEAR, 30000);
+            }
 
-            //ShadowShock_Timer
-            if (ShadowShock_Timer <= diff)
+            void UpdateAI(uint32 const diff)
             {
-                Unit* target = NULL;
-                target = SelectTarget(SELECT_TARGET_RANDOM, 0);
-                if (target) DoCast(target, SPELL_SHADOWSHOCK);
+                if (!UpdateVictim())
+                    return;
 
-                ShadowShock_Timer = 12000;
-            } else ShadowShock_Timer -= diff;
+                events.Update(diff);
 
-            //Silence_Timer
-            if (Silence_Timer <= diff)
-            {
-                DoCast(me->getVictim(), SPELL_SILENCE);
-                Silence_Timer = 14000;
-            } else Silence_Timer -= diff;
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
 
-            //Fear_Timer
-            if (Fear_Timer <= diff)
-            {
-                DoCast(me->getVictim(), SPELL_FEAR);
-                Fear_Timer = 30000;
-            } else Fear_Timer -= diff;
+                while (uint32 eventId = events.ExecuteEvent())
+                {
+                    switch (eventId)
+                    {
+                        case EVENT_CURSEOFAGONY:
+                            DoCastVictim(SPELL_CURSEOFAGONY, true);
+                            events.ScheduleEvent(EVENT_CURSEOFAGONY, 30000);
+                            break;
+                        case EVENT_SHADOWSHOCK:
+                            DoCast(SelectTarget(SELECT_TARGET_RANDOM,0, 100, true),SPELL_SHADOWSHOCK,true);
+                            events.ScheduleEvent(EVENT_SHADOWSHOCK, 12000);
+                            break;
+                        case EVENT_SILENCE:
+                            DoCastVictim(SPELL_SILENCE, true);
+                            events.ScheduleEvent(EVENT_SILENCE, 14000);
+                            break;
+                        case EVENT_FEAR:
+                            DoCastVictim(SPELL_FEAR, true);
+                            events.ScheduleEvent(EVENT_FEAR, 30000);
+                            break;
+                        default:
+                            break;
+                    }
+                }
 
-            DoMeleeAttackIfReady();
-        }
-    };
+                DoMeleeAttackIfReady();
+            }
+        };
 
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_illuciabarovAI (creature);
+        }
 };
 
 void AddSC_boss_illuciabarov()
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp
index 54dc75dd905..daf03f41db5 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_instructor_malicia.cpp
@@ -27,132 +27,132 @@ EndScriptData */
 #include "ScriptedCreature.h"
 #include "scholomance.h"
 
-#define SPELL_CALLOFGRAVES         17831
-#define SPELL_CORRUPTION           11672
-#define SPELL_FLASHHEAL            10917
-#define SPELL_RENEW                10929
-#define SPELL_HEALINGTOUCH         9889
-
-class boss_instructor_malicia : public CreatureScript
+enum Spells
 {
-public:
-    boss_instructor_malicia() : CreatureScript("boss_instructor_malicia") { }
-
-    CreatureAI* GetAI(Creature* creature) const
-    {
-        return new boss_instructormaliciaAI (creature);
-    }
-
-    struct boss_instructormaliciaAI : public ScriptedAI
-    {
-        boss_instructormaliciaAI(Creature* creature) : ScriptedAI(creature) {}
-
-        uint32 CallOfGraves_Timer;
-        uint32 Corruption_Timer;
-        uint32 FlashHeal_Timer;
-        uint32 Renew_Timer;
-        uint32 HealingTouch_Timer;
-        uint32 FlashCounter;
-        uint32 TouchCounter;
-
-        void Reset()
-        {
-            CallOfGraves_Timer = 4000;
-            Corruption_Timer = 8000;
-            FlashHeal_Timer = 38000;
-            Renew_Timer = 32000;
-            HealingTouch_Timer = 45000;
-            FlashCounter = 0;
-            TouchCounter = 0;
-        }
+    SPELL_CALLOFGRAVES          = 17831,
+    SPELL_CORRUPTION            = 11672,
+    SPELL_FLASHHEAL             = 10917,
+    SPELL_RENEW                 = 10929,
+    SPELL_HEALINGTOUCH          = 9889
+};
 
-        void JustDied(Unit* /*killer*/)
-        {
-            InstanceScript* instance = me->GetInstanceScript();
-            if (instance)
-            {
-                instance->SetData(DATA_INSTRUCTORMALICIA_DEATH, 0);
+enum Events
+{
+    EVENT_CALLOFGRAVES          = 1,
+    EVENT_CORRUPTION            = 2,
+    EVENT_FLASHHEAL             = 3,
+    EVENT_RENEW                 = 4,
+    EVENT_HEALINGTOUCH          = 5
+};
 
-                if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
-                {
-                    instance->SetData(TYPE_GANDLING, IN_PROGRESS);
-                    me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
-                }
-            }
-        }
+class boss_instructor_malicia : public CreatureScript
+{
+    public: boss_instructor_malicia() : CreatureScript("boss_instructor_malicia") { }
 
-        void EnterCombat(Unit* /*who*/)
+        struct boss_instructormaliciaAI : public BossAI
         {
-        }
+            boss_instructormaliciaAI(Creature* creature) : BossAI(creature, DATA_INSTRUCTORMALICIA) {}
 
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
+            uint32 FlashCounter;
+            uint32 TouchCounter;
 
-            //CallOfGraves_Timer
-            if (CallOfGraves_Timer <= diff)
+            void Reset()
             {
-                DoCast(me->getVictim(), SPELL_CALLOFGRAVES);
-                CallOfGraves_Timer = 65000;
-            } else CallOfGraves_Timer -= diff;
+                FlashCounter = 0;
+                TouchCounter = 0;
+            }
 
-            //Corruption_Timer
-            if (Corruption_Timer <= diff)
+            void JustDied(Unit* /*killer*/)
             {
-                Unit* target = NULL;
-                target = SelectTarget(SELECT_TARGET_RANDOM, 0);
-                if (target) DoCast(target, SPELL_CORRUPTION);
+                InstanceScript* instance = me->GetInstanceScript();
+                if (instance)
+                {
+                    instance->SetData(DATA_INSTRUCTORMALICIA, DONE);
 
-                Corruption_Timer = 24000;
-            } else Corruption_Timer -= diff;
+                    if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+                    {
+                        instance->SetData(TYPE_GANDLING, IN_PROGRESS);
+                        me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    }
+                }
+            }
 
-            //Renew_Timer
-            if (Renew_Timer <= diff)
+            void EnterCombat(Unit* /*who*/)
             {
-                DoCast(me, SPELL_RENEW);
-                Renew_Timer = 10000;
-            } else Renew_Timer -= diff;
+                events.ScheduleEvent(EVENT_CALLOFGRAVES, 4000);
+                events.ScheduleEvent(EVENT_CORRUPTION, 8000);
+                events.ScheduleEvent(EVENT_RENEW, 32000);
+                events.ScheduleEvent(EVENT_FLASHHEAL, 38000);
+                events.ScheduleEvent(EVENT_HEALINGTOUCH, 45000);
+            }
 
-            //FlashHeal_Timer
-            if (FlashHeal_Timer <= diff)
+            void UpdateAI(uint32 const diff)
             {
-                DoCast(me, SPELL_FLASHHEAL);
+                if (!UpdateVictim())
+                    return;
 
-                //5 Flashheals will be casted
-                if (FlashCounter < 2)
-                {
-                    FlashHeal_Timer = 5000;
-                    ++FlashCounter;
-                }
-                else
-                {
-                    FlashCounter=0;
-                    FlashHeal_Timer = 30000;
-                }
-            } else FlashHeal_Timer -= diff;
+                events.Update(diff);
 
-            //HealingTouch_Timer
-            if (HealingTouch_Timer <= diff)
-            {
-                DoCast(me, SPELL_HEALINGTOUCH);
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
 
-                //3 Healingtouchs will be casted
-                if (HealingTouch_Timer < 2)
-                {
-                    HealingTouch_Timer = 5500;
-                    ++TouchCounter;
-                }
-                else
+                while (uint32 eventId = events.ExecuteEvent())
                 {
-                    TouchCounter=0;
-                    HealingTouch_Timer = 30000;
+                    switch (eventId)
+                    {
+                        case EVENT_CALLOFGRAVES:
+                            DoCastVictim(SPELL_CALLOFGRAVES, true);
+                            events.ScheduleEvent(EVENT_CALLOFGRAVES, 65000);
+                            break;
+                        case EVENT_CORRUPTION:
+                            DoCast(SelectTarget(SELECT_TARGET_RANDOM,0, 100, true),SPELL_CORRUPTION,true);
+                            events.ScheduleEvent(EVENT_CORRUPTION, 24000);
+                            break;
+                        case EVENT_RENEW:
+                            DoCast(me, SPELL_RENEW);
+                            events.ScheduleEvent(EVENT_RENEW, 10000);
+                            break;
+                        case EVENT_FLASHHEAL:
+                            //5 Flashheals will be casted
+                            DoCast(me, SPELL_FLASHHEAL);
+                            if (FlashCounter < 2)
+                            {
+                                events.ScheduleEvent(EVENT_FLASHHEAL, 5000);
+                                ++FlashCounter;
+                            }
+                            else
+                            {
+                                FlashCounter=0;
+                                events.ScheduleEvent(EVENT_FLASHHEAL, 30000);
+                            }
+                            break;
+                        case EVENT_HEALINGTOUCH:
+                            //3 Healing Touch will be casted
+                            DoCast(me, SPELL_HEALINGTOUCH);
+                            if (TouchCounter < 2)
+                            {
+                                events.ScheduleEvent(EVENT_HEALINGTOUCH, 5500);
+                                ++TouchCounter;
+                            }
+                            else
+                            {
+                                TouchCounter=0;
+                                events.ScheduleEvent(EVENT_HEALINGTOUCH, 30000);
+                            }
+                            break;
+                        default:
+                            break;
+                    }
                 }
-            } else HealingTouch_Timer -= diff;
 
-            DoMeleeAttackIfReady();
+                DoMeleeAttackIfReady();
+            }
+        };
+
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_instructormaliciaAI (creature);
         }
-    };
 
 };
 
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 14ef18aba58..68d7dcdebe8 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_kirtonos_the_herald.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_kirtonos_the_herald.cpp
@@ -103,7 +103,8 @@ class boss_kirtonos_the_herald : public CreatureScript
                     brazier->ResetDoorOrButton();
                     brazier->SetGoState(GO_STATE_READY);
                 }
-                _JustDied();
+                if (instance)
+                    instance->SetData(TYPE_KIRTONOS, DONE);
             }
 
             void EnterEvadeMode()
@@ -173,6 +174,7 @@ class boss_kirtonos_the_herald : public CreatureScript
                                 me->SetWalk(true);
                                 me->SetDisableGravity(false);
                                 DoCast(me, SPELL_KIRTONOS_TRANSFORM);
+                                me->SetCanFly(false);
                                 _introTimer = 1000;
                                 _introEvent = INTRO_5;
                                 break;
@@ -184,7 +186,6 @@ class boss_kirtonos_the_herald : public CreatureScript
                                 _introTimer = 5000;
                                 _introEvent = INTRO_6;
                             case INTRO_6:
-                                 // I don't know how to make him not swim across screen here. Tell me and I will fix.
                                 me->GetMotionMaster()->MovePoint(0, 314.8673f, 90.3021f, 101.6459f);
                                 _introTimer = 0;
                                 _introEvent = 0;
@@ -240,11 +241,13 @@ class boss_kirtonos_the_herald : public CreatureScript
                             {
                                 me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
                                 me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(0));
+                                me->SetCanFly(false);
                             }
                             else
                             {
                                 DoCast(me, SPELL_KIRTONOS_TRANSFORM);
                                 me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(WEAPON_KIRTONOS_STAFF));
+                                me->SetCanFly(true);
                             }
                             events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, urand(16000, 18000));
                             break;
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 dc83e0e20cb..55ef0605c31 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_lord_alexei_barov.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_lord_alexei_barov.cpp
@@ -27,79 +27,87 @@ EndScriptData */
 #include "ScriptedCreature.h"
 #include "scholomance.h"
 
-#define SPELL_IMMOLATE             20294                    // Old ID  was 15570
-#define SPELL_VEILOFSHADOW         17820
-
-class boss_lord_alexei_barov : public CreatureScript
+enum Spells
 {
-public:
-    boss_lord_alexei_barov() : CreatureScript("boss_lord_alexei_barov") { }
-
-    CreatureAI* GetAI(Creature* creature) const
-    {
-        return new boss_lordalexeibarovAI (creature);
-    }
+    SPELL_IMMOLATE                  = 20294, // Old ID  was 15570
+    SPELL_VEILOFSHADOW              = 17820
+};
 
-    struct boss_lordalexeibarovAI : public ScriptedAI
-    {
-        boss_lordalexeibarovAI(Creature* creature) : ScriptedAI(creature) {}
+enum Events
+{
+    EVENT_IMMOLATE                  = 1,
+    EVENT_VEILOFSHADOW              = 2
+};
 
-        uint32 Immolate_Timer;
-        uint32 VeilofShadow_Timer;
+class boss_lord_alexei_barov : public CreatureScript
+{
+    public: boss_lord_alexei_barov() : CreatureScript("boss_lord_alexei_barov") { }
 
-        void Reset()
+        struct boss_lordalexeibarovAI : public BossAI
         {
-            Immolate_Timer = 7000;
-            VeilofShadow_Timer = 15000;
+            boss_lordalexeibarovAI(Creature* creature) : BossAI(creature, DATA_LORDALEXEIBAROV) {}
 
-            me->LoadCreaturesAddon();
-        }
-
-        void JustDied(Unit* /*killer*/)
-        {
-            InstanceScript* instance = me->GetInstanceScript();
-            if (instance)
+            void Reset()
             {
-                instance->SetData(DATA_LORDALEXEIBAROV_DEATH, 0);
+                me->LoadCreaturesAddon();
+            }
 
-                if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+            void JustDied(Unit* /*killer*/)
+            {
+                InstanceScript* instance = me->GetInstanceScript();
+                if (instance)
                 {
-                    instance->SetData(TYPE_GANDLING, IN_PROGRESS);
-                    me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    instance->SetData(DATA_LORDALEXEIBAROV, DONE);
+
+                    if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+                    {
+                        instance->SetData(TYPE_GANDLING, IN_PROGRESS);
+                        me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    }
                 }
             }
-        }
 
-        void EnterCombat(Unit* /*who*/)
-        {
-        }
-
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
+            void EnterCombat(Unit* /*who*/)
+            {
+                events.ScheduleEvent(EVENT_IMMOLATE, 7000);
+                events.ScheduleEvent(EVENT_VEILOFSHADOW, 15000);
+            }
 
-            //Immolate_Timer
-            if (Immolate_Timer <= diff)
+            void UpdateAI(uint32 const diff)
             {
-                Unit* target = NULL;
-                target = SelectTarget(SELECT_TARGET_RANDOM, 0);
-                if (target) DoCast(target, SPELL_IMMOLATE);
+                if (!UpdateVictim())
+                    return;
 
-                Immolate_Timer = 12000;
-            } else Immolate_Timer -= diff;
+                events.Update(diff);
 
-            //VeilofShadow_Timer
-            if (VeilofShadow_Timer <= diff)
-            {
-                DoCast(me->getVictim(), SPELL_VEILOFSHADOW);
-                VeilofShadow_Timer = 20000;
-            } else VeilofShadow_Timer -= diff;
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
 
-            DoMeleeAttackIfReady();
-        }
-    };
+                while (uint32 eventId = events.ExecuteEvent())
+                {
+                    switch (eventId)
+                    {
+                        case EVENT_IMMOLATE:
+                            DoCast(SelectTarget(SELECT_TARGET_RANDOM,0, 100, true),SPELL_IMMOLATE,true);
+                            events.ScheduleEvent(EVENT_IMMOLATE, 12000);
+                            break;
+                        case EVENT_VEILOFSHADOW:
+                            DoCastVictim(SPELL_VEILOFSHADOW, true);
+                            events.ScheduleEvent(EVENT_VEILOFSHADOW, 20000);
+                            break;
+                        default:
+                            break;
+                    }
+                }
 
+                DoMeleeAttackIfReady();
+            }
+        };
+
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_lordalexeibarovAI (creature);
+        }
 };
 
 void AddSC_boss_lordalexeibarov()
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp
index e296ae7143d..cc9180ded76 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_lorekeeper_polkelt.cpp
@@ -27,94 +27,98 @@ EndScriptData */
 #include "ScriptedCreature.h"
 #include "scholomance.h"
 
-#define SPELL_VOLATILEINFECTION      24928
-#define SPELL_DARKPLAGUE             18270
-#define SPELL_CORROSIVEACID          23313
-#define SPELL_NOXIOUSCATALYST        18151
-
-class boss_lorekeeper_polkelt : public CreatureScript
+enum Spells
 {
-public:
-    boss_lorekeeper_polkelt() : CreatureScript("boss_lorekeeper_polkelt") { }
-
-    CreatureAI* GetAI(Creature* creature) const
-    {
-        return new boss_lorekeeperpolkeltAI (creature);
-    }
+    SPELL_VOLATILEINFECTION     = 24928,
+    SPELL_DARKPLAGUE            = 18270,
+    SPELL_CORROSIVEACID         = 23313,
+    SPELL_NOXIOUSCATALYST       = 18151
+};
 
-    struct boss_lorekeeperpolkeltAI : public ScriptedAI
-    {
-        boss_lorekeeperpolkeltAI(Creature* creature) : ScriptedAI(creature) {}
+enum Events
+{
+    EVENT_VOLATILEINFECTION     = 1,
+    EVENT_DARKPLAGUE            = 2,
+    EVENT_CORROSIVEACID         = 3,
+    EVENT_NOXIOUSCATALYST       = 4
+};
 
-        uint32 VolatileInfection_Timer;
-        uint32 Darkplague_Timer;
-        uint32 CorrosiveAcid_Timer;
-        uint32 NoxiousCatalyst_Timer;
+class boss_lorekeeper_polkelt : public CreatureScript
+{
+    public: boss_lorekeeper_polkelt() : CreatureScript("boss_lorekeeper_polkelt") { }
 
-        void Reset()
+        struct boss_lorekeeperpolkeltAI : public BossAI
         {
-            VolatileInfection_Timer = 38000;
-            Darkplague_Timer = 8000;
-            CorrosiveAcid_Timer = 45000;
-            NoxiousCatalyst_Timer = 35000;
-        }
+            boss_lorekeeperpolkeltAI(Creature* creature) : BossAI(creature, DATA_LOREKEEPERPOLKELT) {}
 
-        void JustDied(Unit* /*killer*/)
-        {
-            InstanceScript* instance = me->GetInstanceScript();
-            if (instance)
-            {
-                instance->SetData(DATA_LOREKEEPERPOLKELT_DEATH, 0);
+            void Reset() {}
 
-                if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+            void JustDied(Unit* /*killer*/)
+            {
+                InstanceScript* instance = me->GetInstanceScript();
+                if (instance)
                 {
-                    instance->SetData(TYPE_GANDLING, IN_PROGRESS);
-                    me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    instance->SetData(DATA_LOREKEEPERPOLKELT, DONE);
+
+                    if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+                    {
+                        instance->SetData(TYPE_GANDLING, IN_PROGRESS);
+                        me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    }
                 }
             }
-        }
 
-        void EnterCombat(Unit* /*who*/)
-        {
-        }
-
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
-
-            //VolatileInfection_Timer
-            if (VolatileInfection_Timer <= diff)
+            void EnterCombat(Unit* /*who*/)
             {
-                DoCast(me->getVictim(), SPELL_VOLATILEINFECTION);
-                VolatileInfection_Timer = 32000;
-            } else VolatileInfection_Timer -= diff;
+                events.ScheduleEvent(EVENT_VOLATILEINFECTION, 38000);
+                events.ScheduleEvent(EVENT_DARKPLAGUE, 8000);
+                events.ScheduleEvent(EVENT_CORROSIVEACID, 45000);
+                events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 35000);
+            }
 
-            //Darkplague_Timer
-            if (Darkplague_Timer <= diff)
+            void UpdateAI(uint32 const diff)
             {
-                DoCast(me->getVictim(), SPELL_DARKPLAGUE);
-                Darkplague_Timer = 8000;
-            } else Darkplague_Timer -= diff;
+                if (!UpdateVictim())
+                    return;
 
-            //CorrosiveAcid_Timer
-            if (CorrosiveAcid_Timer <= diff)
-            {
-                DoCast(me->getVictim(), SPELL_CORROSIVEACID);
-                CorrosiveAcid_Timer = 25000;
-            } else CorrosiveAcid_Timer -= diff;
+                events.Update(diff);
 
-            //NoxiousCatalyst_Timer
-            if (NoxiousCatalyst_Timer <= diff)
-            {
-                DoCast(me->getVictim(), SPELL_NOXIOUSCATALYST);
-                NoxiousCatalyst_Timer = 38000;
-            } else NoxiousCatalyst_Timer -= diff;
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
 
-            DoMeleeAttackIfReady();
-        }
-    };
+                while (uint32 eventId = events.ExecuteEvent())
+                {
+                    switch (eventId)
+                    {
+                        case EVENT_VOLATILEINFECTION:
+                            DoCastVictim(SPELL_VOLATILEINFECTION, true);
+                            events.ScheduleEvent(EVENT_VOLATILEINFECTION, 32000);
+                            break;
+                        case EVENT_DARKPLAGUE:
+                            DoCastVictim(SPELL_DARKPLAGUE, true);
+                            events.ScheduleEvent(EVENT_DARKPLAGUE, 8000);
+                            break;
+                        case EVENT_CORROSIVEACID:
+                            DoCastVictim(SPELL_CORROSIVEACID, true);
+                            events.ScheduleEvent(EVENT_CORROSIVEACID, 25000);
+                            break;
+                        case EVENT_NOXIOUSCATALYST:
+                            DoCastVictim(SPELL_NOXIOUSCATALYST, true);
+                            events.ScheduleEvent(EVENT_NOXIOUSCATALYST, 38000);
+                            break;
+                        default:
+                            break;
+                    }
+                }
 
+                DoMeleeAttackIfReady();
+            }
+        };
+
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_lorekeeperpolkeltAI (creature);
+        }
 };
 
 void AddSC_boss_lorekeeperpolkelt()
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp b/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp
index ded2f66e95d..5a6f5d436c4 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/boss_the_ravenian.cpp
@@ -27,96 +27,99 @@ EndScriptData */
 #include "ScriptedCreature.h"
 #include "scholomance.h"
 
-#define SPELL_TRAMPLE           15550
-#define SPELL_CLEAVE            20691
-#define SPELL_SUNDERINCLEAVE    25174
-#define SPELL_KNOCKAWAY         10101
-
-class boss_the_ravenian : public CreatureScript
+enum Spells
 {
-public:
-    boss_the_ravenian() : CreatureScript("boss_the_ravenian") { }
+    SPELL_TRAMPLE                   = 15550,
+    SPELL_CLEAVE                    = 20691,
+    SPELL_SUNDERINCLEAVE            = 25174,
+    SPELL_KNOCKAWAY                 = 10101
+};
 
-    CreatureAI* GetAI(Creature* creature) const
-    {
-        return new boss_theravenianAI (creature);
-    }
+enum Events
+{
+    EVENT_TRAMPLE                   = 1,
+    EVENT_CLEAVE                    = 2,
+    EVENT_SUNDERINCLEAVE            = 3,
+    EVENT_KNOCKAWAY                 = 4
+};
 
-    struct boss_theravenianAI : public ScriptedAI
-    {
-        boss_theravenianAI(Creature* creature) : ScriptedAI(creature) {}
 
-        uint32 Trample_Timer;
-        uint32 Cleave_Timer;
-        uint32 SunderingCleave_Timer;
-        uint32 KnockAway_Timer;
-        bool HasYelled;
+class boss_the_ravenian : public CreatureScript
+{
+    public: boss_the_ravenian() : CreatureScript("boss_the_ravenian") { }
 
-        void Reset()
+        struct boss_theravenianAI : public BossAI
         {
-            Trample_Timer = 24000;
-            Cleave_Timer = 15000;
-            SunderingCleave_Timer = 40000;
-            KnockAway_Timer = 32000;
-            HasYelled = false;
-        }
+            boss_theravenianAI(Creature* creature) : BossAI(creature, DATA_THERAVENIAN) {}
 
-        void JustDied(Unit* /*killer*/)
-        {
-            InstanceScript* instance = me->GetInstanceScript();
-            if (instance)
-            {
-                instance->SetData(DATA_THERAVENIAN_DEATH, 0);
+            void Reset() {}
 
-                if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+            void JustDied(Unit* /*killer*/)
+            {
+                InstanceScript* instance = me->GetInstanceScript();
+                if (instance)
                 {
-                    instance->SetData(TYPE_GANDLING, IN_PROGRESS);
-                    me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    instance->SetData(DATA_THERAVENIAN, DONE);
+
+                    if (instance->GetData(TYPE_GANDLING) == IN_PROGRESS)
+                    {
+                        instance->SetData(TYPE_GANDLING, IN_PROGRESS);
+                        me->SummonCreature(1853, 180.73f, -9.43856f, 75.507f, 1.61399f, TEMPSUMMON_DEAD_DESPAWN, 0);
+                    }
                 }
             }
-        }
-
-        void EnterCombat(Unit* /*who*/)
-        {
-        }
-
-        void UpdateAI(const uint32 diff)
-        {
-            if (!UpdateVictim())
-                return;
 
-            //Trample_Timer
-            if (Trample_Timer <= diff)
+            void EnterCombat(Unit* /*who*/)
             {
-                DoCast(me->getVictim(), SPELL_TRAMPLE);
-                Trample_Timer = 10000;
-            } else Trample_Timer -= diff;
+                events.ScheduleEvent(EVENT_TRAMPLE, 24000);
+                events.ScheduleEvent(EVENT_CLEAVE, 15000);
+                events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 40000);
+                events.ScheduleEvent(EVENT_KNOCKAWAY, 32000);
+            }
 
-            //Cleave_Timer
-            if (Cleave_Timer <= diff)
+            void UpdateAI(uint32 const diff)
             {
-                DoCast(me->getVictim(), SPELL_CLEAVE);
-                Cleave_Timer = 7000;
-            } else Cleave_Timer -= diff;
+                if (!UpdateVictim())
+                    return;
 
-            //SunderingCleave_Timer
-            if (SunderingCleave_Timer <= diff)
-            {
-                DoCast(me->getVictim(), SPELL_SUNDERINCLEAVE);
-                SunderingCleave_Timer = 20000;
-            } else SunderingCleave_Timer -= diff;
+                events.Update(diff);
 
-            //KnockAway_Timer
-            if (KnockAway_Timer <= diff)
-            {
-                DoCast(me->getVictim(), SPELL_KNOCKAWAY);
-                KnockAway_Timer = 12000;
-            } else KnockAway_Timer -= diff;
+                if (me->HasUnitState(UNIT_STATE_CASTING))
+                    return;
 
-            DoMeleeAttackIfReady();
-        }
-    };
+                while (uint32 eventId = events.ExecuteEvent())
+                {
+                    switch (eventId)
+                    {
+                        case EVENT_TRAMPLE:
+                            DoCastVictim(SPELL_TRAMPLE, true);
+                            events.ScheduleEvent(EVENT_TRAMPLE, 10000);
+                            break;
+                        case EVENT_CLEAVE:
+                            DoCastVictim(SPELL_CLEAVE, true);
+                            events.ScheduleEvent(EVENT_CLEAVE, 7000);
+                            break;
+                        case EVENT_SUNDERINCLEAVE:
+                            DoCastVictim(SPELL_SUNDERINCLEAVE, true);
+                            events.ScheduleEvent(EVENT_SUNDERINCLEAVE, 20000);
+                            break;
+                        case EVENT_KNOCKAWAY:
+                            DoCastVictim(SPELL_KNOCKAWAY, true);
+                            events.ScheduleEvent(EVENT_KNOCKAWAY, 12000);
+                            break;
+                        default:
+                            break;
+                    }
+                }
 
+                DoMeleeAttackIfReady();
+            }
+        };
+
+        CreatureAI* GetAI(Creature* creature) const
+        {
+            return new boss_theravenianAI (creature);
+        }
 };
 
 void AddSC_boss_theravenian()
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/instance_scholomance.cpp b/src/server/scripts/EasternKingdoms/Scholomance/instance_scholomance.cpp
index fc966c4bbb9..04a12ae2bd2 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/instance_scholomance.cpp
+++ b/src/server/scripts/EasternKingdoms/Scholomance/instance_scholomance.cpp
@@ -93,22 +93,22 @@ public:
         {
             switch (type)
             {
-                case DATA_LORDALEXEIBAROV_DEATH:
+                case DATA_LORDALEXEIBAROV:
                     IsBossDied[0] = true;
                     break;
-                case DATA_DOCTORTHEOLENKRASTINOV_DEATH:
+                case DATA_DOCTORTHEOLENKRASTINOV:
                     IsBossDied[1] = true;
                     break;
-                case DATA_THERAVENIAN_DEATH:
+                case DATA_THERAVENIAN:
                     IsBossDied[2] = true;
                     break;
-                case DATA_LOREKEEPERPOLKELT_DEATH:
+                case DATA_LOREKEEPERPOLKELT:
                     IsBossDied[3] = true;
                     break;
-                case DATA_INSTRUCTORMALICIA_DEATH:
+                case DATA_INSTRUCTORMALICIA:
                     IsBossDied[4] = true;
                     break;
-                case DATA_LADYILLUCIABAROV_DEATH:
+                case DATA_LADYILLUCIABAROV:
                     IsBossDied[5] = true;
                     break;
                 case TYPE_GANDLING:
diff --git a/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h b/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h
index 20b782fd43a..f89f36d91e5 100644
--- a/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h
+++ b/src/server/scripts/EasternKingdoms/Scholomance/scholomance.h
@@ -24,12 +24,12 @@ uint32 const MAX_ENCOUNTER = 2;
 enum DataTypes
 {
     TYPE_GANDLING                       = 1,
-    DATA_DOCTORTHEOLENKRASTINOV_DEATH   = 2,
-    DATA_INSTRUCTORMALICIA_DEATH        = 3,
-    DATA_LADYILLUCIABAROV_DEATH         = 4,
-    DATA_LORDALEXEIBAROV_DEATH          = 5,
-    DATA_LOREKEEPERPOLKELT_DEATH        = 6,
-    DATA_THERAVENIAN_DEATH              = 7,
+    DATA_DOCTORTHEOLENKRASTINOV         = 2,
+    DATA_INSTRUCTORMALICIA              = 3,
+    DATA_LADYILLUCIABAROV               = 4,
+    DATA_LORDALEXEIBAROV                = 5,
+    DATA_LOREKEEPERPOLKELT              = 6,
+    DATA_THERAVENIAN                    = 7,
     TYPE_KIRTONOS                       = 8
 };