Merge remote-tracking branch 'sirikfoll/bossAhune' into 3.3.5 (PR #14884)

(cherry picked from commit 37067ad3905059753f38254e72dae62cd2db2ce6)

4 files changed, 1205 insertions, 6 deletions

diff --git a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/boss_ahune.cpp b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/boss_ahune.cpp
new file mode 100644
index 00000000000..9b53b62cdee
--- /dev/null
+++ b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/boss_ahune.cpp
@@ -0,0 +1,1051 @@
+/*
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "CreatureTextMgr.h"
+#include "LFGMgr.h"
+#include "ScriptedGossip.h"
+#include "ScriptedCreature.h"
+#include "ScriptMgr.h"
+#include "SpellAuraEffects.h"
+#include "SpellScript.h"
+#include "the_slave_pens.h"
+
+enum Spells
+{
+    // Ahune
+    SPELL_SYNCH_HEALTH                  = 46430,
+    SPELL_AHUNES_SHIELD                 = 45954,
+    SPELL_STAY_SUBMERGED                = 46981,
+    SPELL_AHUNE_SELF_STUN               = 46416,
+    SPELL_AHUNE_ACHIEVEMENT             = 62043,
+    SPELL_AHUNE_SPANKY_HANDS            = 46146,
+    SPELL_COLD_SLAP                     = 46145,
+    SPELL_RESURFACE                     = 46402,
+    SPELL_SUBMERGED                     = 37751,
+    SPELL_STAND                         = 37752,
+
+    //Earther Ring Flamecaller
+    SPELL_FIND_OPENING_VISUAL           = 45964,
+    SPELL_FIND_OPENING_BEAM_END         = 46333,
+    SPELL_FIND_OPENING_TRIGGER          = 46341,
+    SPELL_FIND_OPENING_CHANNEL          = 46345,
+    SPELL_BONFIRE_VISUAL                = 46339,
+    SPELL_FOUND_OPENING                 = 46421,
+
+    //Ahune Bunny
+    SPELL_SUMMON_COLDWEAVE              = 46143,
+    SPELL_SUMMON_FROSTWIND              = 46382,
+    SPELL_SUMMON_HAILSTONE              = 46176,
+    SPELL_SUMMONING_VISUAL_1            = 45937,
+    SPELL_SUMMONING_RHYME_AURA          = 45926,
+    SPELL_SUMMONING_RHYME_BONFIRE       = 45930,
+    SPELL_FORCE_WHISP_FLIGHT            = 46603,
+    SPELL_SHAMANS_LOOK_FOR_OPENING      = 46422,
+    SPELL_CLOSE_OPENING_VISUAL          = 46236,
+    SPELL_ICE_BOMBARD                   = 46397,
+    SPELL_ICE_BOMBARDMENT_DEST_PICKER   = 46398,
+    SPELL_ICE_BOMBARDMENT               = 46396,
+
+    // Ice Spear
+    SPELL_SUMMON_ICE_SPEAR_BUNNY        = 46359,
+    SPELL_ICE_SPEAR_KNOCKBACK           = 46360,
+    SPELL_SUMMON_ICE_SPEAR_GO           = 46369,
+    SPELL_ICE_SPEAR_AURA                = 46371,
+    SPELL_ICE_SPEAR_TARGET_PICKER       = 46372,
+    SPELL_ICE_SPEAR_DELAY               = 46878,
+    SPELL_ICE_SPEAR_VISUAL              = 75498,
+
+    // Slippery Floor
+    SPELL_SLIPPERY_FLOOR_AMBIENT        = 46314,
+    SPELL_SLIPPERY_FLOOR_PERIODIC       = 46320,
+    SPELL_SLIPPERY_FLOOR_SLIP           = 45947,
+
+    // Frozen Core
+    SPELL_SUICIDE                       = 45254,
+    SPELL_SUMMON_LOOT_MISSILE           = 45941,
+    SPELL_FROZEN_CORE_GETS_HIT          = 46810,
+    SPELL_MINION_DESPAWNER              = 46843,
+    SPELL_GHOST_DISGUISE                = 46786
+};
+
+enum Emotes
+{
+    EMOTE_EARTHEN_ASSAULT               = 0,
+    EMOTE_RETREAT                       = 0,
+    EMOTE_RESURFACE                     = 1
+};
+
+enum Says
+{
+    SAY_PLAYER_TEXT_1                    = 0,
+    SAY_PLAYER_TEXT_2                    = 1,
+    SAY_PLAYER_TEXT_3                    = 2
+};
+
+enum Events
+{
+    EVENT_EMERGE                        = 1,
+    EVENT_INITIAL_EMERGE                = 2,
+    EVENT_SYNCH_HEALTH                  = 3,
+    EVENT_FOUND_OPENING                 = 4,
+    EVENT_LOOKFOROPENING_0              = 5,
+    EVENT_LOOKFOROPENING_1              = 6,
+    EVENT_LOOKFOROPENING_2              = 7,
+    EVENT_SUMMON_HAILSTONE              = 8,
+    EVENT_SUMMON_COLDWEAVE              = 9,
+    EVENT_SUMMON_FROSTWIND              = 10,
+    EVENT_SUMMON_AHUNE                  = 11,
+    EVENT_CLOSE_OPENING                 = 12,
+    EVENT_AHUNE_PHASE_ONE               = 13,
+    EVENT_AHUNE_PHASE_TWO               = 14,
+    EVENT_START_LOOKING_FOR_OPENING     = 15,
+    EVENT_STOP_LOOKING_FOR_OPENING      = 16
+};
+
+enum Actions
+{
+    ACTION_START_EVENT                  = -2574500,
+    ACTION_AHUNE_RETREAT                = -2586500,
+    ACTION_AHUNE_RESURFACE              = -2586501,
+    ACTION_EMOTE_RESURFACE              = -2575400
+};
+
+enum Phases
+{
+    PHASE_ONE                   = 0,
+    PHASE_TWO                   = 1
+};
+
+enum Points
+{
+    POINT_FLAMECALLER_000,
+    POINT_FLAMECALLER_001,
+    POINT_FLAMECALLER_002
+};
+
+enum Misc
+{
+    MAX_FLAMECALLERS    = 3
+};
+
+Position const SummonPositions[] =
+{
+    { -99.1021f, -233.7526f, -1.22307f, 1.588250f },  // Ahune
+    { -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
+};
+
+Position const FlameCallerSpots[] =
+{
+    { -145.2233f, -137.5543f, -1.59056f, 5.427049f },
+    { -137.4383f, -136.4050f, -1.72384f, 5.336747f },
+    { -129.0413f, -132.1494f, -2.09285f, 5.460842f }
+};
+
+class boss_ahune : public CreatureScript
+{
+public:
+    boss_ahune() : CreatureScript("boss_ahune") { }
+
+    struct boss_ahuneAI : public BossAI
+    {
+        boss_ahuneAI(Creature* creature) : BossAI(creature, DATA_AHUNE)
+        {
+            Initialize();
+        }
+
+        void Initialize()
+        {
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
+        }
+
+        void EnterCombat(Unit* /*who*/) override
+        {
+            _EnterCombat();
+            events.ScheduleEvent(EVENT_INITIAL_EMERGE, 4);
+            events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3000);
+        }
+
+        void EnterEvadeMode(EvadeReason /*why*/) override
+        {
+            if (Creature* ahuneBunny = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_AHUNE_BUNNY)))
+                ahuneBunny->AI()->EnterEvadeMode();
+            summons.DespawnAll();
+            me->DespawnOrUnsummon();
+        }
+
+        void JustDied(Unit* /*killer*/) override
+        {
+            _JustDied();
+            instance->DoCastSpellOnPlayers(SPELL_AHUNE_ACHIEVEMENT);
+
+            if (Creature* ahuneBunny = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_AHUNE_BUNNY)))
+                me->Kill(ahuneBunny);
+            if (Creature* frozenCore = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_FROZEN_CORE)))
+                me->Kill(frozenCore);
+
+            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);
+            }
+        }
+
+        void JustSummoned(Creature* summon) override
+        {
+            BossAI::JustSummoned(summon);
+        }
+
+        void DoAction(int32 action) override
+        {
+            if (action == ACTION_AHUNE_RETREAT)
+            {
+                Submerge();
+                events.ScheduleEvent(EVENT_EMERGE, 35000);
+            }
+        }
+
+        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);
+                        else
+                            DoCast(me, SPELL_SUICIDE);
+                        events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3000);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            DoMeleeAttackIfReady();
+        }
+
+        void Emerge()
+        {
+            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_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
+            events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3000);
+        }
+
+        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_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
+            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();
+        }
+    };
+
+    CreatureAI* GetAI(Creature* creature) const override
+    {
+        return GetInstanceAI<boss_ahuneAI>(creature);
+    }
+};
+
+class npc_frozen_core : public CreatureScript
+{
+public:
+    npc_frozen_core() : CreatureScript("npc_frozen_core") { }
+
+    struct npc_frozen_coreAI : public ScriptedAI
+    {
+        npc_frozen_coreAI(Creature* creature) : ScriptedAI(creature)
+        {
+            _instance = me->GetInstanceScript();
+            Initialize();
+        }
+
+        void Initialize()
+        {
+            me->SetReactState(REACT_PASSIVE);
+            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_DISABLE_MOVE);
+            DoCast(me, SPELL_FROZEN_CORE_GETS_HIT);
+            DoCast(me, SPELL_ICE_SPEAR_AURA);
+        }
+
+        void EnterEvadeMode(EvadeReason /*why*/) override
+        {
+            DoCast(SPELL_MINION_DESPAWNER);
+            if (Creature* ahune = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_AHUNE)))
+                ahune->AI()->EnterEvadeMode();
+        }
+
+        void JustDied(Unit* /*killer*/) override
+        {
+            if (Creature* ahune = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_AHUNE)))
+                me->Kill(ahune);
+
+            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_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_IMMUNE_TO_PC);
+                me->RemoveAurasDueToSpell(SPELL_ICE_SPEAR_AURA);
+                _events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3000, 0, PHASE_TWO);
+            }
+            else if (action == ACTION_AHUNE_RESURFACE)
+            {
+                _events.Reset();
+                DoCast(me, SPELL_ICE_SPEAR_AURA);
+                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_DISABLE_MOVE);
+            }
+        }
+
+        void UpdateAI(uint32 diff) override
+        {
+            if (!UpdateVictim())
+                return;
+
+            _events.Update(diff);
+
+            while (uint32 eventId = _events.ExecuteEvent())
+            {
+                switch (eventId)
+                {
+                    case EVENT_SYNCH_HEALTH:
+                        if (Creature* ahune = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_AHUNE)))
+                            DoCast(ahune, SPELL_SYNCH_HEALTH);
+                        else
+                            DoCast(me, SPELL_SUICIDE);
+                        _events.ScheduleEvent(EVENT_SYNCH_HEALTH, 3000);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+
+    private:
+        InstanceScript* _instance;
+        EventMap _events;
+    };
+
+    CreatureAI* GetAI(Creature* creature) const override
+    {
+        return GetInstanceAI<npc_frozen_coreAI>(creature);
+    }
+};
+
+class npc_ahune_bunny : public CreatureScript
+{
+public:
+    npc_ahune_bunny() : CreatureScript("npc_ahune_bunny") { }
+
+    struct npc_ahune_bunnyAI : public ScriptedAI
+    {
+        npc_ahune_bunnyAI(Creature* creature) : ScriptedAI(creature), _summons(me)
+        {
+            _instance = me->GetInstanceScript();
+            _submerged = false;
+        }
+
+        void JustSummoned(Creature* summon) override
+        {
+            if (summon->GetEntry() == NPC_AHUNE)
+                return;
+
+            summon->SetInCombatWithZone();
+            _summons.Summon(summon);
+        }
+
+        void JustDied(Unit* /*killer*/) override
+        {
+            _summons.DespawnAll();
+            ResetFlameCallers();
+        }
+
+        void EnterEvadeMode(EvadeReason /*why*/) override
+        {
+            _EnterEvadeMode();
+            _summons.DespawnAll();
+            ResetFlameCallers();
+
+            me->SummonGameObject(GO_ICE_STONE, -69.90455f, -162.2449f, -2.366563f, 2.426008f, 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, 10000);
+                _events.ScheduleEvent(EVENT_START_LOOKING_FOR_OPENING, 14000, 0, PHASE_ONE);
+                _events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 22000, 0, PHASE_ONE);
+                _events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, 14000, 0, PHASE_ONE);
+                _events.ScheduleEvent(EVENT_AHUNE_PHASE_TWO, 108000, 0, PHASE_ONE);
+            }
+        }
+
+        void UpdateAI(uint32 diff) override
+        {
+            if (!UpdateVictim())
+                return;
+
+            _events.Update(diff);
+
+            while (uint32 eventId = _events.ExecuteEvent())
+            {
+                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.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 8000, 0, PHASE_ONE);
+                        if (_submerged)
+                            _events.ScheduleEvent(EVENT_SUMMON_FROSTWIND, 4000, 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);
+                            ahune->SetInCombatWithZone();
+                            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, 25000, 0, PHASE_TWO);
+                        _events.ScheduleEvent(EVENT_AHUNE_PHASE_ONE, 35000, 0, PHASE_TWO);
+                        break;
+                    case EVENT_AHUNE_PHASE_ONE:
+                        _submerged = true;
+                        _events.Reset();
+                        _events.SetPhase(PHASE_ONE);
+                        _events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 8000, 0, PHASE_ONE);
+                        _events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, 5000, 0, PHASE_ONE);
+                        _events.ScheduleEvent(EVENT_START_LOOKING_FOR_OPENING, 5000, 0, PHASE_ONE);
+                        _events.ScheduleEvent(EVENT_AHUNE_PHASE_TWO, 100000, 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
+    {
+        return GetInstanceAI<npc_ahune_bunnyAI>(creature);
+    }
+};
+
+class npc_earthen_ring_flamecaller : public CreatureScript
+{
+public:
+    npc_earthen_ring_flamecaller() : CreatureScript("npc_earthen_ring_flamecaller") { }
+
+    struct npc_earthen_ring_flamecallerAI : public ScriptedAI
+    {
+        npc_earthen_ring_flamecallerAI(Creature* creature) : ScriptedAI(creature)
+        {
+            _instance = me->GetInstanceScript();
+        }
+
+        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;
+            }
+
+            DoCast(me, SPELL_FIND_OPENING_CHANNEL);
+        }
+
+        void SpellHit(Unit* /*caster*/, SpellInfo const* spellInfo) override
+        {
+            switch (spellInfo->Id)
+            {
+                case SPELL_SHAMANS_LOOK_FOR_OPENING:
+                    _events.ScheduleEvent(EVENT_LOOKFOROPENING_0, 17000);
+                    break;
+                case SPELL_FOUND_OPENING:
+                    _events.ScheduleEvent(EVENT_FOUND_OPENING, 0);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        void DoAction(int action) override
+        {
+            if (action == ACTION_EMOTE_RESURFACE)
+                Talk(EMOTE_RESURFACE);
+        }
+
+        void UpdateAI(uint32 diff) override
+        {
+            _events.Update(diff);
+
+            while (uint32 eventId = _events.ExecuteEvent())
+            {
+                switch (eventId)
+                {
+                    case EVENT_LOOKFOROPENING_0:
+                        LookOpening(true, 0);
+                        _events.ScheduleEvent(EVENT_LOOKFOROPENING_1, 26000);
+                        break;
+                    case EVENT_LOOKFOROPENING_1:
+                        LookOpening(true, 1);
+                        _events.ScheduleEvent(EVENT_LOOKFOROPENING_2, 25000);
+                        break;
+                    case EVENT_LOOKFOROPENING_2:
+                        LookOpening(true, 2);
+                        _events.ScheduleEvent(EVENT_STOP_LOOKING_FOR_OPENING, 27000);
+                        break;
+                    case EVENT_STOP_LOOKING_FOR_OPENING:
+                        LookOpening(false, _mySpot);
+                        break;
+                    case EVENT_FOUND_OPENING:
+                        Talk(EMOTE_RETREAT);
+                    default:
+                        break;
+                }
+            }
+        }
+
+        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)))
+                {
+                    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);
+                    }
+                }
+        }
+
+    private:
+        EventMap _events;
+        InstanceScript* _instance;
+        uint8 _mySpot;
+    };
+
+    CreatureAI* GetAI(Creature* creature) const override
+    {
+        return GetInstanceAI<npc_earthen_ring_flamecallerAI>(creature);
+    }
+};
+
+class go_ahune_ice_stone : public GameObjectScript
+{
+public:
+    go_ahune_ice_stone() : GameObjectScript("go_ahune_ice_stone") { }
+
+    bool OnGossipSelect(Player* player, GameObject* go, uint32 /*sender*/, uint32 /*action*/)
+    {
+        InstanceScript* instance = go->GetInstanceScript();
+        if (!instance)
+            return false;
+
+        player->PlayerTalkClass->ClearMenus();
+
+        if (Creature* ahuneBunny = ObjectAccessor::GetCreature(*go, instance->GetGuidData(DATA_AHUNE_BUNNY)))
+        {
+            ahuneBunny->AI()->DoAction(ACTION_START_EVENT);
+            ahuneBunny->SetInCombatWithZone();
+        }
+        if (Creature* luma = ObjectAccessor::GetCreature(*go, instance->GetGuidData(DATA_LUMA_SKYMOTHER)))
+            luma->CastSpell(player, SPELL_SUMMONING_RHYME_AURA, true);
+        player->CLOSE_GOSSIP_MENU();
+        go->Delete();
+
+        return true;
+    }
+};
+
+// 46430 - Synch Health
+class spell_ahune_synch_health : public SpellScriptLoader
+{
+public:
+    spell_ahune_synch_health() : SpellScriptLoader("spell_ahune_synch_health") { }
+
+    class spell_ahune_synch_health_SpellScript : public SpellScript
+    {
+        PrepareSpellScript(spell_ahune_synch_health_SpellScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_SYNCH_HEALTH))
+                return false;
+            return true;
+        }
+
+        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);
+        }
+    };
+
+    SpellScript* GetSpellScript() const override
+    {
+        return new spell_ahune_synch_health_SpellScript();
+    }
+};
+
+// 45926 - Summoning Rhyme Aura
+class spell_summoning_rhyme_aura : public SpellScriptLoader
+{
+public:
+    spell_summoning_rhyme_aura() : SpellScriptLoader("spell_summoning_rhyme_aura") { }
+
+    class spell_summoning_rhyme_aura_AuraScript : public AuraScript
+    {
+        PrepareAuraScript(spell_summoning_rhyme_aura_AuraScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_FORCE_WHISP_FLIGHT) || !sSpellMgr->GetSpellInfo(SPELL_SUMMONING_RHYME_BONFIRE))
+                return false;
+            return true;
+        }
+
+        void PeriodicTick(AuraEffect const* aurEff)
+        {
+            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, NULL, 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, NULL, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
+                    break;
+                case 3:
+                    sCreatureTextMgr->SendChat(caster, SAY_PLAYER_TEXT_3, NULL, CHAT_MSG_SAY, LANG_UNIVERSAL, TEXT_RANGE_NORMAL, 0, TEAM_OTHER, false, player);
+                    Remove();
+                    break;
+            }
+        }
+
+        void Register() override
+        {
+            OnEffectPeriodic += AuraEffectPeriodicFn(spell_summoning_rhyme_aura_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+        }
+    };
+
+    AuraScript* GetAuraScript() const override
+    {
+        return new spell_summoning_rhyme_aura_AuraScript();
+    }
+};
+
+// 46878 - Summon Ice Spear Delayer
+class spell_summon_ice_spear_delayer : public SpellScriptLoader
+{
+public:
+    spell_summon_ice_spear_delayer() : SpellScriptLoader("spell_summon_ice_spear_delayer") { }
+
+    class spell_summon_ice_spear_delayer_AuraScript : public AuraScript
+    {
+        PrepareAuraScript(spell_summon_ice_spear_delayer_AuraScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_ICE_SPEAR_GO) || !sSpellMgr->GetSpellInfo(SPELL_ICE_SPEAR_KNOCKBACK))
+                return false;
+            return true;
+        }
+
+        void PeriodicTick(AuraEffect const* aurEff)
+        {
+            if (Creature* caster = GetCaster()->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;
+                }
+        }
+
+        void Register() override
+        {
+            OnEffectPeriodic += AuraEffectPeriodicFn(spell_summon_ice_spear_delayer_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+        }
+    };
+
+    AuraScript* GetAuraScript() const override
+    {
+        return new spell_summon_ice_spear_delayer_AuraScript();
+    }
+};
+
+// 46371 - Ice Spear Control Aura
+class spell_ice_spear_control_aura : public SpellScriptLoader
+{
+public:
+    spell_ice_spear_control_aura() : SpellScriptLoader("spell_ice_spear_control_aura") { }
+
+    class spell_ice_spear_control_aura_AuraScript : public AuraScript
+    {
+        PrepareAuraScript(spell_ice_spear_control_aura_AuraScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_ICE_SPEAR_TARGET_PICKER))
+                return false;
+            return true;
+        }
+
+        void PeriodicTick(AuraEffect const* /*aurEff*/)
+        {
+            if (Unit* caster = GetCaster())
+                caster->CastSpell(caster, SPELL_ICE_SPEAR_TARGET_PICKER);
+        }
+
+        void Register() override
+        {
+            OnEffectPeriodic += AuraEffectPeriodicFn(spell_ice_spear_control_aura_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
+        }
+    };
+
+    AuraScript* GetAuraScript() const override
+    {
+        return new spell_ice_spear_control_aura_AuraScript();
+    }
+};
+
+// 46372 - Ice Spear Target Picker
+class spell_ice_spear_target_picker : public SpellScriptLoader
+{
+public:
+    spell_ice_spear_target_picker() : SpellScriptLoader("spell_ice_spear_target_picker") { }
+
+    class spell_ice_spear_target_picker_SpellScript : public SpellScript
+    {
+        PrepareSpellScript(spell_ice_spear_target_picker_SpellScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_ICE_SPEAR_BUNNY))
+                return false;
+            return true;
+        }
+
+        void HandleDummy(SpellEffIndex /*effIndex*/)
+        {
+            GetCaster()->CastSpell(GetHitUnit(), SPELL_SUMMON_ICE_SPEAR_BUNNY, true);
+        }
+
+        void Register()
+        {
+            OnEffectHitTarget += SpellEffectFn(spell_ice_spear_target_picker_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
+        }
+    };
+
+    SpellScript* GetSpellScript() const override
+    {
+        return new spell_ice_spear_target_picker_SpellScript();
+    }
+};
+
+// 46320 - Spell Slippery Floor Periodic
+class spell_slippery_floor_periodic : public SpellScriptLoader
+{
+public:
+    spell_slippery_floor_periodic() : SpellScriptLoader("spell_slippery_floor_periodic") { }
+
+    class spell_slippery_floor_periodic_SpellScript : public SpellScript
+    {
+        PrepareSpellScript(spell_slippery_floor_periodic_SpellScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_SLIPPERY_FLOOR_SLIP))
+                return false;
+            return true;
+        }
+
+        void HandleScriptEffect(SpellEffIndex /*effIndex*/)
+        {
+            if (Unit* target = GetHitUnit())
+                if (target->isMoving())
+                    target->CastSpell(target, SPELL_SLIPPERY_FLOOR_SLIP, true);
+        }
+
+        void Register() override
+        {
+            OnEffectHitTarget += SpellEffectFn(spell_slippery_floor_periodic_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
+        }
+    };
+
+    SpellScript* GetSpellScript() const override
+    {
+        return new spell_slippery_floor_periodic_SpellScript();
+    }
+};
+
+// 46146 - Ahune Spanky Hands
+class spell_ahune_spanky_hands : public SpellScriptLoader
+{
+public:
+    spell_ahune_spanky_hands() : SpellScriptLoader("spell_ahune_spanky_hands") { }
+
+    class spell_ahune_spanky_hands_AuraScript : public AuraScript
+    {
+        PrepareAuraScript(spell_ahune_spanky_hands_AuraScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_COLD_SLAP))
+                return false;
+            return true;
+        }
+
+        void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
+        {
+            PreventDefaultAction();
+            GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_COLD_SLAP, true);
+        }
+
+        void Register() override
+        {
+            OnEffectProc += AuraEffectProcFn(spell_ahune_spanky_hands_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+        }
+    };
+
+    AuraScript* GetAuraScript() const override
+    {
+        return new spell_ahune_spanky_hands_AuraScript();
+    }
+};
+
+class spell_ahune_minion_despawner : public SpellScriptLoader
+{
+public:
+    spell_ahune_minion_despawner() : SpellScriptLoader("spell_ahune_minion_despawner") { }
+
+    class spell_ahune_minion_despawner_SpellScript : public SpellScript
+    {
+        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);
+        }
+    };
+
+    SpellScript* GetSpellScript() const override
+    {
+        return new spell_ahune_minion_despawner_SpellScript();
+    }
+};
+
+// 46398 - Spell Ice Bombardment Dest Picker
+class spell_ice_bombardment_dest_picker : public SpellScriptLoader
+{
+public:
+    spell_ice_bombardment_dest_picker() : SpellScriptLoader("spell_ice_bombardment_dest_picker") { }
+
+    class spell_ice_bombardment_dest_picker_SpellScript : public SpellScript
+    {
+        PrepareSpellScript(spell_ice_bombardment_dest_picker_SpellScript);
+
+        bool Validate(SpellInfo const* /*spellInfo*/) override
+        {
+            if (!sSpellMgr->GetSpellInfo(SPELL_ICE_BOMBARDMENT))
+                return false;
+            return true;
+        }
+
+        void HandleScriptEffect(SpellEffIndex /*effIndex*/)
+        {
+            GetCaster()->CastSpell(GetHitDest()->GetPositionX(), GetHitDest()->GetPositionY(), GetHitDest()->GetPositionZ(), SPELL_ICE_BOMBARDMENT, true);
+        }
+
+        void Register() override
+        {
+            OnEffectHit += SpellEffectFn(spell_ice_bombardment_dest_picker_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_DUMMY);
+        }
+    };
+
+    SpellScript* GetSpellScript() const override
+    {
+        return new spell_ice_bombardment_dest_picker_SpellScript();
+    }
+};
+
+void AddSC_boss_ahune()
+{
+    new boss_ahune();
+    new npc_frozen_core();
+    new npc_earthen_ring_flamecaller();
+    new 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();
+}
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 87a07cd1e5e..0d85a8f0d86 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
@@ -31,15 +31,125 @@ class instance_the_slave_pens : public InstanceMapScript
 public:
     instance_the_slave_pens() : InstanceMapScript(SPScriptName, 547) { }
 
+    struct instance_the_slave_pens_InstanceMapScript : public InstanceScript
+    {
+        instance_the_slave_pens_InstanceMapScript(Map* map) : InstanceScript(map)
+        {
+            counter = DATA_FLAMECALLER_000;
+        }
+
+        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;
+            }
+        }
+
+        void SetGuidData(uint32 data, ObjectGuid guid)
+        {
+            switch (data)
+            {
+                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;
+            }
+        }
+
+        ObjectGuid GetGuidData(uint32 type) const override
+        {
+            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;
+            }
+            return ObjectGuid::Empty;
+        }
+
+    protected:
+        ObjectGuid AhuneGUID;
+        ObjectGuid AhuneBunnyGUID;
+        ObjectGuid FrozenCoreGUID;
+        ObjectGuid LumaGUID;
+        ObjectGuid FlameCallerGUIDs[3];
+        ObjectGuid BonfireBunnyGUIDs[3];
+        ObjectGuid BeamBunnyGUIDs[3];
+        uint8 counter;
+    };
+
     InstanceScript* GetInstanceScript(InstanceMap* map) const override
     {
         return new instance_the_slave_pens_InstanceMapScript(map);
     }
-
-    struct instance_the_slave_pens_InstanceMapScript : public InstanceScript
-    {
-        instance_the_slave_pens_InstanceMapScript(Map* map) : InstanceScript(map) { }
-    };
 };
 
 void AddSC_instance_the_slave_pens()
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 95e6e44121e..544e98fd206 100644
--- a/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/the_slave_pens.h
+++ b/src/server/scripts/Outland/CoilfangReservoir/TheSlavePens/the_slave_pens.h
@@ -27,7 +27,43 @@ enum DataTypes
 {
     DATA_MENNU_THE_BETRAYER               = 1,
     DATA_ROKMAR_THE_CRACKLER              = 2,
-    DATA_QUAGMIRRAN                       = 3
+    DATA_QUAGMIRRAN                       = 3,
+    DATA_AHUNE                            = 4,
+    DATA_AHUNE_BUNNY                      = 5,
+    DATA_FROZEN_CORE                      = 6,
+    DATA_FLAMECALLER_000                  = 7,
+    DATA_FLAMECALLER_001                  = 8,
+    DATA_FLAMECALLER_002                  = 9,
+    DATA_BONFIRE_BUNNY_000                = 10,
+    DATA_BONFIRE_BUNNY_001                = 11,
+    DATA_BONFIRE_BUNNY_002                = 12,
+    DATA_BEAM_BUNNY_000                   = 13,
+    DATA_BEAM_BUNNY_001                   = 14,
+    DATA_BEAM_BUNNY_002                   = 15,
+    DATA_LUMA_SKYMOTHER                   = 16
+};
+
+enum CreaturesIds
+{
+    NPC_AHUNE                            = 25740,
+    NPC_FROZEN_CORE                      = 25865,
+    NPC_LUMA_SKYMOTHER                   = 25697,
+    NPC_AHUNE_LOC_BUNNY                  = 25745,
+    NPC_EARTHEN_RING_FLAMECALLER         = 25754,
+    NPC_SHAMAN_BONFIRE_BUNNY_000         = 25971,
+    NPC_SHAMAN_BONFIRE_BUNNY_001         = 25972,
+    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
+};
+
+enum GameObjectIds
+{
+    GO_ICE_SPEAR                         = 188077,
+    GO_ICE_STONE                         = 187882
 };
 
 #endif // SLAVE_PENS_H
diff --git a/src/server/scripts/Outland/outland_script_loader.cpp b/src/server/scripts/Outland/outland_script_loader.cpp
index 91ba4e5689f..ed2c21da6c3 100644
--- a/src/server/scripts/Outland/outland_script_loader.cpp
+++ b/src/server/scripts/Outland/outland_script_loader.cpp
@@ -72,6 +72,7 @@ void AddSC_instance_the_slave_pens();
 void AddSC_boss_mennu_the_betrayer();
 void AddSC_boss_rokmar_the_crackler();
 void AddSC_boss_quagmirran();
+void AddSC_boss_ahune();
 
 // Coilfang Reservoir - The Underbog
 void AddSC_instance_the_underbog();
@@ -193,6 +194,7 @@ void AddOutlandScripts()
     AddSC_boss_mennu_the_betrayer();
     AddSC_boss_rokmar_the_crackler();
     AddSC_boss_quagmirran();
+    AddSC_boss_ahune();
 
     // Coilfang Reservoir - The Underbog
     AddSC_instance_the_underbog();