Scripts/TheSlavePens: Boss Ahune fixes and updates

Fixes some visual problems
Fixes encounter start
Updated codestyle

Closes #22071

4 files changed, 577 insertions, 778 deletions

diff --git a/sql/updates/world/3.3.5/2018_06_22_00_world.sql b/sql/updates/world/3.3.5/2018_06_22_00_world.sql
new file mode 100644
index 00000000000..c867ed561c2
--- /dev/null
+++ b/sql/updates/world/3.3.5/2018_06_22_00_world.sql
@@ -0,0 +1,13 @@
+DELETE FROM `creature` WHERE `guid` IN(73427,73428);
+INSERT INTO `creature` (`guid`,`id`,`map`,`zoneId`,`areaId`,`spawnMask`,`phaseMask`,`modelid`,`equipment_id`,`position_x`,`position_y`,`position_z`,`orientation`,`spawntimesecs`,`spawndist`,`currentwaypoint`,`curhealth`,`curmana`,`MovementType`,`npcflag`,`unit_flags`,`dynamicflags`,`ScriptName`,`VerifiedBuild`) VALUES
+(73427,26121,547,0,0,1,1,0,0,-69.8121,-162.4954,-2.30451,1.710423,300,0,0,1,1,0,0,0,0,'',0),
+(73428,26120,547,0,0,1,1,0,0,-98.1029,-230.7864,-10.8085,1.448623,300,0,0,1,1,0,0,0,0,'',0);
+
+DELETE FROM `game_event_creature` WHERE `eventEntry`=1 AND `guid` IN(73427,73428);
+INSERT INTO `game_event_creature` (`eventEntry`, `guid`) VALUES
+(1,73427),
+(1,73428);
+
+DELETE FROM `creature_template_movement` WHERE `CreatureId`=26120;
+INSERT INTO `creature_template_movement` (`CreatureId`, `Ground`, `Swim`, `Flight`, `Rooted`) VALUES
+(26120,0,0,1,0);
diff --git a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/boss_ahune.cpp b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/boss_ahune.cpp
index 25b8832901e..ec905fd47b2 100644
--- a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/boss_ahune.cpp
+++ b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/boss_ahune.cpp
@@ -108,35 +108,36 @@ enum Says
 
 enum Events
 {
-    EVENT_EMERGE                        = 1,
-    EVENT_INITIAL_EMERGE                = 2,
-    EVENT_SYNCH_HEALTH                  = 3,
-    EVENT_LOOKFOROPENING_0              = 4,
-    EVENT_LOOKFOROPENING_1              = 5,
-    EVENT_LOOKFOROPENING_2              = 6,
-    EVENT_SUMMON_HAILSTONE              = 7,
-    EVENT_SUMMON_COLDWEAVE              = 8,
-    EVENT_SUMMON_FROSTWIND              = 9,
-    EVENT_SUMMON_AHUNE                  = 10,
-    EVENT_CLOSE_OPENING                 = 11,
-    EVENT_AHUNE_PHASE_ONE               = 12,
-    EVENT_AHUNE_PHASE_TWO               = 13,
-    EVENT_START_LOOKING_FOR_OPENING     = 14,
-    EVENT_STOP_LOOKING_FOR_OPENING      = 15
+    EVENT_EMERGE = 1,
+    EVENT_INITIAL_EMERGE,
+    EVENT_SYNCH_HEALTH,
+    EVENT_LOOKFOROPENING_0,
+    EVENT_LOOKFOROPENING_1,
+    EVENT_LOOKFOROPENING_2,
+    EVENT_SUMMON_HAILSTONE,
+    EVENT_SUMMON_COLDWEAVE,
+    EVENT_SUMMON_FROSTWIND,
+    EVENT_SUMMON_AHUNE,
+    EVENT_CLOSE_OPENING,
+    EVENT_AHUNE_PHASE_ONE,
+    EVENT_AHUNE_PHASE_TWO,
+    EVENT_START_LOOKING_FOR_OPENING,
+    EVENT_STOP_LOOKING_FOR_OPENING
 };
 
 enum Actions
 {
-    ACTION_START_EVENT                  = -2574500,
-    ACTION_AHUNE_RETREAT                = -2586500,
-    ACTION_AHUNE_RESURFACE              = -2586501,
-    ACTION_EMOTE_RESURFACE              = -2575400
+    ACTION_START_EVENT     = -2574500,
+    ACTION_STOP_EVENT      = -2574501,
+    ACTION_AHUNE_RETREAT   = -2586500,
+    ACTION_AHUNE_RESURFACE = -2586501,
+    ACTION_EMOTE_RESURFACE = -2575400
 };
 
 enum Phases
 {
-    PHASE_ONE                   = 0,
-    PHASE_TWO                   = 1
+    PHASE_ONE = 0,
+    PHASE_TWO = 1
 };
 
 enum Points
@@ -148,7 +149,7 @@ enum Points
 
 enum Misc
 {
-    MAX_FLAMECALLERS    = 3
+    MAX_FLAMECALLERS = 3
 };
 
 Position const SummonPositions[] =
@@ -157,9 +158,7 @@ Position const SummonPositions[] =
     { -98.0151f, -230.4555f, -1.21089f, 1.797689f },  // Frozen Core
     { -143.172f, -147.6801f, -3.16113f, 4.852015f },  // Bonfire Bunny 000
     { -134.304f, -145.7803f, -1.70332f, 4.677482f },  // Bonfire Bunny 001
-    { -125.036f, -144.2065f, -1.91660f, 4.991642f },  // Bonfire Bunny 002
-    { -69.8121f, -162.4954f, -2.30451f, 1.710423f },  // Wisp Source Bunny
-    { -98.1029f, -230.7864f, -10.8085f, 1.448623f }   // Wisp Dest Bunny
+    { -125.036f, -144.2065f, -1.91660f, 4.991642f }  // Bonfire Bunny 002
 };
 
 Position const FlameCallerSpots[] =
@@ -169,487 +168,428 @@ Position const FlameCallerSpots[] =
     { -129.0413f, -132.1494f, -2.09285f, 5.460842f }
 };
 
-class boss_ahune : public CreatureScript
+struct boss_ahune : public BossAI
 {
-public:
-    boss_ahune() : CreatureScript("boss_ahune") { }
-
-    struct boss_ahuneAI : public BossAI
+    boss_ahune(Creature* creature) : BossAI(creature, DATA_AHUNE)
     {
-        boss_ahuneAI(Creature* creature) : BossAI(creature, DATA_AHUNE)
-        {
-            me->SetControlled(true, UNIT_STATE_ROOT);
-        }
-
-        void JustEngagedWith(Unit* /*who*/) override
-        {
-            _JustEngagedWith();
-            events.ScheduleEvent(EVENT_INITIAL_EMERGE, Milliseconds(4));
-            events.ScheduleEvent(EVENT_SYNCH_HEALTH, Seconds(3));
-        }
-
-        void EnterEvadeMode(EvadeReason /*why*/) override
-        {
-            if (Creature* ahuneBunny = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_AHUNE_BUNNY)))
-                ahuneBunny->AI()->EnterEvadeMode();
-            summons.DespawnAll();
-            me->DespawnOrUnsummon();
-        }
+        me->SetControlled(true, UNIT_STATE_ROOT);
+    }
 
-        void JustDied(Unit* /*killer*/) override
-        {
-            instance->DoCastSpellOnPlayers(SPELL_AHUNE_ACHIEVEMENT);
+    void JustEngagedWith(Unit* /*who*/) override
+    {
+        _JustEngagedWith();
+        events.ScheduleEvent(EVENT_INITIAL_EMERGE, 4ms);
+        events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3s);
+    }
 
-            if (Creature* ahuneBunny = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_AHUNE_BUNNY)))
-                Unit::Kill(me, ahuneBunny);
-            if (Creature* frozenCore = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_FROZEN_CORE)))
-                Unit::Kill(me, frozenCore);
+    void EnterEvadeMode(EvadeReason /*why*/) override
+    {
+        if (Creature* ahuneBunny = instance->GetCreature(DATA_AHUNE_BUNNY))
+            ahuneBunny->AI()->DoAction(ACTION_STOP_EVENT);
+        summons.DespawnAll();
+        me->DespawnOrUnsummon();
+    }
 
-            Map::PlayerList const& players = me->GetMap()->GetPlayers();
-            if (!players.isEmpty())
-            {
-                if (Group* group = players.begin()->GetSource()->GetGroup())
-                    if (group->isLFGGroup())
-                        sLFGMgr->FinishDungeon(group->GetGUID(), 286, me->GetMap());
-            }
+    void JustDied(Unit* /*killer*/) override
+    {
+        instance->DoCastSpellOnPlayers(SPELL_AHUNE_ACHIEVEMENT);
 
-            _JustDied();
-        }
+        if (Creature* ahuneBunny = instance->GetCreature(DATA_AHUNE_BUNNY))
+            Unit::Kill(me, ahuneBunny);
+        if (Creature* frozenCore = instance->GetCreature(DATA_FROZEN_CORE))
+            Unit::Kill(me, frozenCore);
 
-        void DoAction(int32 action) override
+        Map::PlayerList const& players = me->GetMap()->GetPlayers();
+        if (!players.isEmpty())
         {
-            if (action == ACTION_AHUNE_RETREAT)
-            {
-                Submerge();
-                events.ScheduleEvent(EVENT_EMERGE, Seconds(35));
-            }
+            if (Group* group = players.begin()->GetSource()->GetGroup())
+                if (group->isLFGGroup())
+                    sLFGMgr->FinishDungeon(group->GetGUID(), 286, me->GetMap());
         }
 
-        void UpdateAI(uint32 diff) override
-        {
-            if (!UpdateVictim())
-                return;
-
-            events.Update(diff);
-
-            while (uint32 eventId = events.ExecuteEvent())
-            {
-                switch (eventId)
-                {
-                    case EVENT_INITIAL_EMERGE:
-                        DoCast(me, SPELL_STAND);
-                        DoCast(me, SPELL_AHUNE_SPANKY_HANDS);
-                        DoCast(me, SPELL_AHUNES_SHIELD);
-                        break;
-                    case EVENT_EMERGE:
-                        Emerge();
-                        break;
-                    case EVENT_SYNCH_HEALTH:
-                        if (Creature* frozenCore = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_FROZEN_CORE)))
-                            DoCast(frozenCore, SPELL_SYNCH_HEALTH, true);
-                        else
-                            DoCast(me, SPELL_SUICIDE);
-                        events.Repeat(Seconds(3));
-                        break;
-                    default:
-                        break;
-                }
-            }
-            DoMeleeAttackIfReady();
-        }
+        _JustDied();
+    }
 
-        void Emerge()
+    void DoAction(int32 action) override
+    {
+        if (action == ACTION_AHUNE_RETREAT)
         {
-            if (Creature* frozenCore = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_FROZEN_CORE)))
-                frozenCore->AI()->DoAction(ACTION_AHUNE_RESURFACE);
-
-            DoCast(me, SPELL_AHUNES_SHIELD);
-            me->RemoveAurasDueToSpell(SPELL_AHUNE_SELF_STUN);
-            me->RemoveAurasDueToSpell(SPELL_STAY_SUBMERGED);
-            DoCast(me, SPELL_STAND);
-            DoCast(me, SPELL_RESURFACE, true);
-            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-            events.ScheduleEvent(EVENT_SYNCH_HEALTH, Seconds(3));
+            Submerge();
+            events.ScheduleEvent(EVENT_EMERGE, Seconds(35));
         }
+    }
 
-        void Submerge()
-        {
-            if (Creature* frozenCore = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_FROZEN_CORE)))
-                frozenCore->AI()->DoAction(ACTION_AHUNE_RETREAT);
-            me->RemoveAurasDueToSpell(SPELL_AHUNES_SHIELD);
-            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNK_31);
-            DoCast(me, SPELL_SUBMERGED, true);
-            DoCast(me, SPELL_AHUNE_SELF_STUN, true);
-            DoCast(me, SPELL_STAY_SUBMERGED, true);
-            me->HandleEmoteCommand(EMOTE_ONESHOT_SUBMERGE);
-            events.Reset();
+    void ExecuteEvent(uint32 eventId) override
+    {
+        switch (eventId)
+        {
+            case EVENT_INITIAL_EMERGE:
+                DoCastSelf(SPELL_STAND);
+                DoCastSelf(SPELL_AHUNE_SPANKY_HANDS);
+                DoCastSelf(SPELL_AHUNES_SHIELD);
+                break;
+            case EVENT_EMERGE:
+                Emerge();
+                break;
+            case EVENT_SYNCH_HEALTH:
+                if (Creature* frozenCore = instance->GetCreature(DATA_FROZEN_CORE))
+                    DoCast(frozenCore, SPELL_SYNCH_HEALTH, true);
+                else
+                    DoCastSelf(SPELL_SUICIDE);
+                events.Repeat(3s);
+                break;
+            default:
+                break;
         }
-    };
+    }
 
-    CreatureAI* GetAI(Creature* creature) const override
+    void Emerge()
     {
-        return GetSlavePensAI<boss_ahuneAI>(creature);
+        if (Creature* frozenCore = instance->GetCreature(DATA_FROZEN_CORE))
+            frozenCore->AI()->DoAction(ACTION_AHUNE_RESURFACE);
+
+        DoCastSelf(SPELL_AHUNES_SHIELD);
+        me->RemoveAurasDueToSpell(SPELL_AHUNE_SELF_STUN);
+        me->RemoveAurasDueToSpell(SPELL_STAY_SUBMERGED);
+        DoCastSelf(SPELL_STAND);
+        DoCastSelf(SPELL_RESURFACE, true);
+        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+        events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3s);
+    }
+
+    void Submerge()
+    {
+        if (Creature* frozenCore = instance->GetCreature(DATA_FROZEN_CORE))
+            frozenCore->AI()->DoAction(ACTION_AHUNE_RETREAT);
+        me->RemoveAurasDueToSpell(SPELL_AHUNES_SHIELD);
+        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNK_31);
+        DoCastSelf(SPELL_SUBMERGED, true);
+        DoCastSelf(SPELL_AHUNE_SELF_STUN, true);
+        DoCastSelf(SPELL_STAY_SUBMERGED, true);
+        me->HandleEmoteCommand(EMOTE_ONESHOT_SUBMERGE);
+        events.Reset();
     }
 };
 
-class npc_frozen_core : public CreatureScript
+struct npc_frozen_core : public ScriptedAI
 {
-public:
-    npc_frozen_core() : CreatureScript("npc_frozen_core") { }
+    npc_frozen_core(Creature* creature) : ScriptedAI(creature)
+    {
+        _instance = me->GetInstanceScript();
+        Initialize();
+    }
 
-    struct npc_frozen_coreAI : public ScriptedAI
+    void Initialize()
     {
-        npc_frozen_coreAI(Creature* creature) : ScriptedAI(creature)
-        {
-            _instance = me->GetInstanceScript();
-            Initialize();
-        }
+        me->SetReactState(REACT_PASSIVE);
+        me->SetRegenerateHealth(false);
+        DoCastSelf(SPELL_FROZEN_CORE_GETS_HIT);
+        DoCastSelf(SPELL_ICE_SPEAR_AURA);
+    }
 
-        void Initialize()
-        {
-            me->SetReactState(REACT_PASSIVE);
-            me->SetRegenerateHealth(false);
-            DoCast(me, SPELL_FROZEN_CORE_GETS_HIT);
-            DoCast(me, SPELL_ICE_SPEAR_AURA);
-        }
+    void JustDied(Unit* /*killer*/) override
+    {
+        if (Creature* ahune = _instance->GetCreature(DATA_AHUNE))
+            Unit::Kill(me, ahune);
 
-        void JustDied(Unit* /*killer*/) override
-        {
-            if (Creature* ahune = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_AHUNE)))
-                Unit::Kill(me, ahune);
+        DoCast(SPELL_SUMMON_LOOT_MISSILE);
+        DoCast(SPELL_MINION_DESPAWNER);
+    }
 
-            DoCast(SPELL_SUMMON_LOOT_MISSILE);
-            DoCast(SPELL_MINION_DESPAWNER);
+    void DoAction(int32 action) override
+    {
+        if (action == ACTION_AHUNE_RETREAT)
+        {
+            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+            me->SetImmuneToPC(false);
+            me->RemoveAurasDueToSpell(SPELL_ICE_SPEAR_AURA);
+            _events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3s, 0, PHASE_TWO);
         }
-
-        void DoAction(int32 action) override
+        else if (action == ACTION_AHUNE_RESURFACE)
         {
-            if (action == ACTION_AHUNE_RETREAT)
-            {
-                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-                me->SetImmuneToPC(false);
-                me->RemoveAurasDueToSpell(SPELL_ICE_SPEAR_AURA);
-                _events.ScheduleEvent(EVENT_SYNCH_HEALTH, Seconds(3), 0, PHASE_TWO);
-            }
-            else if (action == ACTION_AHUNE_RESURFACE)
-            {
-                _events.Reset();
-                DoCast(me, SPELL_ICE_SPEAR_AURA);
-                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
-                me->SetImmuneToPC(true);
-            }
+            _events.Reset();
+            DoCastSelf(SPELL_ICE_SPEAR_AURA);
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
+            me->SetImmuneToPC(true);
         }
+    }
 
-        void UpdateAI(uint32 diff) override
-        {
-            _events.Update(diff);
+    void UpdateAI(uint32 diff) override
+    {
+        _events.Update(diff);
 
-            while (uint32 eventId = _events.ExecuteEvent())
+        while (uint32 eventId = _events.ExecuteEvent())
+        {
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_SYNCH_HEALTH:
-                        if (Creature* ahune = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_AHUNE)))
-                            DoCast(ahune, SPELL_SYNCH_HEALTH, true);
-                        else
-                            DoCast(me, SPELL_SUICIDE);
-                        _events.Repeat(Seconds(3));
-                        break;
-                    default:
-                        break;
-                }
+                case EVENT_SYNCH_HEALTH:
+                    if (Creature* ahune = _instance->GetCreature(DATA_AHUNE))
+                        DoCast(ahune, SPELL_SYNCH_HEALTH, true);
+                    else
+                        DoCastSelf(SPELL_SUICIDE);
+                    _events.Repeat(3s);
+                    break;
+                default:
+                    break;
             }
         }
+    }
 
-    private:
-        InstanceScript* _instance;
-        EventMap _events;
-    };
+private:
+    InstanceScript * _instance;
+    EventMap _events;
+};
 
-    CreatureAI* GetAI(Creature* creature) const override
+struct npc_ahune_bunny : public ScriptedAI
+{
+    npc_ahune_bunny(Creature* creature) : ScriptedAI(creature), _summons(me)
     {
-        return GetSlavePensAI<npc_frozen_coreAI>(creature);
+        _instance = me->GetInstanceScript();
+        _submerged = false;
     }
-};
 
-class npc_ahune_bunny : public CreatureScript
-{
-public:
-    npc_ahune_bunny() : CreatureScript("npc_ahune_bunny") { }
+    void JustSummoned(Creature* summon) override
+    {
+        if (summon->GetEntry() == NPC_AHUNE)
+            return;
+
+        DoZoneInCombat(summon);
+        _summons.Summon(summon);
+    }
 
-    struct npc_ahune_bunnyAI : public ScriptedAI
+    void JustDied(Unit* /*killer*/) override
     {
-        npc_ahune_bunnyAI(Creature* creature) : ScriptedAI(creature), _summons(me)
-        {
-            _instance = me->GetInstanceScript();
-            _submerged = false;
-        }
+        _summons.DespawnAll();
+        ResetFlameCallers();
+    }
 
-        void JustSummoned(Creature* summon) override
+    void DoAction(int32 action) override
+    {
+        if (action == ACTION_START_EVENT)
         {
-            if (summon->GetEntry() == NPC_AHUNE)
-                return;
+            DoCastSelf(SPELL_SUMMONING_VISUAL_1);
+            me->SummonCreature(NPC_SHAMAN_BONFIRE_BUNNY_000, SummonPositions[2], TEMPSUMMON_MANUAL_DESPAWN);
+            me->SummonCreature(NPC_SHAMAN_BONFIRE_BUNNY_001, SummonPositions[3], TEMPSUMMON_MANUAL_DESPAWN);
+            me->SummonCreature(NPC_SHAMAN_BONFIRE_BUNNY_002, SummonPositions[4], TEMPSUMMON_MANUAL_DESPAWN);
 
-            DoZoneInCombat(summon);
-            _summons.Summon(summon);
-        }
+            for (uint8 counter = 0; counter < MAX_FLAMECALLERS; ++counter)
+                if (Creature* flameCaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000 + counter)))
+                    flameCaller->GetMotionMaster()->MovePoint(counter, FlameCallerSpots[counter].GetPosition());
 
-        void JustDied(Unit* /*killer*/) override
-        {
-            _summons.DespawnAll();
-            ResetFlameCallers();
+            _submerged = false;
+            _events.Reset();
+            _events.SetPhase(PHASE_ONE);
+            _events.ScheduleEvent(EVENT_SUMMON_AHUNE, 10s);
+            _events.ScheduleEvent(EVENT_START_LOOKING_FOR_OPENING, 14s, 0, PHASE_ONE);
+            _events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 22s, 0, PHASE_ONE);
+            _events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, 14s, 0, PHASE_ONE);
+            _events.ScheduleEvent(EVENT_AHUNE_PHASE_TWO, 108s, 0, PHASE_ONE);
         }
-
-        void EnterEvadeMode(EvadeReason /*why*/) override
+        else if (action == ACTION_STOP_EVENT)
         {
-            _EnterEvadeMode();
             _summons.DespawnAll();
+            _events.Reset();
             ResetFlameCallers();
 
             me->SummonGameObject(GO_ICE_STONE, -69.90455f, -162.2449f, -2.366563f, 2.426008f, QuaternionData(0.0f, 0.0f, 0.9366722f, 0.3502074f), 0);
         }
+    }
 
-        void DoAction(int32 action) override
-        {
-            if (action == ACTION_START_EVENT)
-            {
-                DoCast(me, SPELL_SUMMONING_VISUAL_1);
-                me->SummonCreature(NPC_WHISP_SOURCE_BUNNY, SummonPositions[5], TEMPSUMMON_MANUAL_DESPAWN);
-                me->SummonCreature(NPC_WHISP_DEST_BUNNY, SummonPositions[6], TEMPSUMMON_MANUAL_DESPAWN);
-                me->SummonCreature(NPC_SHAMAN_BONFIRE_BUNNY_000, SummonPositions[2], TEMPSUMMON_MANUAL_DESPAWN);
-                me->SummonCreature(NPC_SHAMAN_BONFIRE_BUNNY_001, SummonPositions[3], TEMPSUMMON_MANUAL_DESPAWN);
-                me->SummonCreature(NPC_SHAMAN_BONFIRE_BUNNY_002, SummonPositions[4], TEMPSUMMON_MANUAL_DESPAWN);
-
-                for (uint8 counter = 0; counter < MAX_FLAMECALLERS; ++counter)
-                    if (Creature* flameCaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000 + counter)))
-                        flameCaller->GetMotionMaster()->MovePoint(counter, FlameCallerSpots[counter].GetPosition());
-
-                _submerged = false;
-                _events.Reset();
-                _events.SetPhase(PHASE_ONE);
-                _events.ScheduleEvent(EVENT_SUMMON_AHUNE, Seconds(10));
-                _events.ScheduleEvent(EVENT_START_LOOKING_FOR_OPENING, Seconds(14), 0, PHASE_ONE);
-                _events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, Seconds(22), 0, PHASE_ONE);
-                _events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, Seconds(14), 0, PHASE_ONE);
-                _events.ScheduleEvent(EVENT_AHUNE_PHASE_TWO, Seconds(108), 0, PHASE_ONE);
-            }
-        }
+    void UpdateAI(uint32 diff) override
+    {
+        _events.Update(diff);
 
-        void UpdateAI(uint32 diff) override
+        while (uint32 eventId = _events.ExecuteEvent())
         {
-            if (!UpdateVictim())
-                return;
-
-            _events.Update(diff);
-
-            while (uint32 eventId = _events.ExecuteEvent())
+            switch (eventId)
             {
-                switch (eventId)
-                {
-                    case EVENT_START_LOOKING_FOR_OPENING:
-                        Talk(EMOTE_EARTHEN_ASSAULT);
-                        for (uint8 counter = 0; counter < MAX_FLAMECALLERS; ++counter)
-                            if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000 + counter)))
-                                DoCast(flamecaller, SPELL_SHAMANS_LOOK_FOR_OPENING, true);
-                        break;
-                    case EVENT_SUMMON_HAILSTONE:
-                        DoCast(SPELL_SUMMON_HAILSTONE);
-                        break;
-                    case EVENT_SUMMON_COLDWEAVE:
-                        DoCast(SPELL_SUMMON_COLDWEAVE);
-                        DoCast(SPELL_SUMMON_COLDWEAVE);
-                        _events.Repeat(Seconds(8));
-                        if (_submerged)
-                            _events.ScheduleEvent(EVENT_SUMMON_FROSTWIND, Seconds(4), 0, PHASE_ONE);
-                        break;
-                    case EVENT_SUMMON_FROSTWIND:
-                        DoCast(SPELL_SUMMON_FROSTWIND);
-                        break;
-                    case EVENT_SUMMON_AHUNE:
-                        if (TempSummon* ahune = me->SummonCreature(NPC_AHUNE, SummonPositions[0], TEMPSUMMON_DEAD_DESPAWN))
-                        {
-                            ahune->SummonCreature(NPC_FROZEN_CORE, SummonPositions[1], TEMPSUMMON_CORPSE_DESPAWN);
-                            DoZoneInCombat(ahune);
-                            DoCast(ahune, SPELL_RESURFACE);
-                        }
-                        break;
-                    case EVENT_CLOSE_OPENING:
-                        if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000)))
-                            flamecaller->AI()->DoAction(ACTION_EMOTE_RESURFACE);
-                        DoCast(SPELL_CLOSE_OPENING_VISUAL);
-                        DoCast(me, SPELL_ICE_BOMBARD);
-                        break;
-                    case EVENT_AHUNE_PHASE_TWO:
-                        if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000)))
-                            DoCast(flamecaller, SPELL_FOUND_OPENING);
-                        if (Creature* ahune = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_AHUNE)))
-                            ahune->AI()->DoAction(ACTION_AHUNE_RETREAT);
-                        _events.Reset();
-                        _events.SetPhase(PHASE_TWO);
-                        _events.ScheduleEvent(EVENT_CLOSE_OPENING, Seconds(25), 0, PHASE_TWO);
-                        _events.ScheduleEvent(EVENT_AHUNE_PHASE_ONE, Seconds(35), 0, PHASE_TWO);
-                        break;
-                    case EVENT_AHUNE_PHASE_ONE:
-                        _submerged = true;
-                        _events.Reset();
-                        _events.SetPhase(PHASE_ONE);
-                        _events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, Seconds(8), 0, PHASE_ONE);
-                        _events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, Seconds(5), 0, PHASE_ONE);
-                        _events.ScheduleEvent(EVENT_START_LOOKING_FOR_OPENING, Seconds(5), 0, PHASE_ONE);
-                        _events.ScheduleEvent(EVENT_AHUNE_PHASE_TWO, Seconds(100), 0, PHASE_ONE);
-                        break;
-                    default:
-                        break;
-                }
+                case EVENT_START_LOOKING_FOR_OPENING:
+                    Talk(EMOTE_EARTHEN_ASSAULT);
+                    for (uint8 counter = 0; counter < MAX_FLAMECALLERS; ++counter)
+                        if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000 + counter)))
+                            DoCast(flamecaller, SPELL_SHAMANS_LOOK_FOR_OPENING, true);
+                    break;
+                case EVENT_SUMMON_HAILSTONE:
+                    DoCast(SPELL_SUMMON_HAILSTONE);
+                    break;
+                case EVENT_SUMMON_COLDWEAVE:
+                    DoCast(SPELL_SUMMON_COLDWEAVE);
+                    DoCast(SPELL_SUMMON_COLDWEAVE);
+                    _events.Repeat(8s);
+                    if (_submerged)
+                        _events.ScheduleEvent(EVENT_SUMMON_FROSTWIND, 4s, 0, PHASE_ONE);
+                    break;
+                case EVENT_SUMMON_FROSTWIND:
+                    DoCast(SPELL_SUMMON_FROSTWIND);
+                    break;
+                case EVENT_SUMMON_AHUNE:
+                    if (TempSummon* ahune = me->SummonCreature(NPC_AHUNE, SummonPositions[0], TEMPSUMMON_DEAD_DESPAWN))
+                    {
+                        ahune->SummonCreature(NPC_FROZEN_CORE, SummonPositions[1], TEMPSUMMON_CORPSE_DESPAWN);
+                        DoZoneInCombat(ahune);
+                        DoCast(ahune, SPELL_RESURFACE);
+                    }
+                    break;
+                case EVENT_CLOSE_OPENING:
+                    if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000)))
+                        flamecaller->AI()->DoAction(ACTION_EMOTE_RESURFACE);
+                    DoCast(SPELL_CLOSE_OPENING_VISUAL);
+                    DoCastSelf(SPELL_ICE_BOMBARD);
+                    break;
+                case EVENT_AHUNE_PHASE_TWO:
+                    if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000)))
+                        DoCast(flamecaller, SPELL_FOUND_OPENING);
+                    if (Creature* ahune = _instance->GetCreature(DATA_AHUNE))
+                        ahune->AI()->DoAction(ACTION_AHUNE_RETREAT);
+                    _events.Reset();
+                    _events.SetPhase(PHASE_TWO);
+                    _events.ScheduleEvent(EVENT_CLOSE_OPENING, 25s, 0, PHASE_TWO);
+                    _events.ScheduleEvent(EVENT_AHUNE_PHASE_ONE, 35s, 0, PHASE_TWO);
+                    break;
+                case EVENT_AHUNE_PHASE_ONE:
+                    _submerged = true;
+                    _events.Reset();
+                    _events.SetPhase(PHASE_ONE);
+                    _events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 8s, 0, PHASE_ONE);
+                    _events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, 5s, 0, PHASE_ONE);
+                    _events.ScheduleEvent(EVENT_START_LOOKING_FOR_OPENING, 5s, 0, PHASE_ONE);
+                    _events.ScheduleEvent(EVENT_AHUNE_PHASE_TWO, 100s, 0, PHASE_ONE);
+                    break;
+                default:
+                    break;
             }
         }
+    }
 
-        void ResetFlameCallers()
-        {
-            for (uint8 counter = 0; counter < MAX_FLAMECALLERS; ++counter)
-                if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000 + counter)))
-                    flamecaller->AI()->EnterEvadeMode();
-        }
-
-        private:
-            InstanceScript* _instance;
-            EventMap _events;
-            SummonList _summons;
-            bool _submerged;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
+    void ResetFlameCallers()
     {
-        return GetSlavePensAI<npc_ahune_bunnyAI>(creature);
+        for (uint8 counter = 0; counter < MAX_FLAMECALLERS; ++counter)
+            if (Creature* flamecaller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_FLAMECALLER_000 + counter)))
+                flamecaller->AI()->EnterEvadeMode();
     }
+
+private:
+    InstanceScript * _instance;
+    EventMap _events;
+    SummonList _summons;
+    bool _submerged;
 };
 
-class npc_earthen_ring_flamecaller : public CreatureScript
+struct npc_earthen_ring_flamecaller : public ScriptedAI
 {
-public:
-    npc_earthen_ring_flamecaller() : CreatureScript("npc_earthen_ring_flamecaller") { }
+    npc_earthen_ring_flamecaller(Creature* creature) : ScriptedAI(creature)
+    {
+        _instance = me->GetInstanceScript();
+        _mySpot = 0;
+    }
 
-    struct npc_earthen_ring_flamecallerAI : public ScriptedAI
+    void Reset() override
     {
-        npc_earthen_ring_flamecallerAI(Creature* creature) : ScriptedAI(creature)
-        {
-            _instance = me->GetInstanceScript();
-            _mySpot = 0;
-        }
+        _events.Reset();
+    }
 
-        void Reset() override
-        {
-            _events.Reset();
-        }
+    void MovementInform(uint32 motionType, uint32 pointId) override
+    {
+        if (motionType != POINT_MOTION_TYPE)
+            return;
+
+        switch (pointId)
+        {
+            case POINT_FLAMECALLER_000:
+                _mySpot = POINT_FLAMECALLER_000;
+                me->SetOrientation(FlameCallerSpots[_mySpot].GetOrientation());
+                break;
+            case POINT_FLAMECALLER_001:
+                _mySpot = POINT_FLAMECALLER_001;
+                me->SetOrientation(FlameCallerSpots[_mySpot].GetOrientation());
+                break;
+            case POINT_FLAMECALLER_002:
+                _mySpot = POINT_FLAMECALLER_002;
+                me->SetOrientation(FlameCallerSpots[_mySpot].GetOrientation());
+                break;
+            default:
+                break;
+        }
+
+        DoCastSelf(SPELL_FIND_OPENING_CHANNEL);
+    }
 
-        void MovementInform(uint32 motionType, uint32 pointId) override
+    void SpellHit(Unit* /*caster*/, SpellInfo const* spellInfo) override
+    {
+        switch (spellInfo->Id)
         {
-            if (motionType != POINT_MOTION_TYPE)
-                return;
+            case SPELL_SHAMANS_LOOK_FOR_OPENING:
+                _events.ScheduleEvent(EVENT_LOOKFOROPENING_0, 17s);
+                break;
+            case SPELL_FOUND_OPENING:
+                Talk(EMOTE_RETREAT);
+                break;
+            default:
+                break;
+        }
+    }
 
-            switch (pointId)
-            {
-                case POINT_FLAMECALLER_000:
-                    _mySpot = POINT_FLAMECALLER_000;
-                    me->SetOrientation(FlameCallerSpots[_mySpot].GetOrientation());
-                    break;
-                case POINT_FLAMECALLER_001:
-                    _mySpot = POINT_FLAMECALLER_001;
-                    me->SetOrientation(FlameCallerSpots[_mySpot].GetOrientation());
-                    break;
-                case POINT_FLAMECALLER_002:
-                    _mySpot = POINT_FLAMECALLER_002;
-                    me->SetOrientation(FlameCallerSpots[_mySpot].GetOrientation());
-                    break;
-                default:
-                    break;
-            }
+    void DoAction(int action) override
+    {
+        if (action == ACTION_EMOTE_RESURFACE)
+            Talk(EMOTE_RESURFACE);
+    }
 
-            DoCast(me, SPELL_FIND_OPENING_CHANNEL);
-        }
+    void UpdateAI(uint32 diff) override
+    {
+        _events.Update(diff);
 
-        void SpellHit(Unit* /*caster*/, SpellInfo const* spellInfo) override
+        while (uint32 eventId = _events.ExecuteEvent())
         {
-            switch (spellInfo->Id)
+            switch (eventId)
             {
-                case SPELL_SHAMANS_LOOK_FOR_OPENING:
-                    _events.ScheduleEvent(EVENT_LOOKFOROPENING_0, Seconds(17));
+                case EVENT_LOOKFOROPENING_0:
+                    LookOpening(true, 0);
+                    _events.ScheduleEvent(EVENT_LOOKFOROPENING_1, 26s);
+                    break;
+                case EVENT_LOOKFOROPENING_1:
+                    LookOpening(true, 1);
+                    _events.ScheduleEvent(EVENT_LOOKFOROPENING_2, 25s);
+                    break;
+                case EVENT_LOOKFOROPENING_2:
+                    LookOpening(true, 2);
+                    _events.ScheduleEvent(EVENT_STOP_LOOKING_FOR_OPENING, 27s);
                     break;
-                case SPELL_FOUND_OPENING:
-                    Talk(EMOTE_RETREAT);
+                case EVENT_STOP_LOOKING_FOR_OPENING:
+                    LookOpening(false, _mySpot);
                     break;
                 default:
                     break;
             }
         }
+    }
 
-        void DoAction(int action) override
-        {
-            if (action == ACTION_EMOTE_RESURFACE)
-                Talk(EMOTE_RESURFACE);
-        }
-
-        void UpdateAI(uint32 diff) override
-        {
-            _events.Update(diff);
+    void LookOpening(bool activate, uint8 spot)
+    {
+        if (_mySpot != spot)
+            return;
 
-            while (uint32 eventId = _events.ExecuteEvent())
+        if (Creature* bonfireBunny = _instance->GetCreature(DATA_BONFIRE_BUNNY_000 + spot))
+            if (Creature* beamBunny = _instance->GetCreature(DATA_BEAM_BUNNY_000 + spot))
             {
-                switch (eventId)
+                if (activate)
                 {
-                    case EVENT_LOOKFOROPENING_0:
-                        LookOpening(true, 0);
-                        _events.ScheduleEvent(EVENT_LOOKFOROPENING_1, Seconds(26));
-                        break;
-                    case EVENT_LOOKFOROPENING_1:
-                        LookOpening(true, 1);
-                        _events.ScheduleEvent(EVENT_LOOKFOROPENING_2, Seconds(25));
-                        break;
-                    case EVENT_LOOKFOROPENING_2:
-                        LookOpening(true, 2);
-                        _events.ScheduleEvent(EVENT_STOP_LOOKING_FOR_OPENING, Seconds(27));
-                        break;
-                    case EVENT_STOP_LOOKING_FOR_OPENING:
-                        LookOpening(false, _mySpot);
-                        break;
-                    default:
-                        break;
+                    DoCast(bonfireBunny, SPELL_FIND_OPENING_TRIGGER);
+                    bonfireBunny->CastSpell(beamBunny, SPELL_FIND_OPENING_VISUAL, true);
                 }
-            }
-        }
-
-        void LookOpening(bool activate, uint8 spot)
-        {
-            if (_mySpot != spot)
-                return;
-
-            if (Creature* bonfireBunny = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_BONFIRE_BUNNY_000 + spot)))
-                if (Creature* beamBunny = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_BEAM_BUNNY_000 + spot)))
+                else
                 {
-                    if (activate)
-                    {
-                        DoCast(bonfireBunny, SPELL_FIND_OPENING_TRIGGER);
-                        bonfireBunny->CastSpell(beamBunny, SPELL_FIND_OPENING_VISUAL, true);
-                    }
-                    else
-                    {
-                        DoCast(me, SPELL_FIND_OPENING_CHANNEL);
-                        bonfireBunny->CastStop();
-                        beamBunny->RemoveAurasDueToSpell(SPELL_FIND_OPENING_BEAM_END);
-                    }
+                    DoCastSelf(SPELL_FIND_OPENING_CHANNEL);
+                    bonfireBunny->CastStop();
+                    beamBunny->RemoveAurasDueToSpell(SPELL_FIND_OPENING_BEAM_END);
                 }
-        }
-
-    private:
-        EventMap _events;
-        InstanceScript* _instance;
-        uint8 _mySpot;
-    };
-
-    CreatureAI* GetAI(Creature* creature) const override
-    {
-        return GetSlavePensAI<npc_earthen_ring_flamecallerAI>(creature);
+            }
     }
+
+private:
+    EventMap _events;
+    InstanceScript* _instance;
+    uint8 _mySpot;
 };
 
 class go_ahune_ice_stone : public GameObjectScript
@@ -659,25 +599,24 @@ public:
 
     struct go_ahune_ice_stoneAI : public GameObjectAI
     {
-        go_ahune_ice_stoneAI(GameObject* go) : GameObjectAI(go), instance(go->GetInstanceScript()) { }
-
-        InstanceScript* instance;
+        go_ahune_ice_stoneAI(GameObject* go) : GameObjectAI(go), _instance(go->GetInstanceScript()) { }
 
         bool GossipSelect(Player* player, uint32 /*menuId*/, uint32 /*gossipListId*/) override
         {
             ClearGossipMenuFor(player);
 
-            if (Creature* ahuneBunny = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_AHUNE_BUNNY)))
-            {
+            if (Creature* ahuneBunny = _instance->GetCreature(DATA_AHUNE_BUNNY))
                 ahuneBunny->AI()->DoAction(ACTION_START_EVENT);
-                ahuneBunny->AI()->DoZoneInCombat();
-            }
-            if (Creature* luma = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_LUMA_SKYMOTHER)))
+
+            if (Creature* luma = _instance->GetCreature(DATA_LUMA_SKYMOTHER))
                 luma->CastSpell(player, SPELL_SUMMONING_RHYME_AURA, true);
             CloseGossipMenuFor(player);
             me->Delete();
             return true;
         }
+
+    private:
+        InstanceScript* _instance;
     };
 
     GameObjectAI* GetAI(GameObject* go) const override
@@ -687,365 +626,259 @@ public:
 };
 
 // 46430 - Synch Health
-class spell_ahune_synch_health : public SpellScriptLoader
+class spell_ahune_synch_health : public SpellScript
 {
-public:
-    spell_ahune_synch_health() : SpellScriptLoader("spell_ahune_synch_health") { }
+    PrepareSpellScript(spell_ahune_synch_health);
 
-    class spell_ahune_synch_health_SpellScript : public SpellScript
+    void HandleScript(SpellEffIndex /*effIndex*/)
     {
-        PrepareSpellScript(spell_ahune_synch_health_SpellScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_SYNCH_HEALTH });
-        }
-
-        void HandleScript(SpellEffIndex /*effIndex*/)
-        {
-            if (Unit* target = GetHitUnit())
-                if (Unit* caster = GetCaster())
-                    target->SetHealth(caster->GetHealth());
-        }
-
-        void Register() override
-        {
-            OnEffectHitTarget += SpellEffectFn(spell_ahune_synch_health_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
-        }
-    };
+        GetHitUnit()->SetHealth(GetCaster()->GetHealth());
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_ahune_synch_health_SpellScript();
+        OnEffectHitTarget += SpellEffectFn(spell_ahune_synch_health::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
     }
 };
 
 // 45926 - Summoning Rhyme Aura
-class spell_summoning_rhyme_aura : public SpellScriptLoader
+class spell_summoning_rhyme_aura : public AuraScript
 {
-public:
-    spell_summoning_rhyme_aura() : SpellScriptLoader("spell_summoning_rhyme_aura") { }
+    PrepareAuraScript(spell_summoning_rhyme_aura);
 
-    class spell_summoning_rhyme_aura_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_summoning_rhyme_aura_AuraScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_FORCE_WHISP_FLIGHT, SPELL_SUMMONING_RHYME_BONFIRE });
-        }
-
-        void PeriodicTick(AuraEffect const* aurEff)
-        {
-            if (!GetCaster())
-                return;
-
-            Creature* caster = GetCaster()->ToCreature();
-            Player* player = GetTarget()->ToPlayer();
-
-            if (!caster || !player)
-                return;
-
-            player->CastSpell(player, SPELL_FORCE_WHISP_FLIGHT);
-
-            switch (aurEff->GetTickNumber())
-            {
-                case 1:
-                    sCreatureTextMgr->SendChat(caster, SAY_PLAYER_TEXT_1, nullptr, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
-                    player->CastSpell(player, SPELL_SUMMONING_RHYME_BONFIRE, true);
-                    break;
-                case 2:
-                    sCreatureTextMgr->SendChat(caster, SAY_PLAYER_TEXT_2, nullptr, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
-                    break;
-                case 3:
-                    sCreatureTextMgr->SendChat(caster, SAY_PLAYER_TEXT_3, nullptr, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
-                    Remove();
-                    break;
-            }
-        }
+        return ValidateSpellInfo({ SPELL_FORCE_WHISP_FLIGHT, SPELL_SUMMONING_RHYME_BONFIRE });
+    }
 
-        void Register() override
-        {
-            OnEffectPeriodic += AuraEffectPeriodicFn(spell_summoning_rhyme_aura_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+    void PeriodicTick(AuraEffect const* aurEff)
+    {
+        if (!GetCaster())
+            return;
+
+        Creature* caster = GetCaster()->ToCreature();
+        Player* player = GetTarget()->ToPlayer();
+        if (!caster || !player)
+            return;
+
+        player->CastSpell(player, SPELL_FORCE_WHISP_FLIGHT);
+
+        switch (aurEff->GetTickNumber())
+        {
+            case 1:
+                sCreatureTextMgr->SendChat(caster, SAY_PLAYER_TEXT_1, nullptr, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
+                player->CastSpell(player, SPELL_SUMMONING_RHYME_BONFIRE, true);
+                break;
+            case 2:
+                sCreatureTextMgr->SendChat(caster, SAY_PLAYER_TEXT_2, nullptr, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
+                break;
+            case 3:
+                sCreatureTextMgr->SendChat(caster, SAY_PLAYER_TEXT_3, nullptr, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
+                Remove();
+                break;
         }
-    };
+    }
 
-    AuraScript* GetAuraScript() const override
+    void Register() override
     {
-        return new spell_summoning_rhyme_aura_AuraScript();
+        OnEffectPeriodic += AuraEffectPeriodicFn(spell_summoning_rhyme_aura::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
     }
 };
 
 // 46878 - Summon Ice Spear Delayer
-class spell_summon_ice_spear_delayer : public SpellScriptLoader
+class spell_summon_ice_spear_delayer : public AuraScript
 {
-public:
-    spell_summon_ice_spear_delayer() : SpellScriptLoader("spell_summon_ice_spear_delayer") { }
+    PrepareAuraScript(spell_summon_ice_spear_delayer);
 
-    class spell_summon_ice_spear_delayer_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_summon_ice_spear_delayer_AuraScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_SUMMON_ICE_SPEAR_GO, SPELL_ICE_SPEAR_KNOCKBACK });
-        }
-
-        void PeriodicTick(AuraEffect const* aurEff)
-        {
-            if (Unit* tmpCaster = GetCaster())
-                if (Creature* caster = tmpCaster->ToCreature())
-                    switch (aurEff->GetTickNumber())
-                    {
-                        case 1:
-                            caster->CastSpell(caster, SPELL_SUMMON_ICE_SPEAR_GO);
-                            break;
-                        case 3:
-                            if (GameObject* spike = caster->FindNearestGameObject(GO_ICE_SPEAR, 3.0f))
-                                spike->UseDoorOrButton();
-                            caster->AI()->DoCastAOE(SPELL_ICE_SPEAR_KNOCKBACK, true);
-                            break;
-                        case 5:
-                            if (GameObject* spike = caster->FindNearestGameObject(GO_ICE_SPEAR, 3.0f))
-                                spike->Delete();
-                            caster->DespawnOrUnsummon();
-                            break;
-                        default:
-                            break;
-                    }
-        }
+        return ValidateSpellInfo({ SPELL_SUMMON_ICE_SPEAR_GO, SPELL_ICE_SPEAR_KNOCKBACK });
+    }
 
-        void Register() override
-        {
-            OnEffectPeriodic += AuraEffectPeriodicFn(spell_summon_ice_spear_delayer_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
-        }
-    };
+    void PeriodicTick(AuraEffect const* aurEff)
+    {
+        if (Unit* tmpCaster = GetCaster())
+            if (Creature* caster = tmpCaster->ToCreature())
+                switch (aurEff->GetTickNumber())
+                {
+                    case 1:
+                        caster->CastSpell(caster, SPELL_SUMMON_ICE_SPEAR_GO);
+                        break;
+                    case 3:
+                        if (GameObject* spike = caster->FindNearestGameObject(GO_ICE_SPEAR, 3.0f))
+                            spike->UseDoorOrButton();
+                        caster->AI()->DoCastAOE(SPELL_ICE_SPEAR_KNOCKBACK, true);
+                        break;
+                    case 5:
+                        if (GameObject* spike = caster->FindNearestGameObject(GO_ICE_SPEAR, 3.0f))
+                            spike->Delete();
+                        caster->DespawnOrUnsummon();
+                        break;
+                    default:
+                        break;
+                }
+    }
 
-    AuraScript* GetAuraScript() const override
+    void Register() override
     {
-        return new spell_summon_ice_spear_delayer_AuraScript();
+        OnEffectPeriodic += AuraEffectPeriodicFn(spell_summon_ice_spear_delayer::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
     }
 };
 
 // 46371 - Ice Spear Control Aura
-class spell_ice_spear_control_aura : public SpellScriptLoader
+class spell_ice_spear_control_aura : public AuraScript
 {
-public:
-    spell_ice_spear_control_aura() : SpellScriptLoader("spell_ice_spear_control_aura") { }
+    PrepareAuraScript(spell_ice_spear_control_aura);
 
-    class spell_ice_spear_control_aura_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_ice_spear_control_aura_AuraScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_ICE_SPEAR_TARGET_PICKER });
-        }
-
-        void PeriodicTick(AuraEffect const* /*aurEff*/)
-        {
-            if (Unit* caster = GetCaster())
-                caster->CastSpell(caster, SPELL_ICE_SPEAR_TARGET_PICKER);
-        }
+        return ValidateSpellInfo({ SPELL_ICE_SPEAR_TARGET_PICKER });
+    }
 
-        void Register() override
-        {
-            OnEffectPeriodic += AuraEffectPeriodicFn(spell_ice_spear_control_aura_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
-        }
-    };
+    void PeriodicTick(AuraEffect const* /*aurEff*/)
+    {
+        if (Unit* caster = GetCaster())
+            caster->CastSpell(caster, SPELL_ICE_SPEAR_TARGET_PICKER);
+    }
 
-    AuraScript* GetAuraScript() const override
+    void Register() override
     {
-        return new spell_ice_spear_control_aura_AuraScript();
+        OnEffectPeriodic += AuraEffectPeriodicFn(spell_ice_spear_control_aura::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
     }
 };
 
 // 46372 - Ice Spear Target Picker
-class spell_ice_spear_target_picker : public SpellScriptLoader
+class spell_ice_spear_target_picker : public SpellScript
 {
-public:
-    spell_ice_spear_target_picker() : SpellScriptLoader("spell_ice_spear_target_picker") { }
+    PrepareSpellScript(spell_ice_spear_target_picker);
 
-    class spell_ice_spear_target_picker_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareSpellScript(spell_ice_spear_target_picker_SpellScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_SUMMON_ICE_SPEAR_BUNNY });
-        }
-
-        void FilterTargets(std::list<WorldObject*>& targets)
-        {
-            if (targets.empty())
-                return;
+        return ValidateSpellInfo({ SPELL_SUMMON_ICE_SPEAR_BUNNY });
+    }
 
-            WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
-            targets.clear();
-            targets.push_back(target);
-        }
+    void FilterTargets(std::list<WorldObject*>& targets)
+    {
+        if (targets.empty())
+            return;
 
-        void HandleDummy(SpellEffIndex /*effIndex*/)
-        {
-            GetCaster()->CastSpell(GetHitUnit(), SPELL_SUMMON_ICE_SPEAR_BUNNY, true);
-        }
+        WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
+        targets.clear();
+        targets.push_back(target);
+    }
 
-        void Register() override
-        {
-            OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_ice_spear_target_picker_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
-            OnEffectHitTarget += SpellEffectFn(spell_ice_spear_target_picker_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
-        }
-    };
+    void HandleDummy(SpellEffIndex /*effIndex*/)
+    {
+        GetCaster()->CastSpell(GetHitUnit(), SPELL_SUMMON_ICE_SPEAR_BUNNY, true);
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_ice_spear_target_picker_SpellScript();
+        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_ice_spear_target_picker::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
+        OnEffectHitTarget += SpellEffectFn(spell_ice_spear_target_picker::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
     }
 };
 
 // 46320 - Spell Slippery Floor Periodic
-class spell_slippery_floor_periodic : public SpellScriptLoader
+class spell_slippery_floor_periodic : public SpellScript
 {
-public:
-    spell_slippery_floor_periodic() : SpellScriptLoader("spell_slippery_floor_periodic") { }
+    PrepareSpellScript(spell_slippery_floor_periodic);
 
-    class spell_slippery_floor_periodic_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareSpellScript(spell_slippery_floor_periodic_SpellScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_SLIPPERY_FLOOR_SLIP });
-        }
-
-        void HandleScriptEffect(SpellEffIndex /*effIndex*/)
-        {
-            if (Unit* target = GetHitUnit())
-                if (target->isMoving())
-                {
-                    target->CastSpell(target, SPELL_SLIPPERY_FLOOR_SLIP, true);
-                    target->CastSpell(target, SPELL_SLIPPERY_FLOOR_YOU_SLIPPED, true);
-                }
-        }
+        return ValidateSpellInfo({ SPELL_SLIPPERY_FLOOR_SLIP });
+    }
 
-        void Register() override
-        {
-            OnEffectHitTarget += SpellEffectFn(spell_slippery_floor_periodic_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
-        }
-    };
+    void HandleScriptEffect(SpellEffIndex /*effIndex*/)
+    {
+        if (Unit* target = GetHitUnit())
+            if (target->isMoving())
+            {
+                target->CastSpell(target, SPELL_SLIPPERY_FLOOR_SLIP, true);
+                target->CastSpell(target, SPELL_SLIPPERY_FLOOR_YOU_SLIPPED, true);
+            }
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_slippery_floor_periodic_SpellScript();
+        OnEffectHitTarget += SpellEffectFn(spell_slippery_floor_periodic::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
     }
 };
 
 // 46146 - Ahune Spanky Hands
-class spell_ahune_spanky_hands : public SpellScriptLoader
+class spell_ahune_spanky_hands : public AuraScript
 {
-public:
-    spell_ahune_spanky_hands() : SpellScriptLoader("spell_ahune_spanky_hands") { }
+    PrepareAuraScript(spell_ahune_spanky_hands);
 
-    class spell_ahune_spanky_hands_AuraScript : public AuraScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareAuraScript(spell_ahune_spanky_hands_AuraScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_COLD_SLAP });
-        }
-
-        void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
-        {
-            PreventDefaultAction();
-            GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_COLD_SLAP, true);
-        }
+        return ValidateSpellInfo({ SPELL_COLD_SLAP });
+    }
 
-        void Register() override
-        {
-            OnEffectProc += AuraEffectProcFn(spell_ahune_spanky_hands_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
-        }
-    };
+    void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
+    {
+        PreventDefaultAction();
+        GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_COLD_SLAP, true);
+    }
 
-    AuraScript* GetAuraScript() const override
+    void Register() override
     {
-        return new spell_ahune_spanky_hands_AuraScript();
+        OnEffectProc += AuraEffectProcFn(spell_ahune_spanky_hands::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
     }
 };
 
-class spell_ahune_minion_despawner : public SpellScriptLoader
+// 46843 - Minion Despawner
+class spell_ahune_minion_despawner : public SpellScript
 {
-public:
-    spell_ahune_minion_despawner() : SpellScriptLoader("spell_ahune_minion_despawner") { }
+    PrepareSpellScript(spell_ahune_minion_despawner);
 
-    class spell_ahune_minion_despawner_SpellScript : public SpellScript
+    void HandleScript(SpellEffIndex /*effIndex*/)
     {
-        PrepareSpellScript(spell_ahune_minion_despawner_SpellScript);
-
-        void HandleScript(SpellEffIndex /*effIndex*/)
-        {
-            if (GetHitCreature())
-                GetHitCreature()->DespawnOrUnsummon();
-        }
-
-        void Register() override
-        {
-            OnEffectHitTarget += SpellEffectFn(spell_ahune_minion_despawner_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_APPLY_AURA);
-        }
-    };
+        if (GetHitCreature())
+            GetHitCreature()->DespawnOrUnsummon();
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_ahune_minion_despawner_SpellScript();
+        OnEffectHitTarget += SpellEffectFn(spell_ahune_minion_despawner::HandleScript, EFFECT_0, SPELL_EFFECT_APPLY_AURA);
     }
 };
 
 // 46398 - Spell Ice Bombardment Dest Picker
-class spell_ice_bombardment_dest_picker : public SpellScriptLoader
+class spell_ice_bombardment_dest_picker : public SpellScript
 {
-public:
-    spell_ice_bombardment_dest_picker() : SpellScriptLoader("spell_ice_bombardment_dest_picker") { }
+    PrepareSpellScript(spell_ice_bombardment_dest_picker);
 
-    class spell_ice_bombardment_dest_picker_SpellScript : public SpellScript
+    bool Validate(SpellInfo const* /*spellInfo*/) override
     {
-        PrepareSpellScript(spell_ice_bombardment_dest_picker_SpellScript);
-
-        bool Validate(SpellInfo const* /*spellInfo*/) override
-        {
-            return ValidateSpellInfo({ SPELL_ICE_BOMBARDMENT });
-        }
-
-        void HandleScriptEffect(SpellEffIndex /*effIndex*/)
-        {
-            GetCaster()->CastSpell(GetHitDest()->GetPosition(), SPELL_ICE_BOMBARDMENT, true);
-        }
+        return ValidateSpellInfo({ SPELL_ICE_BOMBARDMENT });
+    }
 
-        void Register() override
-        {
-            OnEffectHit += SpellEffectFn(spell_ice_bombardment_dest_picker_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_DUMMY);
-        }
-    };
+    void HandleScriptEffect(SpellEffIndex /*effIndex*/)
+    {
+        GetCaster()->CastSpell(GetHitDest()->GetPosition(), SPELL_ICE_BOMBARDMENT, true);
+    }
 
-    SpellScript* GetSpellScript() const override
+    void Register() override
     {
-        return new spell_ice_bombardment_dest_picker_SpellScript();
+        OnEffectHit += SpellEffectFn(spell_ice_bombardment_dest_picker::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_DUMMY);
     }
 };
 
 void AddSC_boss_ahune()
 {
-    new boss_ahune();
-    new npc_frozen_core();
-    new npc_earthen_ring_flamecaller();
-    new npc_ahune_bunny();
+    RegisterSlavePensCreatureAI(boss_ahune);
+    RegisterSlavePensCreatureAI(npc_frozen_core);
+    RegisterSlavePensCreatureAI(npc_earthen_ring_flamecaller);
+    RegisterSlavePensCreatureAI(npc_ahune_bunny);
     new go_ahune_ice_stone();
-    new spell_ahune_synch_health();
-    new spell_summoning_rhyme_aura();
-    new spell_summon_ice_spear_delayer();
-    new spell_ice_spear_control_aura();
-    new spell_slippery_floor_periodic();
-    new spell_ahune_spanky_hands();
-    new spell_ahune_minion_despawner();
-    new spell_ice_spear_target_picker();
-    new spell_ice_bombardment_dest_picker();
+    RegisterSpellScript(spell_ahune_synch_health);
+    RegisterAuraScript(spell_summoning_rhyme_aura);
+    RegisterAuraScript(spell_summon_ice_spear_delayer);
+    RegisterAuraScript(spell_ice_spear_control_aura);
+    RegisterSpellScript(spell_ice_spear_target_picker);
+    RegisterSpellScript(spell_slippery_floor_periodic);
+    RegisterAuraScript(spell_ahune_spanky_hands);
+    RegisterSpellScript(spell_ahune_minion_despawner);
+    RegisterSpellScript(spell_ice_bombardment_dest_picker);
 }
diff --git a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/instance_the_slave_pens.cpp b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/instance_the_slave_pens.cpp
index 23f09fdfd6f..bb5153304a7 100644
--- a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/instance_the_slave_pens.cpp
+++ b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/instance_the_slave_pens.cpp
@@ -28,6 +28,21 @@ gets instead the deserter debuff.
 #include "Map.h"
 #include "the_slave_pens.h"
 
+ObjectData const creatureData[] =
+{
+    { NPC_AHUNE,                    DATA_AHUNE             },
+    { NPC_FROZEN_CORE,              DATA_FROZEN_CORE       },
+    { NPC_AHUNE_LOC_BUNNY,          DATA_AHUNE_BUNNY       },
+    { NPC_SHAMAN_BONFIRE_BUNNY_000, DATA_BONFIRE_BUNNY_000 },
+    { NPC_SHAMAN_BONFIRE_BUNNY_001, DATA_BONFIRE_BUNNY_001 },
+    { NPC_SHAMAN_BONFIRE_BUNNY_002, DATA_BONFIRE_BUNNY_002 },
+    { NPC_SHAMAN_BEAM_BUNNY_000,    DATA_BEAM_BUNNY_000    },
+    { NPC_SHAMAN_BEAM_BUNNY_001,    DATA_BEAM_BUNNY_001    },
+    { NPC_SHAMAN_BEAM_BUNNY_002,    DATA_BEAM_BUNNY_002    },
+    { NPC_LUMA_SKYMOTHER,           DATA_LUMA_SKYMOTHER    },
+    { 0,                            0,                     }
+};
+
 class instance_the_slave_pens : public InstanceMapScript
 {
 public:
@@ -38,66 +53,30 @@ public:
         instance_the_slave_pens_InstanceMapScript(Map* map) : InstanceScript(map)
         {
             counter = DATA_FLAMECALLER_000;
+            LoadObjectData(creatureData, nullptr);
         }
 
         void OnCreatureCreate(Creature* creature) override
         {
-            switch (creature->GetEntry())
-            {
-                case NPC_AHUNE:
-                    AhuneGUID = creature->GetGUID();
-                    break;
-                case NPC_FROZEN_CORE:
-                    FrozenCoreGUID = creature->GetGUID();
-                    break;
-                case NPC_AHUNE_LOC_BUNNY:
-                    AhuneBunnyGUID = creature->GetGUID();
-                    break;
-                case NPC_SHAMAN_BONFIRE_BUNNY_000:
-                    BonfireBunnyGUIDs[0] = creature->GetGUID();
-                    break;
-                case NPC_SHAMAN_BONFIRE_BUNNY_001:
-                    BonfireBunnyGUIDs[1] = creature->GetGUID();
-                    break;
-                case NPC_SHAMAN_BONFIRE_BUNNY_002:
-                    BonfireBunnyGUIDs[2] = creature->GetGUID();
-                    break;
-                case NPC_SHAMAN_BEAM_BUNNY_000:
-                    BeamBunnyGUIDs[0] = creature->GetGUID();
-                    break;
-                case NPC_SHAMAN_BEAM_BUNNY_001:
-                    BeamBunnyGUIDs[1] = creature->GetGUID();
-                    break;
-                case NPC_SHAMAN_BEAM_BUNNY_002:
-                    BeamBunnyGUIDs[2] = creature->GetGUID();
-                    break;
-                case NPC_LUMA_SKYMOTHER:
-                    LumaGUID = creature->GetGUID();
-                    break;
-                case NPC_EARTHEN_RING_FLAMECALLER:
-                    SetGuidData(counter, creature->GetGUID());
-                    ++counter;
-                    break;
-                default:
-                    break;
-            }
-        }
+            InstanceScript::OnCreatureCreate(creature);
 
-        void SetGuidData(uint32 data, ObjectGuid guid) override
-        {
-            switch (data)
+            if (creature->GetEntry() == NPC_EARTHEN_RING_FLAMECALLER)
             {
-                case DATA_FLAMECALLER_000:
-                    FlameCallerGUIDs[0] = guid;
-                    break;
-                case DATA_FLAMECALLER_001:
-                    FlameCallerGUIDs[1] = guid;
-                    break;
-                case DATA_FLAMECALLER_002:
-                    FlameCallerGUIDs[2] = guid;
-                    break;
-                default:
-                    break;
+                switch (counter)
+                {
+                    case DATA_FLAMECALLER_000:
+                        FlameCallerGUIDs[0] = creature->GetGUID();
+                        break;
+                    case DATA_FLAMECALLER_001:
+                        FlameCallerGUIDs[1] = creature->GetGUID();
+                        break;
+                    case DATA_FLAMECALLER_002:
+                        FlameCallerGUIDs[2] = creature->GetGUID();
+                        break;
+                    default:
+                        break;
+                }
+                ++counter;
             }
         }
 
@@ -105,32 +84,12 @@ public:
         {
             switch (type)
             {
-                case DATA_AHUNE:
-                    return AhuneGUID;
-                case DATA_AHUNE_BUNNY:
-                    return AhuneBunnyGUID;
-                case DATA_FROZEN_CORE:
-                    return FrozenCoreGUID;
                 case DATA_FLAMECALLER_000:
                     return FlameCallerGUIDs[0];
                 case DATA_FLAMECALLER_001:
                     return FlameCallerGUIDs[1];
                 case DATA_FLAMECALLER_002:
                     return FlameCallerGUIDs[2];
-                case DATA_BONFIRE_BUNNY_000:
-                    return BonfireBunnyGUIDs[0];
-                case DATA_BONFIRE_BUNNY_001:
-                    return BonfireBunnyGUIDs[1];
-                case DATA_BONFIRE_BUNNY_002:
-                    return BonfireBunnyGUIDs[2];
-                case DATA_BEAM_BUNNY_000:
-                    return BeamBunnyGUIDs[0];
-                case DATA_BEAM_BUNNY_001:
-                    return BeamBunnyGUIDs[1];
-                case DATA_BEAM_BUNNY_002:
-                    return BeamBunnyGUIDs[2];
-                case DATA_LUMA_SKYMOTHER:
-                    return LumaGUID;
                 default:
                     break;
             }
@@ -138,13 +97,7 @@ public:
         }
 
     protected:
-        ObjectGuid AhuneGUID;
-        ObjectGuid AhuneBunnyGUID;
-        ObjectGuid FrozenCoreGUID;
-        ObjectGuid LumaGUID;
         ObjectGuid FlameCallerGUIDs[3];
-        ObjectGuid BonfireBunnyGUIDs[3];
-        ObjectGuid BeamBunnyGUIDs[3];
         uint8 counter;
     };
 
diff --git a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/the_slave_pens.h b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/the_slave_pens.h
index 2ea69ce5453..593066a1c56 100644
--- a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/the_slave_pens.h
+++ b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/the_slave_pens.h
@@ -57,9 +57,7 @@ enum SPCreaturesIds
     NPC_SHAMAN_BONFIRE_BUNNY_002         = 25973,
     NPC_SHAMAN_BEAM_BUNNY_000            = 25964,
     NPC_SHAMAN_BEAM_BUNNY_001            = 25965,
-    NPC_SHAMAN_BEAM_BUNNY_002            = 25966,
-    NPC_WHISP_DEST_BUNNY                 = 26120,
-    NPC_WHISP_SOURCE_BUNNY               = 26121
+    NPC_SHAMAN_BEAM_BUNNY_002            = 25966
 };
 
 enum SPGameObjectIds
@@ -74,4 +72,6 @@ inline AI* GetSlavePensAI(T* obj)
     return GetInstanceAI<AI>(obj, SPScriptName);
 }
 
+#define RegisterSlavePensCreatureAI(ai_name) RegisterCreatureAIWithFactory(ai_name, GetSlavePensAI)
+
 #endif // SLAVE_PENS_H