refactor(Scripts/Steamvault): Modernize boss/instance scripts (#15224)

src/server/scripts/Outland/CoilfangReservoir/SteamVault/boss_hydromancer_thespia.cpp

@@ -35,55 +35,29 @@ enum HydromancerThespia
     EVENT_SPELL_ENVELOPING      = 3
 };
 
-class boss_hydromancer_thespia : public CreatureScript
+struct boss_hydromancer_thespia : public BossAI
 {
-public:
+    boss_hydromancer_thespia(Creature* creature) : BossAI(creature, DATA_HYDROMANCER_THESPIA) { }
-    boss_hydromancer_thespia() : CreatureScript("boss_hydromancer_thespia") { }
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetSteamVaultAI<boss_thespiaAI>(creature);
-    }
-
-    struct boss_thespiaAI : public ScriptedAI
-    {
-        boss_thespiaAI(Creature* creature) : ScriptedAI(creature)
-        {
-            instance = creature->GetInstanceScript();
-        }
-
-        InstanceScript* instance;
-        EventMap events;
-
-        void Reset() override
-        {
-            events.Reset();
-            if (instance)
-                instance->SetData(TYPE_HYDROMANCER_THESPIA, NOT_STARTED);
-        }
 
     void JustDied(Unit* /*killer*/) override
     {
+        _JustDied();
         Talk(SAY_DEAD);
-            if (instance)
-                instance->SetData(TYPE_HYDROMANCER_THESPIA, DONE);
     }
 
     void KilledUnit(Unit* victim) override
     {
-            if (victim->GetTypeId() == TYPEID_PLAYER)
+        if (victim->IsPlayer())
             Talk(SAY_SLAY);
     }
 
     void JustEngagedWith(Unit* /*who*/) override
     {
         Talk(SAY_AGGRO);
+        _JustEngagedWith();
         events.ScheduleEvent(EVENT_SPELL_LIGHTNING, 15000);
         events.ScheduleEvent(EVENT_SPELL_LUNG, 7000);
         events.ScheduleEvent(EVENT_SPELL_ENVELOPING, 9000);
-
-            if (instance)
-                instance->SetData(TYPE_HYDROMANCER_THESPIA, IN_PROGRESS);
     }
 
     void UpdateAI(uint32 diff) override
@@ -116,9 +90,8 @@ public:
         DoMeleeAttackIfReady();
     }
 };
-};
 
 void AddSC_boss_hydromancer_thespia()
 {
-    new boss_hydromancer_thespia();
+    RegisterSteamvaultCreatureAI(boss_hydromancer_thespia);
 }

src/server/scripts/Outland/CoilfangReservoir/SteamVault/boss_mekgineer_steamrigger.cpp

@@ -42,58 +42,32 @@ enum MekgineerSteamrigger
     EVENT_SPELL_NET             = 6
 };
 
-class boss_mekgineer_steamrigger : public CreatureScript
+struct boss_mekgineer_steamrigger : public BossAI
 {
-public:
+    boss_mekgineer_steamrigger(Creature* creature) : BossAI(creature, DATA_MEKGINEER_STEAMRIGGER) { }
-    boss_mekgineer_steamrigger() : CreatureScript("boss_mekgineer_steamrigger") { }
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetSteamVaultAI<boss_mekgineer_steamriggerAI>(creature);
-    }
-
-    struct boss_mekgineer_steamriggerAI : public ScriptedAI
-    {
-        boss_mekgineer_steamriggerAI(Creature* creature) : ScriptedAI(creature)
-        {
-            instance = creature->GetInstanceScript();
-        }
-
-        InstanceScript* instance;
-        EventMap events;
-
-        void Reset() override
-        {
-            events.Reset();
-            if (instance)
-                instance->SetData(TYPE_MEKGINEER_STEAMRIGGER, NOT_STARTED);
-        }
 
     void JustDied(Unit* /*killer*/) override
     {
         Talk(SAY_DEATH);
-            if (instance)
+        _JustDied();
-                instance->SetData(TYPE_MEKGINEER_STEAMRIGGER, DONE);
     }
 
     void KilledUnit(Unit* victim) override
     {
-            if (victim->GetTypeId() == TYPEID_PLAYER)
+        if (victim->IsPlayer())
             Talk(SAY_SLAY);
     }
 
     void JustEngagedWith(Unit* /*who*/) override
     {
         Talk(SAY_AGGRO);
+        _JustEngagedWith();
         events.ScheduleEvent(EVENT_SPELL_SHRINK, 20000);
         events.ScheduleEvent(EVENT_SPELL_SAW, 15000);
         events.ScheduleEvent(EVENT_SPELL_NET, 10000);
         events.ScheduleEvent(EVENT_CHECK_HP75, 5000);
         events.ScheduleEvent(EVENT_CHECK_HP50, 5000);
         events.ScheduleEvent(EVENT_CHECK_HP25, 5000);
-
-            if (instance)
-                instance->SetData(TYPE_MEKGINEER_STEAMRIGGER, IN_PROGRESS);
     }
 
     void SummonMechanics()
@@ -151,62 +125,57 @@ public:
         DoMeleeAttackIfReady();
     }
 };
-};
 
-class npc_steamrigger_mechanic : public CreatureScript
+struct npc_steamrigger_mechanic : public ScriptedAI
 {
-public:
+    npc_steamrigger_mechanic(Creature* creature) : ScriptedAI(creature) { }
-    npc_steamrigger_mechanic() : CreatureScript("npc_steamrigger_mechanic") { }
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetSteamVaultAI<npc_steamrigger_mechanicAI>(creature);
-    }
-
-    struct npc_steamrigger_mechanicAI : public ScriptedAI
-    {
-        npc_steamrigger_mechanicAI(Creature* creature) : ScriptedAI(creature)
-        {
-        }
-
-        uint32 repairTimer;
-        ObjectGuid bossGUID;
 
     void Reset() override
     {
-            repairTimer = 0;
+        _scheduler.CancelAll();
-            bossGUID.Clear();
+    }
+
+    void JustEngagedWith(Unit* victim) override
+    {
+        ScriptedAI::JustEngagedWith(victim);
+
+        _scheduler.Schedule(2s, [this](TaskContext context)
+        {
             if (InstanceScript* instance = me->GetInstanceScript())
-                bossGUID = instance->GetGuidData(TYPE_MEKGINEER_STEAMRIGGER);
+            {
+                if (Creature* boss = instance->GetCreature(DATA_MEKGINEER_STEAMRIGGER))
+                {
+                    if (me->IsWithinDistInMap(boss, 13.0f))
+                    {
+                        if (!me->HasUnitState(UNIT_STATE_CASTING))
+                        {
+                            me->CastSpell(me, DUNGEON_MODE(SPELL_REPAIR_N, SPELL_REPAIR_H), false);
+                        }
+                    }
+                }
+            }
+
+            context.Repeat();
+        });
     }
 
     void MoveInLineOfSight(Unit* /*who*/) override {}
 
     void UpdateAI(uint32 diff) override
     {
-            repairTimer += diff;
-            if (repairTimer >= 2000)
-            {
-                repairTimer = 0;
-                if (Unit* boss = ObjectAccessor::GetUnit(*me, bossGUID))
-                {
-                    if (me->IsWithinDistInMap(boss, 13.0f))
-                        if (!me->HasUnitState(UNIT_STATE_CASTING))
-                            me->CastSpell(me, DUNGEON_MODE(SPELL_REPAIR_N, SPELL_REPAIR_H), false);
-                }
-                return;
-            }
-
         if (!UpdateVictim())
             return;
 
-            DoMeleeAttackIfReady();
+        _scheduler.Update(diff,
+            std::bind(&BossAI::DoMeleeAttackIfReady, this));
     }
-    };
+
+    private:
+        TaskScheduler _scheduler;
 };
 
 void AddSC_boss_mekgineer_steamrigger()
 {
-    new boss_mekgineer_steamrigger();
+    RegisterSteamvaultCreatureAI(boss_mekgineer_steamrigger);
-    new npc_steamrigger_mechanic();
+    RegisterSteamvaultCreatureAI(npc_steamrigger_mechanic);
 }

src/server/scripts/Outland/CoilfangReservoir/SteamVault/boss_warlord_kalithresh.cpp

@@ -41,55 +41,31 @@ enum NagaDistiller
     EVENT_SPELL_RAGE            = 3
 };
 
-class boss_warlord_kalithresh : public CreatureScript
+struct boss_warlord_kalithresh : public BossAI
 {
-public:
+    boss_warlord_kalithresh(Creature* creature) : BossAI(creature, DATA_WARLORD_KALITHRESH) { }
-    boss_warlord_kalithresh() : CreatureScript("boss_warlord_kalithresh") { }
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetSteamVaultAI<boss_warlord_kalithreshAI>(creature);
-    }
-
-    struct boss_warlord_kalithreshAI : public ScriptedAI
-    {
-        boss_warlord_kalithreshAI(Creature* creature) : ScriptedAI(creature)
-        {
-            instance = creature->GetInstanceScript();
-        }
-
-        InstanceScript* instance;
-        EventMap events;
-
-        void Reset() override
-        {
-            events.Reset();
-            if (instance)
-                instance->SetData(TYPE_WARLORD_KALITHRESH, NOT_STARTED);
-        }
 
     void JustEngagedWith(Unit* /*who*/) override
     {
         Talk(SAY_AGGRO);
+        _JustEngagedWith();
         events.ScheduleEvent(EVENT_SPELL_REFLECTION, 10000);
         events.ScheduleEvent(EVENT_SPELL_IMPALE, urand(7000, 14000));
         events.ScheduleEvent(EVENT_SPELL_RAGE, 20000);
-
-            if (instance)
-                instance->SetData(TYPE_WARLORD_KALITHRESH, IN_PROGRESS);
     }
 
     void KilledUnit(Unit* victim) override
     {
-            if (victim->GetTypeId() == TYPEID_PLAYER)
+        if (victim->IsPlayer())
+        {
             Talk(SAY_SLAY);
         }
+    }
 
     void JustDied(Unit* /*killer*/) override
     {
         Talk(SAY_DEATH);
-            if (instance)
+        _JustDied();
-                instance->SetData(TYPE_WARLORD_KALITHRESH, DONE);
     }
 
     void UpdateAI(uint32 diff) override
@@ -123,26 +99,11 @@ public:
         DoMeleeAttackIfReady();
     }
 };
-};
 
-class npc_naga_distiller : public CreatureScript
+struct npc_naga_distiller : public NullCreatureAI
 {
-public:
+    npc_naga_distiller(Creature* creature) : NullCreatureAI(creature) { }
-    npc_naga_distiller() : CreatureScript("npc_naga_distiller") { }
 
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetSteamVaultAI<npc_naga_distillerAI>(creature);
-    }
-
-    struct npc_naga_distillerAI : public NullCreatureAI
-    {
-        npc_naga_distillerAI(Creature* creature) : NullCreatureAI(creature)
-        {
-            instance = creature->GetInstanceScript();
-        }
-
-        InstanceScript* instance;
     uint32 spellTimer;
 
     void Reset() override
@@ -177,10 +138,9 @@ public:
         }
     }
 };
-};
 
 void AddSC_boss_warlord_kalithresh()
 {
-    new boss_warlord_kalithresh();
+    RegisterSteamvaultCreatureAI(boss_warlord_kalithresh);
-    new npc_naga_distiller();
+    RegisterSteamvaultCreatureAI(npc_naga_distiller);
 }

src/server/scripts/Outland/CoilfangReservoir/SteamVault/instance_steam_vault.cpp

@@ -26,26 +26,48 @@ public:
 
     bool OnGossipHello(Player* /*player*/, GameObject* go) override
     {
-        InstanceScript* instance = go->GetInstanceScript();
+        if (InstanceScript* instance = go->GetInstanceScript())
-        if (!instance)
+        {
-            return false;
-
             if (go->GetEntry() == GO_ACCESS_PANEL_HYDRO)
-            if (instance->GetData(TYPE_HYDROMANCER_THESPIA) == DONE)
+            {
+                if (instance->GetBossState(DATA_HYDROMANCER_THESPIA) == DONE)
                 {
                     go->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
-                instance->SetData(TYPE_HYDROMANCER_THESPIA, SPECIAL);
+                }
+            }
+            else
+            {
+                if (instance->GetBossState(DATA_MEKGINEER_STEAMRIGGER) == DONE)
+                {
+                    go->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
+                }
             }
 
-        if (go->GetEntry() == GO_ACCESS_PANEL_MEK)
+            if (instance->GetBossState(DATA_HYDROMANCER_THESPIA) == DONE && instance->GetBossState(DATA_MEKGINEER_STEAMRIGGER) == DONE)
-            if (instance->GetData(TYPE_MEKGINEER_STEAMRIGGER) == DONE)
             {
-                go->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
+                if (GameObject* mainGate = instance->GetGameObject(DATA_MAIN_CHAMBERS_DOOR))
-                instance->SetData(TYPE_MEKGINEER_STEAMRIGGER, SPECIAL);
+                {
+                    instance->HandleGameObject(ObjectGuid::Empty, true, mainGate);
+                }
             }
 
             return true;
         }
+
+        return false;
+    }
+};
+
+ObjectData const creatureData[] =
+{
+    { NPC_MEKGINEER_STEAMRIGGER, DATA_MEKGINEER_STEAMRIGGER }
+};
+
+ObjectData const objectData[] =
+{
+    { GO_ACCESS_PANEL_HYDRO, DATA_ACCESS_PANEL_HYDROMANCER },
+    { GO_ACCESS_PANEL_MEK,   DATA_ACCESS_PANEL_MEKGINEER   },
+    { GO_MAIN_CHAMBERS_DOOR, DATA_MAIN_CHAMBERS_DOOR       }
 };
 
 class instance_steam_vault : public InstanceMapScript
@@ -53,44 +75,13 @@ class instance_steam_vault : public InstanceMapScript
 public:
     instance_steam_vault() : InstanceMapScript("instance_steam_vault", 545) { }
 
-    InstanceScript* GetInstanceScript(InstanceMap* map) const override
-    {
-        return new instance_steam_vault_InstanceMapScript(map);
-    }
-
     struct instance_steam_vault_InstanceMapScript : public InstanceScript
     {
-        instance_steam_vault_InstanceMapScript(Map* map) : InstanceScript(map) {}
+        instance_steam_vault_InstanceMapScript(Map* map) : InstanceScript(map)
-
-        uint32 m_auiEncounter[MAX_ENCOUNTER];
-
-        ObjectGuid MekgineerGUID;
-        ObjectGuid MainChambersDoor;
-        ObjectGuid AccessPanelHydro;
-        ObjectGuid AccessPanelMek;
-
-        void Initialize() override
         {
-            memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
+            SetHeaders(DataHeaders);
-        }
+            SetBossNumber(EncounterCount);
-
+            LoadObjectData(creatureData, objectData);
-        bool IsEncounterInProgress() const override
-        {
-            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                if (m_auiEncounter[i] == IN_PROGRESS)
-                    return true;
-
-            return false;
-        }
-
-        void OnCreatureCreate(Creature* creature) override
-        {
-            switch (creature->GetEntry())
-            {
-                case NPC_MEKGINEER_STEAMRIGGER:
-                    MekgineerGUID = creature->GetGUID();
-                    break;
-            }
         }
 
         void OnGameObjectCreate(GameObject* go) override
@@ -98,122 +89,56 @@ public:
             switch (go->GetEntry())
             {
                 case GO_MAIN_CHAMBERS_DOOR:
-                    MainChambersDoor = go->GetGUID();
+                    if (GetBossState(DATA_HYDROMANCER_THESPIA) == DONE && GetBossState(DATA_MEKGINEER_STEAMRIGGER) == DONE)
-                    if (GetData(TYPE_HYDROMANCER_THESPIA) == SPECIAL && GetData(TYPE_MEKGINEER_STEAMRIGGER) == SPECIAL)
                         HandleGameObject(ObjectGuid::Empty, true, go);
                     break;
                 case GO_ACCESS_PANEL_HYDRO:
-                    AccessPanelHydro = go->GetGUID();
+                    if (GetBossState(DATA_HYDROMANCER_THESPIA) == DONE)
-                    if (GetData(TYPE_HYDROMANCER_THESPIA) == DONE)
                         go->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
-                    else if (GetData(TYPE_HYDROMANCER_THESPIA) == SPECIAL)
+                    else if (GetBossState(DATA_HYDROMANCER_THESPIA) == SPECIAL)
                         HandleGameObject(ObjectGuid::Empty, true, go);
                     break;
                 case GO_ACCESS_PANEL_MEK:
-                    AccessPanelMek = go->GetGUID();
+                    if (GetBossState(DATA_MEKGINEER_STEAMRIGGER) == DONE)
-                    if (GetData(TYPE_MEKGINEER_STEAMRIGGER) == DONE)
                         go->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
-                    else if (GetData(TYPE_MEKGINEER_STEAMRIGGER) == SPECIAL)
+                    else if (GetBossState(DATA_MEKGINEER_STEAMRIGGER) == SPECIAL)
                         HandleGameObject(ObjectGuid::Empty, true, go);
                     break;
             }
+
+            InstanceScript::OnGameObjectCreate(go);
         }
 
-        void SetData(uint32 type, uint32 data) override
+        bool SetBossState(uint32 bossId, EncounterState state) override
         {
-            switch (type)
+            if (!InstanceScript::SetBossState(bossId, state))
             {
-                case TYPE_HYDROMANCER_THESPIA:
+                return false;
-                    if (data == SPECIAL)
-                    {
-                        if (GetData(TYPE_MEKGINEER_STEAMRIGGER) == SPECIAL)
-                            HandleGameObject(MainChambersDoor, true);
             }
-                    else if (data == DONE)
+
+            if (bossId == DATA_HYDROMANCER_THESPIA && state == DONE)
+            {
+                if (GameObject* panel = GetGameObject(DATA_ACCESS_PANEL_HYDROMANCER))
                 {
-                        if (GameObject* panel = instance->GetGameObject(AccessPanelHydro))
                     panel->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                 }
-
-                    m_auiEncounter[type] = data;
-                    break;
-                case TYPE_MEKGINEER_STEAMRIGGER:
-                    if (data == SPECIAL)
-                    {
-                        if (GetData(TYPE_HYDROMANCER_THESPIA) == SPECIAL)
-                            HandleGameObject(MainChambersDoor, true);
             }
-                    else if (data == DONE)
+            else if (bossId == DATA_MEKGINEER_STEAMRIGGER && state == DONE)
+            {
+                if (GameObject* panel = GetGameObject(DATA_ACCESS_PANEL_MEKGINEER))
                 {
-                        if (GameObject* panel = instance->GetGameObject(AccessPanelMek))
                     panel->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                 }
-
-                    m_auiEncounter[type] = data;
-                    break;
-                case TYPE_WARLORD_KALITHRESH:
-                    m_auiEncounter[type] = data;
-                    break;
             }
 
-            if (data == DONE || data == SPECIAL)
+            return true;
-                SaveToDB();
-        }
-
-        uint32 GetData(uint32 type) const override
-        {
-            switch (type)
-            {
-                case TYPE_HYDROMANCER_THESPIA:
-                case TYPE_MEKGINEER_STEAMRIGGER:
-                case TYPE_WARLORD_KALITHRESH:
-                    return m_auiEncounter[type];
-            }
-            return 0;
-        }
-
-        ObjectGuid GetGuidData(uint32 data) const override
-        {
-            if (data == TYPE_MEKGINEER_STEAMRIGGER)
-                return MekgineerGUID;
-
-            return ObjectGuid::Empty;
-        }
-
-        std::string GetSaveData() override
-        {
-            OUT_SAVE_INST_DATA;
-
-            std::ostringstream stream;
-            stream << "S V " << m_auiEncounter[0] << ' ' << m_auiEncounter[1] << ' ' << m_auiEncounter[2];
-
-            OUT_SAVE_INST_DATA_COMPLETE;
-            return stream.str();
-        }
-
-        void Load(const char* strIn) override
-        {
-            if (!strIn)
-            {
-                OUT_LOAD_INST_DATA_FAIL;
-                return;
-            }
-
-            char dataHead1, dataHead2;
-            std::istringstream loadStream(strIn);
-            loadStream >> dataHead1 >> dataHead2;
-
-            if (dataHead1 == 'S' && dataHead2 == 'V')
-                for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
-                {
-                    loadStream >> m_auiEncounter[i];
-                    if (m_auiEncounter[i] == IN_PROGRESS)
-                        m_auiEncounter[i] = NOT_STARTED;
-                }
-
-            OUT_LOAD_INST_DATA_COMPLETE;
         }
     };
+
+    InstanceScript* GetInstanceScript(InstanceMap* map) const override
+    {
+        return new instance_steam_vault_InstanceMapScript(map);
+    }
 };
 
 void AddSC_instance_steam_vault()

src/server/scripts/Outland/CoilfangReservoir/SteamVault/steam_vault.h

@@ -21,14 +21,22 @@
 #include "CreatureAIImpl.h"
 #include "PassiveAI.h"
 
+#define DataHeaders "SV"
+
+uint32 const EncounterCount = 3;
+
 #define SteamVaultScriptName "instance_steam_vault"
 
 enum steamVault
 {
-    TYPE_HYDROMANCER_THESPIA            = 0,
+    DATA_HYDROMANCER_THESPIA            = 0,
-    TYPE_MEKGINEER_STEAMRIGGER          = 1,
+    DATA_MEKGINEER_STEAMRIGGER          = 1,
-    TYPE_WARLORD_KALITHRESH             = 2,
+    DATA_WARLORD_KALITHRESH             = 2,
-    MAX_ENCOUNTER                       = 3
+    MAX_ENCOUNTER                       = 3,
+
+    DATA_ACCESS_PANEL_HYDROMANCER       = 4,
+    DATA_ACCESS_PANEL_MEKGINEER         = 5,
+    DATA_MAIN_CHAMBERS_DOOR             = 6
 };
 
 enum steamVaultNPCGO
@@ -47,4 +55,6 @@ inline AI* GetSteamVaultAI(T* obj)
     return GetInstanceAI<AI>(obj, SteamVaultScriptName);
 }
 
+#define RegisterSteamvaultCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetSteamVaultAI)
+
 #endif