void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SLIME_SPRAY:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
{
DoSummon(NPC_OOZE_SPRAY_STALKER, *target, 8000, TEMPSUMMON_TIMED_DESPAWN);
Talk(EMOTE_SLIME_SPRAY);
DoCast(me, SPELL_SLIME_SPRAY);
}
events.ScheduleEvent(EVENT_SLIME_SPRAY, 20000);
break;
case EVENT_HASTEN_INFECTIONS:
if (infectionStage++ < 4)
{
infectionCooldown -= 2000;
events.ScheduleEvent(EVENT_HASTEN_INFECTIONS, 90000);
}
break;
case EVENT_MUTATED_INFECTION:
me->CastCustomSpell(SPELL_MUTATED_INFECTION, SPELLVALUE_MAX_TARGETS, 1, NULL, false);
events.ScheduleEvent(EVENT_MUTATED_INFECTION, infectionCooldown);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, urand(10 * IN_MILLISECONDS, 16 * IN_MILLISECONDS));
break;
case EVENT_FRIGHTENING_SHOUT:
DoCastVictim(SPELL_FRIGHTENING_SHOUT);
events.ScheduleEvent(EVENT_FRIGHTENING_SHOUT, urand(10 * IN_MILLISECONDS, 15 * IN_MILLISECONDS));
break;
case EVENT_WHIRLWIND1:
DoCastVictim(SPELL_WHIRLWIND1);
events.ScheduleEvent(EVENT_WHIRLWIND1, urand(6 * IN_MILLISECONDS, 10 * IN_MILLISECONDS));
break;
case EVENT_WHIRLWIND2:
DoCastVictim(SPELL_WHIRLWIND2);
events.ScheduleEvent(EVENT_WHIRLWIND2, urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS));
break;
case EVENT_MORTAL_STRIKE:
DoCastVictim(SPELL_MORTAL_STRIKE);
events.ScheduleEvent(EVENT_MORTAL_STRIKE, urand(10 * IN_MILLISECONDS, 30 * IN_MILLISECONDS));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_WHIRLWIND:
DoCastVictim(SPELL_WHIRLWIND);
events.ScheduleEvent(EVENT_WHIRLWIND, urand(8 * IN_MILLISECONDS, 18 * IN_MILLISECONDS));
break;
case EVENT_WHIRLWIND2:
DoCastVictim(SPELL_WHIRLWIND2);
events.ScheduleEvent(EVENT_WHIRLWIND2, urand(7 * IN_MILLISECONDS, 25 * IN_MILLISECONDS));
break;
case EVENT_KNOCKDOWN:
DoCastVictim(SPELL_KNOCKDOWN);
events.ScheduleEvent(EVENT_KNOCKDOWN, urand(10 * IN_MILLISECONDS, 15 * IN_MILLISECONDS));
break;
case EVENT_FRENZY:
DoCastVictim(SPELL_FRENZY);
events.ScheduleEvent(EVENT_FRENZY, urand(20 * IN_MILLISECONDS, 30 * IN_MILLISECONDS));
break;
case EVENT_RANDOM_YELL:
Talk(SAY_RANDOM);
events.ScheduleEvent(EVENT_RANDOM_YELL, urand(20 * IN_MILLISECONDS, 30 * IN_MILLISECONDS));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_DISRUPT:
DoCastAOE(SPELL_SPELL_DISRUPTION);
events.ScheduleEvent(EVENT_DISRUPT, urand(5000, 10000));
break;
case EVENT_FEVER:
DoCastAOE(SPELL_DECREPIT_FEVER);
events.ScheduleEvent(EVENT_FEVER, urand(20000, 25000));
break;
case EVENT_PHASE:
// TODO : Add missing texts for both phase switches
EnterPhase(phase == PHASE_FIGHT ? PHASE_DANCE : PHASE_FIGHT);
break;
case EVENT_ERUPT:
instance->SetData(DATA_HEIGAN_ERUPT, eruptSection);
TeleportCheaters();
if (eruptSection == 0)
eruptDirection = true;
else if (eruptSection == 3)
eruptDirection = false;
eruptDirection ? ++eruptSection : --eruptSection;
events.ScheduleEvent(EVENT_ERUPT, phase == PHASE_FIGHT ? 10000 : 3000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_IMPALE:
//Cast Impale on a random target
//Do NOT cast it when we are afflicted by locust swarm
if (!me->HasAura(RAID_MODE(SPELL_LOCUST_SWARM_10, SPELL_LOCUST_SWARM_25)))
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, RAID_MODE(SPELL_IMPALE_10, SPELL_IMPALE_25));
events.ScheduleEvent(EVENT_IMPALE, urand(10000, 20000));
break;
case EVENT_LOCUST:
// TODO : Add Text
DoCast(me, RAID_MODE(SPELL_LOCUST_SWARM_10, SPELL_LOCUST_SWARM_25));
DoSummon(MOB_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);
events.ScheduleEvent(EVENT_LOCUST, 90000);
break;
case EVENT_SPAWN_GUARDIAN_NORMAL:
// TODO : Add Text
DoSummon(MOB_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
events.ScheduleEvent(EVENT_BERSERK, 600000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CAST_CLEAVE_ARMOR:
DoCastVictim(SPELL_CLEAVE_ARMOR);
events.ScheduleEvent(EVENT_CAST_CLEAVE_ARMOR, urand(3500,4500));
break;
case EVENT_CAST_INTIMIDATING_ROAR:
DoCastAOE(SPELL_INTIMIDATING_ROAR);
events.ScheduleEvent(EVENT_CAST_INTIMIDATING_ROAR, urand(10000,11000));
break;
case EVENT_CAST_SUMMON_FLAMECALLER:
if (Creature* pCreature1 = me->SummonCreature(NPC_ONYX_FLAMECALLER,SpawnPos[0]))
{
pCreature1->GetMotionMaster()->MovePoint(1,SpawnPos[1]);
}
if (Creature* pCreature2 = me->SummonCreature(NPC_ONYX_FLAMECALLER,SpawnPos[2]))
{
pCreature2->GetMotionMaster()->MovePoint(1,SpawnPos[3]);
}
events.ScheduleEvent(EVENT_CAST_SUMMON_FLAMECALLER, urand(40000,50000));
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->hasUnitState(UNIT_STAT_CASTING))
return;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_MARK:
if (!(rand()%5))
DoScriptText(SAY_SPECIAL[id], me);
DoCastAOE(SPELL_MARK[id]);
events.ScheduleEvent(EVENT_MARK, 15000);
return;
case EVENT_CAST:
if (!(rand()%5))
DoScriptText(SAY_TAUNT[rand()%3][id], me);
DoCast(SPELL_PRIMARY(id));
events.ScheduleEvent(EVENT_CAST, 15000);
return;
case EVENT_BERSERK:
DoScriptText(SAY_SPECIAL[id], me);
DoCast(me, EVENT_BERSERK);
return;
}
}
if (!caster)
DoMeleeAttackIfReady();
else if (!DoSpellAttackIfReady(SPELL_SECONDARY(id)))
DoCastAOE(SPELL_PUNISH[id]);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_IMPALE:
//Cast Impale on a random target
//Do NOT cast it when we are afflicted by locust swarm
if (!me->HasAura(sSpellMgr->GetSpellIdForDifficulty(SPELL_LOCUST_SWARM, me)))
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_IMPALE);
events.ScheduleEvent(EVENT_IMPALE, urand(10000, 20000));
break;
case EVENT_LOCUST:
/// @todo Add Text
DoCast(me, SPELL_LOCUST_SWARM);
DoSummon(NPC_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);
events.ScheduleEvent(EVENT_LOCUST, 90000);
break;
case EVENT_SPAWN_GUARDIAN_NORMAL:
/// @todo Add Text
DoSummon(NPC_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
events.ScheduleEvent(EVENT_BERSERK, 600000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_IMPALE:
if (!me->HasAura(SPELL_LOCUST_SWARM))
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_IMPALE);
events.ScheduleEvent(EVENT_IMPALE, urand(10000, 20000));
break;
case EVENT_LOCUST:
TalkToMap(EMOTE_LOCUST);
DoCast(me, SPELL_LOCUST_SWARM);
me->SummonCreature(NPC_CRYPT_GUARD, GuardSummonPos, TEMPSUMMON_CORPSE_DESPAWN, 5000);
events.ScheduleEvent(EVENT_LOCUST, 90000);
events.RescheduleEvent(EVENT_IMPALE, 20000);
break;
case EVENT_SUMMON_GUARDIAN:
TalkToMap(EMOTE_CRYPT);
me->SummonCreature(NPC_CRYPT_GUARD, GuardSummonPos, TEMPSUMMON_CORPSE_DESPAWN, 5000);
break;
case EVENT_BERSERK:
DoCastAOE(SPELL_BERSERK);
events.ScheduleEvent(EVENT_BERSERK, 600000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_INHALE_BLIGHT:
{
RemoveBlight();
if (_inhaleCounter == 3)
{
Talk(EMOTE_WARN_PUNGENT_BLIGHT);
Talk(SAY_PUNGENT_BLIGHT);
DoCast(me, SPELL_PUNGENT_BLIGHT);
_inhaleCounter = 0;
if (Creature* professor = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_PROFESSOR_PUTRICIDE)))
professor->AI()->DoAction(ACTION_FESTERGUT_GAS);
events.RescheduleEvent(EVENT_GAS_SPORE, urand(20000, 25000));
}
else
{
DoCast(me, SPELL_INHALE_BLIGHT);
// just cast and dont bother with target, conditions will handle it
++_inhaleCounter;
if (_inhaleCounter < 3)
me->CastSpell(me, gaseousBlight[_inhaleCounter], true, NULL, NULL, me->GetGUID());
}
events.ScheduleEvent(EVENT_INHALE_BLIGHT, urand(33500, 35000));
break;
}
case EVENT_VILE_GAS:
{
std::list<Unit*> targets;
uint32 minTargets = RAID_MODE<uint32>(3, 8, 3, 8);
SelectTargetList(targets, minTargets, SELECT_TARGET_RANDOM, -5.0f, true);
float minDist = 0.0f;
if (targets.size() >= minTargets)
minDist = -5.0f;
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, minDist, true))
DoCast(target, SPELL_VILE_GAS);
events.ScheduleEvent(EVENT_VILE_GAS, urand(28000, 35000));
break;
}
case EVENT_GAS_SPORE:
Talk(EMOTE_WARN_GAS_SPORE);
Talk(EMOTE_GAS_SPORE);
me->CastCustomSpell(SPELL_GAS_SPORE, SPELLVALUE_MAX_TARGETS, RAID_MODE<int32>(2, 3, 2, 3), me);
events.ScheduleEvent(EVENT_GAS_SPORE, urand(40000, 45000));
events.RescheduleEvent(EVENT_VILE_GAS, urand(28000, 35000));
break;
case EVENT_GASTRIC_BLOAT:
DoCastVictim(SPELL_GASTRIC_BLOAT);
events.ScheduleEvent(EVENT_GASTRIC_BLOAT, urand(15000, 17500));
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK2);
Talk(SAY_BERSERK);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_INHALE_BLIGHT:
{
RemoveBlight();
if (_inhaleCounter == 3)
{
Talk(EMOTE_WARN_PUNGENT_BLIGHT);
Talk(SAY_PUNGENT_BLIGHT);
DoCast(me, SPELL_PUNGENT_BLIGHT);
_inhaleCounter = 0;
if (Creature* professor = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_PROFESSOR_PUTRICIDE)))
professor->AI()->DoAction(ACTION_FESTERGUT_GAS);
events.RescheduleEvent(EVENT_GAS_SPORE, urand(20000, 25000));
}
else
{
DoCast(me, SPELL_INHALE_BLIGHT);
// just cast and dont bother with target, conditions will handle it
++_inhaleCounter;
if (_inhaleCounter < 3)
me->CastSpell(me, gaseousBlight[_inhaleCounter], true, NULL, NULL, me->GetGUID());
}
events.ScheduleEvent(EVENT_INHALE_BLIGHT, urand(33500, 35000));
break;
}
case EVENT_VILE_GAS:
{
std::list<Unit*> ranged, melee;
uint32 minTargets = RAID_MODE<uint32>(3, 8, 3, 8);
SelectTargetList(ranged, 25, SELECT_TARGET_RANDOM, -5.0f, true);
SelectTargetList(melee, 25, SELECT_TARGET_RANDOM, 5.0f, true);
while (ranged.size() < minTargets)
{
if (melee.empty())
break;
Unit* target = Trinity::Containers::SelectRandomContainerElement(melee);
ranged.push_back(target);
melee.remove(target);
}
if (!ranged.empty())
{
Trinity::Containers::RandomResizeList(ranged, RAID_MODE<uint32>(1, 3, 1, 3));
for (std::list<Unit*>::iterator itr = ranged.begin(); itr != ranged.end(); ++itr)
DoCast(*itr, SPELL_VILE_GAS);
}
events.ScheduleEvent(EVENT_VILE_GAS, urand(28000, 35000));
break;
}
case EVENT_GAS_SPORE:
Talk(EMOTE_WARN_GAS_SPORE);
Talk(EMOTE_GAS_SPORE);
me->CastCustomSpell(SPELL_GAS_SPORE, SPELLVALUE_MAX_TARGETS, RAID_MODE<int32>(2, 3, 2, 3), me);
events.ScheduleEvent(EVENT_GAS_SPORE, urand(40000, 45000));
events.RescheduleEvent(EVENT_VILE_GAS, urand(28000, 35000));
break;
case EVENT_GASTRIC_BLOAT:
DoCastVictim(SPELL_GASTRIC_BLOAT);
events.ScheduleEvent(EVENT_GASTRIC_BLOAT, urand(15000, 17500));
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK2);
Talk(SAY_BERSERK);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BONE_SPIKE_GRAVEYARD:
if (IsHeroic() || !me->HasAura(SPELL_BONE_STORM))
DoCast(me, SPELL_BONE_SPIKE_GRAVEYARD);
events.ScheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, urand(15000, 20000), EVENT_GROUP_SPECIAL);
break;
case EVENT_COLDFLAME:
_coldflameLastPos.Relocate(me);
_coldflameTarget.Clear();
if (!me->HasAura(SPELL_BONE_STORM))
DoCastAOE(SPELL_COLDFLAME_NORMAL);
else
DoCast(me, SPELL_COLDFLAME_BONE_STORM);
events.ScheduleEvent(EVENT_COLDFLAME, 5000, EVENT_GROUP_SPECIAL);
break;
case EVENT_WARN_BONE_STORM:
_boneSlice = false;
Talk(EMOTE_BONE_STORM);
me->FinishSpell(CURRENT_MELEE_SPELL, false);
DoCast(me, SPELL_BONE_STORM);
events.DelayEvents(3000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_BONE_STORM_BEGIN, 3050);
events.ScheduleEvent(EVENT_WARN_BONE_STORM, urand(90000, 95000));
break;
case EVENT_BONE_STORM_BEGIN:
if (Aura* pStorm = me->GetAura(SPELL_BONE_STORM))
pStorm->SetDuration(int32(_boneStormDuration));
me->SetSpeed(MOVE_RUN, _baseSpeed*3.0f, true);
Talk(SAY_BONE_STORM);
events.ScheduleEvent(EVENT_BONE_STORM_END, _boneStormDuration+1);
// no break here
case EVENT_BONE_STORM_MOVE:
{
events.ScheduleEvent(EVENT_BONE_STORM_MOVE, _boneStormDuration/3);
Unit* unit = SelectTarget(SELECT_TARGET_RANDOM, 0, NonTankTargetSelector(me));
if (!unit)
unit = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
if (unit)
me->GetMotionMaster()->MovePoint(POINT_TARGET_BONESTORM_PLAYER, *unit);
break;
}
case EVENT_BONE_STORM_END:
if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
me->GetMotionMaster()->MovementExpired();
me->GetMotionMaster()->MoveChase(me->GetVictim());
me->SetSpeed(MOVE_RUN, _baseSpeed, true);
events.CancelEvent(EVENT_BONE_STORM_MOVE);
events.ScheduleEvent(EVENT_ENABLE_BONE_SLICE, 10000);
if (!IsHeroic())
events.RescheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, 15000, EVENT_GROUP_SPECIAL);
break;
case EVENT_ENABLE_BONE_SLICE:
_boneSlice = true;
break;
case EVENT_ENRAGE:
DoCast(me, SPELL_BERSERK, true);
Talk(SAY_BERSERK);
break;
}
}
// We should not melee attack when storming
if (me->HasAura(SPELL_BONE_STORM))
return;
// 10 seconds since encounter start Bone Slice replaces melee attacks
if (_boneSlice && !me->GetCurrentSpell(CURRENT_MELEE_SPELL))
DoCastVictim(SPELL_BONE_SLICE);
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (!thirtyPercentReached && HealthBelowPct(30) && phaseTwo)
{
thirtyPercentReached = true;
if (instance)
instance->SetData(DATA_GOTHIK_GATE, GO_STATE_ACTIVE);
}
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_SUMMON:
if (waves[waveCount].entry)
{
if ((waves[waveCount].mode == 2) && (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL))
DoGothikSummon(waves[waveCount].entry);
else if ((waves[waveCount].mode == 0) && (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL))
DoGothikSummon(waves[waveCount].entry);
else if (waves[waveCount].mode == 1)
DoGothikSummon(waves[waveCount].entry);
// if group is not splitted, open gate and merge both sides at ~ 2 minutes (wave 11)
if (waveCount == 11)
{
if (!CheckGroupSplitted())
{
if (instance)
instance->SetData(DATA_GOTHIK_GATE, GO_STATE_ACTIVE);
summons.DoAction(0, 0);
summons.DoZoneInCombat();
mergedSides = true;
}
}
if (waves[waveCount].mode == 1)
events.ScheduleEvent(EVENT_SUMMON, waves[waveCount].time);
else if ((waves[waveCount].mode == 2) && (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL))
events.ScheduleEvent(EVENT_SUMMON, waves[waveCount].time);
else if ((waves[waveCount].mode == 0) && (getDifficulty() == RAID_DIFFICULTY_10MAN_NORMAL))
events.ScheduleEvent(EVENT_SUMMON, waves[waveCount].time);
else
events.ScheduleEvent(EVENT_SUMMON, 0);
++waveCount;
}
else
{
phaseTwo = true;
DoScriptText(SAY_TELEPORT, me);
DoTeleportTo(PosGroundLiveSide);
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
summons.DoAction(0, 0);
summons.DoZoneInCombat();
events.ScheduleEvent(EVENT_BOLT, 1000);
events.ScheduleEvent(EVENT_HARVEST, urand(3000, 15000));
events.ScheduleEvent(EVENT_TELEPORT, 20000);
}
break;
case EVENT_BOLT:
DoCast(me->getVictim(), RAID_MODE(SPELL_SHADOW_BOLT, H_SPELL_SHADOW_BOLT));
events.ScheduleEvent(EVENT_BOLT, 1000);
break;
case EVENT_HARVEST:
DoCast(me->getVictim(), SPELL_HARVEST_SOUL, true);
events.ScheduleEvent(EVENT_HARVEST, urand(20000, 25000));
break;
case EVENT_TELEPORT:
if (!thirtyPercentReached)
{
me->AttackStop();
if (IN_LIVE_SIDE(me))
{
DoTeleportTo(PosGroundDeadSide);
}
else
{
DoTeleportTo(PosGroundLiveSide);
}
me->getThreatManager().resetAggro(NotOnSameSide(me));
if (Unit *pTarget = SelectTarget(SELECT_TARGET_NEAREST, 0))
{
me->getThreatManager().addThreat(pTarget, 100.0f);
AttackStart(pTarget);
}
events.ScheduleEvent(EVENT_TELEPORT, 20000);
}
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateCombatState() || !CheckInRoom())
return;
events.Update(diff);
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_CURSE:
DoCastAOE(SPELL_CURSE_PLAGUEBRINGER);
events.ScheduleEvent(EVENT_CURSE, 20000+rand()%10000);
return;
case EVENT_WARRIOR:
DoScriptText(SAY_SUMMON, me);
SummonUndead(MOB_WARRIOR, HEROIC(2,3));
events.ScheduleEvent(EVENT_WARRIOR, 30000);
return;
case EVENT_BLINK:
DoCastAOE(SPELL_CRIPPLE, true);
DoCastAOE(SPELL_BLINK);
DoResetThreat();
events.ScheduleEvent(EVENT_BLINK, 20000+rand()%10000);
return;
case EVENT_BALCONY:
me->SetReactState(REACT_PASSIVE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->AttackStop();
me->RemoveAllAuras();
me->NearTeleportTo(TELE_X, TELE_Y, TELE_Z, TELE_O);
events.Reset();
events.ScheduleEvent(EVENT_WAVE, 2000);
waveCount = 0;
return;
case EVENT_WAVE:
DoScriptText(SAY_SUMMON, me);
switch(balconyCount)
{
case 0: SummonUndead(MOB_CHAMPION, HEROIC(2,4)); break;
case 1: SummonUndead(MOB_CHAMPION, HEROIC(1,2));
SummonUndead(MOB_GUARDIAN, HEROIC(1,2)); break;
case 2: SummonUndead(MOB_GUARDIAN, HEROIC(2,4)); break;
default:SummonUndead(MOB_CHAMPION, HEROIC(5,10));
SummonUndead(MOB_GUARDIAN, HEROIC(5,10));break;
}
++waveCount;
events.ScheduleEvent(waveCount < 2 ? EVENT_WAVE : EVENT_GROUND, 34000);
return;
case EVENT_GROUND:
{
++balconyCount;
float x, y, z, o;
me->GetHomePosition(x, y, z, o);
me->NearTeleportTo(x, y, z, o);
EnterPhaseGround();
return;
}
}
}
if (me->HasReactState(REACT_AGGRESSIVE))
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom() || me->GetCurrentSpell(CURRENT_CHANNELED_SPELL) || _phase == PHASE_SHIELDED)
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_DIVINE_RECKONING:
if(me->getVictim())
DoCast(me->getVictim(), SPELL_DIVINE_RECKONING);
events.ScheduleEvent(EVENT_DIVINE_RECKONING, urand(10000, 12000));
break;
case EVENT_BURNING_LIGHT:
{
Unit* unit = SelectTarget(SELECT_TARGET_RANDOM, 0, NonTankTargetSelector(me));
if (!unit)
unit = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
// Still no target, reschedule everything, then break ;
if (!unit)
{
events.ScheduleEvent(EVENT_SEAR, 2000);
events.ScheduleEvent(EVENT_BURNING_LIGHT, 12000);
break ;
}
DoCast(unit, SPELL_BURNING_LIGHT);
events.ScheduleEvent(EVENT_SEAR, 2000);
events.ScheduleEvent(EVENT_BURNING_LIGHT, 12000);
break;
}
case EVENT_SEAR:
{
Unit* target = me->FindNearestCreature(NPC_SEARING_LIGHT, 100.0f);
if (!target)
break;
std::list<Creature*> stalkers;
GetCreatureListWithEntryInGrid(stalkers, me, NPC_CAVE_IN_STALKER, 100.0f);
stalkers.remove_if(Trinity::HeightDifferenceCheck(ObjectAccessor::GetGameObject(*me, instance->GetData64(DATA_ANHUUR_DOOR)), 5.0f, true));
if (stalkers.empty())
break;
stalkers.sort(Trinity::ObjectDistanceOrderPred(target));
// Get the closest statue face (any of its eyes)
Creature* eye1 = stalkers.front();
// No pointer, break ;
if(!eye1)
break ;
stalkers.remove(eye1); // Remove the eye.
if(stalkers.empty()) // No object, no pointer
break ;
stalkers.sort(Trinity::ObjectDistanceOrderPred(eye1)); // Find the second eye.
Creature* eye2 = stalkers.front();
// Same deal
if(!eye2)
break ;
eye1->CastSpell(eye1, SPELL_SEARING_LIGHT, true);
eye2->CastSpell(eye2, SPELL_SEARING_LIGHT, true);
break;
}
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if ((!UpdateVictim() && !(events.GetPhaseMask() & PHASE_INTRO_MASK)) || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING) && !(events.GetPhaseMask() & PHASE_INTRO_MASK))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_INTRO_2:
Talk(SAY_INTRO_2);
break;
case EVENT_INTRO_3:
Talk(SAY_INTRO_3);
break;
case EVENT_INTRO_4:
Talk(SAY_INTRO_4);
break;
case EVENT_INTRO_5:
Talk(SAY_INTRO_5);
break;
case EVENT_INTRO_6:
Talk(SAY_INTRO_6);
break;
case EVENT_INTRO_7:
Talk(SAY_INTRO_7);
break;
case EVENT_INTRO_FINISH:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
break;
case EVENT_DEATH_AND_DECAY:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
DoCast(target, SPELL_DEATH_AND_DECAY);
events.ScheduleEvent(EVENT_DEATH_AND_DECAY, urand(10000, 12000));
}
break;
case EVENT_DOMINATE_MIND_H:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
Talk(SAY_DOMINATE_MIND);
for (uint8 i = 0; i < _dominateMindCount; i++)
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -SPELL_DOMINATE_MIND_H))
DoCast(target, SPELL_DOMINATE_MIND_H);
events.ScheduleEvent(EVENT_DOMINATE_MIND_H, urand(40000, 45000));
}
break;
case EVENT_P1_SUMMON_WAVE:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
SummonWaveP1();
events.ScheduleEvent(EVENT_P1_SUMMON_WAVE, 60000, 0, PHASE_ONE);
}
break;
case EVENT_P1_SHADOW_BOLT:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
DoCast(target, SPELL_SHADOW_BOLT);
events.ScheduleEvent(EVENT_P1_SHADOW_BOLT, urand(5000, 8000), 0, PHASE_ONE);
}
break;
case EVENT_P1_REANIMATE_CULTIST:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
ReanimateCultist();
break;
case EVENT_P1_EMPOWER_CULTIST:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
EmpowerCultist();
events.ScheduleEvent(EVENT_P1_EMPOWER_CULTIST, urand(18000, 25000));
}
break;
case EVENT_P2_FROSTBOLT:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
DoCastVictim(SPELL_FROSTBOLT);
events.ScheduleEvent(EVENT_P2_FROSTBOLT, urand(10000, 11000), 0, PHASE_TWO);
}
break;
case EVENT_P2_FROSTBOLT_VOLLEY:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
DoCastAOE(SPELL_FROSTBOLT_VOLLEY);
events.ScheduleEvent(EVENT_P2_FROSTBOLT_VOLLEY, urand(13000, 15000), 0, PHASE_TWO);
}
break;
case EVENT_P2_TOUCH_OF_INSIGNIFICANCE:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
DoCastVictim(SPELL_TOUCH_OF_INSIGNIFICANCE);
events.ScheduleEvent(EVENT_P2_TOUCH_OF_INSIGNIFICANCE, urand(9000, 13000), 0, PHASE_TWO);
}
break;
case EVENT_P2_SUMMON_SHADE:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
if (Unit* shadeTarget = SelectTarget(SELECT_TARGET_RANDOM, 1))
{
_nextVengefulShadeTargetGUID = shadeTarget->GetGUID();
DoCast(shadeTarget, SPELL_SUMMON_SHADE);
}
events.ScheduleEvent(EVENT_P2_SUMMON_SHADE, urand(18000, 23000), 0, PHASE_TWO);
}
break;
case EVENT_P2_SUMMON_WAVE:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
SummonWaveP2();
events.ScheduleEvent(EVENT_P2_SUMMON_WAVE, 60000, 0, PHASE_TWO);
}
break;
case EVENT_BERSERK:
if (!instance->GetData(DATA_INSTANCE_SPELL_VERIFICATION))
{
DoCast(me, SPELL_BERSERK);
Talk(SAY_BERSERK);
}
break;
}
}
// We should not melee attack when barrier is up
if (me->HasAura(SPELL_MANA_BARRIER))
return;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!phase)
return;
events.Update(diff);
if ((phase != PHASE_BIRTH && !UpdateVictim()) || !CheckInRoom())
return;
if (CanTheHundredClub)
{
if (CheckFrostResistTimer <= diff)
{
CheckPlayersFrostResist();
CheckFrostResistTimer = (rand() % 5 + 5) * 1000;
} else CheckFrostResistTimer -= diff;
}
if (phase == PHASE_GROUND)
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
DoScriptText(EMOTE_ENRAGE, me);
DoCast(me, SPELL_BERSERK);
return;
case EVENT_CLEAVE:
DoCast(me->getVictim(), SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, 5000+rand()%10000, 0, PHASE_GROUND);
return;
case EVENT_TAIL:
DoCastAOE(SPELL_TAIL_SWEEP);
events.ScheduleEvent(EVENT_TAIL, 5000+rand()%10000, 0, PHASE_GROUND);
return;
case EVENT_DRAIN:
DoCastAOE(SPELL_LIFE_DRAIN);
events.ScheduleEvent(EVENT_DRAIN, 24000, 0, PHASE_GROUND);
return;
case EVENT_BLIZZARD:
{
//DoCastAOE(SPELL_SUMMON_BLIZZARD);
if (Creature* summon = DoSummon(MOB_BLIZZARD, me, 0.0f, urand(25000, 30000), TEMPSUMMON_TIMED_DESPAWN))
summon->GetMotionMaster()->MoveRandom(40);
events.ScheduleEvent(EVENT_BLIZZARD, RAID_MODE(20000, 7000), 0, PHASE_GROUND);
break;
}
case EVENT_FLIGHT:
if (HealthAbovePct(10))
{
phase = PHASE_FLIGHT;
events.SetPhase(PHASE_FLIGHT);
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
float x, y, z, o;
me->GetHomePosition(x, y, z, o);
me->GetMotionMaster()->MovePoint(1, x, y, z);
return;
}
break;
}
}
DoMeleeAttackIfReady();
}
else
{
if (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_LIFTOFF:
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->SetLevitate(true);
me->SendMovementFlagUpdate();
events.ScheduleEvent(EVENT_ICEBOLT, 1500);
iceboltCount = RAID_MODE(2, 3);
return;
case EVENT_ICEBOLT:
{
std::vector<Unit*> targets;
std::list<HostileReference*>::const_iterator i = me->getThreatManager().getThreatList().begin();
for (; i != me->getThreatManager().getThreatList().end(); ++i)
if ((*i)->getTarget()->GetTypeId() == TYPEID_PLAYER && !(*i)->getTarget()->HasAura(SPELL_ICEBOLT))
targets.push_back((*i)->getTarget());
if (targets.empty())
iceboltCount = 0;
else
{
std::vector<Unit*>::const_iterator itr = targets.begin();
advance(itr, rand()%targets.size());
iceblocks.insert(std::make_pair((*itr)->GetGUID(), 0));
DoCast(*itr, SPELL_ICEBOLT);
--iceboltCount;
}
if (iceboltCount)
events.ScheduleEvent(EVENT_ICEBOLT, 1000);
else
events.ScheduleEvent(EVENT_BREATH, 1000);
return;
}
case EVENT_BREATH:
{
DoScriptText(EMOTE_BREATH, me);
DoCastAOE(SPELL_FROST_MISSILE);
events.ScheduleEvent(EVENT_EXPLOSION, 8000);
return;
}
case EVENT_EXPLOSION:
CastExplosion();
ClearIceBlock();
events.ScheduleEvent(EVENT_LAND, 3000);
return;
case EVENT_LAND:
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
me->SetLevitate(false);
me->SendMovementFlagUpdate();
events.ScheduleEvent(EVENT_GROUND, 1500);
return;
case EVENT_GROUND:
EnterPhaseGround();
return;
case EVENT_BIRTH:
me->SetVisible(true);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
return;
}
}//if (uint32 eventId = events.ExecuteEvent())
}//if (phase == PHASE_GROUND)
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CHECK_PLAYERS:
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_TANK_MARKER);
events.ScheduleEvent(EVENT_CHECK_PLAYERS, 2000);
break;
case EVENT_PREPARE_BONE_SPIKE_GRAVEYARD:
events.CancelEvent(EVENT_CHECK_PLAYERS);
break;
case EVENT_BONE_SPIKE_GRAVEYARD:
if (IsHeroic() || !me->HasAura(SPELL_BONE_STORM))
DoCast(me, SPELL_BONE_SPIKE_GRAVEYARD);
events.ScheduleEvent(EVENT_PREPARE_BONE_SPIKE_GRAVEYARD, 12000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, 18000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_CHECK_PLAYERS, 4000);
break;
case EVENT_COLDFLAME:
_coldflameLastPos.Relocate(me);
_coldflameTarget = 0LL;
if (!me->HasAura(SPELL_BONE_STORM))
DoCastAOE(SPELL_COLDFLAME_NORMAL);
else
DoCast(me, SPELL_COLDFLAME_BONE_STORM);
events.ScheduleEvent(EVENT_COLDFLAME, 5000, EVENT_GROUP_SPECIAL);
break;
case EVENT_WARN_BONE_STORM:
_boneSlice = false;
Talk(EMOTE_BONE_STORM);
me->FinishSpell(CURRENT_MELEE_SPELL, false);
DoCast(me, SPELL_BONE_STORM);
events.DelayEvents(3000, EVENT_GROUP_SPECIAL);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
events.ScheduleEvent(EVENT_BONE_STORM_BEGIN, 3050);
events.ScheduleEvent(EVENT_WARN_BONE_STORM, 90000);
break;
case EVENT_BONE_STORM_BEGIN:
if (AuraPtr pStorm = me->GetAura(SPELL_BONE_STORM))
pStorm->SetDuration(int32(_boneStormDuration));
me->SetSpeed(MOVE_RUN, _baseSpeed*3.0f, true);
Talk(SAY_BONE_STORM);
events.ScheduleEvent(EVENT_BONE_STORM_END, _boneStormDuration+1);
// no break here
case EVENT_BONE_STORM_MOVE:
{
events.ScheduleEvent(EVENT_BONE_STORM_MOVE, IsHeroic() ? _boneStormDuration/5 : _boneStormDuration/4);
Unit* unit = SelectTarget(SELECT_TARGET_FARTHEST, 0, 60.0f);
if (!unit || unit->isPet() || unit->isTotem() || !me->IsWithinLOSInMap(unit))
unit = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
if (unit)
if (unit->isPet() || unit->isTotem() || !me->IsWithinLOSInMap(unit))
unit = SelectTarget(SELECT_TARGET_RANDOM, 1);
else
me->GetMotionMaster()->MovePoint(POINT_TARGET_BONESTORM_PLAYER, unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
break;
}
case EVENT_BONE_STORM_END:
if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
me->GetMotionMaster()->MovementExpired();
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
DoStartMovement(me->getVictim());
me->SetSpeed(MOVE_RUN, _baseSpeed, true);
events.CancelEvent(EVENT_BONE_STORM_MOVE);
events.ScheduleEvent(EVENT_ENABLE_BONE_SLICE, 10000);
if (!IsHeroic())
events.RescheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, 15000, EVENT_GROUP_SPECIAL);
break;
case EVENT_ENABLE_BONE_SLICE:
_boneSlice = true;
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
Talk(SAY_BERSERK);
break;
}
}
// We should not melee attack when storming
if (me->HasAura(SPELL_BONE_STORM))
return;
// 10 seconds since encounter start Bone Slice replaces melee attacks
if (_boneSlice && !me->GetCurrentSpell(CURRENT_MELEE_SPELL))
DoCastVictim(SPELL_BONE_SLICE);
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom() || me->HasUnitState(UNIT_STATE_CASTING))
return;
if (instance && instance->IsWipe())
{
EnterEvadeMode();
return;
}
if (me->GetPower(POWER_ENERGY) == 100 && !breathScheduled)
{
events.ScheduleEvent(EVENT_FURIOUS_STONE_BREATH, TIMER_FURIOUS_STONE_BREATH);
events.ScheduleEvent(EVENT_RESET_CAST, TIMER_RESET_CAST);
breathScheduled = true;
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CALL_OF_TORTOS:
Talk(ANN_TURTLES);
DoCast(me, SPELL_CALL_OF_TORTOS);
events.ScheduleEvent(EVENT_CALL_OF_TORTOS, TIMER_CALL_OF_TORTOS_S);
break;
case EVENT_FURIOUS_STONE_BREATH:
Talk(ANN_FURIOUS_BREATH);
DoCast(me, SPELL_FURIOUS_STONE_BREATH);
break;
case EVENT_RESET_CAST:
breathScheduled = false;
break;
case EVENT_SNAPPING_BITE:
DoCast(me->getVictim(), SPELL_SNAPPING_BITE);
events.ScheduleEvent(EVENT_SNAPPING_BITE, IsHeroic() ? TIMER_SNAPPING_BITE_H : TIMER_SNAPPING_BITE_N);
break;
case EVENT_QUAKE_STOMP:
DoCast(me, SPELL_QUAKE_STOMP);
events.ScheduleEvent(EVENT_QUAKE_STOMP, TIMER_QUAKE_STOMP_S);
break;
case EVENT_SUMMON_BATS:
if (Unit* target = SelectTarget(SELECT_TARGET_FARTHEST, 0, 100.0f, true))
me->CastSpell(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ() + 12.0f, SPELL_SUMMON_BATS, true);
events.ScheduleEvent(EVENT_SUMMON_BATS, TIMER_CALL_BATS_S);
break;
case EVENT_GROWING_FURY:
if (!me->IsWithinDistInMap(me->getVictim(), me->GetAttackDistance(me->getVictim())))
DoCast(me, SPELL_GROWING_FURY);
events.ScheduleEvent(EVENT_GROWING_FURY, TIMER_GROWING_FURY);
break;
case EVENT_REGEN_FURY_POWER:
me->SetPower(POWER_ENERGY, me->GetPower(POWER_ENERGY) + 2);
events.ScheduleEvent(EVENT_REGEN_FURY_POWER, TIMER_REGEN_FURY_POWER);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
break;
default: break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
if (events.GetPhaseMask() & PHASE_3_MASK)
{
if (instance->GetData(DATA_DAMAGE) != 0)
me->SetHealth(instance->GetData(DATA_DAMAGE));
else
me->SetHealth(1);
}
if (me->hasUnitState(UNIT_STAT_CASTING))
return;
events.Update(diff);
GameObject* go_flame;
if ((events.GetPhaseMask() & PHASE_1_MASK) || (events.GetPhaseMask() & PHASE_3_MASK))
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CAST_TWILIGHT_PRECISION:
DoCast(me, SPELL_TWILIGHT_PRECISION);
break;
case EVENT_FLAME_WALL:
go_flame = me->SummonGameObject(GO_FLAME_WALLS2, (float)3154.56, (float)535.418, (float)72.8889, (float)4.47206, 0, 0, (float)0.786772, (float)-0.617243, 300);
go_flame->SetPhaseMask(0,true);
break;
case EVENT_CAST_TAIL_LASH:
DoCast(me, SPELL_TAIL_LASH);
events.ScheduleEvent(EVENT_CAST_TAIL_LASH, urand(10000,15000),PHASE_ALL);
break;
case EVENT_CAST_CLEAVE:
DoCast(me, SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CAST_CLEAVE, 15000,PHASE_ALL);
break;
case EVENT_CAST_FLAME_BREATH:
DoCast(me, RAID_MODE(SPELL_FLAME_BREATH_10_NORMAL, SPELL_FLAME_BREATH_25_NORMAL, SPELL_FLAME_BREATH_10_HEROIC, SPELL_FLAME_BREATH_25_HEROIC));
events.ScheduleEvent(EVENT_CAST_FLAME_BREATH, urand(20000,25000),PHASE_ALL);break;
case EVENT_DPS:
CastCorporeality();
events.ScheduleEvent(EVENT_DPS, 5000,PHASE_3);
break;
case EVENT_CAST_FIERY_COMBUSTION:
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);
if (pTarget && !pTarget->HasAura(SPELL_FIERY_COMBUSTION))
DoCast(pTarget, SPELL_FIERY_COMBUSTION);
events.ScheduleEvent(EVENT_CAST_FIERY_COMBUSTION, 15000,PHASE_ALL);
break;
}
}
}
if ((events.GetPhaseMask() & PHASE_1_MASK) && ((me->GetHealth()*100) / me->GetMaxHealth() <= 75))
{
events.SetPhase(PHASE_2);
DoScriptText(SAY_PHASE2, me);
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
DoCast(me, SPELL_SUMMON_TWILIGHT_PORTAL);
DoCast(me, SPELL_TWILIGHT_DIVISION);
me->SummonCreature(NPC_TWILIGHT_HALION,SpawnPos);
me->SetVisible(false);
instance->SetBossState(DATA_HALION, SPECIAL);
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->hasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_INHALE_BLIGHT:
{
if (Creature* gasDummy = Unit::GetCreature(*me, gasDummyGUID))
for (uint8 i = 0; i < 3; ++i)
{
gasDummy->RemoveAurasDueToSpell(gaseousBlight[i]);
gasDummy->RemoveAurasDueToSpell(gaseousBlightVisual[i]);
}
if (uiInhaleCounter == 3)
{
DoScriptText(EMOTE_WARN_PUNGENT_BLIGHT, me);
DoScriptText(SAY_PUNGENT_BLIGHT, me);
DoCast(me, SPELL_PUNGENT_BLIGHT);
uiInhaleCounter = 0;
if (Creature* professor = Unit::GetCreature(*me, instance->GetData64(DATA_PROFESSOR_PUTRICIDE)))
professor->AI()->DoAction(ACTION_FESTERGUT_GAS);
}
else
{
DoCast(me, SPELL_INHALE_BLIGHT);
// just cast and dont bother with target, conditions will handle it
++uiInhaleCounter;
if (uiInhaleCounter < 3)
me->CastSpell(me, gaseousBlight[uiInhaleCounter], true, NULL, NULL, me->GetGUID());
}
events.ScheduleEvent(EVENT_INHALE_BLIGHT, urand(33500, 35000));
return;
}
case EVENT_VILE_GAS:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, -5.0f, true))
DoCast(target, SPELL_VILE_GAS);
events.ScheduleEvent(EVENT_VILE_GAS, urand(28000, 35000));
break;
case EVENT_GAS_SPORE:
DoScriptText(EMOTE_WARN_GAS_SPORE, me);
me->CastCustomSpell(SPELL_GAS_SPORE, SPELLVALUE_MAX_TARGETS, RAID_MODE<int32>(2,3,2,3), me);
DoScriptText(EMOTE_GAS_SPORE, me);
events.ScheduleEvent(EVENT_GAS_SPORE, urand(40000, 45000));
case EVENT_GASTRIC_BLOAT:
DoCastVictim(SPELL_GASTRIC_BLOAT);
events.ScheduleEvent(EVENT_GASTRIC_BLOAT, urand(15000, 17500));
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK2);
DoScriptText(SAY_BERSERK, me);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
Talk(EMOTE_BERSERK_RAID);
Talk(SAY_BERSERK);
DoCast(me, SPELL_BERSERK);
break;
case EVENT_VAMPIRIC_BITE:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
if (!targets.empty())
{
Unit* target = targets.front();
DoCast(target, SPELL_VAMPIRIC_BITE);
DoCastAOE(SPELL_VAMPIRIC_BITE_DUMMY, true);
Talk(SAY_VAMPIRIC_BITE);
_vampires.insert(target->GetGUID());
target->CastSpell(target, SPELL_PRESENCE_OF_THE_DARKFALLEN, TRIGGERED_FULL_MASK);
target->CastSpell(target, SPELL_PRESENCE_OF_THE_DARKFALLEN_2, TRIGGERED_FULL_MASK);
}
break;
}
case EVENT_BLOOD_MIRROR:
{
// victim can be NULL when this is processed in the same update tick as EVENT_AIR_PHASE
if (me->GetVictim())
{
Player* newOfftank = SelectRandomTarget(true);
if (newOfftank)
{
if (_offtankGUID != newOfftank->GetGUID())
{
_offtankGUID = newOfftank->GetGUID();
// both spells have SPELL_ATTR5_SINGLE_TARGET_SPELL, no manual removal needed
newOfftank->CastSpell(me->GetVictim(), SPELL_BLOOD_MIRROR_DAMAGE, true);
me->EnsureVictim()->CastSpell(newOfftank, SPELL_BLOOD_MIRROR_DUMMY, true);
DoCastVictim(SPELL_BLOOD_MIRROR_VISUAL);
if (Is25ManRaid() && newOfftank->GetQuestStatus(QUEST_BLOOD_INFUSION) == QUEST_STATUS_INCOMPLETE &&
newOfftank->HasAura(SPELL_UNSATED_CRAVING) && !newOfftank->HasAura(SPELL_THIRST_QUENCHED) &&
!newOfftank->HasAura(SPELL_GUSHING_WOUND))
newOfftank->CastSpell(newOfftank, SPELL_GUSHING_WOUND, TRIGGERED_FULL_MASK);
}
}
else
_offtankGUID.Clear();
}
events.ScheduleEvent(EVENT_BLOOD_MIRROR, 2500, EVENT_GROUP_CANCELLABLE);
break;
}
case EVENT_DELIRIOUS_SLASH:
if (_offtankGUID && !me->HasByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND | UNIT_BYTE1_FLAG_HOVER))
if (Player* _offtank = ObjectAccessor::GetPlayer(*me, _offtankGUID))
DoCast(_offtank, SPELL_DELIRIOUS_SLASH);
events.ScheduleEvent(EVENT_DELIRIOUS_SLASH, urand(20000, 24000), EVENT_GROUP_NORMAL);
break;
case EVENT_PACT_OF_THE_DARKFALLEN:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
Trinity::Containers::RandomResizeList(targets, Is25ManRaid() ? 3 : 2);
if (targets.size() > 1)
{
Talk(SAY_PACT_OF_THE_DARKFALLEN);
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_PACT_OF_THE_DARKFALLEN);
}
events.ScheduleEvent(EVENT_PACT_OF_THE_DARKFALLEN, 30500, EVENT_GROUP_NORMAL);
break;
}
case EVENT_SWARMING_SHADOWS:
if (Player* target = SelectRandomTarget(false))
{
Talk(EMOTE_SWARMING_SHADOWS, target);
Talk(SAY_SWARMING_SHADOWS);
DoCast(target, SPELL_SWARMING_SHADOWS);
}
events.ScheduleEvent(EVENT_SWARMING_SHADOWS, 30500, EVENT_GROUP_NORMAL);
break;
case EVENT_TWILIGHT_BLOODBOLT:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
Trinity::Containers::RandomResizeList<Player*>(targets, uint32(Is25ManRaid() ? 4 : 2));
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_TWILIGHT_BLOODBOLT);
DoCast(me, SPELL_TWILIGHT_BLOODBOLT_TARGET);
events.ScheduleEvent(EVENT_TWILIGHT_BLOODBOLT, urand(10000, 15000), EVENT_GROUP_NORMAL);
break;
}
case EVENT_AIR_PHASE:
DoStopAttack();
me->SetReactState(REACT_PASSIVE);
events.DelayEvents(10000, EVENT_GROUP_NORMAL);
events.CancelEventGroup(EVENT_GROUP_CANCELLABLE);
me->GetMotionMaster()->MovePoint(POINT_CENTER, centerPos);
break;
case EVENT_AIR_START_FLYING:
me->SetDisableGravity(true);
me->SetByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND);
me->GetMotionMaster()->MovePoint(POINT_AIR, airPos);
break;
case EVENT_AIR_FLY_DOWN:
me->GetMotionMaster()->MovePoint(POINT_GROUND, centerPos);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
if (HealthBelowPct(30) && !me->HasAura(SPELL_FRENZY_HELPER))
{
DoCast(SPELL_FRENZY);
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_WRAP:
{
std::list<Unit*> targets;
SelectTargetList(targets, WebTargetSelector(me), RAID_MODE(1, 2), SELECT_TARGET_RANDOM);
if (!targets.empty())
{
Talk(EMOTE_WEB_WRAP);
int8 wrapPos = -1;
for (Unit* target : targets)
{
if (wrapPos == -1) // allow all positions on the first target
wrapPos = urand(0, MAX_WRAP_POSITION - 1);
else // on subsequent iterations, only allow positions that are not equal to the previous one (this is sufficient since we should only have two targets at most, ever)
wrapPos = (wrapPos + urand(1, MAX_WRAP_POSITION - 1)) % MAX_WRAP_POSITION;
target->RemoveAura(sSpellMgr->GetSpellIdForDifficulty(SPELL_WEB_SPRAY, me));
if (Creature* wrap = DoSummon(NPC_WEB_WRAP, WrapPositions[wrapPos], 70 * IN_MILLISECONDS, TEMPSUMMON_TIMED_DESPAWN))
{
wrap->AI()->SetGUID(target->GetGUID()); // handles application of debuff
target->GetMotionMaster()->MoveJump(WrapPositions[wrapPos], WEB_WRAP_MOVE_SPEED, WEB_WRAP_MOVE_SPEED); // move after stun to avoid stun cancelling move
}
}
}
events.ScheduleEvent(EVENT_WRAP, 40000);
break;
}
case EVENT_SPRAY:
Talk(EMOTE_WEB_SPRAY);
DoCastAOE(SPELL_WEB_SPRAY);
events.ScheduleEvent(EVENT_SPRAY, 40000);
break;
case EVENT_SHOCK:
DoCastAOE(SPELL_POISON_SHOCK);
events.ScheduleEvent(EVENT_SHOCK, urandms(10, 20));
break;
case EVENT_POISON:
DoCastVictim(SPELL_NECROTIC_POISON);
events.ScheduleEvent(EVENT_POISON, urandms(10, 20));
break;
case EVENT_SUMMON:
Talk(EMOTE_SPIDERS);
uint8 amount = urand(8, 10);
for (uint8 i = 0; i < amount; ++i)
DoSummon(NPC_SPIDERLING, me, 4.0f, 5 * IN_MILLISECONDS, TEMPSUMMON_CORPSE_TIMED_DESPAWN);
events.ScheduleEvent(EVENT_SUMMON, 40000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_DISRUPT:
DoCastAOE(SPELL_SPELL_DISRUPTION);
events.ScheduleEvent(EVENT_DISRUPT, 11 * IN_MILLISECONDS);
break;
case EVENT_FEVER:
DoCastAOE(SPELL_DECREPIT_FEVER);
events.ScheduleEvent(EVENT_FEVER, urand(20 * IN_MILLISECONDS, 25 * IN_MILLISECONDS));
break;
case EVENT_DANCE:
events.SetPhase(PHASE_DANCE);
Talk(SAY_TAUNT);
Talk(EMOTE_DANCE);
eruptSection = 3;
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
me->StopMoving();
DoCast(SPELL_TELEPORT_SELF);
DoCastAOE(SPELL_PLAGUE_CLOUD);
events.ScheduleEvent(EVENT_DANCE_END, 45 * IN_MILLISECONDS, 0, PHASE_DANCE);
events.ScheduleEvent(EVENT_ERUPT, 10 * IN_MILLISECONDS);
break;
case EVENT_DANCE_END:
events.SetPhase(PHASE_FIGHT);
Talk(EMOTE_DANCE_END);
eruptSection = 3;
events.ScheduleEvent(EVENT_DISRUPT, urand(10, 25) * IN_MILLISECONDS, 0, PHASE_FIGHT);
events.ScheduleEvent(EVENT_FEVER, urand(15, 20) * IN_MILLISECONDS, 0, PHASE_FIGHT);
events.ScheduleEvent(EVENT_DANCE, 90 * IN_MILLISECONDS, 0, PHASE_FIGHT);
events.ScheduleEvent(EVENT_ERUPT, 15 * IN_MILLISECONDS, 0, PHASE_FIGHT);
me->CastStop();
me->SetReactState(REACT_AGGRESSIVE);
DoZoneInCombat();
break;
case EVENT_ERUPT:
instance->SetData(DATA_HEIGAN_ERUPT, eruptSection);
TeleportCheaters();
if (eruptSection == 0)
eruptDirection = true;
else if (eruptSection == 3)
eruptDirection = false;
eruptDirection ? ++eruptSection : --eruptSection;
if (events.IsInPhase(PHASE_DANCE))
events.ScheduleEvent(EVENT_ERUPT, 3 * IN_MILLISECONDS, 0, PHASE_DANCE);
else
events.ScheduleEvent(EVENT_ERUPT, 10 * IN_MILLISECONDS, 0, PHASE_FIGHT);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_DISRUPT:
DoCastAOE(SPELL_SPELL_DISRUPTION);
events.ScheduleEvent(EVENT_DISRUPT, urand(5000, 10000));
break;
case EVENT_FEVER:
DoCastAOE(RAID_MODE(SPELL_DECREPIT_FEVER_10, SPELL_DECREPIT_FEVER_25));
events.ScheduleEvent(EVENT_FEVER, urand(20000, 25000));
break;
case EVENT_PHASE1:
Talk(EMOTE_TELEPORT2);
me->SetReactState(REACT_AGGRESSIVE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DoZoneInCombat();
events.Reset();
eruptSection = 3;
events.ScheduleEvent(EVENT_DISRUPT, urand(10000, 25000));
events.ScheduleEvent(EVENT_FEVER, urand(15000, 20000));
events.ScheduleEvent(EVENT_PHASE2, 90000);
events.ScheduleEvent(EVENT_ERUPT, 15000);
phase = PHASE_1;
break;
case EVENT_PHASE2:
Talk(SAY_PHASE);
Talk(EMOTE_TELEPORT1);
me->SetReactState(REACT_PASSIVE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->AttackStop();
me->RemoveAllAuras();
float x, y, z, o;
me->GetHomePosition(x, y, z, o);
me->NearTeleportTo(x, y, z, o);
DoCastAOE(SPELL_PLAGUE_CLOUD);
events.Reset();
events.ScheduleEvent(EVENT_PHASE1, 45000);
events.ScheduleEvent(EVENT_ERUPT, 8000);
phase = PHASE_2;
break;
case EVENT_ERUPT:
instance->SetData(DATA_HEIGAN_ERUPT, eruptSection);
TeleportCheaters();
if (eruptSection == 0)
eruptDirection = true;
else if (eruptSection == 3)
eruptDirection = false;
eruptDirection ? ++eruptSection : --eruptSection;
events.ScheduleEvent(EVENT_ERUPT, phase == PHASE_1 ? 10000 : 3000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING)) // Still channeling, do nothing
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SEARING_LIGHT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SEARING_LIGHT);
events.ScheduleEvent(EVENT_SEARING_LIGHT, TIMER_SEARING_LIGHT, 0, PHASE_ONE);
break;
case EVENT_GRAVITY_BOMB:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_GRAVITY_BOMB);
events.ScheduleEvent(EVENT_GRAVITY_BOMB, TIMER_GRAVITY_BOMB, 0, PHASE_ONE);
break;
case EVENT_TYMPANIC_TANTRUM:
Talk(SAY_TYMPANIC_TANTRUM);
Talk(EMOTE_TYMPANIC);
DoCast(SPELL_TYMPANIC_TANTRUM);
events.ScheduleEvent(EVENT_TYMPANIC_TANTRUM, urand(TIMER_TYMPANIC_TANTRUM_MIN, TIMER_TYMPANIC_TANTRUM_MAX), 0, PHASE_ONE);
break;
case EVENT_DISPOSE_HEART:
SetPhaseOne();
break;
case EVENT_ENRAGE:
Talk(SAY_BERSERK);
DoCast(me, SPELL_ENRAGE);
break;
case EVENT_ENTER_HARD_MODE:
me->SetFullHealth();
DoCast(me, SPELL_HEARTBREAK, true);
me->AddLootMode(LOOT_MODE_HARD_MODE_1);
hardMode = true;
SetPhaseOne();
break;
case EVENT_SPAWN_ADDS:
Talk(SAY_SUMMON);
// Spawn Pummeller
me->SummonCreature(NPC_XM024_PUMMELLER, spawnLocations[rand() % 4], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 60000);
// Spawn 5 Scrapbots
for (uint8 n = 0; n < 5; n++)
{
uint8 pos = rand() % 4;
me->SummonCreature(NPC_XS013_SCRAPBOT,
frand(spawnLocations[pos].GetPositionX() - 3.0f, spawnLocations[pos].GetPositionX() + 3.0f),
frand(spawnLocations[pos].GetPositionY() - 3.0f, spawnLocations[pos].GetPositionY() + 3.0f),
spawnLocations[pos].GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 60000);
}
// Spawn 3 Bombs
for (uint8 n = 0; n < 3; n++)
me->SummonCreature(NPC_XE321_BOOMBOT, spawnLocations[rand() % 4], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 60000);
events.ScheduleEvent(EVENT_SPAWN_ADDS, 12*IN_MILLISECONDS, 0, PHASE_TWO);
break;
}
}
if (phase == PHASE_ONE)
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CURSE:
DoCastAOE(SPELL_CURSE_PLAGUEBRINGER);
events.ScheduleEvent(EVENT_CURSE, urand(50000, 60000));
return;
case EVENT_WARRIOR:
Talk(SAY_SUMMON);
SummonUndead(NPC_WARRIOR, RAID_MODE(2, 3));
events.ScheduleEvent(EVENT_WARRIOR, 30000);
return;
case EVENT_BLINK:
DoCastAOE(SPELL_CRIPPLE, true);
DoCastAOE(SPELL_BLINK);
DoResetThreat();
events.ScheduleEvent(EVENT_BLINK, 40000);
return;
case EVENT_BALCONY:
me->SetReactState(REACT_PASSIVE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->AttackStop();
me->RemoveAllAuras();
me->NearTeleportTo(Teleport.GetPositionX(), Teleport.GetPositionY(), Teleport.GetPositionZ(), Teleport.GetOrientation());
events.Reset();
events.ScheduleEvent(EVENT_WAVE, urand(2000, 5000));
waveCount = 0;
return;
case EVENT_WAVE:
Talk(SAY_SUMMON);
switch (balconyCount)
{
case 0:
SummonUndead(NPC_CHAMPION, RAID_MODE(2, 4));
break;
case 1:
SummonUndead(NPC_CHAMPION, RAID_MODE(1, 2));
SummonUndead(NPC_GUARDIAN, RAID_MODE(1, 2));
break;
case 2:
SummonUndead(NPC_GUARDIAN, RAID_MODE(2, 4));
break;
default:
SummonUndead(NPC_CHAMPION, RAID_MODE(5, 10));
SummonUndead(NPC_GUARDIAN, RAID_MODE(5, 10));
break;
}
++waveCount;
events.ScheduleEvent(waveCount < 2 ? EVENT_WAVE : EVENT_GROUND, urand(30000, 45000));
return;
case EVENT_GROUND:
{
++balconyCount;
float x, y, z, o;
me->GetHomePosition(x, y, z, o);
me->NearTeleportTo(x, y, z, o);
events.ScheduleEvent(EVENT_BALCONY, 110000);
EnterPhaseGround();
return;
}
}
}
if (me->HasReactState(REACT_AGGRESSIVE))
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (nextWP && movementStarted && !movementCompleted && !nextMovementStarted)
{
nextMovementStarted = true;
me->GetMotionMaster()->MovePoint(nextWP, WaypointPositions[nextWP]);
}
if (!UpdateVictim() || !CheckInRoom() || !movementCompleted)
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_MARK:
if (!(rand32() % 5))
Talk(SAY_SPECIAL);
DoCastAOE(SPELL_MARK[id]);
events.ScheduleEvent(EVENT_MARK, 15000);
break;
case EVENT_CAST:
if (!(rand32() % 5))
Talk(SAY_TAUNT);
if (caster)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 45.0f, true))
DoCast(target, SPELL_PRIMARY(id));
}
else
DoCastVictim(SPELL_PRIMARY(id));
events.ScheduleEvent(EVENT_CAST, 15000);
break;
case EVENT_BERSERK:
Talk(SAY_SPECIAL);
DoCast(me, EVENT_BERSERK);
break;
}
}
if (punishTimer <= diff)
{
if (doDelayPunish)
{
DoCastAOE(SPELL_PUNISH[id], true);
doDelayPunish = false;
}
punishTimer = 2000;
} else punishTimer -= diff;
if (!caster)
DoMeleeAttackIfReady();
else if ((!DoSpellAttackIfReady(SPELL_SECONDARY(id)) || !me->IsWithinLOSInMap(me->GetVictim())) && movementCompleted && !doDelayPunish)
doDelayPunish = true;
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
DoScriptText(EMOTE_GENERIC_BERSERK_RAID, me);
Talk(SAY_BERSERK);
DoCast(me, SPELL_BERSERK);
break;
case EVENT_VAMPIRIC_BITE:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
if (!targets.empty())
{
Unit* target = targets.front();
DoCast(target, SPELL_VAMPIRIC_BITE);
Talk(SAY_VAMPIRIC_BITE);
_vampires.insert(target->GetGUID());
}
break;
}
case EVENT_BLOOD_MIRROR:
{
// victim can be NULL when this is processed in the same update tick as EVENT_AIR_PHASE
if (me->getVictim())
{
Player* newOfftank = SelectRandomTarget(true);
if (_offtank != newOfftank)
{
_offtank = newOfftank;
if (_offtank)
{
// both spells have SPELL_ATTR5_SINGLE_TARGET_SPELL, no manual removal needed
_offtank->CastSpell(me->getVictim(), SPELL_BLOOD_MIRROR_DAMAGE, true);
me->getVictim()->CastSpell(_offtank, SPELL_BLOOD_MIRROR_DUMMY, true);
DoCastVictim(SPELL_BLOOD_MIRROR_VISUAL);
if (Item* shadowsEdge = _offtank->GetWeaponForAttack(BASE_ATTACK, true))
if (!_offtank->HasAura(SPELL_THIRST_QUENCHED) && shadowsEdge->GetEntry() == ITEM_SHADOW_S_EDGE && !_offtank->HasAura(SPELL_GUSHING_WOUND))
_offtank->CastSpell(_offtank, SPELL_GUSHING_WOUND, true);
}
}
}
events.ScheduleEvent(EVENT_BLOOD_MIRROR, 2500, EVENT_GROUP_CANCELLABLE);
break;
}
case EVENT_DELIRIOUS_SLASH:
if (_offtank && !me->HasByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND | UNIT_BYTE1_FLAG_HOVER))
DoCast(_offtank, SPELL_DELIRIOUS_SLASH);
events.ScheduleEvent(EVENT_DELIRIOUS_SLASH, urand(20000, 24000), EVENT_GROUP_NORMAL);
break;
case EVENT_PACT_OF_THE_DARKFALLEN:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
uint32 targetCount = 2;
// do not combine these checks! we want it incremented TWICE when both conditions are met
if (IsHeroic())
++targetCount;
if (Is25ManRaid())
++targetCount;
Trinity::Containers::RandomResizeList<Player*>(targets, targetCount);
if (targets.size() > 1)
{
Talk(SAY_PACT_OF_THE_DARKFALLEN);
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_PACT_OF_THE_DARKFALLEN);
}
events.ScheduleEvent(EVENT_PACT_OF_THE_DARKFALLEN, 30500, EVENT_GROUP_NORMAL);
break;
}
case EVENT_SWARMING_SHADOWS:
if (Player* target = SelectRandomTarget(false))
{
Talk(EMOTE_SWARMING_SHADOWS, target->GetGUID());
Talk(SAY_SWARMING_SHADOWS);
DoCast(target, SPELL_SWARMING_SHADOWS);
}
events.ScheduleEvent(EVENT_SWARMING_SHADOWS, 30500, EVENT_GROUP_NORMAL);
break;
case EVENT_TWILIGHT_BLOODBOLT:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
Trinity::Containers::RandomResizeList<Player*>(targets, uint32(Is25ManRaid() ? 4 : 2));
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_TWILIGHT_BLOODBOLT);
DoCast(me, SPELL_TWILIGHT_BLOODBOLT_TARGET);
events.ScheduleEvent(EVENT_TWILIGHT_BLOODBOLT, urand(10000, 15000), EVENT_GROUP_NORMAL);
break;
}
case EVENT_AIR_PHASE:
DoStopAttack();
me->SetReactState(REACT_PASSIVE);
events.DelayEvents(10000, EVENT_GROUP_NORMAL);
events.CancelEventGroup(EVENT_GROUP_CANCELLABLE);
me->GetMotionMaster()->MovePoint(POINT_CENTER, centerPos);
break;
case EVENT_AIR_START_FLYING:
me->SetDisableGravity(true);
me->SetByteFlag(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND);
me->SetCanFly(true);
me->SendMovementFlagUpdate();
me->GetMotionMaster()->MovePoint(POINT_AIR, airPos);
break;
case EVENT_AIR_FLY_DOWN:
me->GetMotionMaster()->MovePoint(POINT_GROUND, centerPos);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
events.Update(diff);
if (!bConflagration)
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CAST_CONFLAGRATION:
bConflagration = true;
events.ScheduleEvent(EVENT_CAST_CONFLAGRATION_FLY, 1000);
break;
case EVENT_CAST_ENRAGE:
DoCast(SPELL_ENRAGE);
events.ScheduleEvent(EVENT_CAST_ENRAGE, urand(25000,35000));
break;
case EVENT_CAST_FLAME_BREATH:
DoCast(RAID_MODE(SPELL_FLAME_BREATH_10,SPELL_FLAME_BREATH_25,SPELL_FLAME_BREATH_10,SPELL_FLAME_BREATH_25));
events.ScheduleEvent(EVENT_CAST_FLAME_BREATH, urand(10000,15000));
break;
}
}
}
else
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CAST_CONFLAGRATION_FLY:
me->GetMotionMaster()->MovePoint(1, (float)3159.04, (float)676.08, (float)103.05);
SelectTargetList(playerList, RAID_MODE(TARGETS_10,TARGETS_25,TARGETS_10,TARGETS_25), SELECT_TARGET_RANDOM, 0, true);
for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
Unit *pTemp = (*itr);
me->CastSpell(pTemp, SPELL_FLAME_BEACON, true);
}
events.ScheduleEvent(EVENT_CAST_CONFLAGRATION_CAST, 5000);
break;
case EVENT_CAST_CONFLAGRATION_CAST:
for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
Unit *pTemp = (*itr);
me->CastSpell(pTemp, SPELL_CONFLAGRATION, true);
}
playerList.clear();
me->GetMotionMaster()->MoveTargetedHome();
bConflagration = false;
events.ScheduleEvent(EVENT_CAST_CONFLAGRATION, urand(45000,55000));
break;
}
}
}
DoMeleeAttackIfReady();
}