nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-02-01 18:13:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Big re-organization of repository [W.I.P]

Browse Source
This commit is contained in:
Yehonal
2016-08-11 20:25:27 +02:00
parent c62a72c0a8
commit 0f85ce1c54
3016 changed files with 1271 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
src/server/scripts/Outland/HellfireCitadel/ShatteredHalls/boss_nethekurse.cpp
View File

@@ -1,270 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "shattered_halls.h"
enum eGrandWarlockNethekurse
{
SAY_INTRO = 0,
SAY_PEON_ATTACKED = 1,
SAY_PEON_DIES = 2,
SAY_TAUNT = 3,
SAY_AGGRO = 4,
SAY_SLAY = 5,
SAY_DIE = 6,
SPELL_DEATH_COIL_N = 30741,
SPELL_DEATH_COIL_H = 30500,
SPELL_DARK_SPIN = 30502,
SPELL_SHADOW_FISSURE = 30496,
SPELL_SHADOW_CLEAVE_N = 30495,
SPELL_SHADOW_SLAM_H = 35953,
SPELL_SHADOW_SEAR = 30735,
SETDATA_DATA = 1,
SETDATA_PEON_AGGRO = 1,
SETDATA_PEON_DEATH = 2,
EVENT_STAGE_NONE = 0,
EVENT_STAGE_INTRO = 1,
EVENT_STAGE_TAUNT = 2,
EVENT_STAGE_MAIN = 3,
EVENT_INTRO = 1,
EVENT_SPELL_DEATH_COIL = 2,
EVENT_SPELL_SHADOW_FISSURE = 3,
EVENT_SPELL_CLEAVE = 4,
EVENT_CHECK_HEALTH = 5,
EVENT_START_ATTACK = 6
};
// ########################################################
// Grand Warlock Nethekurse
// ########################################################
class boss_grand_warlock_nethekurse : public CreatureScript
{
public:
boss_grand_warlock_nethekurse() : CreatureScript("boss_grand_warlock_nethekurse") { }
struct boss_grand_warlock_nethekurseAI : public BossAI
{
boss_grand_warlock_nethekurseAI(Creature* creature) : BossAI(creature, DATA_NETHEKURSE) { }
EventMap events2;
void Reset()
{
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
EventStage = EVENT_STAGE_NONE;
PeonEngagedCount = 0;
PeonKilledCount = 0;
_Reset();
SummonMinions();
events2.Reset();
}
void SummonMinions()
{
me->SummonCreature(NPC_FEL_ORC_CONVERT, 172.556f, 258.227f, -13.191f, 1.41189f);
me->SummonCreature(NPC_FEL_ORC_CONVERT, 165.181f, 261.511f, -13.1926f, 0.942743f);
me->SummonCreature(NPC_FEL_ORC_CONVERT, 182.482f, 258.635f, -13.1788f, 1.70929f);
me->SummonCreature(NPC_FEL_ORC_CONVERT, 189.616f, 259.866f, -13.1966f, 1.95748f);
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DIE);
_JustDied();
}
void SetData(uint32 data, uint32 value)
{
if (data != SETDATA_DATA)
return;
switch (value)
{
case SETDATA_PEON_AGGRO:
if (PeonEngagedCount >= 4)
return;
if (EventStage < EVENT_STAGE_TAUNT)
Talk(SAY_PEON_ATTACKED);
break;
case SETDATA_PEON_DEATH:
if (PeonKilledCount >= 4)
return;
if (EventStage < EVENT_STAGE_TAUNT)
Talk(SAY_PEON_DIES);
if (++PeonKilledCount == 4)
events2.ScheduleEvent(EVENT_START_ATTACK, 5000);
break;
}
}
void AttackStart(Unit* who)
{
if (EventStage < EVENT_STAGE_MAIN)
return;
if (me->Attack(who, true))
{
if (me->HealthBelowPct(21))
DoStartNoMovement(who);
else
DoStartMovement(who);
}
}
void JustSummoned(Creature* summon)
{
summons.Summon(summon);
summon->SetReactState(REACT_DEFENSIVE);
summon->SetRegeneratingHealth(false);
}
void MoveInLineOfSight(Unit* who)
{
if (EventStage == EVENT_STAGE_NONE && me->IsWithinDistInMap(who, 30.0f))
{
if (who->GetTypeId() != TYPEID_PLAYER)
return;
events2.ScheduleEvent(EVENT_INTRO, 90000);
Talk(SAY_INTRO);
EventStage = EVENT_STAGE_INTRO;
instance->SetBossState(DATA_NETHEKURSE, IN_PROGRESS);
me->SetInCombatWithZone();
}
if (EventStage < EVENT_STAGE_MAIN)
return;
ScriptedAI::MoveInLineOfSight(who);
}
void EnterCombat(Unit* /*who*/)
{
}
void KilledUnit(Unit* /*victim*/)
{
Talk(SAY_SLAY);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
uint32 eventId = events2.ExecuteEvent();
if (EventStage < EVENT_STAGE_MAIN && instance->GetBossState(DATA_NETHEKURSE) == IN_PROGRESS)
{
if (eventId == EVENT_INTRO)
{
Talk(SAY_TAUNT);
EventStage = EVENT_STAGE_TAUNT;
me->CastSpell(me, SPELL_SHADOW_SEAR, false);
}
else if (eventId == EVENT_START_ATTACK)
{
Talk(SAY_AGGRO);
EventStage = EVENT_STAGE_MAIN;
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (Unit* target = me->SelectNearestPlayer(50.0f))
AttackStart(target);
events.ScheduleEvent(EVENT_SPELL_DEATH_COIL, 20000);
events.ScheduleEvent(EVENT_SPELL_SHADOW_FISSURE, 8000);
events.ScheduleEvent(EVENT_CHECK_HEALTH, 1000);
return;
}
}
if (!UpdateVictim())
return;
events.Update(diff);
if (EventStage < EVENT_STAGE_MAIN || me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_SHADOW_FISSURE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->CastSpell(target, SPELL_SHADOW_FISSURE, false);
events.RescheduleEvent(eventId, urand(7500, 10000));
break;
case EVENT_SPELL_DEATH_COIL:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->CastSpell(target, DUNGEON_MODE(SPELL_DEATH_COIL_N, SPELL_DEATH_COIL_H), false);
events.RescheduleEvent(eventId, urand(15000, 20000));
break;
case EVENT_SPELL_CLEAVE:
me->CastSpell(me->GetVictim(), DUNGEON_MODE(SPELL_SHADOW_CLEAVE_N, SPELL_SHADOW_SLAM_H), false);
events.RescheduleEvent(EVENT_SPELL_CLEAVE, urand(6000, 8000));
break;
case EVENT_CHECK_HEALTH:
if (me->HealthBelowPct(21))
{
me->CastSpell(me, SPELL_DARK_SPIN, true);
events.Reset();
events.ScheduleEvent(EVENT_SPELL_CLEAVE, 3000);
me->GetMotionMaster()->Clear();
break;
}
events.RescheduleEvent(eventId, 1000);
break;
}
if (!me->HealthBelowPct(21))
DoMeleeAttackIfReady();
}
private:
uint32 PeonEngagedCount;
uint32 PeonKilledCount;
uint32 EventStage;
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_grand_warlock_nethekurseAI>(creature);
}
};
class spell_tsh_shadow_sear : public SpellScriptLoader
{
public:
spell_tsh_shadow_sear() : SpellScriptLoader("spell_tsh_shadow_sear") { }
class spell_tsh_shadow_sear_AuraScript : public AuraScript
{
PrepareAuraScript(spell_tsh_shadow_sear_AuraScript);
void CalculateDamageAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
{
amount = 1000;
}
void Register()
{
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_tsh_shadow_sear_AuraScript::CalculateDamageAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
}
};
AuraScript* GetAuraScript() const
{
return new spell_tsh_shadow_sear_AuraScript();
}
};
void AddSC_boss_grand_warlock_nethekurse()
{
new boss_grand_warlock_nethekurse();
new spell_tsh_shadow_sear();
}

259
src/server/scripts/Outland/HellfireCitadel/ShatteredHalls/boss_warbringer_omrogg.cpp
View File

@@ -1,259 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "shattered_halls.h"
enum Spells
{
SPELL_BLAST_WAVE = 30600,
SPELL_FEAR = 30584,
SPELL_THUNDERCLAP = 30633,
SPELL_BURNING_MAUL_N = 30598,
SPELL_BURNING_MAUL_H = 36056,
};
enum Creatures
{
NPC_LEFT_HEAD = 19523,
NPC_RIGHT_HEAD = 19524
};
enum Misc
{
EMOTE_ENRAGE = 0,
SETDATA_DATA = 1,
SETDATA_YELL = 1
};
enum Events
{
EVENT_AGGRO_YELL_1 = 1,
EVENT_AGGRO_YELL_2 = 2,
EVENT_AGGRO_YELL_3 = 3,
EVENT_THREAT_YELL_L_1 = 4,
EVENT_THREAT_YELL_L_2 = 5,
EVENT_THREAT_YELL_L_3 = 6,
EVENT_THREAT_YELL_R_1 = 7,
EVENT_KILL_YELL_LEFT = 8,
EVENT_KILL_YELL_RIGHT = 9,
EVENT_DEATH_YELL = 10,
EVENT_SPELL_FEAR = 20,
EVENT_SPELL_BURNING_MAUL = 21,
EVENT_SPELL_THUNDER_CLAP = 22,
EVENT_RESET_THREAT = 23,
EVENT_SPELL_BLAST_WAVE = 24
};
// ########################################################
// Warbringer_Omrogg
// ########################################################
class boss_warbringer_omrogg : public CreatureScript
{
public:
boss_warbringer_omrogg() : CreatureScript("boss_warbringer_omrogg") { }
struct boss_warbringer_omroggAI : public BossAI
{
boss_warbringer_omroggAI(Creature* creature) : BossAI(creature, DATA_OMROGG)
{
}
EventMap events2;
Creature* GetLeftHead()
{
return summons.GetCreatureWithEntry(NPC_LEFT_HEAD);
}
Creature* GetRightHead()
{
return summons.GetCreatureWithEntry(NPC_RIGHT_HEAD);
}
void EnterCombat(Unit* /*who*/)
{
me->SummonCreature(NPC_LEFT_HEAD, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_DEAD_DESPAWN, 0);
me->SummonCreature(NPC_RIGHT_HEAD, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_DEAD_DESPAWN, 0);
if (Creature* LeftHead = GetLeftHead())
{
uint8 aggroYell = urand(EVENT_AGGRO_YELL_1, EVENT_AGGRO_YELL_3);
LeftHead->AI()->Talk(aggroYell-1);
events2.ScheduleEvent(aggroYell, 3000);
}
_EnterCombat();
events.ScheduleEvent(EVENT_SPELL_FEAR, 8000);
events.ScheduleEvent(EVENT_SPELL_BURNING_MAUL, 25000);
events.ScheduleEvent(EVENT_SPELL_THUNDER_CLAP, 15000);
events.ScheduleEvent(EVENT_RESET_THREAT, 30000);
}
void JustSummoned(Creature* summoned)
{
summons.Summon(summoned);
}
void KilledUnit(Unit* /*victim*/)
{
Creature* head = NULL;
uint32 eventId = EVENT_KILL_YELL_LEFT;
if (urand(0, 1))
{
head = GetLeftHead();
eventId = EVENT_KILL_YELL_LEFT;
}
else
{
head = GetRightHead();
eventId = EVENT_KILL_YELL_RIGHT;
}
if (head)
head->AI()->Talk(eventId-1);
events2.ScheduleEvent(eventId, 3000);
}
void JustDied(Unit* /*killer*/)
{
Creature* LeftHead = GetLeftHead();
Creature* RightHead = GetRightHead();
if (!LeftHead || !RightHead)
return;
LeftHead->DespawnOrUnsummon(5000);
RightHead->DespawnOrUnsummon(5000);
LeftHead->AI()->Talk(EVENT_DEATH_YELL-1);
RightHead->AI()->SetData(SETDATA_DATA, SETDATA_YELL);
instance->SetBossState(DATA_OMROGG, DONE);
}
void UpdateAI(uint32 diff)
{
events2.Update(diff);
switch (uint32 eventId = events2.ExecuteEvent())
{
case EVENT_AGGRO_YELL_1:
case EVENT_AGGRO_YELL_2:
case EVENT_AGGRO_YELL_3:
case EVENT_KILL_YELL_LEFT:
case EVENT_THREAT_YELL_L_1:
case EVENT_THREAT_YELL_L_2:
case EVENT_THREAT_YELL_L_3:
if (Creature* RightHead = GetRightHead())
RightHead->AI()->Talk(eventId-1);
break;
case EVENT_KILL_YELL_RIGHT:
case EVENT_THREAT_YELL_R_1:
if (Creature* LeftHead = GetLeftHead())
LeftHead->AI()->Talk(eventId-1);
break;
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_SPELL_FEAR:
me->CastSpell(me, SPELL_FEAR, false);
events.ScheduleEvent(EVENT_SPELL_FEAR, 22000);
break;
case EVENT_SPELL_THUNDER_CLAP:
me->CastSpell(me, SPELL_THUNDERCLAP, false);
events.ScheduleEvent(EVENT_SPELL_THUNDER_CLAP, 25000);
break;
case EVENT_RESET_THREAT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
uint8 threatYell = urand(EVENT_THREAT_YELL_L_1, EVENT_THREAT_YELL_R_1);
if (Creature* head = threatYell == EVENT_THREAT_YELL_R_1 ? GetRightHead() : GetLeftHead())
head->AI()->Talk(threatYell-1);
events.ScheduleEvent(threatYell, 3000);
DoResetThreat();
me->AddThreat(target, 10.0f);
}
events.ScheduleEvent(EVENT_RESET_THREAT, 30000);
break;
case EVENT_SPELL_BURNING_MAUL:
Talk(EMOTE_ENRAGE);
me->CastSpell(me, DUNGEON_MODE(SPELL_BURNING_MAUL_N, SPELL_BURNING_MAUL_H), false);
events.ScheduleEvent(EVENT_SPELL_BURNING_MAUL, 40000);
events.ScheduleEvent(EVENT_SPELL_BLAST_WAVE, 15000);
events.ScheduleEvent(EVENT_SPELL_BLAST_WAVE, 20000);
break;
case EVENT_SPELL_BLAST_WAVE:
me->CastSpell(me, SPELL_BLAST_WAVE, false);
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_warbringer_omroggAI>(creature);
}
};
class npc_omrogg_heads : public CreatureScript
{
public:
npc_omrogg_heads() : CreatureScript("npc_omrogg_heads") { }
struct npc_omrogg_headsAI : public NullCreatureAI
{
npc_omrogg_headsAI(Creature* creature) : NullCreatureAI(creature) { timer = 0; }
void SetData(uint32 data, uint32 value)
{
if (data == SETDATA_DATA && value == SETDATA_YELL)
timer = 1;
}
void UpdateAI(uint32 diff)
{
if (timer)
{
timer += diff;
if (timer >= 3000)
{
timer = 0;
Talk(EVENT_DEATH_YELL-1);
}
}
}
uint32 timer;
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<npc_omrogg_headsAI>(creature);
}
};
void AddSC_boss_warbringer_omrogg()
{
new boss_warbringer_omrogg();
new npc_omrogg_heads();
}

177
src/server/scripts/Outland/HellfireCitadel/ShatteredHalls/boss_warchief_kargath_bladefist.cpp
View File

@@ -1,177 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "shattered_halls.h"
enum Says
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2
};
enum Spells
{
SPELL_BLADE_DANCE = 30739,
SPELL_CHARGE = 25821,
SPELL_SPRINT = 32720,
};
enum Creatures
{
NPC_SHATTERED_ASSASSIN = 17695,
NPC_HEARTHEN_GUARD = 17621,
NPC_SHARPSHOOTER_GUARD = 17622,
NPC_REAVER_GUARD = 17623
};
float AssassEntrance[3] = { 275.136f, -84.29f, 2.3f }; // y -8
float AssassExit[3] = { 184.233f, -84.29f, 2.3f }; // y -8
float AddsEntrance[3] = { 306.036f, -84.29f, 1.93f };
enum Misc
{
EVENT_CHECK_ROOM = 1,
EVENT_SUMMON_ADDS = 2,
EVENT_SUMMON_ASSASSINS = 3,
EVENT_SPELL_CHARGE = 4,
EVENT_MOVE_TO_NEXT_POINT = 5,
EVENT_BLADE_DANCE = 6,
EVENT_FINISH_BLADE_DANCE = 7
};
class boss_warchief_kargath_bladefist : public CreatureScript
{
public:
boss_warchief_kargath_bladefist() : CreatureScript("boss_warchief_kargath_bladefist") { }
struct boss_warchief_kargath_bladefistAI : public BossAI
{
boss_warchief_kargath_bladefistAI(Creature* creature) : BossAI(creature, DATA_KARGATH) { }
void InitializeAI()
{
BossAI::InitializeAI();
if (instance)
if (Creature* executioner = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_EXECUTIONER)))
executioner->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DEATH);
_JustDied();
if (instance)
if (Creature* executioner = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_EXECUTIONER)))
executioner->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
}
void EnterCombat(Unit* who)
{
Talk(SAY_AGGRO);
_EnterCombat();
events.ScheduleEvent(EVENT_CHECK_ROOM, 5000);
events.ScheduleEvent(EVENT_SUMMON_ADDS, 30000);
events.ScheduleEvent(EVENT_SUMMON_ASSASSINS, 5000);
events.ScheduleEvent(EVENT_BLADE_DANCE, 30000);
events.ScheduleEvent(EVENT_SPELL_CHARGE, 0);
}
void JustSummoned(Creature* summon)
{
if (summon->GetEntry() != NPC_SHATTERED_ASSASSIN)
summon->AI()->AttackStart(SelectTarget(SELECT_TARGET_RANDOM, 0));
summons.Summon(summon);
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void MovementInform(uint32 type, uint32 id)
{
if (type != POINT_MOTION_TYPE || id != 1)
return;
me->CastSpell(me, SPELL_BLADE_DANCE, true);
events.ScheduleEvent(EVENT_MOVE_TO_NEXT_POINT, 0);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
switch (events.ExecuteEvent())
{
case EVENT_CHECK_ROOM:
if (me->GetPositionX() > 255 || me->GetPositionX() < 205)
{
EnterEvadeMode();
return;
}
events.ScheduleEvent(EVENT_CHECK_ROOM, 5000);
break;
case EVENT_SUMMON_ASSASSINS:
me->SummonCreature(NPC_SHATTERED_ASSASSIN, AssassEntrance[0], AssassEntrance[1]+8, AssassEntrance[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
me->SummonCreature(NPC_SHATTERED_ASSASSIN, AssassEntrance[0], AssassEntrance[1]-8, AssassEntrance[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
me->SummonCreature(NPC_SHATTERED_ASSASSIN, AssassExit[0], AssassExit[1]+8, AssassExit[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
me->SummonCreature(NPC_SHATTERED_ASSASSIN, AssassExit[0], AssassExit[1]-8, AssassExit[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
break;
case EVENT_SUMMON_ADDS:
for (uint8 i = 0; i < 2; ++i)
me->SummonCreature(NPC_HEARTHEN_GUARD+urand(0,2), AddsEntrance[0], AddsEntrance[1], AddsEntrance[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
events.ScheduleEvent(EVENT_SUMMON_ADDS, 30000);
break;
case EVENT_BLADE_DANCE:
events.DelayEvents(10001);
events.ScheduleEvent(EVENT_BLADE_DANCE, 40000);
events.ScheduleEvent(EVENT_MOVE_TO_NEXT_POINT, 0);
events.ScheduleEvent(EVENT_FINISH_BLADE_DANCE, 10000);
events.SetPhase(1);
me->CastSpell(me, SPELL_SPRINT, true);
break;
case EVENT_MOVE_TO_NEXT_POINT:
{
float x = 210 + frand(0.0f, 35.0f);
float y = -65.0f - frand(0.0f, 35.0f);
me->GetMotionMaster()->MovePoint(1, x, y, me->GetPositionZ());
break;
}
case EVENT_FINISH_BLADE_DANCE:
events.SetPhase(0);
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MoveChase(me->GetVictim());
if (IsHeroic())
events.ScheduleEvent(EVENT_SPELL_CHARGE, 3000);
break;
case EVENT_SPELL_CHARGE:
me->CastSpell(me->GetVictim(), SPELL_CHARGE, false);
break;
}
if (!events.IsInPhase(1))
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_warchief_kargath_bladefistAI>(creature);
}
};
void AddSC_boss_warchief_kargath_bladefist()
{
new boss_warchief_kargath_bladefist();
}

290
src/server/scripts/Outland/HellfireCitadel/ShatteredHalls/instance_shattered_halls.cpp
View File

@@ -1,290 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "InstanceScript.h"
#include "shattered_halls.h"
#include "CreatureTextMgr.h"
class instance_shattered_halls : public InstanceMapScript
{
public:
instance_shattered_halls() : InstanceMapScript("instance_shattered_halls", 540) { }
InstanceScript* GetInstanceScript(InstanceMap* map) const
{
return new instance_shattered_halls_InstanceMapScript(map);
}
struct instance_shattered_halls_InstanceMapScript : public InstanceScript
{
instance_shattered_halls_InstanceMapScript(Map* map) : InstanceScript(map) { }
void Initialize()
{
SetBossNumber(ENCOUNTER_COUNT);
nethekurseDoor1GUID = 0;
nethekurseDoor2GUID = 0;
warchiefKargathGUID = 0;
executionerGUID = 0;
memset(&prisonerGUID, 0, sizeof(prisonerGUID));
TeamIdInInstance = TEAM_NEUTRAL;
RescueTimer = 100*MINUTE*IN_MILLISECONDS;
}
void OnPlayerEnter(Player* player)
{
if (TeamIdInInstance == TEAM_NEUTRAL)
TeamIdInInstance = player->GetTeamId();
}
void OnGameObjectCreate(GameObject* go)
{
switch (go->GetEntry())
{
case GO_GRAND_WARLOCK_CHAMBER_DOOR_1:
nethekurseDoor1GUID = go->GetGUID();
if (GetBossState(DATA_NETHEKURSE) == DONE)
HandleGameObject(0, true, go);
break;
case GO_GRAND_WARLOCK_CHAMBER_DOOR_2:
nethekurseDoor2GUID = go->GetGUID();
if (GetBossState(DATA_NETHEKURSE) == DONE)
HandleGameObject(0, true, go);
break;
}
}
void OnCreatureCreate(Creature* creature)
{
if (TeamIdInInstance == TEAM_NEUTRAL)
{
Map::PlayerList const &players = instance->GetPlayers();
if (!players.isEmpty())
if (Player* player = players.begin()->GetSource())
TeamIdInInstance = player->GetTeamId();
}
switch (creature->GetEntry())
{
case NPC_WARCHIEF_KARGATH:
warchiefKargathGUID = creature->GetGUID();
break;
case NPC_SHATTERED_EXECUTIONER:
if (RescueTimer > 25*MINUTE*IN_MILLISECONDS)
creature->AddLootMode(2);
executionerGUID = creature->GetGUID();
break;
case NPC_RIFLEMAN_BROWNBEARD:
if (TeamIdInInstance == TEAM_HORDE)
creature->UpdateEntry(NPC_KORAG_PROUDMANE);
prisonerGUID[0] = creature->GetGUID();
break;
case NPC_CAPTAIN_ALINA:
if (TeamIdInInstance == TEAM_HORDE)
creature->UpdateEntry(NPC_CAPTAIN_BONESHATTER);
prisonerGUID[1] = creature->GetGUID();
break;
case NPC_PRIVATE_JACINT:
if (TeamIdInInstance == TEAM_HORDE)
creature->UpdateEntry(NPC_SCOUT_ORGARR);
prisonerGUID[2] = creature->GetGUID();
break;
}
}
bool SetBossState(uint32 type, EncounterState state)
{
if (!InstanceScript::SetBossState(type, state))
return false;
switch (type)
{
case DATA_NETHEKURSE:
if (state == IN_PROGRESS)
{
HandleGameObject(nethekurseDoor1GUID, false);
HandleGameObject(nethekurseDoor2GUID, false);
}
else
{
HandleGameObject(nethekurseDoor1GUID, true);
HandleGameObject(nethekurseDoor2GUID, true);
}
break;
}
return true;
}
void SetData(uint32 type, uint32 data)
{
if (type == DATA_ENTERED_ROOM && data == DATA_ENTERED_ROOM && RescueTimer == 100*MINUTE*IN_MILLISECONDS)
{
DoCastSpellOnPlayers(SPELL_KARGATHS_EXECUTIONER_1);
instance->LoadGrid(230, -80);
if (Creature* kargath = instance->GetCreature(warchiefKargathGUID))
sCreatureTextMgr->SendChat(kargath, TeamIdInInstance == TEAM_ALLIANCE ? 3 : 4, NULL, CHAT_MSG_ADDON, LANG_ADDON, TEXT_RANGE_MAP);
RescueTimer = 80*MINUTE*IN_MILLISECONDS;
}
}
uint64 GetData64(uint32 data) const
{
switch (data)
{
case DATA_PRISONER_1:
case DATA_PRISONER_2:
case DATA_PRISONER_3:
return prisonerGUID[data-DATA_PRISONER_1];
case DATA_EXECUTIONER:
return executionerGUID;
}
return 0;
}
void Update(uint32 diff)
{
if (RescueTimer && RescueTimer < 100*MINUTE*IN_MILLISECONDS)
{
RescueTimer -= std::min(RescueTimer, diff);
if ((RescueTimer / IN_MILLISECONDS) == 25*MINUTE)
{
DoRemoveAurasDueToSpellOnPlayers(SPELL_KARGATHS_EXECUTIONER_1);
DoCastSpellOnPlayers(SPELL_KARGATHS_EXECUTIONER_2);
if (Creature* prisoner = instance->GetCreature(prisonerGUID[0]))
Unit::Kill(prisoner, prisoner);
if (Creature* executioner = instance->GetCreature(executionerGUID))
executioner->RemoveLootMode(2);
}
else if ((RescueTimer / IN_MILLISECONDS) == 15*MINUTE)
{
DoRemoveAurasDueToSpellOnPlayers(SPELL_KARGATHS_EXECUTIONER_2);
DoCastSpellOnPlayers(SPELL_KARGATHS_EXECUTIONER_3);
if (Creature* prisoner = instance->GetCreature(prisonerGUID[1]))
Unit::Kill(prisoner, prisoner);
}
else if ((RescueTimer / IN_MILLISECONDS) == 0)
{
DoRemoveAurasDueToSpellOnPlayers(SPELL_KARGATHS_EXECUTIONER_3);
if (Creature* prisoner = instance->GetCreature(prisonerGUID[2]))
Unit::Kill(prisoner, prisoner);
}
}
}
std::string GetSaveData()
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << "S H " << GetBossSaveData() << ' ' << RescueTimer;
OUT_SAVE_INST_DATA_COMPLETE;
return saveStream.str();
}
void Load(const char* strIn)
{
if (!strIn)
{
OUT_LOAD_INST_DATA_FAIL;
return;
}
OUT_LOAD_INST_DATA(strIn);
char dataHead1, dataHead2;
std::istringstream loadStream(strIn);
loadStream >> dataHead1 >> dataHead2;
if (dataHead1 == 'S' && dataHead2 == 'H')
{
for (uint8 i = 0; i < ENCOUNTER_COUNT; ++i)
{
uint32 tmpState;
loadStream >> tmpState;
if (tmpState == IN_PROGRESS || tmpState > SPECIAL)
tmpState = NOT_STARTED;
SetBossState(i, EncounterState(tmpState));
}
loadStream >> RescueTimer;
}
else
OUT_LOAD_INST_DATA_FAIL;
OUT_LOAD_INST_DATA_COMPLETE;
}
protected:
uint64 warchiefKargathGUID;
uint64 nethekurseDoor1GUID;
uint64 nethekurseDoor2GUID;
uint64 executionerGUID;
uint64 prisonerGUID[3];
uint32 RescueTimer;
TeamId TeamIdInInstance;
};
};
class spell_tsh_shoot_flame_arrow : public SpellScriptLoader
{
public:
spell_tsh_shoot_flame_arrow() : SpellScriptLoader("spell_tsh_shoot_flame_arrow") { }
class spell_tsh_shoot_flame_arrow_SpellScript : public SpellScript
{
PrepareSpellScript(spell_tsh_shoot_flame_arrow_SpellScript);
void FilterTargets(std::list<WorldObject*>& unitList)
{
Trinity::Containers::RandomResizeList(unitList, 1);
}
void HandleScriptEffect(SpellEffIndex effIndex)
{
PreventHitDefaultEffect(effIndex);
if (Unit* target = GetHitUnit())
target->CastSpell(target, 30953, true);
}
void Register()
{
OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_tsh_shoot_flame_arrow_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
OnEffectHitTarget += SpellEffectFn(spell_tsh_shoot_flame_arrow_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_tsh_shoot_flame_arrow_SpellScript();
}
};
class at_shattered_halls_execution : public AreaTriggerScript
{
public:
at_shattered_halls_execution() : AreaTriggerScript("at_shattered_halls_execution") { }
bool OnTrigger(Player* player, AreaTriggerEntry const* /*areaTrigger*/)
{
if (InstanceScript* instanceScript = player->GetInstanceScript())
instanceScript->SetData(DATA_ENTERED_ROOM, DATA_ENTERED_ROOM);
return true;
}
};
void AddSC_instance_shattered_halls()
{
new instance_shattered_halls();
new spell_tsh_shoot_flame_arrow();
new at_shattered_halls_execution();
}

51
src/server/scripts/Outland/HellfireCitadel/ShatteredHalls/shattered_halls.h
View File

@@ -1,51 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#ifndef DEF_SHATTERED_H
#define DEF_SHATTERED_H
enum DataTypes
{
DATA_NETHEKURSE = 0,
DATA_OMROGG = 1,
DATA_KARGATH = 2,
ENCOUNTER_COUNT = 3,
DATA_ENTERED_ROOM = 10,
DATA_PRISONER_1 = 11,
DATA_PRISONER_2 = 12,
DATA_PRISONER_3 = 13,
DATA_EXECUTIONER = 14
};
enum CreatureIds
{
NPC_GRAND_WARLOCK_NETHEKURSE = 16807,
NPC_WARCHIEF_KARGATH = 16808,
NPC_FEL_ORC_CONVERT = 17083,
// Trial of the Naaru: Mercy
NPC_SHATTERED_EXECUTIONER = 17301,
NPC_RIFLEMAN_BROWNBEARD = 17289,
NPC_CAPTAIN_ALINA = 17290,
NPC_PRIVATE_JACINT = 17292,
NPC_KORAG_PROUDMANE = 17295,
NPC_CAPTAIN_BONESHATTER = 17296,
NPC_SCOUT_ORGARR = 17297,
};
enum GameobjectIds
{
GO_GRAND_WARLOCK_CHAMBER_DOOR_1 = 182539,
GO_GRAND_WARLOCK_CHAMBER_DOOR_2 = 182540
};
enum SpellIds
{
SPELL_KARGATHS_EXECUTIONER_1 = 39288,
SPELL_KARGATHS_EXECUTIONER_2 = 39289,
SPELL_KARGATHS_EXECUTIONER_3 = 39290
};
#endif