blackrock_caverns.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * 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 "ScriptMgr.h"
#include "blackrock_caverns.h"
#include "ScriptedCreature.h"
#include "SpellAuras.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
 
/*#####
# npc_fire_cyclone
#####*/
 
enum FireCyclone
{
 SPELL_FIRE_CYCLONE_AURA = 74851,
 EVENT_FIRE_CYCLONE_AURA = 1
};
 
class npc_fire_cyclone : public CreatureScript
{
 public: npc_fire_cyclone() : CreatureScript("npc_fire_cyclone") { }
 
 struct npc_fire_cycloneAI : public ScriptedAI
 {
 npc_fire_cycloneAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void Reset() override
 {
 _events.Reset();
 _events.ScheduleEvent(EVENT_FIRE_CYCLONE_AURA, 100ms);
 }
 
 void UpdateAI(uint32 diff) override
 {
 _events.Update(diff);
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_FIRE_CYCLONE_AURA:
 DoCast(me, SPELL_FIRE_CYCLONE_AURA, true);
 _events.ScheduleEvent(EVENT_FIRE_CYCLONE_AURA, 4s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap _events;
 InstanceScript* _instance;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_fire_cycloneAI>(creature);
 }
};
 
/*#####
# npc_twilight_flame_caller
#####*/
 
enum TwilightFlameCaller
{
 SPELL_FIRE_CHANNELING_1 = 74911,
 SPELL_FIRE_CHANNELING_2 = 74912,
 SPELL_BLAST_WAVE = 76473,
 SPELL_CALL_FLAMES = 76325,
 NPC_FIRE_CYCLONE = 40164,
 EVENT_CHANNEL = 2,
 EVENT_BLAST_WAVE = 3,
 EVENT_CALL_FLAMES = 4
};
 
Position const SummonPos[6] =
{
 { 162.5990f, 1085.321f, 201.1190f, 0.0f },
 { 170.5469f, 1063.403f, 201.1409f, 0.0f },
 { 191.2326f, 1100.160f, 201.1071f, 0.0f },
 { 228.0816f, 1106.000f, 201.1292f, 0.0f },
 { 252.8351f, 1095.127f, 201.1436f, 0.0f },
 { 253.6476f, 1070.226f, 201.1344f, 0.0f }
};
 
class npc_twilight_flame_caller : public CreatureScript
{
public: npc_twilight_flame_caller() : CreatureScript("npc_twilight_flame_caller") { }
 
 struct npc_twilight_flame_callerAI : public ScriptedAI
 {
 npc_twilight_flame_callerAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()), _summons(me)
 {
 Initialize();
 }
 
 void Initialize()
 {
 _combatPhase = false;
 }
 
 void Reset() override
 {
 Initialize();
 _flamecaller1GUID.Clear();
 _flamecaller2GUID.Clear();
 
 if (me->GetPositionX() > 172 && me->GetPositionX() < 173 && me->GetPositionY() > 1086 && me->GetPositionY() < 1087)
 {
 _flamecaller1GUID = me->GetGUID();
 me->SummonCreature(NPC_FIRE_CYCLONE, SummonPos[0], TEMPSUMMON_CORPSE_DESPAWN, 0s);
 me->SummonCreature(NPC_FIRE_CYCLONE, SummonPos[1], TEMPSUMMON_CORPSE_DESPAWN, 0s);
 me->SummonCreature(NPC_FIRE_CYCLONE, SummonPos[2], TEMPSUMMON_CORPSE_DESPAWN, 0s);
 }
 if (me->GetPositionX() > 247 && me->GetPositionX() < 248 && me->GetPositionY() > 1081 && me->GetPositionY() < 1082)
 {
 _flamecaller2GUID = me->GetGUID();
 me->SummonCreature(NPC_FIRE_CYCLONE, SummonPos[3], TEMPSUMMON_CORPSE_DESPAWN, 0s);
 me->SummonCreature(NPC_FIRE_CYCLONE, SummonPos[4], TEMPSUMMON_CORPSE_DESPAWN, 0s);
 me->SummonCreature(NPC_FIRE_CYCLONE, SummonPos[5], TEMPSUMMON_CORPSE_DESPAWN, 0s);
 }
 
 _events.ScheduleEvent(EVENT_CHANNEL, 100ms);
 }
 
 void JustSummoned(Creature* summoned) override
 {
 _summons.Summon(summoned);
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 _summons.DespawnAll();
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 _events.Reset();
 _combatPhase = true;
 _events.ScheduleEvent(EVENT_BLAST_WAVE, 8s, 10s);
 _events.ScheduleEvent(EVENT_CALL_FLAMES, 10s, 14s);
 }
 
 void UpdateAI(uint32 diff) override
 {
 _events.Update(diff);
 
 if (!_combatPhase)
 {
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_CHANNEL:
 if (me->GetGUID() == _flamecaller1GUID)
 DoCast(me, SPELL_FIRE_CHANNELING_1);
 if (me->GetGUID() == _flamecaller2GUID)
 DoCast(me, SPELL_FIRE_CHANNELING_2);
 _events.ScheduleEvent(EVENT_CHANNEL, 12s);
 break;
 default:
 break;
 }
 }
 return;
 }
 
 if (!UpdateVictim())
 return;
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_BLAST_WAVE:
 DoCast(me, SPELL_BLAST_WAVE);
 _events.ScheduleEvent(EVENT_BLAST_WAVE, 16s, 20s);
 break;
 case EVENT_CALL_FLAMES:
 DoCast(me, SPELL_CALL_FLAMES);
 _events.ScheduleEvent(EVENT_CALL_FLAMES, 12s, 15s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap _events;
 InstanceScript* _instance;
 ObjectGuid _flamecaller1GUID;
 ObjectGuid _flamecaller2GUID;
 SummonList _summons;
 bool _combatPhase;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_twilight_flame_callerAI>(creature);
 }
};
 
/*#####
# npc_twilight_torturer
#####*/
 
enum TwilightTorturer
{
 SPELL_INFLICT_PAIN = 75590,
 SPELL_RED_HOT_POKER = 76478,
 SPELL_SHACKLES = 76484,
 SPELL_WILD_BEATDOWN = 76487,
 EVENT_INFLICT_PAIN_TT = 5,
 EVENT_RED_HOT_POKER = 6,
 EVENT_SHACKLES = 7,
 EVENT_WILD_BEATDOWN = 8
};
 
class npc_twilight_torturer : public CreatureScript
{
 public: npc_twilight_torturer() : CreatureScript("npc_twilight_torturer") { }
 
 struct npc_twilight_torturerAI : public ScriptedAI
 {
 npc_twilight_torturerAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript())
 {
 Initialize();
 }
 
 void Initialize()
 {
 _combatPhase = false;
 }
 
 void Reset() override
 {
 Initialize();
 if (!me->GetWaypointPathId())
 _events.ScheduleEvent(EVENT_INFLICT_PAIN_TT, 6s, 18s);
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 _events.Reset();
 _combatPhase = true;
 _events.ScheduleEvent(EVENT_RED_HOT_POKER, 9s);
 _events.ScheduleEvent(EVENT_SHACKLES, 13s);
 _events.ScheduleEvent(EVENT_WILD_BEATDOWN, 17s);
 }
 
 void UpdateAI(uint32 diff) override
 {
 _events.Update(diff);
 
 if (!_combatPhase)
 {
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_INFLICT_PAIN_TT:
 DoCast(me, SPELL_INFLICT_PAIN);
 _events.ScheduleEvent(EVENT_INFLICT_PAIN_TT, 25s, 32s);
 break;
 default:
 break;
 }
 }
 return;
 }
 
 if (!UpdateVictim())
 return;
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_RED_HOT_POKER:
 DoCast(me, SPELL_RED_HOT_POKER);
 _events.ScheduleEvent(EVENT_RED_HOT_POKER, 16s, 20s);
 break;
 case EVENT_SHACKLES:
 DoCast(me, SPELL_SHACKLES);
 _events.ScheduleEvent(EVENT_SHACKLES, 12s, 15s);
 break;
 case EVENT_WILD_BEATDOWN:
 DoCast(me, SPELL_WILD_BEATDOWN);
 _events.ScheduleEvent(EVENT_WILD_BEATDOWN, 12s, 15s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap _events;
 InstanceScript* _instance;
 bool _combatPhase;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_twilight_torturerAI>(creature);
 }
};
 
/*#####
# npc_twilight_sadist
#####*/
 
enum TwilightSadist
{
 SPELL_INFLICT_PAIN_1 = 76497,
 SPELL_HEAT_SEEKER_BLADE = 76502,
 SPELL_SHORT_THROW = 76572,
 SPELL_SINISTER_STRIKE = 76500,
 EVENT_INFLICT_PAIN_TS = 9,
 EVENT_HEAT_SEEKER_BLADE = 10,
 EVENT_SHORT_THROW = 11,
 EVENT_SINISTER_STRIKE = 12
};
 
class npc_twilight_sadist : public CreatureScript
{
 public: npc_twilight_sadist() : CreatureScript("npc_twilight_sadist") { }
 
 struct npc_twilight_sadistAI : public ScriptedAI
 {
 npc_twilight_sadistAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void Reset() override
 {
 _combatPhase = false;
 if (!me->GetWaypointPathId())
 _events.ScheduleEvent(EVENT_INFLICT_PAIN_TS, 6s, 18s);
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 _events.Reset();
 _combatPhase = true;
 _events.ScheduleEvent(EVENT_INFLICT_PAIN_TS, 9s);
 _events.ScheduleEvent(EVENT_HEAT_SEEKER_BLADE, 13s);
 _events.ScheduleEvent(EVENT_SHORT_THROW, 17s);
 _events.ScheduleEvent(EVENT_SINISTER_STRIKE, 17s);
 }
 
 void UpdateAI(uint32 diff) override
 {
 _events.Update(diff);
 
 if (!_combatPhase)
 {
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_INFLICT_PAIN_TS:
 DoCast(me, SPELL_INFLICT_PAIN);
 _events.ScheduleEvent(EVENT_INFLICT_PAIN_TS, 25s, 32s);
 break;
 default:
 break;
 }
 }
 return;
 }
 
 if (!UpdateVictim())
 return;
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_RED_HOT_POKER:
 DoCast(me, SPELL_RED_HOT_POKER);
 _events.ScheduleEvent(EVENT_RED_HOT_POKER, 16s, 20s);
 break;
 case EVENT_SHACKLES:
 DoCast(me, SPELL_SHACKLES);
 _events.ScheduleEvent(EVENT_SHACKLES, 12s, 15s);
 break;
 case EVENT_WILD_BEATDOWN:
 DoCast(me, SPELL_WILD_BEATDOWN);
 _events.ScheduleEvent(EVENT_WILD_BEATDOWN, 12s, 15s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap _events;
 InstanceScript* _instance;
 bool _combatPhase = false;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_twilight_sadistAI>(creature);
 }
};
 
/*#####
# npc_mad_prisoner
#####*/
 
enum MadPrisoner
{
 SPELL_HEAD_CRACK = 77568,
 SPELL_INFECTED_WOUND = 76512,
 SPELL_ENRAGE = 8599,
 EVENT_HEAD_CRACK = 13,
 EVENT_INFECTED_WOUND = 14,
 EVENT_ENRAGE = 15
};
 
class npc_mad_prisoner : public CreatureScript
{
 public: npc_mad_prisoner() : CreatureScript("npc_mad_prisoner") { }
 
 struct npc_mad_prisonerAI : public ScriptedAI
 {
 npc_mad_prisonerAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void Reset() override { }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 _events.Reset();
 _events.ScheduleEvent(EVENT_HEAD_CRACK, 9s);
 _events.ScheduleEvent(EVENT_INFECTED_WOUND, 13s);
 _events.ScheduleEvent(EVENT_ENRAGE, 17s);
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim())
 return;
 
 _events.Update(diff);
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_HEAD_CRACK:
 DoCast(me, SPELL_HEAD_CRACK);
 _events.ScheduleEvent(EVENT_HEAD_CRACK, 16s, 20s);
 break;
 case EVENT_INFECTED_WOUND:
 DoCast(me, SPELL_INFECTED_WOUND);
 _events.ScheduleEvent(EVENT_INFECTED_WOUND, 12s, 15s);
 break;
 case EVENT_ENRAGE:
 DoCast(me, SPELL_ENRAGE);
 _events.ScheduleEvent(EVENT_ENRAGE, 12s, 15s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap _events;
 InstanceScript* _instance;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_mad_prisonerAI>(creature);
 }
};
 
/*#####
# npc_crazed_mage
#####*/
 
enum CrazedMage
{
 EVENT_HEAD_CRACK2 = 16,
 EVENT_INFECTED_WOUND2 = 17,
 EVENT_ENRAGE2 = 18
};
 
class npc_crazed_mage : public CreatureScript
{
 public: npc_crazed_mage() : CreatureScript("npc_crazed_mage") { }
 
 struct npc_crazed_mageAI : public ScriptedAI
 {
 npc_crazed_mageAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void Reset() override { }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 _events.Reset();
 _events.ScheduleEvent(EVENT_HEAD_CRACK2, 9s);
 _events.ScheduleEvent(EVENT_INFECTED_WOUND2, 13s);
 _events.ScheduleEvent(EVENT_ENRAGE2, 17s);
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim())
 return;
 
 _events.Update(diff);
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_HEAD_CRACK2:
 DoCast(me, SPELL_HEAD_CRACK);
 _events.ScheduleEvent(EVENT_HEAD_CRACK2, 16s, 20s);
 break;
 case EVENT_INFECTED_WOUND2:
 DoCast(me, SPELL_INFECTED_WOUND);
 _events.ScheduleEvent(EVENT_INFECTED_WOUND2, 12s, 15s);
 break;
 case EVENT_ENRAGE2:
 DoCast(me, SPELL_ENRAGE);
 _events.ScheduleEvent(EVENT_ENRAGE2, 12s, 15s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap _events;
 InstanceScript* _instance;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_crazed_mageAI>(creature);
 }
};
 
/*#####
# npc_raz_the_crazed
#####*/
 
enum RazTheCrazed
{
 SAY_SMASH = 0,
 SPELL_AGGRO_NEARBY_TARGETS = 80196,
 SPELL_SHADOW_PRISON = 79725,
 SPELL_LEAP_FROM_CAGE = 79720,
 SPELL_FURIOUS_SWIPE = 80206,
 SPELL_LEAP_FROM_BRIDGE = 80273,
 TYPE_RAZ = 1,
 DATA_ROMOGG_DEAD = 1,
 EVENT_AGGO_NEARBY_TARGETS = 19,
 EVENT_START_FIRST_PATH = 20,
 EVENT_FURIOUS_SWIPE = 21
};
 
class npc_raz_the_crazed : public CreatureScript
{
 public: npc_raz_the_crazed() : CreatureScript("npc_raz_the_crazed") { }
 
 struct npc_raz_the_crazedAI : public ScriptedAI
 {
 npc_raz_the_crazedAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void Reset() override { }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 _events.Reset();
 _events.ScheduleEvent(SPELL_FURIOUS_SWIPE, 500ms);
 }
 
 void IsSummonedBy(WorldObject* summoner) override
 {
 if (summoner->GetEntry() == NPC_ROMOGG_BONECRUSHER)
 {
 me->SetDisableGravity(true);
 DoCast(me, SPELL_SHADOW_PRISON);
 _events.ScheduleEvent(EVENT_AGGO_NEARBY_TARGETS, 1s);
 }
 }
 
 void SetData(uint32 id, uint32 data) override
 {
 if (id == TYPE_RAZ && data == DATA_ROMOGG_DEAD)
 {
 me->RemoveAura(SPELL_SHADOW_PRISON);
 me->SetDisableGravity(false);
 DoCast(me, SPELL_LEAP_FROM_CAGE);
 _events.ScheduleEvent(EVENT_START_FIRST_PATH, 3s);
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 _events.Update(diff);
 
 while (uint32 eventId = _events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_AGGO_NEARBY_TARGETS:
 DoCast(me, SPELL_AGGRO_NEARBY_TARGETS);
 _events.ScheduleEvent(EVENT_AGGO_NEARBY_TARGETS, 1500ms);
 break;
 case EVENT_START_FIRST_PATH:
 Talk(SAY_SMASH);
 break;
 case EVENT_FURIOUS_SWIPE:
 DoCastVictim(SPELL_FURIOUS_SWIPE, true);
 _events.ScheduleEvent(SPELL_FURIOUS_SWIPE, 500ms);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap _events;
 InstanceScript* _instance;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_raz_the_crazedAI>(creature);
 }
};
 
/*#####
# npc_chains_of_woe
#####*/
 
enum ChainsOfWoe
{
 SPELL_CHAINS_OF_WOE_1 = 75437,
 SPELL_CHAINS_OF_WOE_2 = 75441,
 SPELL_CHAINS_OF_WOE_3 = 75464,
 SPELL_CHAINS_OF_WOE_4 = 82189,
 SPELL_CHAINS_OF_WOE_5 = 82192,
 MODEL_INVISIBLE = 38330
};
 
class npc_chains_of_woe : public CreatureScript
{
 public: npc_chains_of_woe() : CreatureScript("npc_chains_of_woe") { }
 
 struct npc_chains_of_woeAI : public ScriptedAI
 {
 npc_chains_of_woeAI(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void IsSummonedBy(WorldObject* /*summoner*/) override
 {
 me->SetDisplayId(MODEL_INVISIBLE);
 DoCast(me, SPELL_CHAINS_OF_WOE_1, true);
 DoCast(me, SPELL_CHAINS_OF_WOE_2, true);
 }
 
 private:
 InstanceScript* _instance;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetBlackrockCavernsAI<npc_chains_of_woeAI>(creature);
 }
};
 
/*#####
# spell_chains_of_woe_1
#####*/
 
class spell_chains_of_woe_1 : public SpellScriptLoader
{
 public: spell_chains_of_woe_1() : SpellScriptLoader("spell_chains_of_woe_1") { }
 
 class spell_chains_of_woe_1_SpellScript : public SpellScript
 {
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_CHAINS_OF_WOE_1 });
 }
 
 void HandleScriptEffect(SpellEffIndex /*effIndex*/)
 {
 if (GetHitUnit()->GetTypeId() == TYPEID_PLAYER)
 GetHitUnit()->CastSpell(GetCaster(), SPELL_CHAINS_OF_WOE_3, true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_chains_of_woe_1_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_chains_of_woe_1_SpellScript();
 }
};
 
/*#####
# spell_chains_of_woe_4
#####*/
 
class spell_chains_of_woe_4 : public SpellScriptLoader
{
 public: spell_chains_of_woe_4() : SpellScriptLoader("spell_chains_of_woe_4") { }
 
 class spell_chains_of_woe_4_SpellScript : public SpellScript
 {
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_CHAINS_OF_WOE_4 });
 }
 
 void HandleScriptEffect(SpellEffIndex /*effIndex*/)
 {
 if (GetHitUnit()->GetTypeId() == TYPEID_PLAYER)
 GetHitUnit()->CastSpell(GetHitUnit(), SPELL_CHAINS_OF_WOE_5, true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_chains_of_woe_4_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_chains_of_woe_4_SpellScript();
 }
};
 
/*#####
# spell_nether_dragon_essence_1
#####*/
 
enum NetherDragonEssence
{
 SPELL_NETHER_DRAGON_ESSENCE_1 = 75649,
 SPELL_NETHER_DRAGON_ESSENCE_2 = 75650,
 SPELL_NETHER_DRAGON_ESSENCE_3 = 75653,
 SPELL_NETHER_DRAGON_ESSENCE_4 = 75654
};
 
class spell_nether_dragon_essence_1 : public SpellScriptLoader
{
 public: spell_nether_dragon_essence_1() : SpellScriptLoader("spell_nether_dragon_essence_1") { }
 
 class spell_nether_dragon_essence_1_AuraScript : public AuraScript
 {
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo(
 {
 SPELL_NETHER_DRAGON_ESSENCE_2,
 SPELL_NETHER_DRAGON_ESSENCE_3,
 SPELL_NETHER_DRAGON_ESSENCE_4
 });
 }
 
 void HandleTriggerSpell(AuraEffect const* /*aurEff*/)
 {
 if (Unit* caster = GetCaster())
 caster->CastSpell(caster, RAND(SPELL_NETHER_DRAGON_ESSENCE_2, SPELL_NETHER_DRAGON_ESSENCE_3, SPELL_NETHER_DRAGON_ESSENCE_4));
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_nether_dragon_essence_1_AuraScript::HandleTriggerSpell, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
 }
 };
 
 AuraScript* GetAuraScript() const override
 {
 return new spell_nether_dragon_essence_1_AuraScript();
 }
};
 
/*#####
# spell_nether_dragon_essence_2
#####*/
 
class spell_nether_dragon_essence_2 : public SpellScriptLoader
{
 public:
 spell_nether_dragon_essence_2() : SpellScriptLoader("spell_nether_dragon_essence_2") { }
 
 class spell_nether_dragon_essence_2_SpellScript : public SpellScript
 {
 void ModDestHeight(SpellDestination& dest)
 {
 Position offset = { frand(-35.0f, 35.0f), frand(-25.0f, 25.0f), 0.0f, 0.0f };
 
 switch (GetSpellInfo()->Id)
 {
 case SPELL_NETHER_DRAGON_ESSENCE_2:
 offset.m_positionZ = 25.0f;
 break;
 case SPELL_NETHER_DRAGON_ESSENCE_3:
 offset.m_positionZ = 17.0f;
 break;
 case SPELL_NETHER_DRAGON_ESSENCE_4:
 offset.m_positionZ = 33.0f;
 break;
 }
 
 dest.RelocateOffset(offset);
 }
 
 void Register() override
 {
 OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_nether_dragon_essence_2_SpellScript::ModDestHeight, EFFECT_0, TARGET_DEST_CASTER_RANDOM);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_nether_dragon_essence_2_SpellScript();
 }
};
 
void AddSC_blackrock_caverns()
{
 // Creature Scripts
 new npc_fire_cyclone();
 new npc_twilight_flame_caller();
 new npc_twilight_torturer();
 new npc_twilight_sadist();
 new npc_mad_prisoner();
 new npc_crazed_mage();
 new npc_raz_the_crazed();
 new npc_chains_of_woe();
 // Spell Scripts
 new spell_chains_of_woe_1();
 new spell_chains_of_woe_4();
 new spell_nether_dragon_essence_1();
 new spell_nether_dragon_essence_2();
}