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

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

@@ -35,90 +35,63 @@ 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
+    void JustDied(Unit* /*killer*/) override
     {
-        return GetSteamVaultAI<boss_thespiaAI>(creature);
+        _JustDied();
+        Talk(SAY_DEAD);
     }
 
-    struct boss_thespiaAI : public ScriptedAI
+    void KilledUnit(Unit* victim) override
     {
-        boss_thespiaAI(Creature* creature) : ScriptedAI(creature)
+        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);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        events.Update(diff);
+        switch (events.ExecuteEvent())
         {
-            instance = creature->GetInstanceScript();
+        case EVENT_SPELL_LIGHTNING:
+            for (uint8 i = 0; i < DUNGEON_MODE(1, 2); ++i)
+                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                    me->CastSpell(target, SPELL_LIGHTNING_CLOUD, false);
+            events.RepeatEvent(urand(15000, 25000));
+            break;
+        case EVENT_SPELL_LUNG:
+            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                DoCast(target, SPELL_LUNG_BURST);
+            events.RepeatEvent(urand(7000, 12000));
+            break;
+        case EVENT_SPELL_ENVELOPING:
+            for (uint8 i = 0; i < DUNGEON_MODE(1, 2); ++i)
+                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
+                    me->CastSpell(target, SPELL_ENVELOPING_WINDS, false);
+            events.RepeatEvent(urand(10000, 15000));
+            break;
         }
 
-        InstanceScript* instance;
+        DoMeleeAttackIfReady();
-        EventMap events;
+    }
-
-        void Reset() override
-        {
-            events.Reset();
-            if (instance)
-                instance->SetData(TYPE_HYDROMANCER_THESPIA, NOT_STARTED);
-        }
-
-        void JustDied(Unit* /*killer*/) override
-        {
-            Talk(SAY_DEAD);
-            if (instance)
-                instance->SetData(TYPE_HYDROMANCER_THESPIA, DONE);
-        }
-
-        void KilledUnit(Unit* victim) override
-        {
-            if (victim->GetTypeId() == TYPEID_PLAYER)
-                Talk(SAY_SLAY);
-        }
-
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-            Talk(SAY_AGGRO);
-            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
-        {
-            if (!UpdateVictim())
-                return;
-
-            events.Update(diff);
-            switch (events.ExecuteEvent())
-            {
-                case EVENT_SPELL_LIGHTNING:
-                    for (uint8 i = 0; i < DUNGEON_MODE(1, 2); ++i)
-                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                            me->CastSpell(target, SPELL_LIGHTNING_CLOUD, false);
-                    events.RepeatEvent(urand(15000, 25000));
-                    break;
-                case EVENT_SPELL_LUNG:
-                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                        DoCast(target, SPELL_LUNG_BURST);
-                    events.RepeatEvent(urand(7000, 12000));
-                    break;
-                case EVENT_SPELL_ENVELOPING:
-                    for (uint8 i = 0; i < DUNGEON_MODE(1, 2); ++i)
-                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                            me->CastSpell(target, SPELL_ENVELOPING_WINDS, false);
-                    events.RepeatEvent(urand(10000, 15000));
-                    break;
-            }
-
-            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,171 +42,140 @@ 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
+    void JustDied(Unit* /*killer*/) override
     {
-        return GetSteamVaultAI<boss_mekgineer_steamriggerAI>(creature);
+        Talk(SAY_DEATH);
+        _JustDied();
     }
 
-    struct boss_mekgineer_steamriggerAI : public ScriptedAI
+    void KilledUnit(Unit* victim) override
     {
-        boss_mekgineer_steamriggerAI(Creature* creature) : ScriptedAI(creature)
+        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);
+    }
+
+    void SummonMechanics()
+    {
+        Talk(SAY_MECHANICS);
+
+        me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() + 15.0f, me->GetPositionY() + 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
+        me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() - 15.0f, me->GetPositionY() + 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
+        me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() - 15.0f, me->GetPositionY() - 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
+        if (urand(0, 1))
+            me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() + 15.0f, me->GetPositionY() - 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
+    }
+
+    void JustSummoned(Creature* cr) override
+    {
+        cr->GetMotionMaster()->MoveFollow(me, 0.0f, 0.0f);
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        events.Update(diff);
+        switch (uint32 eventId = events.ExecuteEvent())
         {
-            instance = creature->GetInstanceScript();
+        case EVENT_SPELL_SHRINK:
-        }
+            me->CastSpell(me->GetVictim(), SPELL_SUPER_SHRINK_RAY, false);
-
+            events.RepeatEvent(20000);
-        InstanceScript* instance;
+            break;
-        EventMap events;
+        case EVENT_SPELL_SAW:
-
+            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1))
-        void Reset() override
+                me->CastSpell(target, SPELL_SAW_BLADE, false);
-        {
+            else
-            events.Reset();
+                me->CastSpell(me->GetVictim(), SPELL_SAW_BLADE, false);
-            if (instance)
+            events.RepeatEvent(15000);
-                instance->SetData(TYPE_MEKGINEER_STEAMRIGGER, NOT_STARTED);
+            break;
-        }
+        case EVENT_SPELL_NET:
-
+            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-        void JustDied(Unit* /*killer*/) override
+                me->CastSpell(target, SPELL_ELECTRIFIED_NET, false);
-        {
+            events.RepeatEvent(10000);
-            Talk(SAY_DEATH);
+            break;
-            if (instance)
+        case EVENT_CHECK_HP25:
-                instance->SetData(TYPE_MEKGINEER_STEAMRIGGER, DONE);
+        case EVENT_CHECK_HP50:
-        }
+        case EVENT_CHECK_HP75:
-
+            if (me->HealthBelowPct(eventId * 25))
-        void KilledUnit(Unit* victim) override
-        {
-            if (victim->GetTypeId() == TYPEID_PLAYER)
-                Talk(SAY_SLAY);
-        }
-
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-            Talk(SAY_AGGRO);
-            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()
-        {
-            Talk(SAY_MECHANICS);
-
-            me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() + 15.0f, me->GetPositionY() + 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
-            me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() - 15.0f, me->GetPositionY() + 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
-            me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() - 15.0f, me->GetPositionY() - 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
-            if (urand(0, 1))
-                me->SummonCreature(NPC_STREAMRIGGER_MECHANIC, me->GetPositionX() + 15.0f, me->GetPositionY() - 15.0f, me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
-        }
-
-        void JustSummoned(Creature* cr) override
-        {
-            cr->GetMotionMaster()->MoveFollow(me, 0.0f, 0.0f);
-        }
-
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
-
-            events.Update(diff);
-            switch (uint32 eventId = events.ExecuteEvent())
             {
-                case EVENT_SPELL_SHRINK:
+                SummonMechanics();
-                    me->CastSpell(me->GetVictim(), SPELL_SUPER_SHRINK_RAY, false);
+                return;
-                    events.RepeatEvent(20000);
-                    break;
-                case EVENT_SPELL_SAW:
-                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1))
-                        me->CastSpell(target, SPELL_SAW_BLADE, false);
-                    else
-                        me->CastSpell(me->GetVictim(), SPELL_SAW_BLADE, false);
-                    events.RepeatEvent(15000);
-                    break;
-                case EVENT_SPELL_NET:
-                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
-                        me->CastSpell(target, SPELL_ELECTRIFIED_NET, false);
-                    events.RepeatEvent(10000);
-                    break;
-                case EVENT_CHECK_HP25:
-                case EVENT_CHECK_HP50:
-                case EVENT_CHECK_HP75:
-                    if (me->HealthBelowPct(eventId * 25))
-                    {
-                        SummonMechanics();
-                        return;
-                    }
-                    events.RepeatEvent(2000);
-                    break;
             }
-
+            events.RepeatEvent(2000);
-            DoMeleeAttackIfReady();
+            break;
         }
-    };
+
+        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
+    void Reset() override
     {
-        return GetSteamVaultAI<npc_steamrigger_mechanicAI>(creature);
+        _scheduler.CancelAll();
     }
 
-    struct npc_steamrigger_mechanicAI : public ScriptedAI
+    void JustEngagedWith(Unit* victim) override
     {
-        npc_steamrigger_mechanicAI(Creature* creature) : ScriptedAI(creature)
+        ScriptedAI::JustEngagedWith(victim);
-        {
-        }
 
-        uint32 repairTimer;
+        _scheduler.Schedule(2s, [this](TaskContext context)
-        ObjectGuid bossGUID;
-
-        void Reset() override
         {
-            repairTimer = 0;
-            bossGUID.Clear();
             if (InstanceScript* instance = me->GetInstanceScript())
-                bossGUID = instance->GetGuidData(TYPE_MEKGINEER_STEAMRIGGER);
-        }
-
-        void MoveInLineOfSight(Unit* /*who*/) override {}
-
-        void UpdateAI(uint32 diff) override
-        {
-            repairTimer += diff;
-            if (repairTimer >= 2000)
             {
-                repairTimer = 0;
+                if (Creature* boss = instance->GetCreature(DATA_MEKGINEER_STEAMRIGGER))
-                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())
+            context.Repeat();
-                return;
+        });
+    }
 
-            DoMeleeAttackIfReady();
+    void MoveInLineOfSight(Unit* /*who*/) override {}
-        }
+
-    };
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        _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,146 +41,106 @@ 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
+    void JustEngagedWith(Unit* /*who*/) override
     {
-        return GetSteamVaultAI<boss_warlord_kalithreshAI>(creature);
+        Talk(SAY_AGGRO);
+        _JustEngagedWith();
+        events.ScheduleEvent(EVENT_SPELL_REFLECTION, 10000);
+        events.ScheduleEvent(EVENT_SPELL_IMPALE, urand(7000, 14000));
+        events.ScheduleEvent(EVENT_SPELL_RAGE, 20000);
     }
 
-    struct boss_warlord_kalithreshAI : public ScriptedAI
+    void KilledUnit(Unit* victim) override
     {
-        boss_warlord_kalithreshAI(Creature* creature) : ScriptedAI(creature)
+        if (victim->IsPlayer())
         {
-            instance = creature->GetInstanceScript();
+            Talk(SAY_SLAY);
         }
+    }
 
-        InstanceScript* instance;
+    void JustDied(Unit* /*killer*/) override
-        EventMap events;
+    {
+        Talk(SAY_DEATH);
+        _JustDied();
+    }
 
-        void Reset() override
+    void UpdateAI(uint32 diff) override
+    {
+        if (!UpdateVictim())
+            return;
+
+        events.Update(diff);
+        switch (events.ExecuteEvent())
         {
-            events.Reset();
+        case EVENT_SPELL_REFLECTION:
-            if (instance)
+            me->CastSpell(me, SPELL_SPELL_REFLECTION, false);
-                instance->SetData(TYPE_WARLORD_KALITHRESH, NOT_STARTED);
+            events.RepeatEvent(urand(15000, 20000));
-        }
+            break;
-
+        case EVENT_SPELL_IMPALE:
-        void JustEngagedWith(Unit* /*who*/) override
+            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 10.0f, true))
-        {
+                me->CastSpell(target, SPELL_IMPALE, false);
-            Talk(SAY_AGGRO);
+            events.RepeatEvent(urand(7500, 12500));
-            events.ScheduleEvent(EVENT_SPELL_REFLECTION, 10000);
+            break;
-            events.ScheduleEvent(EVENT_SPELL_IMPALE, urand(7000, 14000));
+        case EVENT_SPELL_RAGE:
-            events.ScheduleEvent(EVENT_SPELL_RAGE, 20000);
+            if (Creature* distiller = me->FindNearestCreature(NPC_NAGA_DISTILLER, 100.0f))
-
-            if (instance)
-                instance->SetData(TYPE_WARLORD_KALITHRESH, IN_PROGRESS);
-        }
-
-        void KilledUnit(Unit* victim) override
-        {
-            if (victim->GetTypeId() == TYPEID_PLAYER)
-                Talk(SAY_SLAY);
-        }
-
-        void JustDied(Unit* /*killer*/) override
-        {
-            Talk(SAY_DEATH);
-            if (instance)
-                instance->SetData(TYPE_WARLORD_KALITHRESH, DONE);
-        }
-
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
-
-            events.Update(diff);
-            switch (events.ExecuteEvent())
             {
-                case EVENT_SPELL_REFLECTION:
+                Talk(SAY_REGEN);
-                    me->CastSpell(me, SPELL_SPELL_REFLECTION, false);
+                //me->CastSpell(me, SPELL_WARLORDS_RAGE, false);
-                    events.RepeatEvent(urand(15000, 20000));
+                distiller->AI()->DoAction(1);
-                    break;
-                case EVENT_SPELL_IMPALE:
-                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 10.0f, true))
-                        me->CastSpell(target, SPELL_IMPALE, false);
-                    events.RepeatEvent(urand(7500, 12500));
-                    break;
-                case EVENT_SPELL_RAGE:
-                    if (Creature* distiller = me->FindNearestCreature(NPC_NAGA_DISTILLER, 100.0f))
-                    {
-                        Talk(SAY_REGEN);
-                        //me->CastSpell(me, SPELL_WARLORDS_RAGE, false);
-                        distiller->AI()->DoAction(1);
-                    }
-                    events.RepeatEvent(45000);
-                    break;
             }
-
+            events.RepeatEvent(45000);
-            DoMeleeAttackIfReady();
+            break;
         }
-    };
+
+        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
+    uint32 spellTimer;
+
+    void Reset() override
     {
-        return GetSteamVaultAI<npc_naga_distillerAI>(creature);
+        spellTimer = 0;
+        me->SetUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
+        me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
     }
 
-    struct npc_naga_distillerAI : public NullCreatureAI
+    void DoAction(int32 param) override
     {
-        npc_naga_distillerAI(Creature* creature) : NullCreatureAI(creature)
+        if (param != 1)
+            return;
+
+        me->RemoveUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
+        me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
+        me->CastSpell(me, SPELL_WARLORDS_RAGE_NAGA, true);
+        spellTimer = 1;
+    }
+
+    void UpdateAI(uint32 diff) override
+    {
+        if (spellTimer)
         {
-            instance = creature->GetInstanceScript();
+            spellTimer += diff;
-        }
+            if (spellTimer >= 12000)
-
-        InstanceScript* instance;
-        uint32 spellTimer;
-
-        void Reset() override
-        {
-            spellTimer = 0;
-            me->SetUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
-            me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
-        }
-
-        void DoAction(int32 param) override
-        {
-            if (param != 1)
-                return;
-
-            me->RemoveUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
-            me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
-            me->CastSpell(me, SPELL_WARLORDS_RAGE_NAGA, true);
-            spellTimer = 1;
-        }
-
-        void UpdateAI(uint32 diff) override
-        {
-            if (spellTimer)
             {
-                spellTimer += diff;
+                if (Creature* kali = me->FindNearestCreature(NPC_WARLORD_KALITHRESH, 100.0f))
-                if (spellTimer >= 12000)
+                    kali->CastSpell(kali, SPELL_WARLORDS_RAGE_PROC, true);
-                {
+                me->KillSelf();
-                    if (Creature* kali = me->FindNearestCreature(NPC_WARLORD_KALITHRESH, 100.0f))
-                        kali->CastSpell(kali, SPELL_WARLORDS_RAGE_PROC, true);
-                    me->KillSelf();
-                }
             }
         }
-    };
+    }
 };
 
 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,71 +26,62 @@ 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 (go->GetEntry() == GO_ACCESS_PANEL_HYDRO)
-            if (instance->GetData(TYPE_HYDROMANCER_THESPIA) == DONE)
             {
-                go->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
+                if (instance->GetBossState(DATA_HYDROMANCER_THESPIA) == DONE)
-                instance->SetData(TYPE_HYDROMANCER_THESPIA, SPECIAL);
+                {
+                    go->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
+                }
+            }
+            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 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
 {
 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 (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)
-                    {
-                        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)
+            if (bossId == DATA_HYDROMANCER_THESPIA && state == DONE)
-                SaveToDB();
-        }
-
-        uint32 GetData(uint32 type) const override
-        {
-            switch (type)
             {
-                case TYPE_HYDROMANCER_THESPIA:
+                if (GameObject* panel = GetGameObject(DATA_ACCESS_PANEL_HYDROMANCER))
-                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];
+                    panel->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
-                    if (m_auiEncounter[i] == IN_PROGRESS)
-                        m_auiEncounter[i] = NOT_STARTED;
                 }
+            }
+            else if (bossId == DATA_MEKGINEER_STEAMRIGGER && state == DONE)
+            {
+                if (GameObject* panel = GetGameObject(DATA_ACCESS_PANEL_MEKGINEER))
+                {
+                    panel->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
+                }
+            }
 
-            OUT_LOAD_INST_DATA_COMPLETE;
+            return true;
         }
     };
+
+    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