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

185
src/server/scripts/Northrend/VioletHold/boss_cyanigosa.cpp
View File

@@ -1,185 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
#include "SpellInfo.h"
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SPAWN = 3,
SAY_DISRUPTION = 4,
SAY_BREATH_ATTACK = 5,
SAY_SPECIAL_ATTACK = 6
};
enum eSpells
{
SPELL_ARCANE_VACUUM = 58694,
SPELL_BLIZZARD_N = 58693,
SPELL_BLIZZARD_H = 59369,
SPELL_MANA_DESTRUCTION = 59374,
SPELL_TAIL_SWEEP_N = 58690,
SPELL_TAIL_SWEEP_H = 59283,
SPELL_UNCONTROLLABLE_ENERGY_N = 58688,
SPELL_UNCONTROLLABLE_ENERGY_H = 59281,
};
#define SPELL_BLIZZARD DUNGEON_MODE(SPELL_BLIZZARD_N, SPELL_BLIZZARD_H)
#define SPELL_TAIL_SWEEP DUNGEON_MODE(SPELL_TAIL_SWEEP_N, SPELL_TAIL_SWEEP_H)
#define SPELL_UNCONTROLLABLE_ENERGY DUNGEON_MODE(SPELL_UNCONTROLLABLE_ENERGY_N, SPELL_UNCONTROLLABLE_ENERGY_H)
enum eEvents
{
EVENT_SPELL_ARCANE_VACUUM = 1,
EVENT_SPELL_BLIZZARD,
EVENT_SPELL_MANA_DESTRUCTION,
EVENT_SPELL_TAIL_SWEEP,
EVENT_SPELL_UNCONTROLLABLE_ENERGY,
EVENT_UNROOT,
};
class boss_cyanigosa : public CreatureScript
{
public:
boss_cyanigosa() : CreatureScript("boss_cyanigosa") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_cyanigosaAI (pCreature);
}
struct boss_cyanigosaAI : public ScriptedAI
{
boss_cyanigosaAI(Creature *c) : ScriptedAI(c)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
void Reset()
{
events.Reset();
}
void EnterCombat(Unit* /*who*/)
{
DoZoneInCombat();
Talk(SAY_AGGRO);
events.Reset();
events.RescheduleEvent(EVENT_SPELL_ARCANE_VACUUM, 30000);
events.RescheduleEvent(EVENT_SPELL_BLIZZARD, urand(5000,10000));
events.RescheduleEvent(EVENT_SPELL_TAIL_SWEEP, urand(15000,20000));
events.RescheduleEvent(EVENT_SPELL_UNCONTROLLABLE_ENERGY, urand(5000,8000));
if (IsHeroic())
events.RescheduleEvent(EVENT_SPELL_MANA_DESTRUCTION, 20000);
}
void SpellHitTarget(Unit* target, const SpellInfo* spell)
{
if (!target || !spell)
return;
switch(spell->Id)
{
case SPELL_ARCANE_VACUUM:
target->NearTeleportTo(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+10.0f, target->GetOrientation());
break;
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.GetEvent())
{
case 0:
break;
case EVENT_SPELL_ARCANE_VACUUM:
me->CastSpell((Unit*)NULL, SPELL_ARCANE_VACUUM, false);
DoResetThreat();
me->SetControlled(true, UNIT_STATE_ROOT);
me->setAttackTimer(BASE_ATTACK, 3000);
events.RepeatEvent(30000);
events.ScheduleEvent(EVENT_UNROOT, 3000);
break;
case EVENT_UNROOT:
me->SetControlled(false, UNIT_STATE_ROOT);
events.PopEvent();
break;
case EVENT_SPELL_BLIZZARD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 45.0f, true))
me->CastSpell(target, SPELL_BLIZZARD, false);
events.RepeatEvent(15000);
break;
case EVENT_SPELL_MANA_DESTRUCTION:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true))
me->CastSpell(target, SPELL_MANA_DESTRUCTION, false);
events.RepeatEvent(20000);
break;
case EVENT_SPELL_TAIL_SWEEP:
me->CastSpell(me->GetVictim(), SPELL_TAIL_SWEEP, false);
events.RepeatEvent(urand(15000,20000));
break;
case EVENT_SPELL_UNCONTROLLABLE_ENERGY:
me->CastSpell(me->GetVictim(), SPELL_UNCONTROLLABLE_ENERGY, false);
events.RepeatEvent(urand(20000,25000));
break;
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DEATH);
if (pInstance)
pInstance->SetData(DATA_BOSS_DIED, 0);
float h = me->GetMap()->GetHeight(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ()+2.0f);
if (h != INVALID_HEIGHT && me->GetPositionZ()-h > 3.0f)
{
me->UpdatePosition(me->GetPositionX(), me->GetPositionY(), h, me->GetOrientation(), true); // move to ground
me->StopMovingOnCurrentPos();
me->DestroyForNearbyPlayers();
}
}
void KilledUnit(Unit* victim)
{
if (victim && victim->GetGUID() == me->GetGUID())
return;
Talk(SAY_SLAY);
}
void MoveInLineOfSight(Unit* /*who*/) {}
void EnterEvadeMode()
{
me->SetControlled(false, UNIT_STATE_ROOT);
ScriptedAI::EnterEvadeMode();
events.Reset();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (pInstance)
pInstance->SetData(DATA_FAILED, 1);
}
};
};
void AddSC_boss_cyanigosa()
{
new boss_cyanigosa();
}

301
src/server/scripts/Northrend/VioletHold/boss_erekem.cpp
View File

@@ -1,301 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
enum eSpells
{
SPELL_BLOODLUST = 54516,
SPELL_BREAK_BONDS = 59463,
SPELL_CHAIN_HEAL_N = 54481,
SPELL_CHAIN_HEAL_H = 59473,
SPELL_EARTH_SHIELD_N = 54479,
SPELL_EARTH_SHIELD_H = 59471,
//SPELL_EARTH_SHIELD_TRIGGERED_N = 54480,
//SPELL_EARTH_SHIELD_TRIGGERED_H = 59472,
SPELL_EARTH_SHOCK = 54511,
SPELL_LIGHTNING_BOLT = 53044,
SPELL_STORMSTRIKE = 51876,
};
#define SPELL_CHAIN_HEAL DUNGEON_MODE(SPELL_CHAIN_HEAL_N, SPELL_CHAIN_HEAL_H)
#define SPELL_EARTH_SHIELD DUNGEON_MODE(SPELL_EARTH_SHIELD_N, SPELL_EARTH_SHIELD_H)
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SPAWN = 3,
SAY_ADD_KILLED = 4,
SAY_BOTH_ADDS_KILLED = 5
};
enum eEvents
{
EVENT_SPELL_BLOODLUST = 1,
EVENT_SPELL_BREAK_BONDS,
EVENT_SPELL_CHAIN_HEAL,
EVENT_SPELL_EARTH_SHIELD,
EVENT_SPELL_EARTH_SHOCK,
EVENT_SPELL_LIGHTNING_BOLT,
EVENT_SPELL_STORMSTRIKE,
};
class boss_erekem : public CreatureScript
{
public:
boss_erekem() : CreatureScript("boss_erekem") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_erekemAI (pCreature);
}
struct boss_erekemAI : public ScriptedAI
{
boss_erekemAI(Creature *c) : ScriptedAI(c)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
void Reset()
{
events.Reset();
}
void EnterCombat(Unit* who)
{
DoZoneInCombat();
Talk(SAY_AGGRO);
DoCast(me, SPELL_EARTH_SHIELD);
events.Reset();
events.RescheduleEvent(EVENT_SPELL_BLOODLUST, 15000);
events.RescheduleEvent(EVENT_SPELL_BREAK_BONDS, urand(9000,14000));
events.RescheduleEvent(EVENT_SPELL_CHAIN_HEAL, 0);
events.RescheduleEvent(EVENT_SPELL_EARTH_SHIELD, 20000);
events.RescheduleEvent(EVENT_SPELL_EARTH_SHOCK, urand(2000,8000));
events.RescheduleEvent(EVENT_SPELL_LIGHTNING_BOLT, urand(5000,10000));
if (IsHeroic())
events.RescheduleEvent(EVENT_SPELL_STORMSTRIKE, 3000);
if (Creature* c = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_1_GUID)))
if (!c->IsInCombat())
c->AI()->AttackStart(who);
if (Creature* c = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_2_GUID)))
if (!c->IsInCombat())
c->AI()->AttackStart(who);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.GetEvent())
{
case 0:
break;
case EVENT_SPELL_BLOODLUST:
me->CastSpell((Unit*)NULL, SPELL_BLOODLUST, false);
events.RepeatEvent(urand(35000,45000));
break;
case EVENT_SPELL_BREAK_BONDS:
me->CastSpell((Unit*)NULL, SPELL_BREAK_BONDS, false);
events.RepeatEvent(urand(16000,22000));
break;
case EVENT_SPELL_CHAIN_HEAL:
if (uint64 TargetGUID = GetChainHealTargetGUID())
if (pInstance)
{
if (Creature* target = pInstance->instance->GetCreature(TargetGUID))
me->CastSpell(target, SPELL_CHAIN_HEAL, false);
Creature *pGuard1 = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_1_GUID));
Creature *pGuard2 = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_2_GUID));
if (pGuard1 && !pGuard1->IsAlive() || pGuard2 && !pGuard2->IsAlive())
{
events.RepeatEvent(urand(3000,6000));
break;
}
}
events.RepeatEvent(urand(8000,11000));
break;
case EVENT_SPELL_EARTH_SHIELD:
me->CastSpell(me, SPELL_EARTH_SHIELD, false);
events.RepeatEvent(20000);
break;
case EVENT_SPELL_EARTH_SHOCK:
me->CastSpell(me->GetVictim(), SPELL_EARTH_SHOCK, false);
events.RepeatEvent(urand(8000,13000));
break;
case EVENT_SPELL_LIGHTNING_BOLT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 35.0f, true))
me->CastSpell(target, SPELL_LIGHTNING_BOLT, false);
events.RepeatEvent(urand(15000,25000));
break;
case EVENT_SPELL_STORMSTRIKE:
{
Creature *pGuard1 = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_1_GUID));
Creature *pGuard2 = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_2_GUID));
if (pGuard1 && !pGuard1->IsAlive() && pGuard2 && !pGuard2->IsAlive()) // both dead
me->CastSpell(me->GetVictim(), SPELL_STORMSTRIKE, false);
events.RepeatEvent(3000);
}
break;
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DEATH);
if (pInstance)
pInstance->SetData(DATA_BOSS_DIED, 0);
}
void KilledUnit(Unit* victim)
{
if (victim && victim->GetGUID() == me->GetGUID())
return;
Talk(SAY_SLAY);
}
void MoveInLineOfSight(Unit* /*who*/) {}
void EnterEvadeMode()
{
ScriptedAI::EnterEvadeMode();
events.Reset();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (pInstance)
pInstance->SetData(DATA_FAILED, 1);
}
uint64 GetChainHealTargetGUID()
{
if (HealthBelowPct(85))
return me->GetGUID();
if (pInstance)
{
if (Creature* c = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_1_GUID)))
if (c->IsAlive() && !c->HealthAbovePct(75))
return c->GetGUID();
if (Creature* c = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUARD_2_GUID)))
if (c->IsAlive() && !c->HealthAbovePct(75))
return c->GetGUID();
}
return me->GetGUID();
}
};
};
enum GuardSpells
{
SPELL_GUSHING_WOUND = 39215,
SPELL_HOWLING_SCREECH = 54462,
SPELL_STRIKE = 14516
};
enum eGuardEvents
{
EVENT_SPELL_GUSHING_WOUND = 1,
EVENT_SPELL_HOWLING_SCREECH,
EVENT_SPELL_STRIKE
};
class npc_erekem_guard : public CreatureScript
{
public:
npc_erekem_guard() : CreatureScript("npc_erekem_guard") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new npc_erekem_guardAI (pCreature);
}
struct npc_erekem_guardAI : public ScriptedAI
{
npc_erekem_guardAI(Creature *c) : ScriptedAI(c)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
void Reset()
{
events.Reset();
}
void EnterCombat(Unit* who)
{
DoZoneInCombat();
events.Reset();
events.RescheduleEvent(EVENT_SPELL_GUSHING_WOUND, urand(1000,3000));
events.RescheduleEvent(EVENT_SPELL_HOWLING_SCREECH, urand(8000, 13000));
events.RescheduleEvent(EVENT_SPELL_STRIKE, urand(4000, 8000));
if (Creature* c = pInstance->instance->GetCreature(pInstance->GetData64(DATA_EREKEM_GUID)))
if (!c->IsInCombat())
c->AI()->AttackStart(who);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.GetEvent())
{
case 0:
break;
case EVENT_SPELL_GUSHING_WOUND:
me->CastSpell(me->GetVictim(), SPELL_GUSHING_WOUND, false);
events.RepeatEvent(urand(7000,12000));
break;
case EVENT_SPELL_HOWLING_SCREECH:
me->CastSpell(me->GetVictim(), SPELL_HOWLING_SCREECH, false);
events.RepeatEvent(urand(8000,13000));
break;
case EVENT_SPELL_STRIKE:
me->CastSpell(me->GetVictim(), SPELL_STRIKE, false);
events.RepeatEvent(urand(4000,8000));
break;
}
DoMeleeAttackIfReady();
}
void MoveInLineOfSight(Unit* /*who*/) {}
};
};
void AddSC_boss_erekem()
{
new boss_erekem();
new npc_erekem_guard();
}

359
src/server/scripts/Northrend/VioletHold/boss_ichoron.cpp
View File

@@ -1,359 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
#include "Player.h"
#include "SpellInfo.h"
#define ACTION_WATER_ELEMENT_HIT 1
#define ACTION_WATER_ELEMENT_KILLED 2
#define MAX_SPAWN_LOC 5
static Position SpawnLoc[MAX_SPAWN_LOC]=
{
{1840.64f, 795.407f, 44.079f, 1.676f},
{1886.24f, 757.733f, 47.750f, 5.201f},
{1877.91f, 845.915f, 43.417f, 3.560f},
{1918.97f, 850.645f, 47.225f, 4.136f},
{1935.50f, 796.224f, 52.492f, 4.224f},
};
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SPAWN = 3,
SAY_ENRAGE = 4,
SAY_SHATTER = 5,
SAY_BUBBLE = 6
};
enum eCreatures
{
NPC_ICHOR_GLOBULE = 29321,
};
enum eSpells
{
SPELL_DRAINED = 59820,
SPELL_FRENZY_N = 54312,
SPELL_FRENZY_H = 59522,
SPELL_PROTECTIVE_BUBBLE = 54306,
SPELL_WATER_BLAST_N = 54237,
SPELL_WATER_BLAST_H = 59520,
SPELL_WATER_BOLT_VOLLEY_N = 54241,
SPELL_WATER_BOLT_VOLLEY_H = 59521,
SPELL_SPLASH = 59516, // casted by globule upon death
SPELL_WATER_GLOBULE = 54268, // casted when hit by visual
SPELL_CREATE_GLOBULE_VISUAL = 54260, // tar 25
};
#define SPELL_WATER_BLAST DUNGEON_MODE(SPELL_WATER_BLAST_N, SPELL_WATER_BLAST_H)
#define SPELL_WATER_BOLT_VOLLEY DUNGEON_MODE(SPELL_WATER_BOLT_VOLLEY_N, SPELL_WATER_BOLT_VOLLEY_H)
#define SPELL_FRENZY DUNGEON_MODE(SPELL_FRENZY_N, SPELL_FRENZY_H)
enum eEvents
{
EVENT_SPELL_WATER_BOLT_VOLLEY = 1,
};
class boss_ichoron : public CreatureScript
{
public:
boss_ichoron() : CreatureScript("boss_ichoron") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_ichoronAI (pCreature);
}
struct boss_ichoronAI : public ScriptedAI
{
boss_ichoronAI(Creature *c) : ScriptedAI(c), globules(me)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
SummonList globules;
bool bIsExploded;
bool bIsFrenzy;
uint32 uiWaterBoltVolleyTimer;
uint32 uiDrainedTimer;
void Reset()
{
globules.DespawnAll();
bIsExploded = false;
bIsFrenzy = false;
uiDrainedTimer = 15000;
uiWaterBoltVolleyTimer = urand(7000,12000);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(me->GetNativeDisplayId());
}
void DoAction(int32 param)
{
if (!me->IsAlive())
return;
switch(param)
{
case ACTION_WATER_ELEMENT_HIT:
if (pInstance)
pInstance->SetData(DATA_ACHIEV, 0);
me->ModifyHealth(int32(me->CountPctFromMaxHealth(1)));
if (bIsExploded)
DoExplodeCompleted();
break;
case ACTION_WATER_ELEMENT_KILLED:
uint32 damage = me->CountPctFromMaxHealth(3);
damage = std::min(damage, me->GetHealth()-1);
me->ModifyHealth(-int32(damage));
me->LowerPlayerDamageReq(damage);
break;
}
}
void DoExplodeCompleted()
{
bIsExploded = false;
me->RemoveAura(SPELL_DRAINED);
if (!HealthBelowPct(25))
{
Talk(SAY_BUBBLE);
me->CastSpell(me, SPELL_PROTECTIVE_BUBBLE, true);
}
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(me->GetNativeDisplayId());
}
void IchoronDoCastToAllHostilePlayers(uint32 spellId, bool triggered)
{
Map::PlayerList const &PlayerList = me->GetMap()->GetPlayers();
if (PlayerList.isEmpty())
return;
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player *plr = i->GetSource())
me->CastSpell(plr, spellId, triggered);
}
void EnterCombat(Unit* /*who*/)
{
bIsExploded = false;
bIsFrenzy = false;
uiDrainedTimer = 15000;
uiWaterBoltVolleyTimer = urand(7000,12000);
DoZoneInCombat();
Talk(SAY_AGGRO);
me->CastSpell(me, SPELL_PROTECTIVE_BUBBLE, true);
if (pInstance)
pInstance->SetData(DATA_ACHIEV, 1);
}
void UpdateAI(uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (!bIsFrenzy && !bIsExploded && HealthBelowPct(25))
{
Talk(SAY_ENRAGE);
me->CastSpell(me, SPELL_FRENZY, true);
bIsFrenzy = true;
}
if (!bIsFrenzy)
{
if (!bIsExploded)
{
if (!me->HasAura(SPELL_PROTECTIVE_BUBBLE))
{
me->InterruptNonMeleeSpells(false);
Talk(SAY_SHATTER);
DoZoneInCombat();
IchoronDoCastToAllHostilePlayers(SPELL_WATER_BLAST, true);
me->CastSpell(me, SPELL_DRAINED, true);
bIsExploded = true;
uiDrainedTimer = 15000;
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(11686);
for (uint8 i=0; i<MAX_SPAWN_LOC; ++i)
{
float angle = rand_norm()*2*M_PI;
Position p1(SpawnLoc[i]), p2(SpawnLoc[i]);
p1.m_positionX += 2.5f*cos(angle);
p1.m_positionY += 2.5f*sin(angle);
p2.m_positionX -= 2.5f*cos(angle);
p2.m_positionY -= 2.5f*sin(angle);
DoSummon(NPC_ICHOR_GLOBULE, p1, 60000, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN);
DoSummon(NPC_ICHOR_GLOBULE, p2, 60000, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN);
}
}
}
else
{
if (uiDrainedTimer <= uiDiff)
DoExplodeCompleted();
else
{
uiDrainedTimer -= uiDiff;
bool bIsWaterElementsAlive = false;
if (!globules.empty())
{
for (std::list<uint64>::const_iterator itr = globules.begin(); itr != globules.end(); ++itr)
if (Creature* pTemp = ObjectAccessor::GetCreature(*me, *itr))
if (pTemp->IsAlive())
{
bIsWaterElementsAlive = true;
break;
}
}
if (!bIsWaterElementsAlive)
DoExplodeCompleted();
}
}
}
if (!bIsExploded)
{
if (uiWaterBoltVolleyTimer <= uiDiff)
{
me->CastSpell((Unit*)NULL, SPELL_WATER_BOLT_VOLLEY, false);
uiWaterBoltVolleyTimer = urand(10000, 15000);
}
else uiWaterBoltVolleyTimer -= uiDiff;
}
DoMeleeAttackIfReady();
}
void JustSummoned(Creature* pSummoned)
{
if (pSummoned)
{
pSummoned->SetSpeed(MOVE_RUN, 0.3f);
pSummoned->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
pSummoned->GetMotionMaster()->MoveFollow(me, 0, 0);
me->CastSpell(pSummoned, SPELL_CREATE_GLOBULE_VISUAL, true); // triggered should ignore los
globules.Summon(pSummoned);
if (pInstance)
pInstance->SetData64(DATA_ADD_TRASH_MOB, pSummoned->GetGUID());
}
}
void SummonedCreatureDespawn(Creature *pSummoned)
{
if (pSummoned)
{
globules.Despawn(pSummoned);
if (pInstance)
pInstance->SetData64(DATA_DELETE_TRASH_MOB, pSummoned->GetGUID());
}
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DEATH);
bIsExploded = false;
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(me->GetNativeDisplayId());
globules.DespawnAll();
if (pInstance)
pInstance->SetData(DATA_BOSS_DIED, 0);
}
void KilledUnit(Unit * victim)
{
if (victim && victim->GetGUID() == me->GetGUID())
return;
Talk(SAY_SLAY);
}
void MoveInLineOfSight(Unit* /*who*/) {}
void EnterEvadeMode()
{
ScriptedAI::EnterEvadeMode();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (pInstance)
pInstance->SetData(DATA_FAILED, 1);
}
};
};
class npc_ichor_globule : public CreatureScript
{
public:
npc_ichor_globule() : CreatureScript("npc_ichor_globule") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new npc_ichor_globuleAI (pCreature);
}
struct npc_ichor_globuleAI : public ScriptedAI
{
npc_ichor_globuleAI(Creature *c) : ScriptedAI(c)
{
pInstance = c->GetInstanceScript();
uiRangeCheck_Timer = 1000;
}
InstanceScript* pInstance;
uint32 uiRangeCheck_Timer;
void SpellHit(Unit* caster, const SpellInfo* spell)
{
if (spell->Id == SPELL_CREATE_GLOBULE_VISUAL)
me->CastSpell(me, SPELL_WATER_GLOBULE, true);
}
void UpdateAI(uint32 uiDiff)
{
if (uiRangeCheck_Timer < uiDiff)
{
if (pInstance)
if (Creature* pIchoron = pInstance->instance->GetCreature(pInstance->GetData64(DATA_ICHORON_GUID)))
if (me->IsWithinDist(pIchoron, 2.0f , false))
{
if (pIchoron->AI())
pIchoron->AI()->DoAction(ACTION_WATER_ELEMENT_HIT);
me->DespawnOrUnsummon();
}
uiRangeCheck_Timer = 1000;
}
else uiRangeCheck_Timer -= uiDiff;
}
void JustDied(Unit* /*killer*/)
{
me->CastSpell(me, SPELL_SPLASH, true);
if (pInstance)
if (Creature* pIchoron = pInstance->instance->GetCreature(pInstance->GetData64(DATA_ICHORON_GUID)))
if (pIchoron->AI())
pIchoron->AI()->DoAction(ACTION_WATER_ELEMENT_KILLED);
me->DespawnOrUnsummon(2500);
}
void AttackStart(Unit* /*who*/) {}
void MoveInLineOfSight(Unit* /*who*/) {}
};
};
void AddSC_boss_ichoron()
{
new boss_ichoron();
new npc_ichor_globule();
}

124
src/server/scripts/Northrend/VioletHold/boss_lavanthor.cpp
View File

@@ -1,124 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
enum eSpells
{
SPELL_CAUTERIZING_FLAMES = 59466,
SPELL_FIREBOLT_N = 54235,
SPELL_FIREBOLT_H = 59468,
SPELL_FLAME_BREATH_N = 54282,
SPELL_FLAME_BREATH_H = 59469,
SPELL_LAVA_BURN_N = 54249,
SPELL_LAVA_BURN_H = 59594,
};
#define SPELL_FIREBOLT DUNGEON_MODE(SPELL_FIREBOLT_N, SPELL_FIREBOLT_H)
#define SPELL_FLAME_BREATH DUNGEON_MODE(SPELL_FLAME_BREATH_N, SPELL_FLAME_BREATH_H)
#define SPELL_LAVA_BURN DUNGEON_MODE(SPELL_LAVA_BURN_N, SPELL_LAVA_BURN_H)
enum eEvents
{
EVENT_SPELL_FIREBOLT = 1,
EVENT_SPELL_FLAME_BREATH,
EVENT_SPELL_LAVA_BURN,
EVENT_SPELL_CAUTERIZING_FLAMES,
};
class boss_lavanthor : public CreatureScript
{
public:
boss_lavanthor() : CreatureScript("boss_lavanthor") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_lavanthorAI (pCreature);
}
struct boss_lavanthorAI : public ScriptedAI
{
boss_lavanthorAI(Creature *c) : ScriptedAI(c)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
void Reset()
{
events.Reset();
}
void EnterCombat(Unit* /*who*/)
{
DoZoneInCombat();
events.Reset();
events.RescheduleEvent(EVENT_SPELL_FIREBOLT, 1000);
events.RescheduleEvent(EVENT_SPELL_FLAME_BREATH, 5000);
events.RescheduleEvent(EVENT_SPELL_LAVA_BURN, 10000);
if (IsHeroic())
events.RescheduleEvent(EVENT_SPELL_CAUTERIZING_FLAMES, 3000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.GetEvent())
{
case 0:
break;
case EVENT_SPELL_FIREBOLT:
me->CastSpell(me->GetVictim(), SPELL_FIREBOLT, false);
events.RepeatEvent(urand(5000,13000));
break;
case EVENT_SPELL_FLAME_BREATH:
me->CastSpell(me->GetVictim(), SPELL_FLAME_BREATH, false);
events.RepeatEvent(urand(10000,15000));
break;
case EVENT_SPELL_LAVA_BURN:
me->CastSpell(me->GetVictim(), SPELL_LAVA_BURN, false);
events.RepeatEvent(urand(14000,20000));
break;
case EVENT_SPELL_CAUTERIZING_FLAMES:
me->CastSpell((Unit*)NULL, SPELL_FLAME_BREATH, false);
events.RepeatEvent(urand(10000,16000));
break;
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/)
{
if (pInstance)
pInstance->SetData(DATA_BOSS_DIED, 0);
}
void MoveInLineOfSight(Unit* /*who*/) {}
void EnterEvadeMode()
{
ScriptedAI::EnterEvadeMode();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (pInstance)
pInstance->SetData(DATA_FAILED, 1);
}
};
};
void AddSC_boss_lavanthor()
{
new boss_lavanthor();
}

154
src/server/scripts/Northrend/VioletHold/boss_moragg.cpp
View File

@@ -1,154 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
#include "SpellScript.h"
#include "SpellAuraEffects.h"
enum eSpells
{
SPELL_RAY_OF_SUFFERING_N = 54442,
SPELL_RAY_OF_SUFFERING_H = 59524,
//SPELL_RAY_OF_SUFFERING_TRIGGERED = 54417,
SPELL_RAY_OF_PAIN_N = 54438,
SPELL_RAY_OF_PAIN_H = 59523,
//SPELL_RAY_OF_PAIN_TRIGGERED_N = 54416,
//SPELL_RAY_OF_PAIN_TRIGGERED_H = 59525,
SPELL_CORROSIVE_SALIVA = 54527,
SPELL_OPTIC_LINK = 54396,
};
#define SPELL_RAY_OF_SUFFERING DUNGEON_MODE(SPELL_RAY_OF_SUFFERING_N, SPELL_RAY_OF_SUFFERING_H)
#define SPELL_RAY_OF_PAIN DUNGEON_MODE(SPELL_RAY_OF_PAIN_N, SPELL_RAY_OF_PAIN_H)
enum eEvents
{
EVENT_SPELL_CORROSIVE_SALIVA = 1,
EVENT_SPELL_OPTIC_LINK,
};
class boss_moragg : public CreatureScript
{
public:
boss_moragg() : CreatureScript("boss_moragg") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_moraggAI (pCreature);
}
struct boss_moraggAI : public ScriptedAI
{
boss_moraggAI(Creature *c) : ScriptedAI(c)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
void Reset()
{
events.Reset();
}
void EnterCombat(Unit* /*who*/)
{
DoZoneInCombat();
me->CastSpell(me, SPELL_RAY_OF_SUFFERING, true);
me->CastSpell(me, SPELL_RAY_OF_PAIN, true);
events.Reset();
events.RescheduleEvent(EVENT_SPELL_CORROSIVE_SALIVA, urand(4000,6000));
events.RescheduleEvent(EVENT_SPELL_OPTIC_LINK, urand(10000,11000));
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.GetEvent())
{
case 0:
break;
case EVENT_SPELL_CORROSIVE_SALIVA:
me->CastSpell(me->GetVictim(), SPELL_CORROSIVE_SALIVA, false);
events.RepeatEvent(urand(8000,10000));
break;
case EVENT_SPELL_OPTIC_LINK:
if (Unit* target = SelectTarget(SELECT_TARGET_FARTHEST, 0, 40.0f, true))
{
me->CastSpell(target, SPELL_OPTIC_LINK, false);
events.RepeatEvent(urand(18000,21000));
}
else
events.RepeatEvent(5000);
break;
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/)
{
if (pInstance)
pInstance->SetData(DATA_BOSS_DIED, 0);
}
void MoveInLineOfSight(Unit* /*who*/) {}
void EnterEvadeMode()
{
ScriptedAI::EnterEvadeMode();
events.Reset();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (pInstance)
pInstance->SetData(DATA_FAILED, 1);
}
};
};
class spell_optic_link : public SpellScriptLoader
{
public:
spell_optic_link() : SpellScriptLoader("spell_optic_link") { }
class spell_optic_linkAuraScript : public AuraScript
{
PrepareAuraScript(spell_optic_linkAuraScript)
void HandleEffectPeriodic(AuraEffect const * aurEff)
{
if (Unit* target = GetTarget())
if (Unit* caster = GetCaster())
if (GetAura() && GetAura()->GetEffect(0))
GetAura()->GetEffect(0)->SetAmount(aurEff->GetSpellInfo()->Effects[EFFECT_0].BasePoints+(((int32)target->GetExactDist(caster))*25)+(aurEff->GetTickNumber()*100));
}
void Register()
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_optic_linkAuraScript::HandleEffectPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE);
}
};
AuraScript *GetAuraScript() const
{
return new spell_optic_linkAuraScript();
}
};
void AddSC_boss_moragg()
{
new boss_moragg();
new spell_optic_link();
}

204
src/server/scripts/Northrend/VioletHold/boss_xevozz.cpp
View File

@@ -1,204 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SPAWN = 3,
SAY_CHARGED = 4,
SAY_REPEAT_SUMMON = 5,
SAY_SUMMON_ENERGY = 6
};
enum eSpells
{
SPELL_ARCANE_BARRAGE_VOLLEY_N = 54202,
SPELL_ARCANE_BARRAGE_VOLLEY_H = 59483,
SPELL_ARCANE_BUFFET_N = 54226,
SPELL_ARCANE_BUFFET_H = 59485,
SPELL_SUMMON_ETHEREAL_SPHERE_1 = 54102,
SPELL_SUMMON_ETHEREAL_SPHERE_2 = 54137,
SPELL_SUMMON_ETHEREAL_SPHERE_3 = 54138,
SPELL_ARCANE_POWER_N = 54160,
SPELL_ARCANE_POWER_H = 59474,
//SPELL_SUMMON_PLAYERS = 54164, // not used
//SPELL_POWER_BALL_VISUAL = 54141,
};
#define SPELL_ARCANE_BARRAGE_VOLLEY DUNGEON_MODE(SPELL_ARCANE_BARRAGE_VOLLEY_N, SPELL_ARCANE_BARRAGE_VOLLEY_H)
#define SPELL_ARCANE_BUFFET DUNGEON_MODE(SPELL_ARCANE_BUFFET_N, SPELL_ARCANE_BUFFET_H)
#define SPELL_ARCANE_POWER DUNGEON_MODE(SPELL_ARCANE_POWER_N, SPELL_ARCANE_POWER_H)
enum eEvents
{
EVENT_SPELL_ARCANE_BARRAGE_VOLLEY = 1,
EVENT_SPELL_ARCANE_BUFFET,
EVENT_SUMMON_SPHERES,
EVENT_CHECK_DISTANCE,
};
class boss_xevozz : public CreatureScript
{
public:
boss_xevozz() : CreatureScript("boss_xevozz") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_xevozzAI (pCreature);
}
struct boss_xevozzAI : public ScriptedAI
{
boss_xevozzAI(Creature *c) : ScriptedAI(c), spheres(me)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
SummonList spheres;
void Reset()
{
events.Reset();
spheres.DespawnAll();
}
void EnterCombat(Unit* /*who*/)
{
Talk(SAY_AGGRO);
DoZoneInCombat();
events.Reset();
events.RescheduleEvent(EVENT_SPELL_ARCANE_BARRAGE_VOLLEY, urand(16000,20000));
events.RescheduleEvent(EVENT_SUMMON_SPHERES, 10000);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.GetEvent())
{
case 0:
break;
case EVENT_SPELL_ARCANE_BARRAGE_VOLLEY:
me->CastSpell((Unit*)NULL, SPELL_ARCANE_BARRAGE_VOLLEY, false);
events.RepeatEvent(20000);
break;
case EVENT_SPELL_ARCANE_BUFFET:
me->CastSpell(me->GetVictim(), SPELL_ARCANE_BUFFET, false);
events.PopEvent();
break;
case EVENT_SUMMON_SPHERES:
{
Talk(SAY_SUMMON_ENERGY);
spheres.DespawnAll();
uint32 entry1 = RAND(SPELL_SUMMON_ETHEREAL_SPHERE_1, SPELL_SUMMON_ETHEREAL_SPHERE_2, SPELL_SUMMON_ETHEREAL_SPHERE_3);
me->CastSpell((Unit*)NULL, entry1, true);
if (IsHeroic())
{
uint32 entry2;
do { entry2 = RAND(SPELL_SUMMON_ETHEREAL_SPHERE_1, SPELL_SUMMON_ETHEREAL_SPHERE_2, SPELL_SUMMON_ETHEREAL_SPHERE_3); } while (entry1 == entry2);
me->CastSpell((Unit*)NULL, entry2, true);
}
events.RepeatEvent(45000);
events.RescheduleEvent(EVENT_SPELL_ARCANE_BUFFET, 5000);
events.RescheduleEvent(EVENT_CHECK_DISTANCE, 6000);
}
break;
case EVENT_CHECK_DISTANCE:
{
bool found = false;
if (pInstance)
for (std::list<uint64>::iterator itr = spheres.begin(); itr != spheres.end(); ++itr)
if (Creature* c = pInstance->instance->GetCreature(*itr))
if (me->GetDistance(c) < 3.0f)
{
c->CastSpell(me, SPELL_ARCANE_POWER, false);
c->DespawnOrUnsummon(8000);
found = true;
}
if (found)
{
Talk(SAY_CHARGED);
events.RepeatEvent(9000);
events.RescheduleEvent(EVENT_SUMMON_SPHERES, 10000);
}
else
events.RepeatEvent(2000);
}
break;
}
DoMeleeAttackIfReady();
}
void JustSummoned(Creature* pSummoned)
{
if (pSummoned)
{
pSummoned->GetMotionMaster()->MoveFollow(me, 0.0f, 0.0f);
pSummoned->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
spheres.Summon(pSummoned);
if (pInstance)
pInstance->SetData64(DATA_ADD_TRASH_MOB, pSummoned->GetGUID());
}
}
void SummonedCreatureDespawn(Creature *pSummoned)
{
if (pSummoned)
{
spheres.Despawn(pSummoned);
if (pInstance)
pInstance->SetData64(DATA_DELETE_TRASH_MOB, pSummoned->GetGUID());
}
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DEATH);
spheres.DespawnAll();
if (pInstance)
pInstance->SetData(DATA_BOSS_DIED, 0);
}
void KilledUnit(Unit* pVictim)
{
if (pVictim && pVictim->GetGUID() == me->GetGUID())
return;
Talk(SAY_SLAY);
}
void MoveInLineOfSight(Unit* /*who*/) {}
void EnterEvadeMode()
{
ScriptedAI::EnterEvadeMode();
events.Reset();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (pInstance)
pInstance->SetData(DATA_FAILED, 1);
}
};
};
void AddSC_boss_xevozz()
{
new boss_xevozz();
}

248
src/server/scripts/Northrend/VioletHold/boss_zuramat.cpp
View File

@@ -1,248 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
#include "PassiveAI.h"
enum Yells
{
SAY_AGGRO = 0,
SAY_SLAY = 1,
SAY_DEATH = 2,
SAY_SPAWN = 3,
SAY_SHIELD = 4,
SAY_WHISPER = 5
};
enum eSpells
{
SPELL_SHROUD_OF_DARKNESS_N = 54524,
SPELL_SHROUD_OF_DARKNESS_H = 59745,
SPELL_VOID_SHIFT_N = 54361,
SPELL_VOID_SHIFT_H = 59743,
SPELL_SUMMON_VOID_SENTRY = 54369,
SPELL_SUMMON_VOID_SENTRY_BALL = 58650,
//SPELL_ZURAMAT_ADD_2_N = 54342,
//SPELL_ZURAMAT_ADD_2_H = 59747,
};
#define NPC_VOID_SENTRY_BALL 29365
#define SPELL_SHROUD_OF_DARKNESS DUNGEON_MODE(SPELL_SHROUD_OF_DARKNESS_N, SPELL_SHROUD_OF_DARKNESS_H)
#define SPELL_VOID_SHIFT DUNGEON_MODE(SPELL_VOID_SHIFT_N, SPELL_VOID_SHIFT_H)
enum eEvents
{
EVENT_SPELL_SHROUD_OF_DARKNESS = 1,
EVENT_SPELL_VOID_SHIFT,
EVENT_SPELL_SUMMON_VOID_SENTRY,
};
class boss_zuramat : public CreatureScript
{
public:
boss_zuramat() : CreatureScript("boss_zuramat") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new boss_zuramatAI (pCreature);
}
struct boss_zuramatAI : public ScriptedAI
{
boss_zuramatAI(Creature *c) : ScriptedAI(c), summons(me)
{
pInstance = c->GetInstanceScript();
}
InstanceScript* pInstance;
EventMap events;
SummonList summons;
void Reset()
{
events.Reset();
summons.DespawnAll();
}
void EnterCombat(Unit* /*who*/)
{
Talk(SAY_AGGRO);
DoZoneInCombat();
events.Reset();
events.RescheduleEvent(EVENT_SPELL_SHROUD_OF_DARKNESS, urand(5000,7000));
events.RescheduleEvent(EVENT_SPELL_VOID_SHIFT, urand(23000,25000));
events.RescheduleEvent(EVENT_SPELL_SUMMON_VOID_SENTRY, 10000);
if (pInstance)
pInstance->SetData(DATA_ACHIEV, 1);
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch(events.GetEvent())
{
case 0:
break;
case EVENT_SPELL_SHROUD_OF_DARKNESS:
me->CastSpell(me, SPELL_SHROUD_OF_DARKNESS, false);
Talk(SAY_SHIELD);
events.RepeatEvent(20000);
break;
case EVENT_SPELL_VOID_SHIFT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 60.0f, true))
{
me->CastSpell(target, SPELL_VOID_SHIFT, false);
me->MonsterWhisper("Gaze... into the void.", target->ToPlayer(), false);
}
events.RepeatEvent(urand(18000,22000));
break;
case EVENT_SPELL_SUMMON_VOID_SENTRY:
me->CastSpell((Unit*)NULL, SPELL_SUMMON_VOID_SENTRY, false);
events.RepeatEvent(12000);
break;
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/)
{
summons.DespawnAll();
Talk(SAY_DEATH);
if (pInstance)
pInstance->SetData(DATA_BOSS_DIED, 0);
}
void KilledUnit(Unit * victim)
{
if (victim && victim->GetGUID() == me->GetGUID())
return;
Talk(SAY_SLAY);
}
void JustSummoned(Creature* pSummoned)
{
if (pSummoned)
{
summons.Summon(pSummoned);
pSummoned->SetPhaseMask(16, true);
if (pInstance)
pInstance->SetData64(DATA_ADD_TRASH_MOB, pSummoned->GetGUID());
}
}
void SummonedCreatureDespawn(Creature *pSummoned)
{
if (pSummoned)
{
summons.Despawn(pSummoned);
if (pSummoned->IsAIEnabled)
pSummoned->AI()->DoAction(-1337);
if (pInstance)
pInstance->SetData64(DATA_DELETE_TRASH_MOB, pSummoned->GetGUID());
}
}
void MoveInLineOfSight(Unit* /*who*/) {}
void EnterEvadeMode()
{
ScriptedAI::EnterEvadeMode();
events.Reset();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
if (pInstance)
pInstance->SetData(DATA_FAILED, 1);
}
};
};
class npc_vh_void_sentry : public CreatureScript
{
public:
npc_vh_void_sentry() : CreatureScript("npc_vh_void_sentry") { }
CreatureAI* GetAI(Creature* pCreature) const
{
return new npc_vh_void_sentryAI (pCreature);
}
struct npc_vh_void_sentryAI : public NullCreatureAI
{
npc_vh_void_sentryAI(Creature *c) : NullCreatureAI(c)
{
pInstance = c->GetInstanceScript();
SummonedGUID = 0;
checkTimer = 5000;
//me->CastSpell(me, SPELL_SUMMON_VOID_SENTRY_BALL, true);
if (Creature* pSummoned = me->SummonCreature(NPC_VOID_SENTRY_BALL, *me, TEMPSUMMON_TIMED_DESPAWN, 300000))
{
pSummoned->SetPhaseMask(1, true);
SummonedGUID = pSummoned->GetGUID();
pInstance->SetData64(DATA_ADD_TRASH_MOB, pSummoned->GetGUID());
}
}
InstanceScript* pInstance;
uint64 SummonedGUID;
uint16 checkTimer;
void DoAction(int32 a)
{
if (a == -1337)
if (Creature* c = pInstance->instance->GetCreature(SummonedGUID))
c->DespawnOrUnsummon();
}
void JustDied(Unit* /*killer*/)
{
if (pInstance)
{
pInstance->SetData(DATA_ACHIEV, 0);
if (Creature* c = pInstance->instance->GetCreature(SummonedGUID))
c->DespawnOrUnsummon();
}
me->DespawnOrUnsummon(5000);
}
void SummonedCreatureDespawn(Creature *pSummoned)
{
if (pSummoned)
pInstance->SetData64(DATA_DELETE_TRASH_MOB, pSummoned->GetGUID());
}
void UpdateAI(uint32 diff)
{
if (checkTimer <= diff)
{
checkTimer = 5000;
bool good = false;
if (me->IsSummon())
if (Unit* s = me->ToTempSummon()->GetSummoner())
if (s->IsAlive())
good = true;
if (!good)
Unit::Kill(me, me);
}
else
checkTimer -= diff;
}
};
};
void AddSC_boss_zuramat()
{
new boss_zuramat();
new npc_vh_void_sentry();
}

708
src/server/scripts/Northrend/VioletHold/instance_violet_hold.cpp
View File

@@ -1,708 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "violet_hold.h"
#include "Player.h"
#define CLEANUP_CHECK_INTERVAL 5000
#define SPAWN_TIME 20000
enum vYells
{
CYANIGOSA_SAY_SPAWN = 3,
SAY_SINCLARI_1 = 0
};
class instance_violet_hold : public InstanceMapScript
{
public:
instance_violet_hold() : InstanceMapScript("instance_violet_hold", 608) { }
InstanceScript* GetInstanceScript(InstanceMap* pMap) const
{
return new instance_violet_hold_InstanceMapScript(pMap);
}
struct instance_violet_hold_InstanceMapScript : public InstanceScript
{
instance_violet_hold_InstanceMapScript(Map* pMap) : InstanceScript(pMap) {}
uint32 m_auiEncounter[MAX_ENCOUNTER];
bool CLEANED;
uint8 EncounterStatus;
uint32 uiFirstBoss, uiSecondBoss;
std::string str_data;
EventMap events;
uint8 GateHealth;
uint8 WaveCount;
uint8 PortalLocation;
bool bAchiev;
bool bDefensesUsed;
std::vector<uint64> GO_ActivationCrystalGUID;
uint64 GO_MainGateGUID;
uint64 GO_MoraggCellGUID;
uint64 GO_ErekemCellGUID;
uint64 GO_ErekemRightGuardCellGUID;
uint64 GO_ErekemLeftGuardCellGUID;
uint64 GO_IchoronCellGUID;
uint64 GO_LavanthorCellGUID;
uint64 GO_XevozzCellGUID;
uint64 GO_ZuramatCellGUID;
std::set<uint64> trashMobs;
uint64 NPC_SinclariGUID;
uint64 NPC_GuardGUID[4];
uint64 NPC_PortalGUID;
uint64 NPC_DoorSealGUID;
uint64 NPC_MoraggGUID;
uint64 NPC_ErekemGUID;
uint64 NPC_ErekemGuardGUID[2];
uint64 NPC_IchoronGUID;
uint64 NPC_LavanthorGUID;
uint64 NPC_XevozzGUID;
uint64 NPC_ZuramatGUID;
uint64 NPC_CyanigosaGUID;
void Initialize()
{
memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
CLEANED = false;
EncounterStatus = NOT_STARTED;
uiFirstBoss = 0;
uiSecondBoss = 0;
events.Reset();
events.RescheduleEvent(EVENT_CHECK_PLAYERS, 0);
GateHealth = 100;
WaveCount = 0;
PortalLocation = 0;
bDefensesUsed = false;
GO_ActivationCrystalGUID.clear();
GO_MainGateGUID = 0;
GO_MoraggCellGUID = 0;
GO_ErekemCellGUID = 0;
GO_ErekemRightGuardCellGUID = 0;
GO_ErekemLeftGuardCellGUID = 0;
GO_IchoronCellGUID = 0;
GO_LavanthorCellGUID = 0;
GO_XevozzCellGUID = 0;
GO_ZuramatCellGUID = 0;
NPC_SinclariGUID = 0;
memset(&NPC_GuardGUID, 0, sizeof(NPC_GuardGUID));
NPC_PortalGUID = 0;
NPC_DoorSealGUID = 0;
NPC_MoraggGUID = 0;
NPC_ErekemGUID = 0;
NPC_ErekemGuardGUID[0] = NPC_ErekemGuardGUID[1] = 0;
NPC_IchoronGUID = 0;
NPC_LavanthorGUID = 0;
NPC_XevozzGUID = 0;
NPC_ZuramatGUID = 0;
NPC_CyanigosaGUID = 0;
}
bool IsEncounterInProgress() const
{
return false;
}
void OnCreatureCreate(Creature* creature)
{
switch(creature->GetEntry())
{
case NPC_SINCLARI:
NPC_SinclariGUID = creature->GetGUID();
break;
case NPC_VIOLET_HOLD_GUARD:
for (uint8 i=0; i<4; ++i)
if (NPC_GuardGUID[i] == 0)
{
NPC_GuardGUID[i] = creature->GetGUID();
break;
}
break;
case NPC_DEFENSE_DUMMY_TARGET:
creature->ApplySpellImmune(0, IMMUNITY_ID, SPELL_ARCANE_LIGHTNING, true);
break;
case NPC_TELEPORTATION_PORTAL:
NPC_PortalGUID = creature->GetGUID();
break;
case NPC_PRISON_DOOR_SEAL:
NPC_DoorSealGUID = creature->GetGUID();
break;
// BOSSES BELOW:
case NPC_XEVOZZ:
NPC_XevozzGUID = creature->GetGUID();
break;
case NPC_LAVANTHOR:
NPC_LavanthorGUID = creature->GetGUID();
break;
case NPC_ICHORON:
NPC_IchoronGUID = creature->GetGUID();
break;
case NPC_ZURAMAT:
NPC_ZuramatGUID = creature->GetGUID();
break;
case NPC_EREKEM:
NPC_ErekemGUID = creature->GetGUID();
break;
case NPC_EREKEM_GUARD:
if (NPC_ErekemGuardGUID[0] == 0)
NPC_ErekemGuardGUID[0] = creature->GetGUID();
else
NPC_ErekemGuardGUID[1] = creature->GetGUID();
break;
case NPC_MORAGG:
NPC_MoraggGUID = creature->GetGUID();
break;
case NPC_CYANIGOSA:
NPC_CyanigosaGUID = creature->GetGUID();
break;
}
}
void OnGameObjectCreate(GameObject* go)
{
switch(go->GetEntry())
{
case GO_ACTIVATION_CRYSTAL:
HandleGameObject(0, false, go); // make go not used yet
go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE); // not useable at the beginning
GO_ActivationCrystalGUID.push_back(go->GetGUID());
break;
case GO_MAIN_DOOR:
GO_MainGateGUID = go->GetGUID();
break;
// BOSS GATES BELOW:
case GO_EREKEM_GUARD_1_DOOR:
GO_ErekemLeftGuardCellGUID = go->GetGUID();
break;
case GO_EREKEM_GUARD_2_DOOR:
GO_ErekemRightGuardCellGUID = go->GetGUID();
break;
case GO_EREKEM_DOOR:
GO_ErekemCellGUID = go->GetGUID();
break;
case GO_ZURAMAT_DOOR:
GO_ZuramatCellGUID = go->GetGUID();
break;
case GO_LAVANTHOR_DOOR:
GO_LavanthorCellGUID = go->GetGUID();
break;
case GO_MORAGG_DOOR:
GO_MoraggCellGUID = go->GetGUID();
break;
case GO_ICHORON_DOOR:
GO_IchoronCellGUID = go->GetGUID();
break;
case GO_XEVOZZ_DOOR:
GO_XevozzCellGUID = go->GetGUID();
break;
}
}
void SetData(uint32 type, uint32 data)
{
switch(type)
{
case DATA_ACTIVATE_DEFENSE_SYSTEM:
{
if (data)
bDefensesUsed = true;
const Position pos = {1919.09546f, 812.29724f, 86.2905f, M_PI};
instance->SummonCreature(NPC_DEFENSE_SYSTEM, pos, 0, 6499);
}
break;
case DATA_START_INSTANCE:
if (EncounterStatus == NOT_STARTED)
{
EncounterStatus = IN_PROGRESS;
if (Creature* c = instance->GetCreature(NPC_SinclariGUID))
c->AI()->Talk(SAY_SINCLARI_1);
events.RescheduleEvent(EVENT_GUARDS_FALL_BACK, 4000);
}
break;
case DATA_PORTAL_DEFEATED:
events.RescheduleEvent(EVENT_SUMMON_PORTAL, 3000);
break;
case DATA_PORTAL_LOCATION:
PortalLocation = data;
break;
case DATA_DECRASE_DOOR_HEALTH:
if (GateHealth>0)
--GateHealth;
if (GateHealth==0)
{
CLEANED = false;
InstanceCleanup();
}
DoUpdateWorldState(WORLD_STATE_VH_PRISON_STATE, (uint32)GateHealth);
break;
case DATA_RELEASE_BOSS:
if (WaveCount == 6)
StartBossEncounter(uiFirstBoss);
else
StartBossEncounter(uiSecondBoss);
break;
case DATA_BOSS_DIED:
if (WaveCount == 6)
m_auiEncounter[0] = DONE;
else if (WaveCount == 12)
m_auiEncounter[1] = DONE;
else if (WaveCount == 18)
{
m_auiEncounter[2] = DONE;
EncounterStatus = DONE;
HandleGameObject(GO_MainGateGUID, true);
DoUpdateWorldState(WORLD_STATE_VH_SHOW, 0);
if (Creature* c = instance->GetCreature(NPC_SinclariGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); }
}
SaveToDB();
if (WaveCount < 18)
events.RescheduleEvent(EVENT_SUMMON_PORTAL, 35000);
break;
case DATA_FAILED:
CLEANED = false;
InstanceCleanup();
break;
case DATA_ACHIEV:
bAchiev = data ? true : false;
break;
}
}
void SetData64(uint32 type, uint64 data)
{
switch(type)
{
case DATA_ADD_TRASH_MOB:
trashMobs.insert(data);
break;
case DATA_DELETE_TRASH_MOB:
if (!CLEANED)
trashMobs.erase(data);
break;
}
}
uint32 GetData(uint32 type) const
{
switch(type)
{
case DATA_ENCOUNTER_STATUS:
return (uint32)EncounterStatus;
case DATA_WAVE_COUNT:
return (uint32)WaveCount;
case DATA_PORTAL_LOCATION:
return PortalLocation;
case DATA_FIRST_BOSS_NUMBER:
return uiFirstBoss;
case DATA_SECOND_BOSS_NUMBER:
return uiSecondBoss;
}
return 0;
}
uint64 GetData64(uint32 identifier) const
{
switch(identifier)
{
case DATA_TELEPORTATION_PORTAL_GUID:
return NPC_PortalGUID;
case DATA_DOOR_SEAL_GUID:
return NPC_DoorSealGUID;
case DATA_EREKEM_GUID:
return NPC_ErekemGUID;
case DATA_EREKEM_GUARD_1_GUID:
return NPC_ErekemGuardGUID[0];
case DATA_EREKEM_GUARD_2_GUID:
return NPC_ErekemGuardGUID[1];
case DATA_ICHORON_GUID:
return NPC_IchoronGUID;
}
return 0;
}
void StartBossEncounter(uint8 uiBoss)
{
Creature* pBoss = NULL;
switch(uiBoss)
{
case BOSS_MORAGG:
HandleGameObject(GO_MoraggCellGUID, true);
pBoss = instance->GetCreature(NPC_MoraggGUID);
if (pBoss)
pBoss->GetMotionMaster()->MovePoint(0, BossStartMove1);
break;
case BOSS_EREKEM:
HandleGameObject(GO_ErekemCellGUID, true);
HandleGameObject(GO_ErekemRightGuardCellGUID, true);
HandleGameObject(GO_ErekemLeftGuardCellGUID, true);
pBoss = instance->GetCreature(NPC_ErekemGUID);
if (pBoss)
pBoss->GetMotionMaster()->MovePoint(0, BossStartMove2);
if (Creature* pGuard1 = instance->GetCreature(NPC_ErekemGuardGUID[0]))
{
pGuard1->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
pGuard1->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC);
pGuard1->GetMotionMaster()->MovePoint(0, BossStartMove21);
}
if (Creature* pGuard2 = instance->GetCreature(NPC_ErekemGuardGUID[1]))
{
pGuard2->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
pGuard2->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC);
pGuard2->GetMotionMaster()->MovePoint(0, BossStartMove22);
}
break;
case BOSS_ICHORON:
HandleGameObject(GO_IchoronCellGUID, true);
pBoss = instance->GetCreature(NPC_IchoronGUID);
if (pBoss)
pBoss->GetMotionMaster()->MovePoint(0, BossStartMove3);
break;
case BOSS_LAVANTHOR:
HandleGameObject(GO_LavanthorCellGUID, true);
pBoss = instance->GetCreature(NPC_LavanthorGUID);
if (pBoss)
pBoss->GetMotionMaster()->MovePoint(0, BossStartMove4);
break;
case BOSS_XEVOZZ:
HandleGameObject(GO_XevozzCellGUID, true);
pBoss = instance->GetCreature(NPC_XevozzGUID);
if (pBoss)
pBoss->GetMotionMaster()->MovePoint(0, BossStartMove5);
break;
case BOSS_ZURAMAT:
HandleGameObject(GO_ZuramatCellGUID, true);
pBoss = instance->GetCreature(NPC_ZuramatGUID);
if (pBoss)
pBoss->GetMotionMaster()->MovePoint(0, BossStartMove6);
break;
}
if (pBoss)
{
pBoss->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
pBoss->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC);
pBoss->SetReactState(REACT_AGGRESSIVE);
if (WaveCount == 6 && m_auiEncounter[0] == DONE || WaveCount == 12 && m_auiEncounter[1] == DONE)
pBoss->SetLootMode(0);
}
}
void Update(uint32 diff)
{
events.Update(diff);
switch( events.GetEvent() )
{
case 0:
break;
case EVENT_CHECK_PLAYERS:
{
if( DoNeedCleanup(false) )
InstanceCleanup();
events.RepeatEvent(CLEANUP_CHECK_INTERVAL);
}
break;
case EVENT_GUARDS_FALL_BACK:
{
for (uint8 i=0; i<4; ++i)
if (Creature* c = instance->GetCreature(NPC_GuardGUID[i]))
{
c->SetReactState(REACT_PASSIVE);
c->CombatStop();
c->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
c->GetMotionMaster()->MovePoint(0, guardMovePosition);
}
events.PopEvent();
events.RescheduleEvent(EVENT_GUARDS_DISAPPEAR, 5000);
}
break;
case EVENT_GUARDS_DISAPPEAR:
{
for (uint8 i=0; i<4; ++i)
if (Creature* c = instance->GetCreature(NPC_GuardGUID[i]))
c->SetVisible(false);
events.PopEvent();
events.RescheduleEvent(EVENT_SINCLARI_FALL_BACK, 2000);
}
break;
case EVENT_SINCLARI_FALL_BACK:
{
if (Creature* c = instance->GetCreature(NPC_SinclariGUID))
{
c->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
c->GetMotionMaster()->MovePoint(0, sinclariOutsidePosition);
}
SetData(DATA_ACTIVATE_DEFENSE_SYSTEM, 0);
events.PopEvent();
events.RescheduleEvent(EVENT_START_ENCOUNTER, 4000);
}
break;
case EVENT_START_ENCOUNTER:
{
if (Creature* c = instance->GetCreature(NPC_DoorSealGUID))
c->RemoveAllAuras(); // just to be sure...
GateHealth = 100;
HandleGameObject(GO_MainGateGUID, false);
DoUpdateWorldState(WORLD_STATE_VH_SHOW, 1);
DoUpdateWorldState(WORLD_STATE_VH_PRISON_STATE, (uint32)GateHealth);
DoUpdateWorldState(WORLD_STATE_VH_WAVE_COUNT, (uint32)WaveCount);
for (std::vector<uint64>::iterator itr = GO_ActivationCrystalGUID.begin(); itr != GO_ActivationCrystalGUID.end(); ++itr)
if (GameObject* go = instance->GetGameObject(*itr))
{
HandleGameObject(0, false, go); // not used yet
go->RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE); // make it useable
}
events.PopEvent();
events.RescheduleEvent(EVENT_SUMMON_PORTAL, 4000);
}
break;
case EVENT_SUMMON_PORTAL:
++WaveCount;
DoUpdateWorldState(WORLD_STATE_VH_WAVE_COUNT, (uint32)WaveCount);
SetData(DATA_PORTAL_LOCATION, (GetData(DATA_PORTAL_LOCATION) + urand(1, 5))%6);
if (Creature* c = instance->GetCreature(NPC_SinclariGUID))
{
if (WaveCount%6 != 0)
c->SummonCreature(NPC_TELEPORTATION_PORTAL, PortalLocations[GetData(DATA_PORTAL_LOCATION)], TEMPSUMMON_CORPSE_DESPAWN);
else if (WaveCount == 6 || WaveCount == 12) // first or second boss
{
if (!uiFirstBoss || !uiSecondBoss)
{
uiFirstBoss = urand(1,6);
do { uiSecondBoss = urand(1,6); } while (uiFirstBoss==uiSecondBoss);
SaveToDB();
}
c->SummonCreature(NPC_TELEPORTATION_PORTAL, MiddleRoomPortalSaboLocation, TEMPSUMMON_CORPSE_DESPAWN);
}
else // cyanigossa
{
if (Creature* cyanigosa = c->SummonCreature(NPC_CYANIGOSA, CyanigosasSpawnLocation, TEMPSUMMON_DEAD_DESPAWN))
{
cyanigosa->CastSpell(cyanigosa, SPELL_CYANIGOSA_BLUE_AURA, false);
cyanigosa->AI()->Talk(CYANIGOSA_SAY_SPAWN);
cyanigosa->GetMotionMaster()->MoveJump(MiddleRoomLocation.GetPositionX(), MiddleRoomLocation.GetPositionY(), MiddleRoomLocation.GetPositionZ(), 10.0f, 20.0f);
}
events.RescheduleEvent(EVENT_CYANIGOSSA_TRANSFORM, 10000);
}
}
events.PopEvent();
break;
case EVENT_CYANIGOSSA_TRANSFORM:
if (Creature* c = instance->GetCreature(NPC_CyanigosaGUID))
{
c->RemoveAurasDueToSpell(SPELL_CYANIGOSA_BLUE_AURA);
c->CastSpell(c, SPELL_CYANIGOSA_TRANSFORM, 0);
events.RescheduleEvent(EVENT_CYANIGOSA_ATTACK, 2500);
}
events.PopEvent();
break;
case EVENT_CYANIGOSA_ATTACK:
if (Creature* c = instance->GetCreature(NPC_CyanigosaGUID))
c->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC);
events.PopEvent();
break;
}
}
void OnPlayerEnter(Player* plr)
{
if( DoNeedCleanup(plr->IsAlive()) )
InstanceCleanup();
if (EncounterStatus == IN_PROGRESS)
{
plr->SendUpdateWorldState(WORLD_STATE_VH_SHOW, 1);
plr->SendUpdateWorldState(WORLD_STATE_VH_PRISON_STATE, (uint32)GateHealth);
plr->SendUpdateWorldState(WORLD_STATE_VH_WAVE_COUNT, (uint32)WaveCount);
}
else
plr->SendUpdateWorldState(WORLD_STATE_VH_SHOW, 0);
events.RescheduleEvent(EVENT_CHECK_PLAYERS, CLEANUP_CHECK_INTERVAL);
}
bool DoNeedCleanup(bool enter)
{
uint8 aliveCount = 0;
Map::PlayerList const &pl = instance->GetPlayers();
for( Map::PlayerList::const_iterator itr = pl.begin(); itr != pl.end(); ++itr )
if( Player* plr = itr->GetSource() )
if( plr->IsAlive() && !plr->IsGameMaster() && !plr->HasAura(27827)/*spirit of redemption aura*/ )
++aliveCount;
bool need = enter ? aliveCount<=1 : aliveCount==0;
if( !need && CLEANED )
CLEANED = false;
return need;
}
void InstanceCleanup()
{
if( CLEANED )
return;
CLEANED = true;
// reset defense crystals
for (std::vector<uint64>::iterator itr = GO_ActivationCrystalGUID.begin(); itr != GO_ActivationCrystalGUID.end(); ++itr)
if (GameObject* go = instance->GetGameObject(*itr))
{
HandleGameObject(0, false, go); // not used yet
go->SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NOT_SELECTABLE); // not useable at the beginning
}
// reset positions of Sinclari and Guards
if (Creature* c = instance->GetCreature(NPC_SinclariGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); }
for (uint8 i=0; i<4; ++i)
if (Creature* c = instance->GetCreature(NPC_GuardGUID[i]))
{
c->DespawnOrUnsummon();
c->SetRespawnTime(3);
if (m_auiEncounter[MAX_ENCOUNTER-1] == DONE)
c->SetVisible(false);
else
c->SetVisible(true);
c->SetReactState(REACT_AGGRESSIVE);
}
// remove portal if any
if (Creature* c = instance->GetCreature(NPC_PortalGUID))
c->DespawnOrUnsummon();
NPC_PortalGUID = 0;
// remove trash
for (std::set<uint64>::iterator itr = trashMobs.begin(); itr != trashMobs.end(); ++itr)
if (Creature* c = instance->GetCreature(*itr))
c->DespawnOrUnsummon();
trashMobs.clear();
// clear door seal damaging auras:
if (Creature* c = instance->GetCreature(NPC_DoorSealGUID))
c->RemoveAllAuras();
// open main gate
HandleGameObject(GO_MainGateGUID, true);
if (m_auiEncounter[MAX_ENCOUNTER-1] != DONE) // instance not finished
{
// close all cells
HandleGameObject(GO_MoraggCellGUID, false);
HandleGameObject(GO_ErekemCellGUID, false);
HandleGameObject(GO_ErekemRightGuardCellGUID, false);
HandleGameObject(GO_ErekemLeftGuardCellGUID, false);
HandleGameObject(GO_IchoronCellGUID, false);
HandleGameObject(GO_LavanthorCellGUID, false);
HandleGameObject(GO_XevozzCellGUID, false);
HandleGameObject(GO_ZuramatCellGUID, false);
// respawn bosses
if (Creature* c = instance->GetCreature(NPC_MoraggGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_MoraggGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_ErekemGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_ErekemGuardGUID[0])) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_ErekemGuardGUID[1])) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_IchoronGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_LavanthorGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_XevozzGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_ZuramatGUID)) { c->DespawnOrUnsummon(); c->SetRespawnTime(3); c->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_NPC); }
if (Creature* c = instance->GetCreature(NPC_CyanigosaGUID)) { c->DespawnOrUnsummon(); }
}
// reinitialize variables and events
DoUpdateWorldState(WORLD_STATE_VH_SHOW, 0);
EncounterStatus = NOT_STARTED;
GateHealth = 100;
WaveCount = 0;
bDefensesUsed = false;
if (m_auiEncounter[MAX_ENCOUNTER-1] == DONE)
EncounterStatus = DONE;
events.Reset();
events.RescheduleEvent(EVENT_CHECK_PLAYERS, CLEANUP_CHECK_INTERVAL);
}
bool CheckAchievementCriteriaMeet(uint32 criteria_id, Player const* source, Unit const* target = NULL, uint32 miscvalue1 = 0)
{
switch(criteria_id)
{
case CRITERIA_DEFENSELESS:
return GateHealth == 100 && !bDefensesUsed;
case CRITERIA_A_VOID_DANCE:
case CRITERIA_DEHYDRATION:
return bAchiev;
}
return false;
}
std::string GetSaveData()
{
OUT_SAVE_INST_DATA;
std::ostringstream saveStream;
saveStream << "V H " << m_auiEncounter[0] << ' ' << m_auiEncounter[1] << ' ' << m_auiEncounter[2] << ' ' << uiFirstBoss << ' ' << uiSecondBoss;
str_data = saveStream.str();
OUT_SAVE_INST_DATA_COMPLETE;
return str_data;
}
void Load(const char* in)
{
EncounterStatus = NOT_STARTED;
CLEANED = false;
events.Reset();
events.RescheduleEvent(EVENT_CHECK_PLAYERS, 0);
if (!in)
{
OUT_LOAD_INST_DATA_FAIL;
return;
}
OUT_LOAD_INST_DATA(in);
char dataHead1, dataHead2;
uint32 data0, data1, data2, data3, data4;
std::istringstream loadStream(in);
loadStream >> dataHead1 >> dataHead2 >> data0 >> data1 >> data2 >> data3 >> data4;
if (dataHead1 == 'V' && dataHead2 == 'H')
{
m_auiEncounter[0] = data0;
m_auiEncounter[1] = data1;
m_auiEncounter[2] = data2;
uiFirstBoss = data3;
uiSecondBoss = data4;
for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
if (m_auiEncounter[i] == IN_PROGRESS)
m_auiEncounter[i] = NOT_STARTED;
if (m_auiEncounter[MAX_ENCOUNTER-1] == DONE)
EncounterStatus = DONE;
}
else OUT_LOAD_INST_DATA_FAIL;
OUT_LOAD_INST_DATA_COMPLETE;
}
};
};
void AddSC_instance_violet_hold()
{
new instance_violet_hold();
}

1175
src/server/scripts/Northrend/VioletHold/violet_hold.cpp
View File

File diff suppressed because it is too large Load Diff

285
src/server/scripts/Northrend/VioletHold/violet_hold.h
View File

@@ -1,285 +0,0 @@
/*
REWRITTEN FROM SCRATCH BY PUSSYWIZARD, IT OWNS NOW!
*/
#ifndef DEF_VIOLET_HOLD_H
#define DEF_VIOLET_HOLD_H
#define MAX_ENCOUNTER 3
enum Creatures
{
NPC_TELEPORTATION_PORTAL = 31011,
NPC_DEFENSE_SYSTEM = 30837,
NPC_PRISON_DOOR_SEAL = 30896,
NPC_DEFENSE_DUMMY_TARGET = 30857,
NPC_SINCLARI = 30658,
NPC_VIOLET_HOLD_GUARD = 30659,
NPC_SABOTEOUR = 31079,
NPC_XEVOZZ = 29266,
NPC_LAVANTHOR = 29312,
NPC_ICHORON = 29313,
NPC_ZURAMAT = 29314,
NPC_EREKEM = 29315,
NPC_EREKEM_GUARD = 29395,
NPC_MORAGG = 29316,
NPC_CYANIGOSA = 31134,
NPC_PORTAL_GUARDIAN = 30660,
NPC_PORTAL_KEEPER = 30695,
NPC_AZURE_INVADER_1 = 30661,
NPC_AZURE_INVADER_2 = 30961,
NPC_AZURE_SPELLBREAKER_1 = 30662,
NPC_AZURE_SPELLBREAKER_2 = 30962,
NPC_AZURE_BINDER_1 = 30663,
NPC_AZURE_BINDER_2 = 30918,
NPC_AZURE_MAGE_SLAYER_1 = 30664,
NPC_AZURE_MAGE_SLAYER_2 = 30963,
NPC_AZURE_CAPTAIN = 30666,
NPC_AZURE_SORCEROR = 30667,
NPC_AZURE_RAIDER = 30668,
NPC_AZURE_STALKER = 32191,
};
enum GameObjects
{
GO_MAIN_DOOR = 191723,
GO_XEVOZZ_DOOR = 191556,
GO_LAVANTHOR_DOOR = 191566,
GO_ICHORON_DOOR = 191722,
GO_ZURAMAT_DOOR = 191565,
GO_EREKEM_DOOR = 191564,
GO_EREKEM_GUARD_1_DOOR = 191563,
GO_EREKEM_GUARD_2_DOOR = 191562,
GO_MORAGG_DOOR = 191606,
GO_INTRO_ACTIVATION_CRYSTAL = 193615,
GO_ACTIVATION_CRYSTAL = 193611,
};
enum Bosses
{
BOSS_NONE,
BOSS_MORAGG,
BOSS_EREKEM,
BOSS_ICHORON,
BOSS_LAVANTHOR,
BOSS_XEVOZZ,
BOSS_ZURAMAT,
BOSS_CYANIGOSA
};
enum VHWorldStates
{
WORLD_STATE_VH_SHOW = 3816,
WORLD_STATE_VH_PRISON_STATE = 3815,
WORLD_STATE_VH_WAVE_COUNT = 3810,
};
enum Spells
{
SPELL_CONTROL_CRYSTAL_ACTIVATION= 57804,
SPELL_ARCANE_LIGHTNING = 57912,
SPELL_ARCANE_LIGHTNING_VISUAL = 57930,
SPELL_PORTAL_CHANNEL = 58012,
SPELL_DESTROY_DOOR_SEAL = 58040,
SPELL_CYANIGOSA_TRANSFORM = 58668,
SPELL_CYANIGOSA_BLUE_AURA = 45870,
};
enum Events
{
EVENT_CHECK_PLAYERS = 1,
EVENT_GUARDS_FALL_BACK,
EVENT_GUARDS_DISAPPEAR,
EVENT_SINCLARI_FALL_BACK,
EVENT_START_ENCOUNTER,
EVENT_SUMMON_PORTAL,
EVENT_CYANIGOSSA_TRANSFORM,
EVENT_CYANIGOSA_ATTACK,
};
enum Data
{
DATA_ACTIVATE_DEFENSE_SYSTEM = 1,
DATA_ENCOUNTER_STATUS,
DATA_START_INSTANCE,
DATA_ADD_TRASH_MOB,
DATA_DELETE_TRASH_MOB,
DATA_PORTAL_DEFEATED,
DATA_WAVE_COUNT,
DATA_PORTAL_LOCATION,
DATA_TELEPORTATION_PORTAL_GUID,
DATA_DOOR_SEAL_GUID,
DATA_FIRST_BOSS_NUMBER,
DATA_SECOND_BOSS_NUMBER,
DATA_RELEASE_BOSS,
DATA_DECRASE_DOOR_HEALTH,
DATA_BOSS_DIED,
DATA_FAILED,
DATA_EREKEM_GUID,
DATA_EREKEM_GUARD_1_GUID,
DATA_EREKEM_GUARD_2_GUID,
DATA_ICHORON_GUID,
DATA_ACHIEV,
};
enum AchievCriteria
{
CRITERIA_DEFENSELESS = 6803,
CRITERIA_A_VOID_DANCE = 7587,
CRITERIA_DEHYDRATION = 7320,
};
/**************
** POSITIONS AND WAYPOINTS:
**************/
const Position guardMovePosition = {1806.955566f, 803.851807f, 44.363323f, 0.0f};
const Position playerTeleportPosition = {1830.531006f, 803.939758f, 44.340508f, 6.281611f};
const Position sinclariOutsidePosition = {1817.315674f, 804.060608f, 44.363998f, 0.0f};
const Position MiddleRoomPortalSaboLocation = {1896.622925f, 804.854126f, 38.504772f, 3.139621f};
const Position BossStartMove1 = {1894.684448f, 739.390503f, 47.668003f, 0.0f};
const Position BossStartMove2 = {1875.173950f, 860.832703f, 43.333565f, 0.0f};
const Position BossStartMove21 = {1858.854614f, 855.071411f, 43.333565f, 0.0f};
const Position BossStartMove22 = {1891.926636f, 863.388977f, 43.333565f, 0.0f};
const Position BossStartMove3 = {1916.138062f, 778.152222f, 35.772308f, 0.0f};
const Position BossStartMove4 = {1853.618286f, 758.557617f, 38.657505f, 0.0f};
const Position BossStartMove5 = {1906.683960f, 842.348022f, 38.637459f, 0.0f};
const Position BossStartMove6 = {1928.207031f, 852.864441f, 47.200813f, 0.0f};
const Position CyanigosasSpawnLocation = {1930.281250f, 804.407715f, 52.410946f, 3.139621f};
const Position MiddleRoomLocation = {1892.291260f, 805.696838f, 38.438862f, 3.139621f};
const uint8 PLocWPCount[6] = {6,9,8,9,6,4};
const Position PortalLocations[] =
{
{1877.51f, 850.104f, 44.6599f, 4.78220f},
{1918.37f, 853.437f, 47.1624f, 4.12294f},
{1936.07f, 803.198f, 53.3749f, 3.12414f},
{1927.61f, 758.436f, 51.4533f, 2.20891f},
{1890.64f, 753.471f, 48.7224f, 1.71042f},
{1908.31f, 809.657f, 38.7037f, 3.08701f},
};
const float FirstPortalTrashWPs [6][3] =
{
{1877.670288f, 842.280273f, 43.333591f},
{1877.338867f, 834.615356f, 38.762287f},
{1872.161011f, 823.854309f, 38.645401f},
{1864.860474f, 815.787170f, 38.784843f},
{1858.953735f, 810.048950f, 44.008759f},
{1843.707153f, 805.807739f, 44.135197f},
};
const float SecondPortalTrashWPs1 [9][3] =
{
{1902.561401f, 853.334656f, 47.106117f},
{1895.486084f, 855.376404f, 44.334591f},
{1882.805176f, 854.993286f, 43.333591f},
{1877.670288f, 842.280273f, 43.333591f},
{1877.338867f, 834.615356f, 38.762287f},
{1872.161011f, 823.854309f, 38.645401f},
{1864.860474f, 815.787170f, 38.784843f},
{1858.953735f, 810.048950f, 44.008759f},
{1843.707153f, 805.807739f, 44.135197f},
};
const float SecondPortalTrashWPs2 [8][3] =
{
{1929.392212f, 837.614990f, 47.136166f},
{1928.290649f, 824.750427f, 45.474411f},
{1915.544922f, 826.919373f, 38.642811f},
{1900.933960f, 818.855652f, 38.801647f},
{1886.810547f, 813.536621f, 38.490490f},
{1869.079712f, 808.701538f, 38.689003f},
{1860.843384f, 806.645020f, 44.008789f},
{1843.707153f, 805.807739f, 44.135197f},
};
const float ThirdPortalTrashWPs [8][3] =
{
{1934.049438f, 815.778503f, 52.408699f},
{1928.290649f, 824.750427f, 45.474411f},
{1915.544922f, 826.919373f, 38.642811f},
{1900.933960f, 818.855652f, 38.801647f},
{1886.810547f, 813.536621f, 38.490490f},
{1869.079712f, 808.701538f, 38.689003f},
{1860.843384f, 806.645020f, 44.008789f},
{1843.707153f, 805.807739f, 44.135197f},
};
const float FourthPortalTrashWPs [9][3] =
{
{1921.658447f, 761.657043f, 50.866741f},
{1910.559814f, 755.780457f, 47.701447f},
{1896.664673f, 752.920898f, 47.667004f},
{1887.398804f, 763.633240f, 47.666851f},
{1879.020386f, 775.396973f, 38.705990f},
{1872.439087f, 782.568604f, 38.808292f},
{1863.573364f, 791.173584f, 38.743660f},
{1857.811890f, 796.765564f, 43.950329f},
{1845.577759f, 800.681152f, 44.104248f},
};
const float FifthPortalTrashWPs [6][3] =
{
{1887.398804f, 763.633240f, 47.666851f},
{1879.020386f, 775.396973f, 38.705990f},
{1872.439087f, 782.568604f, 38.808292f},
{1863.573364f, 791.173584f, 38.743660f},
{1857.811890f, 796.765564f, 43.950329f},
{1845.577759f, 800.681152f, 44.104248f},
};
const float SixthPoralTrashWPs [4][3] =
{
{1888.861084f, 805.074768f, 38.375790f},
{1869.793823f, 804.135804f, 38.647018f},
{1861.541504f, 804.149780f, 43.968292f},
{1843.567017f, 804.288208f, 44.139091f},
};
const float SaboteurFinalPos1[3][3] =
{
{1892.502319f, 777.410767f, 38.630402f},
{1891.165161f, 762.969421f, 47.666920f},
{1893.168091f, 740.919189f, 47.666920f}
};
const float SaboteurFinalPos2[3][3] =
{
{1882.242676f, 834.818726f, 38.646786f},
{1879.220825f, 842.224854f, 43.333641f},
{1873.842896f, 863.892456f, 43.333641f}
};
const float SaboteurFinalPos3[2][3] =
{
{1904.298340f, 792.400391f, 38.646782f},
{1935.716919f, 758.437073f, 30.627895f}
};
const float SaboteurFinalPos4[3] =
{
1855.006104f, 760.641724f, 38.655266f
};
const float SaboteurFinalPos5[3] =
{
1906.667358f, 841.705566f, 38.637894f
};
const float SaboteurFinalPos6[5][3] =
{
{1911.437012f, 821.289246f, 38.684128f},
{1920.734009f, 822.978027f, 41.525414f},
{1928.262939f, 830.836609f, 44.668266f},
{1929.338989f, 837.593933f, 47.137596f},
{1931.063354f, 848.468445f, 47.190434f}
};
#endif