Scripts/SteamVault: Hydromancer Thespia rewritten to BossAI

1 files changed, 125 insertions, 112 deletions

diff --git a/src/server/scripts/Outland/CoilfangReservoir/SteamVault/boss_hydromancer_thespia.cpp b/src/server/scripts/Outland/CoilfangReservoir/SteamVault/boss_hydromancer_thespia.cpp
index dc0a6643624..d4fdb262c8e 100644
--- a/src/server/scripts/Outland/CoilfangReservoir/SteamVault/boss_hydromancer_thespia.cpp
+++ b/src/server/scripts/Outland/CoilfangReservoir/SteamVault/boss_hydromancer_thespia.cpp
@@ -19,156 +19,169 @@
 #include "ScriptedCreature.h"
 #include "steam_vault.h"
 
-enum HydromancerThespia
+enum Yells
 {
     SAY_SUMMON                  = 0,
     SAY_AGGRO                   = 1,
     SAY_SLAY                    = 2,
     SAY_DEAD                    = 3,
+};
 
+enum Spells
+{
     SPELL_LIGHTNING_CLOUD       = 25033,
     SPELL_LUNG_BURST            = 31481,
-    SPELL_ENVELOPING_WINDS      = 31718,
+    SPELL_ENVELOPING_WINDS      = 31718
+};
 
-    SPELL_WATER_BOLT_VOLLEY     = 34449,
-    H_SPELL_WATER_BOLT_VOLLEY   = 37924
+enum Events
+{
+    EVENT_LIGHTNING_CLOUD       = 1,
+    EVENT_LUNG_BURST,
+    EVENT_ENVELOPING_WINDS
 };
 
 class boss_hydromancer_thespia : public CreatureScript
 {
-public:
-    boss_hydromancer_thespia() : CreatureScript("boss_hydromancer_thespia") { }
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetInstanceAI<boss_thespiaAI>(creature);
-    }
-
-    struct boss_thespiaAI : public ScriptedAI
-    {
-        boss_thespiaAI(Creature* creature) : ScriptedAI(creature)
-        {
-            instance = creature->GetInstanceScript();
-        }
-
-        InstanceScript* instance;
-
-        uint32 LightningCloud_Timer;
-        uint32 LungBurst_Timer;
-        uint32 EnvelopingWinds_Timer;
-
-        void Reset() override
-        {
-            LightningCloud_Timer = 15000;
-            LungBurst_Timer = 7000;
-            EnvelopingWinds_Timer = 9000;
-
-            instance->SetBossState(DATA_HYDROMANCER_THESPIA, NOT_STARTED);
-        }
-
-        void JustDied(Unit* /*killer*/) override
-        {
-            Talk(SAY_DEAD);
-
-            instance->SetBossState(DATA_HYDROMANCER_THESPIA, DONE);
-        }
-
-        void KilledUnit(Unit* /*victim*/) override
-        {
-            Talk(SAY_SLAY);
-        }
+    public:
+        boss_hydromancer_thespia() : CreatureScript("boss_hydromancer_thespia") { }
 
-        void EnterCombat(Unit* /*who*/) override
+        struct boss_thespiaAI : public BossAI
         {
-            Talk(SAY_AGGRO);
+            boss_thespiaAI(Creature* creature) : BossAI(creature, DATA_HYDROMANCER_THESPIA) { }
 
-            instance->SetBossState(DATA_HYDROMANCER_THESPIA, IN_PROGRESS);
-        }
+            void Reset() override
+            {
+                _Reset();
+            }
 
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
+            void JustDied(Unit* /*killer*/) override
+            {
+                Talk(SAY_DEAD);
+                _JustDied();
+            }
 
-            //LightningCloud_Timer
-            if (LightningCloud_Timer <= diff)
+            void KilledUnit(Unit* who) override
             {
-                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
-                    DoCast(target, SPELL_LIGHTNING_CLOUD);
+                if (who->GetTypeId() == TYPEID_PLAYER)
+                    Talk(SAY_SLAY);
+            }
 
-                //cast twice in Heroic mode
-                if (IsHeroic())
-                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
-                        DoCast(target, SPELL_LIGHTNING_CLOUD);
+            void EnterCombat(Unit* /*who*/) override
+            {
+                Talk(SAY_AGGRO);
+                _EnterCombat();
 
-                LightningCloud_Timer = 15000 + rand32() % 10000;
-            } else LightningCloud_Timer -=diff;
+                events.ScheduleEvent(EVENT_LIGHTNING_CLOUD, 15000);
+                events.ScheduleEvent(EVENT_LUNG_BURST, 7000);
+                events.ScheduleEvent(EVENT_ENVELOPING_WINDS, 9000);
+            }
 
-            //LungBurst_Timer
-            if (LungBurst_Timer <= diff)
+            void ExecuteEvent(uint32 eventId) override
             {
-                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
-                    DoCast(target, SPELL_LUNG_BURST);
-                LungBurst_Timer = 7000 + rand32() % 5000;
-            } else LungBurst_Timer -=diff;
-
-            //EnvelopingWinds_Timer
-            if (EnvelopingWinds_Timer <= diff)
+                switch (eventId)
+                {
+                    case EVENT_LIGHTNING_CLOUD:
+                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30.0f, true))
+                            DoCast(target, SPELL_LIGHTNING_CLOUD);
+                        // cast twice in Heroic mode
+                        if (IsHeroic())
+                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30.0f, true))
+                                DoCast(target, SPELL_LIGHTNING_CLOUD);
+
+                        events.ScheduleEvent(EVENT_LIGHTNING_CLOUD, urand(15000, 25000));
+                        break;
+                    case EVENT_LUNG_BURST:
+                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 40.0f, true))
+                            DoCast(target, SPELL_LUNG_BURST);
+                        events.ScheduleEvent(EVENT_LUNG_BURST, urand(7000, 12000));
+                        break;
+                    case EVENT_ENVELOPING_WINDS:
+                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 35.0f, true))
+                            DoCast(target, SPELL_ENVELOPING_WINDS);
+                        // cast twice in Heroic mode
+                        if (IsHeroic())
+                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 35.0f, true))
+                                DoCast(target, SPELL_ENVELOPING_WINDS);
+
+                        events.ScheduleEvent(EVENT_ENVELOPING_WINDS, urand(10000, 15000));
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            void UpdateAI(uint32 diff) override
             {
-                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
-                    DoCast(target, SPELL_ENVELOPING_WINDS);
-
-                //cast twice in Heroic mode
-                if (IsHeroic())
-                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
-                        DoCast(target, SPELL_ENVELOPING_WINDS);
-                EnvelopingWinds_Timer = 10000 + rand32() % 5000;
-            } else EnvelopingWinds_Timer -=diff;
+                BossAI::UpdateAI(diff);
+            }
+        };
 
-            DoMeleeAttackIfReady();
+        CreatureAI* GetAI(Creature* creature) const override
+        {
+            return GetInstanceAI<boss_thespiaAI>(creature);
         }
-    };
+};
 
+enum CoilfangWaterElemental
+{
+    EVENT_WATER_BOLT_VOLLEY     = 1,
+    SPELL_WATER_BOLT_VOLLEY     = 34449
 };
 
 class npc_coilfang_waterelemental : public CreatureScript
 {
-public:
-    npc_coilfang_waterelemental() : CreatureScript("npc_coilfang_waterelemental") { }
+    public:
+        npc_coilfang_waterelemental() : CreatureScript("npc_coilfang_waterelemental") { }
 
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return new npc_coilfang_waterelementalAI(creature);
-    }
-
-    struct npc_coilfang_waterelementalAI : public ScriptedAI
-    {
-        npc_coilfang_waterelementalAI(Creature* creature) : ScriptedAI(creature) { }
-
-        uint32 WaterBoltVolley_Timer;
-
-        void Reset() override
+        struct npc_coilfang_waterelementalAI : public ScriptedAI
         {
-            WaterBoltVolley_Timer = 3000 + rand32() % 3000;
-        }
-
-        void EnterCombat(Unit* /*who*/) override { }
+            npc_coilfang_waterelementalAI(Creature* creature) : ScriptedAI(creature) { }
 
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
+            void Reset() override
+            {
+                _events.Reset();
+            }
 
-            if (WaterBoltVolley_Timer <= diff)
+            void EnterCombat(Unit* /*who*/) override
             {
-                DoCast(me, SPELL_WATER_BOLT_VOLLEY);
-                WaterBoltVolley_Timer = 7000 + rand32() % 5000;
-            } else WaterBoltVolley_Timer -= diff;
+                _events.ScheduleEvent(EVENT_WATER_BOLT_VOLLEY, urand(3000, 6000));
+            }
 
-            DoMeleeAttackIfReady();
+            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_WATER_BOLT_VOLLEY:
+                            DoCast(me, SPELL_WATER_BOLT_VOLLEY);
+                            _events.ScheduleEvent(EVENT_WATER_BOLT_VOLLEY, urand(7000, 12000));
+                            break;
+                        default:
+                            break;
+                    }
+                }
+
+                DoMeleeAttackIfReady();
+            }
+
+        private:
+            EventMap _events;
+        };
+
+        CreatureAI* GetAI(Creature* creature) const override
+        {
+            return new npc_coilfang_waterelementalAI(creature);
         }
-    };
-
 };
 
 void AddSC_boss_hydromancer_thespia()