nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-02-01 01:53:47 +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

41
src/server/scripts/Outland/HellfireCitadel/BloodFurnace/blood_furnace.h
View File

@@ -1,41 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#ifndef DEF_BLOOD_FURNACE_H
#define DEF_BLOOD_FURNACE_H
enum bloodFurnace
{
DATA_THE_MAKER = 0,
DATA_BROGGOK = 1,
DATA_KELIDAN = 2,
MAX_ENCOUNTER = 3,
DATA_DOOR1 = 10,
DATA_DOOR2 = 11,
DATA_DOOR3 = 12,
DATA_DOOR4 = 13,
DATA_DOOR5 = 14,
DATA_DOOR6 = 15,
DATA_PRISON_CELL1 = 20,
DATA_PRISON_CELL2 = 21,
DATA_PRISON_CELL3 = 22,
DATA_PRISON_CELL4 = 23,
ACTION_ACTIVATE_BROGGOK = 30,
ACTION_PREPARE_BROGGOK = 31
};
enum bloodFurnaceNPC
{
NPC_THE_MAKER = 17381,
NPC_BROGGOK = 17380,
NPC_KELIDAN = 17377,
NPC_NASCENT_FEL_ORC = 17398,
NPC_CHANNELER = 17653
};
#endif

197
src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_broggok.cpp
View File

@@ -1,197 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "blood_furnace.h"
enum eEnums
{
SAY_AGGRO = 0,
SPELL_SLIME_SPRAY = 30913,
SPELL_POISON_CLOUD = 30916,
SPELL_POISON_BOLT = 30917,
SPELL_POISON = 30914,
EVENT_SPELL_SLIME = 1,
EVENT_SPELL_POISON = 2,
EVENT_SPELL_BOLT = 3
};
class boss_broggok : public CreatureScript
{
public:
boss_broggok() : CreatureScript("boss_broggok")
{
}
struct boss_broggokAI : public ScriptedAI
{
boss_broggokAI(Creature* creature) : ScriptedAI(creature)
{
instance = creature->GetInstanceScript();
}
InstanceScript* instance;
EventMap events;
bool canAttack;
void Reset()
{
events.Reset();
me->SetReactState(REACT_PASSIVE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC | UNIT_FLAG_NON_ATTACKABLE);
canAttack = false;
if (instance)
instance->SetData(DATA_BROGGOK, NOT_STARTED);
}
void EnterCombat(Unit* /*who*/)
{
Talk(SAY_AGGRO);
}
void JustSummoned(Creature* summoned)
{
summoned->setFaction(16);
summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
summoned->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
summoned->CastSpell(summoned, SPELL_POISON, false, 0, 0, me->GetGUID());
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() || !canAttack)
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_SPELL_SLIME:
me->CastSpell(me->GetVictim(), SPELL_SLIME_SPRAY, false);
events.RepeatEvent(urand(7000, 12000));
break;
case EVENT_SPELL_BOLT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->CastSpell(target, SPELL_POISON_BOLT, false);
events.RepeatEvent(urand(6000, 11000));
break;
case EVENT_SPELL_POISON:
me->CastSpell(me, SPELL_POISON_CLOUD, false);
events.RepeatEvent(20000);
break;
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/)
{
if (instance)
{
instance->HandleGameObject(instance->GetData64(DATA_DOOR4), true);
instance->HandleGameObject(instance->GetData64(DATA_DOOR5), true);
instance->SetData(DATA_BROGGOK, DONE);
}
}
void DoAction(int32 action)
{
switch (action)
{
case ACTION_PREPARE_BROGGOK:
me->SetInCombatWithZone();
break;
case ACTION_ACTIVATE_BROGGOK:
events.ScheduleEvent(EVENT_SPELL_SLIME, 10000);
events.ScheduleEvent(EVENT_SPELL_POISON, 5000);
events.ScheduleEvent(EVENT_SPELL_BOLT, 7000);
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC | UNIT_FLAG_NON_ATTACKABLE);
canAttack = true;
break;
}
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_broggokAI(creature);
}
};
class go_broggok_lever : public GameObjectScript
{
public:
go_broggok_lever() : GameObjectScript("go_broggok_lever") {}
bool OnGossipHello(Player* /*player*/, GameObject* go)
{
if (InstanceScript* instance = go->GetInstanceScript())
if (instance->GetData(DATA_BROGGOK) != DONE && instance->GetData(DATA_BROGGOK) != IN_PROGRESS)
if (Creature* broggok = ObjectAccessor::GetCreature(*go, instance->GetData64(DATA_BROGGOK)))
{
instance->SetData(DATA_BROGGOK, IN_PROGRESS);
broggok->AI()->DoAction(ACTION_PREPARE_BROGGOK);
}
go->UseDoorOrButton();
return false;
}
};
// 30914, 38462 - Poison (Broggok)
class spell_broggok_poison_cloud : public SpellScriptLoader
{
public:
spell_broggok_poison_cloud() : SpellScriptLoader("spell_broggok_poison_cloud") { }
class spell_broggok_poison_cloud_AuraScript : public AuraScript
{
PrepareAuraScript(spell_broggok_poison_cloud_AuraScript);
bool Validate(SpellInfo const* spellInfo)
{
if (!sSpellMgr->GetSpellInfo(spellInfo->Effects[EFFECT_0].TriggerSpell))
return false;
return true;
}
void PeriodicTick(AuraEffect const* aurEff)
{
PreventDefaultAction();
uint32 triggerSpell = GetSpellInfo()->Effects[aurEff->GetEffIndex()].TriggerSpell;
int32 mod = int32(((float(aurEff->GetTickNumber()) / aurEff->GetTotalTicks()) * 0.9f + 0.1f) * 10000 * 2 / 3);
GetTarget()->CastCustomSpell(triggerSpell, SPELLVALUE_RADIUS_MOD, mod, (Unit*)NULL, TRIGGERED_FULL_MASK, NULL, aurEff);
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_broggok_poison_cloud_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
AuraScript* GetAuraScript() const
{
return new spell_broggok_poison_cloud_AuraScript();
}
};
void AddSC_boss_broggok()
{
new boss_broggok();
new go_broggok_lever();
new spell_broggok_poison_cloud();
}

352
src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_kelidan_the_breaker.cpp
View File

@@ -1,352 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "SpellAuras.h"
#include "blood_furnace.h"
enum eKelidan
{
SAY_WAKE = 0,
SAY_ADD_AGGRO = 1,
SAY_KILL = 2,
SAY_NOVA = 3,
SAY_DIE = 4,
// Keldian spells
SPELL_CORRUPTION = 30938,
SPELL_EVOCATION = 30935,
SPELL_FIRE_NOVA = 33132,
SPELL_SHADOW_BOLT_VOLLEY = 28599,
SPELL_BURNING_NOVA = 30940,
SPELL_VORTEX = 37370,
// Channelers spells
SPELL_SHADOW_BOLT = 12739,
SPELL_SHADOW_BOLT_H = 15472,
SPELL_MARK_OF_SHADOW = 30937,
SPELL_CHANNELING = 39123,
// Events
EVENT_SPELL_VOLLEY = 1,
EVENT_SPELL_CORRUPTION = 2,
EVENT_SPELL_BURNING_NOVA = 3,
EVENT_SPELL_FIRE_NOVA = 4,
EVENT_SPELL_SHADOW_BOLT = 5,
EVENT_SPELL_MARK = 6,
// Actions
ACTION_CHANNELER_ENGAGED = 1,
ACTION_CHANNELER_DIED = 2,
};
const float ShadowmoonChannelers[5][4] =
{
{302.0f, -87.0f, -24.4f, 0.157f},
{321.0f, -63.5f, -24.6f, 4.887f},
{346.0f, -74.5f, -24.6f, 3.595f},
{344.0f, -103.5f, -24.5f, 2.356f},
{316.0f, -109.0f, -24.6f, 1.257f}
};
class boss_kelidan_the_breaker : public CreatureScript
{
public:
boss_kelidan_the_breaker() : CreatureScript("boss_kelidan_the_breaker")
{
}
struct boss_kelidan_the_breakerAI : public ScriptedAI
{
boss_kelidan_the_breakerAI(Creature* creature) : ScriptedAI(creature)
{
instance = creature->GetInstanceScript();
memset(&channelers, 0, sizeof(channelers));
}
InstanceScript* instance;
EventMap events;
uint64 channelers[5];
uint32 checkTimer;
bool addYell;
void Reset()
{
addYell = false;
checkTimer = 5000;
events.Reset();
ApplyImmunities(true);
SummonChannelers();
me->SetReactState(REACT_PASSIVE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC | UNIT_FLAG_NON_ATTACKABLE);
if (instance)
instance->SetData(DATA_KELIDAN, NOT_STARTED);
}
void EnterCombat(Unit* who)
{
events.ScheduleEvent(EVENT_SPELL_VOLLEY, 1000);
events.ScheduleEvent(EVENT_SPELL_CORRUPTION, 5000);
events.ScheduleEvent(EVENT_SPELL_BURNING_NOVA, 15000);
me->InterruptNonMeleeSpells(false);
Talk(SAY_WAKE);
if (instance)
instance->SetData(DATA_KELIDAN, IN_PROGRESS);
}
void KilledUnit(Unit* /*victim*/)
{
if (urand(0,1))
Talk(SAY_KILL);
}
void DoAction(int32 param)
{
if (param == ACTION_CHANNELER_ENGAGED)
{
if (!addYell)
{
addYell = true;
Talk(SAY_ADD_AGGRO);
for (uint8 i = 0; i < 5; ++i)
{
Creature* channeler = ObjectAccessor::GetCreature(*me, channelers[i]);
if (channeler && !channeler->IsInCombat())
channeler->SetInCombatWithZone();
}
}
}
else if (param == ACTION_CHANNELER_DIED)
{
for (uint8 i = 0; i < 5; ++i)
{
Creature* channeler = ObjectAccessor::GetCreature(*me, channelers[i]);
if (channeler && channeler->IsAlive())
return;
}
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC | UNIT_FLAG_NON_ATTACKABLE);
if (Unit* target = me->SelectNearestPlayer(100.0f))
AttackStart(target);
}
}
void CheckChannelers()
{
if (addYell)
{
if (!SelectTargetFromPlayerList(100.0f))
EnterEvadeMode();
return;
}
SummonChannelers();
for (uint8 i = 0; i < 5; ++i)
{
Creature* channeler = ObjectAccessor::GetCreature(*me, channelers[i]);
if (channeler && !channeler->HasUnitState(UNIT_STATE_CASTING) && !channeler->IsInCombat())
{
Creature* target = ObjectAccessor::GetCreature(*me, channelers[(i+2)%5]);
if (target)
channeler->CastSpell(target, SPELL_CHANNELING, false);
}
}
}
void SummonChannelers()
{
for (uint8 i = 0; i < 5; ++i)
{
Creature* channeler = ObjectAccessor::GetCreature(*me, channelers[i]);
if (channeler && channeler->isDead())
{
channeler->DespawnOrUnsummon(1);
channeler = NULL;
}
if (!channeler)
channeler = me->SummonCreature(NPC_CHANNELER, ShadowmoonChannelers[i][0], ShadowmoonChannelers[i][1], ShadowmoonChannelers[i][2], ShadowmoonChannelers[i][3], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 300000);
channelers[i] = channeler ? channeler->GetGUID() : 0;
}
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DIE);
if (instance)
{
// Xinef: load grid with start doors
me->GetMap()->LoadGrid(0, -111.0f);
instance->SetData(DATA_KELIDAN, DONE);
instance->HandleGameObject(instance->GetData64(DATA_DOOR1), true);
instance->HandleGameObject(instance->GetData64(DATA_DOOR6), true);
}
}
void ApplyImmunities(bool apply)
{
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_CHARM, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_DISORIENTED, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_DISTRACT, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_FEAR, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_ROOT, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_SILENCE, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_SLEEP, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_SNARE, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_STUN, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_FREEZE, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_KNOCKOUT, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_POLYMORPH, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_BANISH, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_SHACKLE, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_TURN, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_HORROR, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_DAZE, apply);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_SAPPED, apply);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
{
checkTimer += diff;
if (checkTimer >= 5000)
{
checkTimer = 0;
CheckChannelers();
if (!me->HasUnitState(UNIT_STATE_CASTING))
me->CastSpell(me, SPELL_EVOCATION, false);
}
return;
}
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_SPELL_VOLLEY:
me->CastSpell(me, SPELL_SHADOW_BOLT_VOLLEY, false);
events.RepeatEvent(urand(8000, 13000));
break;
case EVENT_SPELL_CORRUPTION:
me->CastSpell(me, SPELL_CORRUPTION, false);
events.RepeatEvent(urand(30000, 50000));
break;
case EVENT_SPELL_BURNING_NOVA:
Talk(SAY_NOVA);
ApplyImmunities(false);
me->AddAura(SPELL_BURNING_NOVA, me);
ApplyImmunities(true);
if (IsHeroic())
DoTeleportAll(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation());
events.DelayEvents(6000, 0);
events.RepeatEvent(urand(25000, 32000));
events.ScheduleEvent(EVENT_SPELL_FIRE_NOVA, 5000);
break;
case EVENT_SPELL_FIRE_NOVA:
me->CastSpell(me, SPELL_FIRE_NOVA, true);
events.PopEvent();
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_kelidan_the_breakerAI(creature);
}
};
class npc_shadowmoon_channeler : public CreatureScript
{
public:
npc_shadowmoon_channeler() : CreatureScript("npc_shadowmoon_channeler") {}
struct npc_shadowmoon_channelerAI : public ScriptedAI
{
npc_shadowmoon_channelerAI(Creature* creature) : ScriptedAI(creature){}
EventMap events;
void Reset()
{
events.Reset();
}
Creature* GetKelidan()
{
if (me->GetInstanceScript())
return ObjectAccessor::GetCreature(*me, me->GetInstanceScript()->GetData64(DATA_KELIDAN));
return NULL;
}
void EnterCombat(Unit* who)
{
if (Creature* kelidan = GetKelidan())
kelidan->AI()->DoAction(ACTION_CHANNELER_ENGAGED);
me->InterruptNonMeleeSpells(false);
events.ScheduleEvent(EVENT_SPELL_SHADOW_BOLT, urand(1500, 3500));
events.ScheduleEvent(EVENT_SPELL_MARK, urand(5000, 6500));
}
void JustDied(Unit* killer)
{
if (Creature* kelidan = GetKelidan())
kelidan->AI()->DoAction(ACTION_CHANNELER_DIED);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_SPELL_SHADOW_BOLT:
me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_SHADOW_BOLT_H : SPELL_SHADOW_BOLT, false);
events.RepeatEvent(urand(6000, 7500));
break;
case EVENT_SPELL_MARK:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->CastSpell(target, SPELL_MARK_OF_SHADOW, false);
events.RepeatEvent(urand(16000, 17500));
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new npc_shadowmoon_channelerAI(creature);
}
};
void AddSC_boss_kelidan_the_breaker()
{
new boss_kelidan_the_breaker();
new npc_shadowmoon_channeler();
}

133
src/server/scripts/Outland/HellfireCitadel/BloodFurnace/boss_the_maker.cpp
View File

@@ -1,133 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "blood_furnace.h"
enum eEnums
{
SAY_AGGRO = 0,
SAY_KILL = 1,
SAY_DIE = 2,
SPELL_ACID_SPRAY = 38153,
SPELL_EXPLODING_BREAKER = 30925,
SPELL_KNOCKDOWN = 20276,
SPELL_DOMINATION = 25772,
EVENT_SPELL_ACID = 1,
EVENT_SPELL_EXPLODING = 2,
EVENT_SPELL_DOMINATION = 3,
EVENT_SPELL_KNOCKDOWN = 4,
};
class boss_the_maker : public CreatureScript
{
public:
boss_the_maker() : CreatureScript("boss_the_maker")
{
}
struct boss_the_makerAI : public ScriptedAI
{
boss_the_makerAI(Creature* creature) : ScriptedAI(creature)
{
instance = creature->GetInstanceScript();
}
InstanceScript* instance;
EventMap events;
void Reset()
{
events.Reset();
if (!instance)
return;
instance->SetData(DATA_THE_MAKER, NOT_STARTED);
instance->HandleGameObject(instance->GetData64(DATA_DOOR2), true);
}
void EnterCombat(Unit* /*who*/)
{
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_SPELL_ACID, 15000);
events.ScheduleEvent(EVENT_SPELL_EXPLODING, 6000);
events.ScheduleEvent(EVENT_SPELL_DOMINATION, 120000);
events.ScheduleEvent(EVENT_SPELL_KNOCKDOWN, 10000);
if (!instance)
return;
instance->SetData(DATA_THE_MAKER, IN_PROGRESS);
instance->HandleGameObject(instance->GetData64(DATA_DOOR2), false);
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER && urand(0,1))
Talk(SAY_KILL);
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DIE);
if (!instance)
return;
instance->SetData(DATA_THE_MAKER, DONE);
instance->HandleGameObject(instance->GetData64(DATA_DOOR2), true);
instance->HandleGameObject(instance->GetData64(DATA_DOOR3), true);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_SPELL_ACID:
me->CastSpell(me->GetVictim(), SPELL_ACID_SPRAY, false);
events.RepeatEvent(urand(15000, 23000));
break;
case EVENT_SPELL_EXPLODING:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->CastSpell(target, SPELL_EXPLODING_BREAKER, false);
events.RepeatEvent(urand(7000, 11000));
break;
case EVENT_SPELL_DOMINATION:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->CastSpell(target, SPELL_DOMINATION, false);
events.RepeatEvent(120000);
break;
case EVENT_SPELL_KNOCKDOWN:
me->CastSpell(me->GetVictim(), SPELL_KNOCKDOWN, false);
events.RepeatEvent(urand(4000, 12000));
break;
}
DoMeleeAttackIfReady();
}
};
CreatureAI* GetAI(Creature* creature) const
{
return new boss_the_makerAI(creature);
}
};
void AddSC_boss_the_maker()
{
new boss_the_maker();
}

329
src/server/scripts/Outland/HellfireCitadel/BloodFurnace/instance_blood_furnace.cpp
View File

@@ -1,329 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "InstanceScript.h"
#include "blood_furnace.h"
#include "CreatureAI.h"
class instance_blood_furnace : public InstanceMapScript
{
public:
instance_blood_furnace() : InstanceMapScript("instance_blood_furnace", 542) {}
struct instance_blood_furnace_InstanceMapScript : public InstanceScript
{
instance_blood_furnace_InstanceMapScript(Map* map) : InstanceScript(map) {}
uint32 _auiEncounter[MAX_ENCOUNTER];
uint64 _bossGUIDs[3];
uint64 _doorGUIDs[6];
uint64 _prisonGUIDs[4];
std::set<uint64> _prisonersCell[4];
uint8 _prisonerCounter[4];
uint64 _broggokLeverGUID;
void Initialize()
{
memset(&_auiEncounter, 0, sizeof(_auiEncounter));
memset(&_bossGUIDs, 0, sizeof(_bossGUIDs));
memset(&_doorGUIDs, 0, sizeof(_doorGUIDs));
memset(&_prisonGUIDs, 0, sizeof(_prisonGUIDs));
memset(&_prisonerCounter, 0, sizeof(_prisonerCounter));
for (uint8 i = 0; i < 4; ++i)
_prisonersCell[i].clear();
_broggokLeverGUID = 0;
}
void OnCreatureCreate(Creature* creature)
{
switch (creature->GetEntry())
{
case NPC_THE_MAKER:
_bossGUIDs[DATA_THE_MAKER] = creature->GetGUID();
break;
case NPC_BROGGOK:
_bossGUIDs[DATA_BROGGOK] = creature->GetGUID();
break;
case NPC_KELIDAN:
_bossGUIDs[DATA_KELIDAN] = creature->GetGUID();
break;
case NPC_NASCENT_FEL_ORC:
StorePrisoner(creature);
break;
}
}
void OnUnitDeath(Unit* unit)
{
if (unit && unit->GetTypeId() == TYPEID_UNIT && unit->GetEntry() == NPC_NASCENT_FEL_ORC)
PrisonerDied(unit->GetGUID());
}
void OnGameObjectCreate(GameObject* go)
{
if (go->GetEntry() == 181766) //Final exit door
_doorGUIDs[0] = go->GetGUID();
if (go->GetEntry() == 181811) //The Maker Front door
_doorGUIDs[1] = go->GetGUID();
if (go->GetEntry() == 181812) //The Maker Rear door
{
_doorGUIDs[2] = go->GetGUID();
if (GetData(DATA_THE_MAKER) == DONE)
HandleGameObject(go->GetGUID(), true);
}
if (go->GetEntry() == 181822) //Broggok Front door
_doorGUIDs[3] = go->GetGUID();
if (go->GetEntry() == 181819) //Broggok Rear door
{
_doorGUIDs[4] = go->GetGUID();
if (GetData(DATA_BROGGOK) == DONE)
HandleGameObject(go->GetGUID(), true);
}
if (go->GetEntry() == 181823) //Kelidan exit door
_doorGUIDs[5] = go->GetGUID();
if (go->GetEntry() == 181821) //Broggok prison cell front right
_prisonGUIDs[0] = go->GetGUID();
if (go->GetEntry() == 181818) //Broggok prison cell back right
_prisonGUIDs[1] = go->GetGUID();
if (go->GetEntry() == 181820) //Broggok prison cell front left
_prisonGUIDs[2] = go->GetGUID();
if (go->GetEntry() == 181817) //Broggok prison cell back left
_prisonGUIDs[3] = go->GetGUID();
if (go->GetEntry() == 181982)
_broggokLeverGUID = go->GetGUID(); //Broggok lever
}
uint64 GetData64(uint32 data) const
{
switch (data)
{
case DATA_THE_MAKER:
case DATA_BROGGOK:
case DATA_KELIDAN:
return _bossGUIDs[data];
case DATA_DOOR1:
case DATA_DOOR2:
case DATA_DOOR3:
case DATA_DOOR4:
case DATA_DOOR5:
case DATA_DOOR6:
return _doorGUIDs[data-DATA_DOOR1];
case DATA_PRISON_CELL1:
case DATA_PRISON_CELL2:
case DATA_PRISON_CELL3:
case DATA_PRISON_CELL4:
return _prisonGUIDs[data-DATA_PRISON_CELL1];
}
return 0;
}
void SetData(uint32 type, uint32 data)
{
switch (type)
{
case DATA_THE_MAKER:
case DATA_BROGGOK:
case DATA_KELIDAN:
_auiEncounter[type] = data;
if (type == DATA_BROGGOK)
UpdateBroggokEvent(data);
break;
}
if (data == DONE)
SaveToDB();
}
std::string GetSaveData()
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << "B F " << _auiEncounter[0] << ' ' << _auiEncounter[1] << ' ' << _auiEncounter[2];
OUT_SAVE_INST_DATA_COMPLETE;
return saveStream.str();
}
uint32 GetData(uint32 type) const
{
switch (type)
{
case DATA_THE_MAKER:
case DATA_BROGGOK:
case DATA_KELIDAN:
return _auiEncounter[type];
}
return 0;
}
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 == 'B' && dataHead2 == 'F')
{
loadStream >> _auiEncounter[0] >> _auiEncounter[1] >> _auiEncounter[2];
for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
if (_auiEncounter[i] == IN_PROGRESS || _auiEncounter[i] == FAIL)
_auiEncounter[i] = NOT_STARTED;
}
OUT_LOAD_INST_DATA_COMPLETE;
}
void UpdateBroggokEvent(uint32 data)
{
switch (data)
{
case IN_PROGRESS:
ActivateCell(DATA_PRISON_CELL1);
HandleGameObject(_doorGUIDs[3], false);
break;
case NOT_STARTED:
ResetPrisons();
HandleGameObject(_doorGUIDs[4], false);
HandleGameObject(_doorGUIDs[3], true);
if (GameObject* lever = instance->GetGameObject(_broggokLeverGUID))
lever->Respawn();
break;
}
}
void ResetPrisons()
{
for (uint8 i = 0; i < 4; ++i)
{
_prisonerCounter[i] = _prisonersCell[i].size();
ResetPrisoners(_prisonersCell[i]);
HandleGameObject(_prisonGUIDs[i], false);
}
}
void ResetPrisoners(std::set<uint64> prisoners)
{
for (std::set<uint64>::iterator i = prisoners.begin(); i != prisoners.end(); ++i)
if (Creature* prisoner = instance->GetCreature(*i))
ResetPrisoner(prisoner);
}
void ResetPrisoner(Creature* prisoner)
{
if (!prisoner->IsAlive())
prisoner->Respawn(true);
prisoner->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC | UNIT_FLAG_NON_ATTACKABLE);
}
void StorePrisoner(Creature* creature)
{
float posX = creature->GetPositionX();
float posY = creature->GetPositionY();
if (posX >= 405.0f && posX <= 423.0f)
{
if (posY >= 106.0f && posY <= 123.0f)
{
_prisonersCell[0].insert(creature->GetGUID());
++_prisonerCounter[0];
ResetPrisoner(creature);
}
else if (posY >= 76.0f && posY <= 91.0f)
{
_prisonersCell[1].insert(creature->GetGUID());
++_prisonerCounter[1];
ResetPrisoner(creature);
}
}
else if (posX >= 490.0f && posX <= 506.0f)
{
if (posY >= 106.0f && posY <= 123.0f)
{
_prisonersCell[2].insert(creature->GetGUID());
++_prisonerCounter[2];
ResetPrisoner(creature);
}
else if (posY >= 76.0f && posY <= 91.0f)
{
_prisonersCell[3].insert(creature->GetGUID());
++_prisonerCounter[3];
ResetPrisoner(creature);
}
}
}
void PrisonerDied(uint64 guid)
{
if (_prisonersCell[0].find(guid) != _prisonersCell[0].end() && --_prisonerCounter[0] <= 0)
ActivateCell(DATA_PRISON_CELL2);
else if (_prisonersCell[1].find(guid) != _prisonersCell[1].end() && --_prisonerCounter[1] <= 0)
ActivateCell(DATA_PRISON_CELL3);
else if (_prisonersCell[2].find(guid) != _prisonersCell[2].end() && --_prisonerCounter[2] <= 0)
ActivateCell(DATA_PRISON_CELL4);
else if (_prisonersCell[3].find(guid) != _prisonersCell[3].end() && --_prisonerCounter[3] <= 0)
ActivateCell(DATA_DOOR5);
}
void ActivateCell(uint8 id)
{
switch (id)
{
case DATA_PRISON_CELL1:
case DATA_PRISON_CELL2:
case DATA_PRISON_CELL3:
case DATA_PRISON_CELL4:
HandleGameObject(_prisonGUIDs[id-DATA_PRISON_CELL1], true);
ActivatePrisoners(_prisonersCell[id-DATA_PRISON_CELL1]);
break;
case DATA_DOOR5:
HandleGameObject(_doorGUIDs[4], true);
if (Creature* broggok = instance->GetCreature(GetData64(DATA_BROGGOK)))
broggok->AI()->DoAction(ACTION_ACTIVATE_BROGGOK);
break;
}
}
void ActivatePrisoners(std::set<uint64> prisoners)
{
for (std::set<uint64>::iterator i = prisoners.begin(); i != prisoners.end(); ++i)
if (Creature* prisoner = instance->GetCreature(*i))
{
prisoner->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC | UNIT_FLAG_NON_ATTACKABLE);
prisoner->SetInCombatWithZone();
}
}
};
InstanceScript* GetInstanceScript(InstanceMap* map) const
{
return new instance_blood_furnace_InstanceMapScript(map);
}
};
void AddSC_instance_blood_furnace()
{
new instance_blood_furnace();
}