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

487
src/server/scripts/Northrend/Gundrak/boss_drakkari_colossus.cpp
View File

@@ -1,487 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "gundrak.h"
enum Spells
{
SPELL_MOJO_PUDDLE = 55627,
SPELL_MOJO_WAVE = 55626,
SPELL_FREEZE_ANIM = 52656,
SPELL_MIGHTY_BLOW = 54719,
SPELL_ELEMENTAL_SPAWN_EFFECT = 54888,
SPELL_EMERGE = 54850,
SPELL_EMERGE_SUMMON = 54851,
SPELL_MOJO_VOLLEY = 54849,
SPELL_SURGE_VISUAL = 54827,
SPELL_SURGE = 54801,
SPELL_SURGE_DAMAGE = 54819,
SPELL_FACE_ME = 54991,
SPELL_MERGE = 54878,
};
enum Misc
{
NPC_LIVING_MOJO = 29830,
NPC_DRAKKARI_ELEMENTAL = 29573,
ACTION_MERGE = 1,
ACTION_INFORM = 2,
POINT_MERGE = 1,
SAY_SURGE = 0,
EMOTE_ALTAR = 1,
EVENT_COLOSSUS_MIGHTY_BLOW = 1,
EVENT_COLOSSUS_HEALTH_1 = 2,
EVENT_COLOSSUS_HEALTH_2 = 3,
EVENT_COLOSSUS_START_FIGHT = 4,
EVENT_ELEMENTAL_HEALTH = 10,
EVENT_ELEMENTAL_SURGE = 11,
EVENT_ELEMENTAL_VOLLEY = 12,
EVENT_MOJO_MOJO_WAVE = 20,
EVENT_MOJO_MOJO_PUDDLE = 21,
};
static Position mojoPosition[] =
{
{1663.1f, 743.6f, 143.1f},
{1669.97f, 753.7f, 143.1f},
{1680.7f, 750.7f, 143.1f},
{1680.7f, 737.1f, 143.1f},
{1670.4f, 733.5f, 143.1f}
};
class RestoreFight : public BasicEvent
{
public:
RestoreFight(Creature* owner) : _owner(owner) { }
bool Execute(uint64 /*execTime*/, uint32 /*diff*/)
{
_owner->SetReactState(REACT_AGGRESSIVE);
_owner->SetInCombatWithZone();
return true;
}
private:
Creature* _owner;
};
class boss_drakkari_colossus : public CreatureScript
{
public:
boss_drakkari_colossus() : CreatureScript("boss_drakkari_colossus") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_drakkari_colossusAI (creature);
}
struct boss_drakkari_colossusAI : public BossAI
{
boss_drakkari_colossusAI(Creature* creature) : BossAI(creature, DATA_DRAKKARI_COLOSSUS)
{
}
void MoveInLineOfSight(Unit* who)
{
}
void DoAction(int32 param)
{
if (param == ACTION_INFORM)
{
me->SetInCombatWithZone();
summons.DoAction(ACTION_MERGE);
events.ScheduleEvent(EVENT_COLOSSUS_START_FIGHT, 3500);
}
}
void Reset()
{
BossAI::Reset();
for (uint8 i = 0; i < 5; i++)
me->SummonCreature(NPC_LIVING_MOJO, mojoPosition[i].GetPositionX(), mojoPosition[i].GetPositionY(), mojoPosition[i].GetPositionZ(), 0, TEMPSUMMON_MANUAL_DESPAWN, 0);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
void InitializeAI()
{
BossAI::InitializeAI();
me->CastSpell(me, SPELL_FREEZE_ANIM, true);
}
void JustReachedHome()
{
BossAI::JustReachedHome();
me->CastSpell(me, SPELL_FREEZE_ANIM, true);
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
events.ScheduleEvent(EVENT_COLOSSUS_MIGHTY_BLOW, 10000);
events.ScheduleEvent(EVENT_COLOSSUS_HEALTH_1, 1000);
events.ScheduleEvent(EVENT_COLOSSUS_HEALTH_2, 1000);
}
void JustSummoned(Creature* summon)
{
if (summon->GetEntry() == NPC_DRAKKARI_ELEMENTAL)
{
summon->SetRegeneratingHealth(false);
summon->SetReactState(REACT_PASSIVE);
summon->m_Events.AddEvent(new RestoreFight(summon), summon->m_Events.CalculateTime(3000));
if (events.GetNextEventTime(EVENT_COLOSSUS_HEALTH_2) == 0)
{
summon->SetHealth(summon->GetMaxHealth()/2);
summon->LowerPlayerDamageReq(summon->GetMaxHealth()/2);
summon->AI()->DoAction(ACTION_INFORM);
}
}
summons.Summon(summon);
}
void SummonedCreatureDies(Creature* summon, Unit*)
{
summons.Despawn(summon);
if (summon->GetEntry() == NPC_DRAKKARI_ELEMENTAL)
Unit::Kill(me, me);
}
void SummonedCreatureDespawn(Creature* summon)
{
summons.Despawn(summon);
if (summon->GetEntry() == NPC_DRAKKARI_ELEMENTAL)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->RemoveAurasDueToSpell(SPELL_FREEZE_ANIM);
if (me->GetVictim())
me->GetMotionMaster()->MoveChase(me->GetVictim());
}
}
void DamageTaken(Unit* attacker, uint32& damage, DamageEffectType, SpellSchoolMask)
{
if (damage >= me->GetHealth())
damage = 0;
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))
return;
events.Update(diff);
switch (events.ExecuteEvent())
{
case EVENT_COLOSSUS_START_FIGHT:
me->RemoveAurasDueToSpell(SPELL_FREEZE_ANIM);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
break;
case EVENT_COLOSSUS_MIGHTY_BLOW:
me->CastSpell(me->GetVictim(), SPELL_MIGHTY_BLOW, false);
events.ScheduleEvent(EVENT_COLOSSUS_MIGHTY_BLOW, 10000);
break;
case EVENT_COLOSSUS_HEALTH_1:
if (me->HealthBelowPct(51))
{
me->CastSpell(me, SPELL_EMERGE, false);
me->CastSpell(me, SPELL_EMERGE_SUMMON, true);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->GetMotionMaster()->Clear();
break;
}
events.ScheduleEvent(EVENT_COLOSSUS_HEALTH_1, 1000);
break;
case EVENT_COLOSSUS_HEALTH_2:
if (me->HealthBelowPct(21))
{
me->CastSpell(me, SPELL_EMERGE, false);
me->CastSpell(me, SPELL_EMERGE_SUMMON, true);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->GetMotionMaster()->Clear();
break;
}
events.ScheduleEvent(EVENT_COLOSSUS_HEALTH_2, 1000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class boss_drakkari_elemental : public CreatureScript
{
public:
boss_drakkari_elemental() : CreatureScript("boss_drakkari_elemental") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_drakkari_elementalAI (pCreature);
}
struct boss_drakkari_elementalAI : public ScriptedAI
{
boss_drakkari_elementalAI(Creature* pCreature) : ScriptedAI(pCreature)
{
events.ScheduleEvent(EVENT_ELEMENTAL_HEALTH, 1000);
events.ScheduleEvent(EVENT_ELEMENTAL_SURGE, 7000);
events.ScheduleEvent(EVENT_ELEMENTAL_VOLLEY, 0);
}
EventMap events;
void DoAction(int32 param)
{
if (param == ACTION_INFORM)
events.CancelEvent(EVENT_ELEMENTAL_HEALTH);
}
void Reset()
{
me->CastSpell(me, SPELL_ELEMENTAL_SPAWN_EFFECT, false);
}
void JustDied(Unit*)
{
Talk(EMOTE_ALTAR);
}
void EnterCombat(Unit*)
{
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING) || me->HasUnitState(UNIT_STATE_CHARGING))
return;
switch (events.ExecuteEvent())
{
case EVENT_ELEMENTAL_HEALTH:
if (me->HealthBelowPct(51))
{
me->CastSpell(me, SPELL_FACE_ME, true);
me->CastSpell(me, SPELL_SURGE_VISUAL, true);
me->CastSpell(me, SPELL_MERGE, false);
me->DespawnOrUnsummon(2000);
events.Reset();
break;
}
events.ScheduleEvent(EVENT_ELEMENTAL_HEALTH, 1000);
break;
case EVENT_ELEMENTAL_SURGE:
Talk(SAY_SURGE);
me->CastSpell(me, SPELL_SURGE_VISUAL, true);
me->CastSpell(me->GetVictim(), SPELL_SURGE, false);
events.ScheduleEvent(EVENT_ELEMENTAL_SURGE, 15000);
break;
case EVENT_ELEMENTAL_VOLLEY:
me->CastSpell(me, SPELL_MOJO_VOLLEY, true);
break;
}
DoMeleeAttackIfReady();
}
};
};
class npc_living_mojo : public CreatureScript
{
public:
npc_living_mojo() : CreatureScript("npc_living_mojo") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new npc_living_mojoAI (pCreature);
}
struct npc_living_mojoAI : public ScriptedAI
{
npc_living_mojoAI(Creature* pCreature) : ScriptedAI(pCreature)
{
}
EventMap events;
void Reset()
{
events.Reset();
events.ScheduleEvent(EVENT_MOJO_MOJO_PUDDLE, 13000);
events.ScheduleEvent(EVENT_MOJO_MOJO_WAVE, 15000);
}
void MoveInLineOfSight(Unit* who)
{
if (me->ToTempSummon())
return;
ScriptedAI::MoveInLineOfSight(who);
}
void AttackStart(Unit* who)
{
if (me->ToTempSummon())
{
if (who->GetTypeId() == TYPEID_PLAYER || IS_PLAYER_GUID(who->GetOwnerGUID()))
if (Unit* summoner = me->ToTempSummon()->GetSummoner())
summoner->GetAI()->DoAction(ACTION_INFORM);
return;
}
ScriptedAI::AttackStart(who);
}
void DoAction(int32 param)
{
if (param == ACTION_MERGE)
{
me->SetReactState(REACT_PASSIVE);
me->GetMotionMaster()->MoveCharge(1672.96f, 743.488f, 143.338f, 7.0f, POINT_MERGE);
me->DespawnOrUnsummon(1200);
}
}
void UpdateAI(uint32 diff)
{
if (me->ToTempSummon() || !UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_MOJO_MOJO_PUDDLE:
{
me->CastSpell(me, SPELL_MOJO_PUDDLE, false);
events.ScheduleEvent(EVENT_MOJO_MOJO_PUDDLE, 13000);
break;
}
case EVENT_MOJO_MOJO_WAVE:
{
me->CastSpell(me->GetVictim(), SPELL_MOJO_WAVE, false);
events.ScheduleEvent(EVENT_MOJO_MOJO_WAVE, 15000);
break;
}
}
DoMeleeAttackIfReady();
}
};
};
class spell_drakkari_colossus_emerge : public SpellScriptLoader
{
public:
spell_drakkari_colossus_emerge() : SpellScriptLoader("spell_drakkari_colossus_emerge") { }
class spell_drakkari_colossus_emerge_SpellScript : public SpellScript
{
PrepareSpellScript(spell_drakkari_colossus_emerge_SpellScript);
void HandleDummy(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetCaster(), SPELL_FREEZE_ANIM, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_drakkari_colossus_emerge_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_drakkari_colossus_emerge_SpellScript();
}
};
class spell_drakkari_colossus_surge : public SpellScriptLoader
{
public:
spell_drakkari_colossus_surge() : SpellScriptLoader("spell_drakkari_colossus_surge") { }
class spell_drakkari_colossus_surge_SpellScript : public SpellScript
{
PrepareSpellScript(spell_drakkari_colossus_surge_SpellScript);
void HandleDummy(SpellEffIndex /*effIndex*/)
{
if (Unit* target = GetHitUnit())
GetCaster()->CastSpell(target, SPELL_SURGE_DAMAGE, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_drakkari_colossus_surge_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
SpellScript* GetSpellScript() const
{
return new spell_drakkari_colossus_surge_SpellScript();
}
};
class spell_drakkari_colossus_face_me : public SpellScriptLoader
{
public:
spell_drakkari_colossus_face_me() : SpellScriptLoader("spell_drakkari_colossus_face_me") { }
class spell_drakkari_colossus_face_me_SpellScript : public SpellScript
{
PrepareSpellScript(spell_drakkari_colossus_face_me_SpellScript);
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
{
if (Unit* target = GetHitUnit())
{
GetCaster()->SetInFront(target);
GetCaster()->SetFacingTo(GetCaster()->GetAngle(target));
}
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_drakkari_colossus_face_me_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_drakkari_colossus_face_me_SpellScript();
}
};
void AddSC_boss_drakkari_colossus()
{
new boss_drakkari_colossus();
new boss_drakkari_elemental();
new npc_living_mojo();
new spell_drakkari_colossus_emerge();
new spell_drakkari_colossus_surge();
new spell_drakkari_colossus_face_me();
}

132
src/server/scripts/Northrend/Gundrak/boss_eck.cpp
View File

@@ -1,132 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "gundrak.h"
enum Spells
{
SPELL_ECK_BERSERK = 55816,
SPELL_ECK_BITE = 55813,
SPELL_ECK_SPIT = 55814,
SPELL_ECK_SPRING = 55815,
SPELL_ECK_SPRING_INIT = 55837
};
enum Misc
{
POINT_START = 0,
EVENT_ECK_BERSERK = 1,
EVENT_ECK_BITE = 2,
EVENT_ECK_SPIT = 3,
EVENT_ECK_SPRING = 4,
EVENT_ECK_HEALTH = 5
};
class boss_eck : public CreatureScript
{
public:
boss_eck() : CreatureScript("boss_eck") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_eckAI>(creature);
}
struct boss_eckAI : public BossAI
{
boss_eckAI(Creature* creature) : BossAI(creature, DATA_ECK_THE_FEROCIOUS)
{
}
void InitializeAI()
{
BossAI::InitializeAI();
me->GetMotionMaster()->MovePoint(POINT_START, 1638.55f, 919.76f, 104.95f, false);
me->SetHomePosition(1642.712f, 934.646f, 107.205f, 0.767f);
me->SetReactState(REACT_PASSIVE);
}
void MovementInform(uint32 type, uint32 id)
{
if (type == POINT_MOTION_TYPE && id == POINT_START)
{
me->CastSpell(me, SPELL_ECK_SPRING_INIT, true);
me->SetReactState(REACT_AGGRESSIVE);
}
}
void Reset()
{
BossAI::Reset();
}
void EnterCombat(Unit* who)
{
BossAI::EnterCombat(who);
events.ScheduleEvent(EVENT_ECK_BERSERK, urand(60000, 90000));
events.ScheduleEvent(EVENT_ECK_BITE, 5000);
events.ScheduleEvent(EVENT_ECK_SPIT, 10000);
events.ScheduleEvent(EVENT_ECK_SPRING, 8000);
}
void JustDied(Unit* killer)
{
BossAI::JustDied(killer);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_ECK_HEALTH:
if (me->HealthBelowPct(21))
{
events.CancelEvent(EVENT_ECK_BERSERK);
me->CastSpell(me, SPELL_ECK_BERSERK, false);
break;
}
events.ScheduleEvent(EVENT_ECK_HEALTH, 1000);
break;
case EVENT_ECK_BERSERK:
me->CastSpell(me, SPELL_ECK_BERSERK, false);
events.CancelEvent(EVENT_ECK_HEALTH);
break;
case EVENT_ECK_BITE:
me->CastSpell(me->GetVictim(), SPELL_ECK_BITE, false);
events.ScheduleEvent(EVENT_ECK_BITE, urand(8000, 12000));
break;
case EVENT_ECK_SPIT:
me->CastSpell(me->GetVictim(), SPELL_ECK_SPIT, false);
events.ScheduleEvent(EVENT_ECK_SPIT, 10000);
break;
case EVENT_ECK_SPRING:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 30.0f, true))
{
me->getThreatManager().resetAllAggro();
me->AddThreat(target, 500.0f);
me->CastSpell(target, SPELL_ECK_SPRING, false);
}
events.ScheduleEvent(EVENT_ECK_SPRING, urand(5000, 10000));
break;
}
DoMeleeAttackIfReady();
}
};
};
void AddSC_boss_eck()
{
new boss_eck();
}

283
src/server/scripts/Northrend/Gundrak/boss_gal_darah.cpp
View File

@@ -1,283 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "gundrak.h"
enum Spells
{
SPELL_START_VISUAL = 54988,
SPELL_ENRAGE = 55285,
SPELL_IMPALING_CHARGE = 54956,
SPELL_IMPALING_CHARGE_VEHICLE = 54958,
SPELL_STOMP = 55292,
SPELL_PUNCTURE = 55276,
SPELL_STAMPEDE = 55218,
SPELL_STAMPEDE_DMG = 55220,
SPELL_WHIRLING_SLASH = 55250,
SPELL_TRANSFORM_TO_RHINO = 55297,
SPELL_TRANSFORM_TO_TROLL = 55299
};
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SUMMON_RHINO = 3,
SAY_TRANSFORM_1 = 4,
SAY_TRANSFORM_2 = 5
};
enum Events
{
EVENT_STAMPEDE = 1,
EVENT_WHIRLING_SLASH = 2,
EVENT_PUNCTURE = 3,
EVENT_ENRAGE = 4,
EVENT_IMPALING_CHARGE = 5,
EVENT_UNSUMMON_RHINO = 6,
EVENT_STOMP = 7,
EVENT_KILL_TALK = 8
};
class boss_gal_darah : public CreatureScript
{
public:
boss_gal_darah() : CreatureScript("boss_gal_darah") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_gal_darahAI>(creature);
}
struct boss_gal_darahAI : public BossAI
{
boss_gal_darahAI(Creature* creature) : BossAI(creature, DATA_GAL_DARAH)
{
}
uint8 phaseCounter;
std::set<uint64> impaledList;
void Reset()
{
BossAI::Reset();
impaledList.clear();
phaseCounter = 0;
}
void InitializeAI()
{
BossAI::InitializeAI();
me->CastSpell(me, SPELL_START_VISUAL, false);
}
void JustReachedHome()
{
BossAI::JustReachedHome();
me->CastSpell(me, SPELL_START_VISUAL, false);
}
void ScheduleEvents(bool troll)
{
events.Reset();
if (troll)
{
events.RescheduleEvent(EVENT_STAMPEDE, 10000);
events.RescheduleEvent(EVENT_WHIRLING_SLASH, 21000);
}
else
{
events.RescheduleEvent(EVENT_PUNCTURE, 10000);
events.RescheduleEvent(EVENT_ENRAGE, 15000);
events.RescheduleEvent(EVENT_IMPALING_CHARGE, 21000);
events.RescheduleEvent(EVENT_STOMP, 5000);
}
}
void EnterCombat(Unit* who)
{
Talk(SAY_AGGRO);
BossAI::EnterCombat(who);
ScheduleEvents(true);
me->RemoveAurasDueToSpell(SPELL_START_VISUAL);
me->InterruptNonMeleeSpells(true);
}
void JustSummoned(Creature* summon)
{
uint32 despawnTime = 0;
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 60.0f, true))
{
summon->CastSpell(target, SPELL_STAMPEDE_DMG, true);
despawnTime = (summon->GetDistance(target)/40.0f*1000)+500;
}
summon->DespawnOrUnsummon(despawnTime);
}
uint32 GetData(uint32 type) const
{
return impaledList.size();
}
void JustDied(Unit* killer)
{
Talk(SAY_DEATH);
BossAI::JustDied(killer);
}
void KilledUnit(Unit*)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING|UNIT_STATE_CHARGING))
return;
switch (events.ExecuteEvent())
{
case EVENT_STAMPEDE:
Talk(SAY_SUMMON_RHINO);
me->CastSpell(me->GetVictim(), SPELL_STAMPEDE, false);
events.ScheduleEvent(EVENT_STAMPEDE, 15000);
break;
case EVENT_WHIRLING_SLASH:
if (++phaseCounter >= 3)
{
ScheduleEvents(false);
me->CastSpell(me, SPELL_TRANSFORM_TO_RHINO, false);
Talk(SAY_TRANSFORM_1);
phaseCounter = 0;
return;
}
events.ScheduleEvent(EVENT_WHIRLING_SLASH, 21000);
me->CastSpell(me, SPELL_WHIRLING_SLASH, false);
break;
case EVENT_PUNCTURE:
me->CastSpell(me->GetVictim(), SPELL_PUNCTURE, false);
events.ScheduleEvent(EVENT_PUNCTURE, 8000);
break;
case EVENT_ENRAGE:
me->CastSpell(me, SPELL_ENRAGE, false);
events.ScheduleEvent(EVENT_ENRAGE, 20000);
break;
case EVENT_STOMP:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30.0f, true))
me->CastSpell(target, SPELL_STOMP, false);
events.ScheduleEvent(EVENT_STOMP, 20000);
break;
case EVENT_IMPALING_CHARGE:
if (++phaseCounter >= 3)
{
ScheduleEvents(true);
me->CastSpell(me, SPELL_TRANSFORM_TO_TROLL, false);
Talk(SAY_TRANSFORM_2);
phaseCounter = 0;
return;
}
events.ScheduleEvent(EVENT_IMPALING_CHARGE, 21000);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true))
{
me->CastSpell(target, SPELL_IMPALING_CHARGE, false);
impaledList.insert(target->GetGUID());
}
break;
}
DoMeleeAttackIfReady();
}
};
};
class spell_galdarah_impaling_charge : public SpellScriptLoader
{
public:
spell_galdarah_impaling_charge() : SpellScriptLoader("spell_galdarah_impaling_charge") { }
class spell_galdarah_impaling_charge_SpellScript : public SpellScript
{
PrepareSpellScript(spell_galdarah_impaling_charge_SpellScript);
void HandleApplyAura(SpellEffIndex /*effIndex*/)
{
if (Unit* target = GetHitUnit())
target->CastSpell(GetCaster(), SPELL_IMPALING_CHARGE_VEHICLE, true);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_galdarah_impaling_charge_SpellScript::HandleApplyAura, EFFECT_1, SPELL_EFFECT_APPLY_AURA);
}
};
SpellScript* GetSpellScript() const
{
return new spell_galdarah_impaling_charge_SpellScript();
}
};
class spell_galdarah_transform : public SpellScriptLoader
{
public:
spell_galdarah_transform() : SpellScriptLoader("spell_galdarah_transform") { }
class spell_galdarah_transform_SpellScript : public SpellScript
{
PrepareSpellScript(spell_galdarah_transform_SpellScript);
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
{
if (Unit* target = GetHitUnit())
target->RemoveAurasDueToSpell(SPELL_TRANSFORM_TO_RHINO);
}
void Register()
{
OnEffectHitTarget += SpellEffectFn(spell_galdarah_transform_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
}
};
SpellScript* GetSpellScript() const
{
return new spell_galdarah_transform_SpellScript();
}
};
class achievement_share_the_love : public AchievementCriteriaScript
{
public:
achievement_share_the_love() : AchievementCriteriaScript("achievement_share_the_love")
{
}
bool OnCheck(Player* /*player*/, Unit* target)
{
if (!target)
return false;
return target->GetAI()->GetData(target->GetEntry()) >= 5;
}
};
void AddSC_boss_gal_darah()
{
new boss_gal_darah();
new spell_galdarah_impaling_charge();
new spell_galdarah_transform();
new achievement_share_the_love();
}

207
src/server/scripts/Northrend/Gundrak/boss_moorabi.cpp
View File

@@ -1,207 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "gundrak.h"
enum eSpells
{
SPELL_SUMMON_PHANTOM = 55205,
SPELL_SUMMON_PHANTOM_TRANSFORM = 55097,
SPELL_DETERMINED_STAB = 55104,
SPELL_DETERMINED_GORE = 55102,
SPELL_GROUND_TREMOR = 55142,
SPELL_QUAKE = 55101,
SPELL_NUMBING_SHOUT = 55106,
SPELL_NUMBING_ROAR = 55100,
SPELL_MOJO_FRENZY = 55163,
SPELL_TRANSFORMATION = 55098
};
enum eSays
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_TRANSFORM = 3,
SAY_QUAKE = 4,
EMOTE_TRANSFORM = 5,
EMOTE_TRANSFORMED = 6,
EMOTE_ALTAR = 7
};
enum Events
{
EVENT_GROUND_TREMOR = 1,
EVENT_NUMBLING_SHOUT = 2,
EVENT_DETERMINED_STAB = 3,
EVENT_TRANSFORMATION = 4,
EVENT_KILL_TALK = 5,
EVENT_PHANTOM = 10
};
class boss_moorabi : public CreatureScript
{
public:
boss_moorabi() : CreatureScript("boss_moorabi") { }
CreatureAI* GetAI(Creature* creature) const
{
return GetInstanceAI<boss_moorabiAI>(creature);
}
struct boss_moorabiAI : public BossAI
{
boss_moorabiAI(Creature* creature) : BossAI(creature, DATA_MOORABI)
{
}
EventMap events2;
void Reset()
{
BossAI::Reset();
events2.Reset();
events2.ScheduleEvent(EVENT_PHANTOM, 21000);
}
void EnterCombat(Unit* who)
{
Talk(SAY_AGGRO);
BossAI::EnterCombat(who);
me->CastSpell(me, SPELL_MOJO_FRENZY, true);
events.ScheduleEvent(EVENT_GROUND_TREMOR, 18000);
events.ScheduleEvent(EVENT_NUMBLING_SHOUT, 10000);
events.ScheduleEvent(EVENT_DETERMINED_STAB, 20000);
events.ScheduleEvent(EVENT_TRANSFORMATION, 12000);
}
void SpellHitTarget(Unit* caster, const SpellInfo* spellInfo)
{
if (spellInfo->Id == SPELL_TRANSFORMATION)
{
me->RemoveAurasDueToSpell(SPELL_MOJO_FRENZY);
events.CancelEvent(EVENT_TRANSFORMATION);
Talk(EMOTE_TRANSFORMED);
}
}
void JustDied(Unit* killer)
{
Talk(SAY_DEATH);
Talk(EMOTE_ALTAR);
BossAI::JustDied(killer);
}
void KilledUnit(Unit*)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void UpdateAI(uint32 diff)
{
if (!me->IsInCombat())
{
events2.Update(diff);
if (events2.ExecuteEvent() == EVENT_PHANTOM)
{
me->CastSpell(me, SPELL_SUMMON_PHANTOM, true);
events2.ScheduleEvent(EVENT_PHANTOM, urand(20000, 25000));
}
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_GROUND_TREMOR:
if (roll_chance_i(50))
Talk(SAY_QUAKE);
me->CastSpell(me, me->GetDisplayId() != me->GetNativeDisplayId() ? SPELL_QUAKE : SPELL_GROUND_TREMOR, false);
events.ScheduleEvent(EVENT_GROUND_TREMOR, 10000);
break;
case EVENT_NUMBLING_SHOUT:
me->CastSpell(me, me->GetDisplayId() != me->GetNativeDisplayId() ? SPELL_NUMBING_ROAR : SPELL_NUMBING_SHOUT, false);
events.ScheduleEvent(EVENT_NUMBLING_SHOUT, 10000);
break;
case EVENT_DETERMINED_STAB:
me->CastSpell(me->GetVictim(), me->GetDisplayId() != me->GetNativeDisplayId() ? SPELL_DETERMINED_GORE : SPELL_DETERMINED_STAB, false);
events.ScheduleEvent(EVENT_DETERMINED_STAB, 8000);
break;
case EVENT_TRANSFORMATION:
Talk(EMOTE_TRANSFORM);
Talk(SAY_TRANSFORM);
me->CastSpell(me, SPELL_TRANSFORMATION, false);
me->CastSpell(me,SPELL_SUMMON_PHANTOM_TRANSFORM, true);
events.ScheduleEvent(EVENT_TRANSFORMATION, 10000);
break;
}
DoMeleeAttackIfReady();
}
};
};
class spell_moorabi_mojo_frenzy : public SpellScriptLoader
{
public:
spell_moorabi_mojo_frenzy() : SpellScriptLoader("spell_moorabi_mojo_frenzy") { }
class spell_moorabi_mojo_frenzy_AuraScript : public AuraScript
{
PrepareAuraScript(spell_moorabi_mojo_frenzy_AuraScript);
void HandlePeriodic(AuraEffect const* aurEff)
{
PreventDefaultAction();
if (GetUnitOwner()->GetMap()->IsHeroic())
GetUnitOwner()->SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f * (GetUnitOwner()->GetHealthPct()*GetUnitOwner()->GetHealthPct()/10000.0f));
else
GetUnitOwner()->SetFloatValue(UNIT_MOD_CAST_SPEED, 1.0f * (GetUnitOwner()->GetHealthPct()/100.0f));
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_moorabi_mojo_frenzy_AuraScript::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
};
AuraScript* GetAuraScript() const
{
return new spell_moorabi_mojo_frenzy_AuraScript();
}
};
class achievement_less_rabi : public AchievementCriteriaScript
{
public:
achievement_less_rabi() : AchievementCriteriaScript("achievement_less_rabi")
{
}
bool OnCheck(Player* /*player*/, Unit* target)
{
return target && target->GetDisplayId() == target->GetNativeDisplayId();
}
};
void AddSC_boss_moorabi()
{
new boss_moorabi();
new spell_moorabi_mojo_frenzy();
new achievement_less_rabi();
}

240
src/server/scripts/Northrend/Gundrak/boss_slad_ran.cpp
View File

@@ -1,240 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "gundrak.h"
enum Spells
{
SPELL_POISON_NOVA = 55081,
SPELL_POWERFULL_BITE = 48287,
SPELL_VENOM_BOLT = 54970,
SPELL_SNAKE_WRAP = 55126
};
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SUMMON_SNAKES = 3,
SAY_SUMMON_CONSTRICTORS = 4,
EMOTE_NOVA = 5,
EMOTE_ALTAR = 6
};
enum Misc
{
NPC_SLADRAN_VIPER = 29680,
NPC_SLADRAN_CONSTRICTORS = 29713,
MAX_VIPER = 2,
MAX_CONSTRICTOR = 3,
MAX_SUMMONS = 5,
EVENT_POISON_NOVA = 1,
EVENT_POWERFULL_BITE = 2,
EVENT_VENOM_BOLT = 3,
EVENT_CHECK_HEALTH1 = 4,
EVENT_CHECK_HEALTH2 = 5,
EVENT_SUMMON1 = 6,
EVENT_SUMMON2 = 7,
EVENT_KILL_TALK = 8
};
const Position SpawnLoc[]=
{
{1783.81f, 646.637f, 133.948f, 3.71755f},
{1775.03f, 606.586f, 134.165f, 1.43117f},
{1765.66f, 646.542f, 134.02f, 5.11381f},
{1717.39f, 630.041f, 129.282f, 5.96903f},
{1716.76f, 635.159f, 129.282f, 0.191986f}
};
class boss_slad_ran : public CreatureScript
{
public:
boss_slad_ran() : CreatureScript("boss_slad_ran") { }
CreatureAI* GetAI(Creature* creature) const
{
return new boss_slad_ranAI(creature);
}
struct boss_slad_ranAI : public BossAI
{
boss_slad_ranAI(Creature* creature) : BossAI(creature, DATA_SLAD_RAN)
{
}
void Reset()
{
BossAI::Reset();
_achievement = true;
}
uint32 GetData(uint32 data) const
{
if (data == me->GetEntry())
return uint32(_achievement);
return 0;
}
void SetData(uint32 data, uint32)
{
if (data == me->GetEntry())
_achievement = false;
}
void EnterCombat(Unit* who)
{
Talk(SAY_AGGRO);
BossAI::EnterCombat(who);
events.ScheduleEvent(EVENT_POISON_NOVA, 10000);
events.ScheduleEvent(EVENT_POWERFULL_BITE, 3000);
events.ScheduleEvent(EVENT_VENOM_BOLT, 15000);
events.ScheduleEvent(EVENT_CHECK_HEALTH1, 1000);
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
}
void JustDied(Unit* killer)
{
Talk(SAY_DEATH);
Talk(EMOTE_ALTAR);
BossAI::JustDied(killer);
}
void KilledUnit(Unit*)
{
if (events.GetNextEventTime(EVENT_KILL_TALK) == 0)
{
Talk(SAY_SLAY);
events.ScheduleEvent(EVENT_KILL_TALK, 6000);
}
}
void JustSummoned(Creature* summon)
{
summon->SetInCombatWithZone();
summons.Summon(summon);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.ExecuteEvent())
{
case EVENT_CHECK_HEALTH1:
if (me->HealthBelowPct(70))
{
Talk(SAY_SUMMON_SNAKES);
events.ScheduleEvent(EVENT_SUMMON1, 1000);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH1, 1000);
break;
case EVENT_CHECK_HEALTH2:
if (me->HealthBelowPct(50))
{
Talk(SAY_SUMMON_CONSTRICTORS);
events.ScheduleEvent(EVENT_SUMMON2, 1000);
break;
}
events.ScheduleEvent(EVENT_CHECK_HEALTH2, 1000);
break;
case EVENT_POISON_NOVA:
Talk(EMOTE_NOVA);
me->CastSpell(me, SPELL_POISON_NOVA, false);
events.ScheduleEvent(EVENT_POISON_NOVA, 15000);
break;
case EVENT_POWERFULL_BITE:
me->CastSpell(me->GetVictim(), SPELL_POWERFULL_BITE, false);
events.ScheduleEvent(EVENT_POWERFULL_BITE, 10000);
break;
case EVENT_VENOM_BOLT:
me->CastSpell(me->GetVictim(), SPELL_VENOM_BOLT, false);
events.ScheduleEvent(EVENT_VENOM_BOLT, 10000);
break;
case EVENT_SUMMON1:
for (uint8 i = MAX_CONSTRICTOR; i < MAX_SUMMONS; ++i)
me->SummonCreature(NPC_SLADRAN_VIPER, SpawnLoc[i], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 20*IN_MILLISECONDS);
events.ScheduleEvent(EVENT_SUMMON1, 8000);
break;
case EVENT_SUMMON2:
for (uint8 i = 0; i < MAX_CONSTRICTOR; ++i)
me->SummonCreature(NPC_SLADRAN_CONSTRICTORS, SpawnLoc[i], TEMPSUMMON_CORPSE_TIMED_DESPAWN, 20*IN_MILLISECONDS);
events.ScheduleEvent(EVENT_SUMMON2, urand(3000, 5000));
break;
}
DoMeleeAttackIfReady();
}
private:
bool _achievement;
};
};
class spell_sladran_grip_of_sladran : public SpellScriptLoader
{
public:
spell_sladran_grip_of_sladran() : SpellScriptLoader("spell_sladran_grip_of_sladran") { }
class spell_sladran_grip_of_sladran_AuraScript : public AuraScript
{
PrepareAuraScript(spell_sladran_grip_of_sladran_AuraScript);
void HandlePeriodic(AuraEffect const* aurEff)
{
PreventDefaultAction();
if (GetStackAmount() >= 5)
{
SetDuration(0);
GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SNAKE_WRAP, true);
}
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_sladran_grip_of_sladran_AuraScript::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
};
AuraScript* GetAuraScript() const
{
return new spell_sladran_grip_of_sladran_AuraScript();
}
};
class achievement_snakes_whyd_it_have_to_be_snakes : public AchievementCriteriaScript
{
public:
achievement_snakes_whyd_it_have_to_be_snakes() : AchievementCriteriaScript("achievement_snakes_whyd_it_have_to_be_snakes")
{
}
bool OnCheck(Player* /*player*/, Unit* target)
{
if (!target)
return false;
return target->GetAI()->GetData(target->GetEntry());
}
};
void AddSC_boss_slad_ran()
{
new boss_slad_ran();
new spell_sladran_grip_of_sladran();
new achievement_snakes_whyd_it_have_to_be_snakes();
}

44
src/server/scripts/Northrend/Gundrak/gundrak.h
View File

@@ -1,44 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#ifndef DEF_GUNDRAK_H
#define DEF_GUNDRAK_H
enum Data
{
DATA_SLAD_RAN = 0,
DATA_MOORABI = 1,
DATA_DRAKKARI_COLOSSUS = 2,
DATA_GAL_DARAH = 3,
DATA_ECK_THE_FEROCIOUS_INIT = 4,
DATA_ECK_THE_FEROCIOUS = 5,
MAX_ENCOUNTERS = 6
};
enum Creatures
{
NPC_ECK_THE_FEROCIOUS = 29932
};
enum GameObjects
{
GO_ALTAR_OF_SLAD_RAN = 192518,
GO_STATUE_OF_SLAD_RAN = 192564,
GO_ALTAR_OF_DRAKKARI = 192520,
GO_STATUE_OF_DRAKKARI = 192567,
GO_ALTAR_OF_MOORABI = 192519,
GO_STATUE_OF_MOORABI = 192565,
GO_STATUE_OF_GAL_DARAH = 192566,
GO_GUNDRAK_BRIDGE = 193188,
GO_GUNDRAK_COLLISION = 192633,
GO_ECK_DOORS = 192632,
GO_ECK_UNDERWATER_GATE = 192569,
GO_GAL_DARAH_DOORS0 = 192568,
GO_GAL_DARAH_DOORS1 = 193208,
GO_GAL_DARAH_DOORS2 = 193209
};
#endif

239
src/server/scripts/Northrend/Gundrak/instance_gundrak.cpp
View File

@@ -1,239 +0,0 @@
/*
REWRITTEN BY XINEF
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "gundrak.h"
DoorData const doorData[] =
{
{ GO_ECK_DOORS, DATA_MOORABI, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_ECK_UNDERWATER_GATE, DATA_ECK_THE_FEROCIOUS, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_GAL_DARAH_DOORS0, DATA_GAL_DARAH, DOOR_TYPE_ROOM, BOUNDARY_NONE },
{ GO_GAL_DARAH_DOORS1, DATA_GAL_DARAH, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ GO_GAL_DARAH_DOORS2, DATA_GAL_DARAH, DOOR_TYPE_PASSAGE, BOUNDARY_NONE },
{ 0, 0, DOOR_TYPE_ROOM, BOUNDARY_NONE }
};
class instance_gundrak : public InstanceMapScript
{
public:
instance_gundrak() : InstanceMapScript("instance_gundrak", 604) { }
InstanceScript* GetInstanceScript(InstanceMap* pMap) const
{
return new instance_gundrak_InstanceMapScript(pMap);
}
struct instance_gundrak_InstanceMapScript : public InstanceScript
{
instance_gundrak_InstanceMapScript(Map* map) : InstanceScript(map)
{
}
uint64 _sladRanAltarGUID;
uint64 _moorabiAltarGUID;
uint64 _drakkariAltarGUID;
uint64 _bridgeGUIDs[6];
uint32 _keysInCount;
uint32 _activateTimer;
void Initialize()
{
SetBossNumber(MAX_ENCOUNTERS);
LoadDoorData(doorData);
_sladRanAltarGUID = 0;
_moorabiAltarGUID = 0;
_drakkariAltarGUID = 0;
_keysInCount = 0;
_activateTimer = 0;
memset(&_bridgeGUIDs, 0, sizeof(_bridgeGUIDs));
}
void OnGameObjectCreate(GameObject* gameobject)
{
switch (gameobject->GetEntry())
{
case GO_ALTAR_OF_SLAD_RAN:
_sladRanAltarGUID = gameobject->GetGUID();
gameobject->SetGoState(GetBossState(DATA_SLAD_RAN) == DONE ? GO_STATE_ACTIVE : GO_STATE_READY);
break;
case GO_ALTAR_OF_DRAKKARI:
_drakkariAltarGUID = gameobject->GetGUID();
gameobject->SetGoState(GetBossState(DATA_DRAKKARI_COLOSSUS) == DONE ? GO_STATE_ACTIVE : GO_STATE_READY);
break;
case GO_ALTAR_OF_MOORABI:
_moorabiAltarGUID = gameobject->GetGUID();
gameobject->SetGoState(GetBossState(DATA_MOORABI) == DONE ? GO_STATE_ACTIVE : GO_STATE_READY);
break;
case GO_STATUE_OF_SLAD_RAN:
_bridgeGUIDs[0] = gameobject->GetGUID();
gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : (GetBossState(DATA_SLAD_RAN) == DONE ? GO_STATE_READY : GO_STATE_ACTIVE));
break;
case GO_STATUE_OF_DRAKKARI:
_bridgeGUIDs[1] = gameobject->GetGUID();
gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : (GetBossState(DATA_DRAKKARI_COLOSSUS) == DONE ? GO_STATE_READY : GO_STATE_ACTIVE));
break;
case GO_STATUE_OF_MOORABI:
_bridgeGUIDs[2] = gameobject->GetGUID();
gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : (GetBossState(DATA_MOORABI) == DONE ? GO_STATE_READY : GO_STATE_ACTIVE));
break;
case GO_STATUE_OF_GAL_DARAH:
_bridgeGUIDs[3] = gameobject->GetGUID();
gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : GO_STATE_READY);
break;
case GO_GUNDRAK_COLLISION:
_bridgeGUIDs[4] = gameobject->GetGUID();
gameobject->SetGoState(_keysInCount == 3 ? GO_STATE_ACTIVE_ALTERNATIVE : GO_STATE_READY);
break;
case GO_GUNDRAK_BRIDGE:
_bridgeGUIDs[5] = gameobject->GetGUID();
gameobject->SetGoState(GO_STATE_READY);
break;
case GO_ECK_DOORS:
case GO_ECK_UNDERWATER_GATE:
case GO_GAL_DARAH_DOORS0:
case GO_GAL_DARAH_DOORS1:
case GO_GAL_DARAH_DOORS2:
AddDoor(gameobject, true);
break;
}
}
void OnGameObjectRemove(GameObject* gameobject)
{
switch (gameobject->GetEntry())
{
case GO_ECK_DOORS:
case GO_ECK_UNDERWATER_GATE:
case GO_GAL_DARAH_DOORS0:
case GO_GAL_DARAH_DOORS1:
case GO_GAL_DARAH_DOORS2:
AddDoor(gameobject, false);
break;
}
}
void SetData(uint32 type, uint32)
{
switch (type)
{
case NPC_ECK_THE_FEROCIOUS:
if (GetBossState(DATA_ECK_THE_FEROCIOUS_INIT) != DONE)
{
SetBossState(DATA_ECK_THE_FEROCIOUS_INIT, NOT_STARTED);
SetBossState(DATA_ECK_THE_FEROCIOUS_INIT, DONE);
}
break;
case GO_ALTAR_OF_SLAD_RAN:
if (GameObject* statue = instance->GetGameObject(_bridgeGUIDs[0]))
statue->SetGoState(GO_STATE_READY);
break;
case GO_ALTAR_OF_DRAKKARI:
if (GameObject* statue = instance->GetGameObject(_bridgeGUIDs[1]))
statue->SetGoState(GO_STATE_READY);
break;
case GO_ALTAR_OF_MOORABI:
if (GameObject* statue = instance->GetGameObject(_bridgeGUIDs[2]))
statue->SetGoState(GO_STATE_READY);
break;
}
if (type >= GO_ALTAR_OF_SLAD_RAN)
{
for (uint8 i = 0; i < 3; ++i)
if (GameObject* statue = instance->GetGameObject(_bridgeGUIDs[i]))
if (statue->GetGoState() != GO_STATE_READY)
return;
_activateTimer = 1;
}
}
bool SetBossState(uint32 type, EncounterState state)
{
if (!InstanceScript::SetBossState(type, state))
{
if (state == DONE && (type == DATA_SLAD_RAN || type == DATA_MOORABI || type == DATA_DRAKKARI_COLOSSUS))
++_keysInCount;
return false;
}
if (state != DONE)
return true;
switch (type)
{
case DATA_SLAD_RAN:
if (GameObject* altar = instance->GetGameObject(_sladRanAltarGUID))
altar->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
break;
case DATA_MOORABI:
if (GameObject* altar = instance->GetGameObject(_moorabiAltarGUID))
altar->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
break;
case DATA_DRAKKARI_COLOSSUS:
if (GameObject* altar = instance->GetGameObject(_drakkariAltarGUID))
altar->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE);
break;
case DATA_ECK_THE_FEROCIOUS_INIT:
{
Position pos = {1624.70f, 891.43f, 95.08f, 1.2f};
if (instance->IsHeroic())
instance->SummonCreature(NPC_ECK_THE_FEROCIOUS, pos);
break;
}
}
return true;
}
std::string GetSaveData()
{
std::ostringstream saveStream;
saveStream << "G D " << GetBossSaveData();
return saveStream.str();
}
void Load(const char* in)
{
if (!in)
return;
char dataHead1, dataHead2;
std::istringstream loadStream(in);
loadStream >> dataHead1 >> dataHead2;
if (dataHead1 == 'G' && dataHead2 == 'D')
{
for (uint8 i = 0; i < MAX_ENCOUNTERS; ++i)
{
uint32 tmpState;
loadStream >> tmpState;
if (tmpState == IN_PROGRESS || tmpState > SPECIAL)
tmpState = NOT_STARTED;
SetBossState(i, EncounterState(tmpState));
}
}
}
void Update(uint32 diff)
{
if (!_activateTimer)
return;
_activateTimer += diff;
if (_activateTimer >= 5000)
{
_activateTimer = 0;
for (uint8 i = 0; i < 5; ++i)
if (GameObject* go = instance->GetGameObject(_bridgeGUIDs[i]))
go->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
}
}
};
};
void AddSC_instance_gundrak()
{
new instance_gundrak();
}