void ZerberhorseAI::HandleEvent(const uint32 Event)
{
switch (Event)
{
case EVT_EAT_PLAYER:
{
Unit *victim = SelectTarget(SELECT_TARGET_RANDOM, 0, 40, true);
if (victim)
me->CastSpell(victim, EAT_PLAYER, false);
break;
}
case EVT_EAT_BUFFS:
{
std::list<Unit *> targets;
SelectTargetList(targets, 5, SELECT_TARGET_RANDOM, 40, true);
for (std::list<Unit *>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
{
Unit *victim = *itr;
DispelChargesList dispelList;
victim->GetDispellableAuraList(me, DISPEL_MAGIC, dispelList);
DispelChargesList::iterator ditr = dispelList.begin();
std::advance(ditr, urand(0, dispelList.size() - 1));
Aura *aura = ditr->first;
if (aura)
{
aura->Remove();
ModPower(ADD_BUFF);
}
}
break;
}
case EVT_EXPLODE_TIMER:
{
if (ModPower(-1))
{
events.ScheduleEvent(EVT_EXPLODE_TIMER, TMR_EXPLODE_TIMER);
break;
}
if (round >= MAX_ROUNDS)
{
const int32 bp0 = 14000;
me->CastCustomSpell(me, EXPLODE, &bp0, NULL, NULL, false);
}
else
{
const int32 bp0 = 3500;
me->CastCustomSpell(me, EXPLODE, &bp0, NULL, NULL, false);
}
events.ScheduleEvent(EVT_EAT_PLAYER, TMR_EAT_PLAYER);
events.ScheduleEvent(EVT_EAT_BUFFS, TMR_EAT_BUFFS);
phase = EATING_PHASE;
break;
}
}
}
void UpdateAI(const uint32 diff)
{
if (IsIntro)
{
if (IntroPhaseTimer <= diff)
DoIntro();
else IntroPhaseTimer -= diff;
if (IntroPhase == 3 + 1)
{
if (IntroFrostBoltTimer <= diff)
{
if (Madrigosa)
{
Madrigosa->CastSpell(m_creature, SPELL_INTRO_FROSTBOLT, true);
IntroFrostBoltTimer = 2000;
}
} else IntroFrostBoltTimer -= diff;
}
DoMeleeAttackIfReady();
}
if (!UpdateVictim() || IsIntro)
return;
if (SlashTimer <= diff)
{
DoCast(m_creature->getVictim(), SPELL_METEOR_SLASH);
SlashTimer = 11000;
} else SlashTimer -= diff;
if (StompTimer <= diff)
{
DoScriptText(RAND(YELL_LOVE1,YELL_LOVE2,YELL_LOVE3), m_creature);
DoCast(m_creature->getVictim(), SPELL_STOMP);
StompTimer = 30000;
} else StompTimer -= diff;
if (BurnTimer <= diff)
{
std::list<Unit*> pTargets;
SelectTargetList(pTargets, 10, SELECT_TARGET_RANDOM, 100, true);
for (std::list<Unit*>::iterator i = pTargets.begin(); i != pTargets.end(); ++i)
if(!(*i)->HasAura(SPELL_BURN))
{
(*i)->CastSpell((*i), SPELL_BURN, true);
break;
}
BurnTimer = urand(60000,180000);
} else BurnTimer -= diff;
if (BerserkTimer < diff && !Enraged)
{
DoScriptText(YELL_BERSERK, m_creature);
DoCast(m_creature, SPELL_BERSERK);
Enraged = true;
} else BerserkTimer -= diff;
DoMeleeAttackIfReady();
}
void doBeacon(bool command = false)
{
if (command)
{
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_BEACON, true);
}
conflagated = true;
}
else
{
me->InterruptNonMeleeSpells(true);
for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
Unit *pTemp = (*itr);
me->CastSpell(pTemp, SPELL_CONFLAGATION_2, true);
}
playerList.clear();
conflagated = false;
}
}
void CastCountDown()
{
std::list<Unit*> targets;
SelectTargetList(targets, 2, SELECT_TARGET_RANDOM, 0.0f, true);
if (!targets.empty())
for (std::list<Unit*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_COUNTDOWN);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHIELD:
DoCast(me, SPELL_TIDAL_SHIELD, true);
ResetTimer(45000);
break;
case EVENT_BERSERK:
Talk(SAY_ENRAGE);
DoCast(me, SPELL_BERSERK, true);
events.DelayEvents(15000, GCD_YELL);
break;
case EVENT_SPINE:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target) target = me->GetVictim();
if (target)
{
DoCast(target, SPELL_IMPALING_SPINE, true);
SpineTargetGUID = target->GetGUID();
//must let target summon, otherwise you cannot click the spine
target->SummonGameObject(GOBJECT_SPINE, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), me->GetOrientation(), 0, 0, 0, 0, 30);
Talk(SAY_NEEDLE);
events.DelayEvents(1500, GCD_CAST);
events.DelayEvents(15000, GCD_YELL);
}
events.ScheduleEvent(EVENT_SPINE, 21000, GCD_CAST);
return;
}
case EVENT_NEEDLE:
{
//DoCast(me, SPELL_NEEDLE_SPINE, true);
std::list<Unit*> targets;
SelectTargetList(targets, 3, SELECT_TARGET_RANDOM, 80, true);
for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)
DoCast(*i, 39835, true);
events.ScheduleEvent(EVENT_NEEDLE, urand(15000, 25000), GCD_CAST);
events.DelayEvents(1500, GCD_CAST);
return;
}
case EVENT_YELL:
Talk(SAY_SPECIAL);
events.ScheduleEvent(EVENT_YELL, urand(25000, 100000), GCD_YELL);
events.DelayEvents(15000, GCD_YELL);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_SHIELD:
m_creature->CastSpell(m_creature, SPELL_TIDAL_SHIELD, true);
ResetTimer(45000);
break;
case EVENT_BERSERK:
DoScriptText(SAY_ENRAGE2, m_creature);
m_creature->CastSpell(m_creature, SPELL_BERSERK, true);
events.DelayEvents(15000, GCD_YELL);
break;
case EVENT_SPINE:
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
if (!pTarget) pTarget = m_creature->getVictim();
if (pTarget)
{
m_creature->CastSpell(pTarget, SPELL_IMPALING_SPINE, true);
SpineTargetGUID = pTarget->GetGUID();
//must let target summon, otherwise you cannot click the spine
pTarget->SummonGameObject(GOBJECT_SPINE, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), m_creature->GetOrientation(), 0, 0, 0, 0, 30);
DoScriptText(rand()%2 ? SAY_NEEDLE1 : SAY_NEEDLE2, m_creature);
events.DelayEvents(1500, GCD_CAST);
events.DelayEvents(15000, GCD_YELL);
}
events.ScheduleEvent(EVENT_SPINE, 21000, GCD_CAST);
return;
}
case EVENT_NEEDLE:
{
//m_creature->CastSpell(m_creature, SPELL_NEEDLE_SPINE, true);
std::list<Unit*> pTargets;
SelectTargetList(pTargets, 3, SELECT_TARGET_RANDOM, 80, true);
for (std::list<Unit*>::iterator i = pTargets.begin(); i != pTargets.end(); ++i)
m_creature->CastSpell(*i, 39835, true);
events.ScheduleEvent(EVENT_NEEDLE, urand(15000,25000), GCD_CAST);
events.DelayEvents(1500, GCD_CAST);
return;
}
case EVENT_YELL:
DoScriptText(RAND(SAY_SPECIAL1, SAY_SPECIAL2), m_creature);
events.ScheduleEvent(EVENT_YELL, urand(25000,100000), GCD_YELL);
events.DelayEvents(15000, GCD_YELL);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (m_uiConsumingDarknessTimer <= uiDiff)
{
std::list<Unit*> targets;
SelectTargetList(targets, RAID_MODE(3, 8), SELECT_TARGET_RANDOM, 0.0f, true);
if (!targets.empty())
for (std::list<Unit*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
me->AddAura(SPELL_CONSUMING_DARKNESS, *itr);
m_uiConsumingDarknessTimer = urand(40000, 50000);
}
else
m_uiConsumingDarknessTimer -= uiDiff;
if (m_uiMeteorSlashTimer <= uiDiff)
{
DoCastAOE(SPELL_METEOR_SLASH);
m_uiMeteorSlashTimer = urand(15000, 18000);
}
else
m_uiMeteorSlashTimer -= uiDiff;
if(me->GetHealth() <= me->CountPctFromMaxHealth(66) && !felfire1)
{
me->CastStop();
DoCastAOE(SPELL_FEL_FIRESTORM);
m_uiConsumingDarknessTimer += 23000;
m_uiMeteorSlashTimer += 23000;
m_uiCancelTimer = 21000;
felfire1 = true;
}
if(me->GetHealth() <= me->CountPctFromMaxHealth(33) && !felfire2)
{
me->CastStop();
DoCastAOE(SPELL_FEL_FIRESTORM);
m_uiConsumingDarknessTimer += 23000;
m_uiMeteorSlashTimer += 23000;
m_uiCancelTimer = 21000;
felfire2 = true;
}
if (m_uiCancelTimer <= uiDiff && m_uiCancelTimer > 0)
Summons.clear();
else
m_uiCancelTimer -= uiDiff;
if (m_uiBerserkTimer <= uiDiff)
DoCast(me, SPELL_BERSERK);
else
m_uiBerserkTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (m_uiRangeCheckTimer < uiDiff)
{
if (Unit* target = me->SelectNearestTarget(3.0f))
{
if (target->GetTypeId() == TYPEID_PLAYER && target->isAlive())
{
if (target->HasAura(SPELL_DARK_ESSENCE))
{
DoCastAOE(SPELL_UNLEASHED_LIGHT);
me->GetMotionMaster()->MoveIdle();
me->DespawnOrUnsummon();
}
else if (target->HasAura(SPELL_LIGHT_ESSENCE))
{
std::list<Unit*> targetList;
SelectTargetList(targetList, 100, SELECT_TARGET_NEAREST, 6.0f, true, SPELL_LIGHT_ESSENCE);
if (!targetList.empty())
{
for (std::list<Unit* >::const_iterator itr = targetList.begin(); itr != targetList.end(); ++itr)
{
Unit* pUnit = (*itr);
if (pUnit && pUnit->isAlive())
{
if (!pUnit->HasAura(SPELL_POWER_UP))
pUnit->AddAura(SPELL_POWER_UP, pUnit);
if (Aura* aur = pUnit->GetAura(SPELL_POWER_UP))
{
if (aur->GetStackAmount() + 6 > 100)
{
pUnit->RemoveAurasDueToSpell(SPELL_POWER_UP);
pUnit->CastSpell(pUnit, SPELL_EMPOWERED_LIGHT, true);
}
else
{
if (urand(0, 100) <= 15)
pUnit->CastSpell(pUnit, SPELL_SPEED, true);
aur->SetStackAmount(aur->GetStackAmount() + 6);
}
}
}
}
}
me->GetMotionMaster()->MoveIdle();
me->DespawnOrUnsummon();
}
}
}
m_uiRangeCheckTimer = 500;
}
else m_uiRangeCheckTimer -= uiDiff;
}
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))
{
me->SetFacingToObject(target);
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;
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,true);
events.ScheduleEvent(EVENT_VILE_GAS, urand(15000, 20000));
break;
}
default:
break;
}
}
DoMeleeAttackIfReady();
}
void SpellHit(Unit* /*caster*/, SpellInfo const* spell) override
{
if (spell->Id == SPELL_CHAINS_DUMMY)
{
Talk(SAY_CHAINS);
std::list<Unit*> targets;
SelectTargetList(targets, 3, SELECT_TARGET_RANDOM, 0.0f, true);
for (Unit* target : targets)
if (me->GetVictim() != target) // skip MT
DoCast(target, SPELL_CHAINS);
}
}
void DoDefilingHorror()
{
std::list<Unit*> targetList;
SelectTargetList(targetList, 5, SELECT_TARGET_RANDOM, 100.0f, true);
if (targetList.empty())
return;
for (std::list<Unit*>::const_iterator i = targetList.begin(); i != targetList.end(); ++i)
{
if ((*i))
if (me->IsValidAttackTarget((*i)))
me->AddAura(DUNGEON_MODE(SPELL_DEFILING_HORROR, H_SPELL_DEFILING_HORROR), (*i));
}
}
// Cast aura spell on all players farther than 10y
void ApplySoulStorm()
{
std::list<Unit*> targetList;
SelectTargetList(targetList, 100, SELECT_TARGET_TOPAGGRO, -10.0f);
if (targetList.empty())
return;
for (std::list<Unit *>::const_iterator itr = targetList.begin(); itr != targetList.end(); ++itr)
{
Unit* pUnit = (*itr);
if (pUnit && pUnit->isAlive())
me->CastSpell(pUnit, SPELL_SOULSTORM_AURA, true);
}
}
void ExecuteEvent(uint32 const eventId)
{
switch (eventId)
{
case EVENT_BERSERK:
events.Reset();
me->MonsterYell(LM_YELL_BERSERK, LANG_UNIVERSAL, 0);
DoCast(me, SPELL_BERSERK);
break;
case EVENT_DEATH_AND_DECAY:
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_SUMMON_SNOBOLD_VASSAL:
me->SummonCreature(NPC_SNOBOLD_VASSAL, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_CORPSE_DESPAWN);
events.ScheduleEvent(EVENT_SUMMON_SNOBOLD_VASSAL, 20000);
break;
case EVENT_DOMINATE_MIND:
{
for (uint8 i = 0; i < 3; i++)
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -SPELL_DOMINATE_MIND))
DoCast(target, SPELL_DOMINATE_MIND);
events.ScheduleEvent(EVENT_DOMINATE_MIND, urand(40000, 45000));
break;
}
case EVENT_P2_CHILLING_WAVE:
DoCast(me, SPELL_CHILLING_WAVE);
events.ScheduleEvent(EVENT_P2_CHILLING_WAVE, urand(20000, 30000), 0, PHASE_TWO);
break;
case EVENT_P3_TWILIGHT_BLOODBOLT:
{
std::list<Unit*> targets;
SelectTargetList(targets, 5, SELECT_TARGET_RANDOM, 100, true);
for (std::list<Unit*>::const_iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_TWILIGHT_BLOODBOLT);
events.ScheduleEvent(EVENT_P3_TWILIGHT_BLOODBOLT, urand(15000, 25000), 0, PHASE_THREE);
break;
}
case EVENT_P4_BLIZZARD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
DoCast(target, SPELL_BLIZZARD);
events.ScheduleEvent(EVENT_P4_BLIZZARD, urand(20000, 25000), 0, PHASE_FOUR);
break;
case EVENT_P4_MANA_DETONATION:
{
// Select a random target in the threat list that has mana
/*std::vector<Unit*> unitList;
std::list<HostileReference*>& threatList = me->getThreatManager().getThreatList();
for (std::list<HostileReference*>::const_iterator itr = threatList.begin(); itr != threatList.end(); ++itr)
{
if (Unit* target = Unit::GetUnit(*me, (*itr)->getUnitGuid()))
if (target->GetCreateMana() > 0) // target has mana
unitList.push_back(target);
}
if (!unitList.empty())
{
std::vector<Unit*>::const_iterator itr = unitList.begin();
advance(itr, rand() % unitList.size());
DoCast(*itr, SPELL_MANA_DETONATION);
}
events.ScheduleEvent(EVENT_P4_MANA_DETONATION, urand(20000, 40000), 0, PHASE_FOUR);
break;*/
}
case EVENT_P5_FURY:
if (urand(0, 4) == 0) // 20% chance to increase damage
me->CastSpell(me, SPELL_FURY, true);
events.ScheduleEvent(EVENT_P5_FURY, urand(4000, 6000), 0, PHASE_FIVE);
break;
case EVENT_P5_STUNNING_FORCE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
me->CastSpell(target, SPELL_STUNNING_FORCE, true);
events.ScheduleEvent(EVENT_P5_STUNNING_FORCE, urand(8000, 12000), 0, PHASE_FIVE);
break;
case EVENT_P5_FLASH_HEAL:
if (urand(0, 1) == 0) // 50% chance to heal
me->CastSpell(me, SPELL_FLASH_HEAL, true);
events.ScheduleEvent(EVENT_P5_FLASH_HEAL, 5000, 0, PHASE_FIVE);
break;
}
}
void UpdateAI(const uint32 diff)
{
if (IsIntro)
{
if (IntroPhaseTimer <= diff)
DoIntro();
else IntroPhaseTimer -= diff;
if (IntroPhase == 3 + 1)
{
if (IntroFrostBoltTimer <= diff)
{
if (Creature* Madrigosa = Unit::GetCreature(*me, instance ? instance->GetData64(DATA_MADRIGOSA) : 0))
{
Madrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, true);
IntroFrostBoltTimer = 2000;
}
} else IntroFrostBoltTimer -= diff;
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
if (!UpdateVictim() || IsIntro)
return;
if (SlashTimer <= diff)
{
DoCastVictim(SPELL_METEOR_SLASH);
SlashTimer = 11000;
} else SlashTimer -= diff;
if (StompTimer <= diff)
{
Talk(YELL_LOVE);
DoCastVictim(SPELL_STOMP);
StompTimer = 30000;
} else StompTimer -= diff;
if (BurnTimer <= diff)
{
std::list<Unit*> targets;
SelectTargetList(targets, 10, SELECT_TARGET_RANDOM, 100, true);
for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)
if (!(*i)->HasAura(SPELL_BURN))
{
(*i)->CastSpell((*i), SPELL_BURN, true);
break;
}
BurnTimer = urand(60000, 180000);
} else BurnTimer -= diff;
if (BerserkTimer < diff && !Enraged)
{
Talk(YELL_BERSERK);
DoCast(me, SPELL_BERSERK);
Enraged = true;
} else BerserkTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (Intro)
{
if (IntroPhaseTimer > diff)
IntroPhaseTimer = IntroPhaseTimer - diff;
else
{
++IntroPhase;
if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
CAST_AI(npc_madrigosaAI, Madrigosa->AI())->IntroPhase = IntroPhase;
DoIntro();
}
if (IntroPhase == 6 + 1)
{
if (IntroAttackTimer < diff)
{
if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
{
Madrigosa->CastSpell(me, SPELL_INTRO_FREEZE, true);
DoCast(me, SPELL_INTRO_FROST_BLAST);
IntroAttackTimer = 12000;
}
}
else IntroAttackTimer -= diff;
if (IntroFrostBoltTimer < diff)
{
if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
{
Madrigosa->SetInCombatState(true, me);
Madrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, true);
IntroFrostBoltTimer = 1100;
}
}
else IntroFrostBoltTimer -= diff;
}
if (IntroPhase == 11 + 1)
{
if (IntroAttackTimer < diff)
{
if (Creature* Madrigosa = Unit::GetCreature(*me, pInstance ? pInstance->GetData64(DATA_MADRIGOSA) : 0))
{
me->Attack(Madrigosa, true);
me->CastSpell(Madrigosa, 45185, true);
IntroAttackTimer = 1700;
}
}
else IntroAttackTimer -= diff;
}
if (!UpdateVictim())
return;
if (IntroPhase >= 5 && IntroPhase < 13)
return;
DoMeleeAttackIfReady();
return;
}
if (!UpdateVictim())
return;
if (SlashTimer <= diff)
{
DoCastVictim( SPELL_METEOR_SLASH);
SlashTimer = 11000;
}
else SlashTimer -= diff;
if (StompTimer <= diff)
{
DoScriptText(RAND(YELL_LOVE1, YELL_LOVE2, YELL_LOVE3), me);
DoCastVictim( SPELL_STOMP);
StompTimer = 30000;
}
else StompTimer -= diff;
if (BurnTimer <= diff)
{
std::list<Unit*> pTargets;
SelectTargetList(pTargets, 10, SELECT_TARGET_RANDOM, 100, true);
for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.end(); ++i)
if (!(*i)->HasAura(SPELL_BURN, 0))
{
(*i)->CastSpell((*i), SPELL_BURN, true);
break;
}
BurnTimer = urand(60000, 180000);
}
else BurnTimer -= diff;
if (BerserkTimer <= diff && !Enraged)
{
DoScriptText(YELL_BERSERK, me);
DoCast(me, SPELL_BERSERK);
Enraged = true;
}
else BerserkTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_instance || !UpdateVictim())
return;
if (m_instance->GetData(DATA_HEALTH_TWIN_SHARED) != 0)
me->SetHealth(m_instance->GetData(DATA_HEALTH_TWIN_SHARED));
else if (me->getVictim())
{
me->LowerPlayerDamageReq(me->GetMaxHealth());
me->getVictim()->Kill(me);
return;
}
else
me->SetHealth(1);
if (m_uiSpecialAbilityTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (urand(0, 1))
{
DoScriptText(m_uiVortexEmote, me);
DoScriptText(m_uiVortexSay, me);
DoCastAOE(m_uiVortexSpellId);
std::list<Unit*> targetList;
SelectTargetList(targetList, 100, SELECT_TARGET_NEAREST, 150.0f, true, m_uiMyEssenceSpellId);
if (!targetList.empty())
{
for (std::list<Unit* >::const_iterator itr = targetList.begin(); itr != targetList.end(); ++itr)
{
Unit* pUnit = (*itr);
if (pUnit && pUnit->isAlive())
{
if (!pUnit->HasAura(SPELL_POWER_UP))
pUnit->AddAura(SPELL_POWER_UP, pUnit);
if (Aura* aur = pUnit->GetAura(SPELL_POWER_UP))
{
if (aur->GetStackAmount() + 30 > 100)
{
pUnit->RemoveAurasDueToSpell(SPELL_POWER_UP);
pUnit->CastSpell(pUnit, me->GetEntry() == NPC_LIGHTBANE ? SPELL_EMPOWERED_LIGHT : SPELL_EMPOWERED_DARK, true);
}
else
{
if (urand(0, 100) <= 15)
pUnit->CastSpell(pUnit, SPELL_SPEED, true);
aur->SetStackAmount(aur->GetStackAmount() + 30);
}
}
}
}
}
}
else
{
DoScriptText(EMOTE_SHIELD, me);
DoScriptText(SAY_SHIELD, me);
if (Creature* Sister = GetSister())
Sister->CastSpell(Sister, SPELL_TWIN_POWER, true);
DoCast(me, m_uiShieldSpellId);
me->CastCustomSpell(me, m_uiTwinPactSpellId, 0, 0, 0, false);
}
m_uiSpecialAbilityTimer = 80000;
} else m_uiSpecialAbilityTimer -= uiDiff;
if (m_uiSpikeTimer <= uiDiff)
{
DoCastVictim(m_uiSpikeSpellId);
m_uiSpikeTimer = 20*1000;
} else m_uiSpikeTimer -= uiDiff;
if (IsHeroic())
{
if (m_uiTouchTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 200.0f, true, m_uiOtherEssenceSpellId))
{
if (!target->HasAura(m_uiTouchSpellId))
{
target->AddAura(m_uiTouchSpellId, target);
}
}
m_uiTouchTimer = urand(10, 15)*1000;
} else m_uiTouchTimer -= uiDiff;
}
if (m_uiColorballsTimer <= uiDiff)
{
if (m_uiWaveCount >= 2)
{
SummonColorballs(15);
m_uiWaveCount = 0;
}
else
{
SummonColorballs(2);
m_uiWaveCount++;
}
m_uiColorballsTimer = 15*1000;
} else m_uiColorballsTimer -= uiDiff;
if (m_uiBerserkTimer <= uiDiff)
{
if (!m_bIsBerserk)
{
DoCast(me, SPELL_BERSERK);
DoScriptText(SAY_BERSERK, me);
m_bIsBerserk = true;
}
} else m_uiBerserkTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (m_uiEnrageTimer <= uiDiff && !m_bIsEnrage)
{
if(!me->FindNearestCreature(NPC_DREADSCALE, 300, true))
{
DoCast(me, SPELL_ENRAGE );
m_bIsEnrage = true;
}
m_uiEnrageTimer = 2000;
}
else m_uiEnrageTimer -= uiDiff;
if(m_uiPhase == 1)
{
if (!me->HasAura(SPELL_ROOT))
DoCast(me, SPELL_ROOT);
if (m_uiParalyticSprayTimer <= uiDiff)
{
DoCast(me->getVictim(), SPELL_PARALYTIC_SPRAY);
m_uiParalyticSprayTimer = 5*IN_MILLISECONDS;
}
else m_uiParalyticSprayTimer -= uiDiff;
if (m_uiAcidSpitTimer <= uiDiff)
{
std::list<Unit*> pTargets;
SelectTargetList(pTargets, 5, SELECT_TARGET_RANDOM, 80, true);
for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.end(); ++i)
DoCast(*i, SPELL_ACID_SPIT);
m_uiAcidSpitTimer = 20*IN_MILLISECONDS;
}
else m_uiAcidSpitTimer -= uiDiff;
if (m_uiSweapTimer <= uiDiff)
{
DoCast(me->getVictim(), SPELL_SWEAP);
m_uiSweapTimer = 20*IN_MILLISECONDS;
}
else m_uiSweapTimer -= uiDiff;
if (m_uiPhase2Timer <= uiDiff)
{
DoCast(me, SPELL_SUBMERGE);
m_uiPhase = 2;
m_uiPhase2Timer = 50*IN_MILLISECONDS;
m_uiPhase1Timer = 50*IN_MILLISECONDS;
m_uiRemoveSubmergedTimer = 10000;
}
else m_uiPhase2Timer -= uiDiff;
if (m_uiRemoveSubmergedTimer <= uiDiff)
{
me->CastSpell(me, 35177, false);
me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
m_uiRemoveSubmergedTimer = 999*IN_MILLISECONDS;
}
else m_uiRemoveSubmergedTimer -= uiDiff;
}
if(m_uiPhase == 2)
{
if (me->HasAura(SPELL_ROOT))
me->RemoveAurasDueToSpell(SPELL_ROOT);
if (m_uiRemoveSubmergedTimer <= uiDiff)
{
me->CastSpell(me, 35177, false);
me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
m_uiRemoveSubmergedTimer = 999*IN_MILLISECONDS;
}
else m_uiRemoveSubmergedTimer -= uiDiff;
if (m_uiAcidSpewTimer <= uiDiff)
{
DoCast(me->getVictim(), SPELL_ACID_SPEW);
m_uiAcidSpewTimer = 20*IN_MILLISECONDS;
}
else m_uiAcidSpewTimer -= uiDiff;
if (m_uiParalyticBiteTimer <= uiDiff)
{
DoCast(me->getVictim(), SPELL_PARALYTIC_BITE);
m_uiParalyticBiteTimer = 5*IN_MILLISECONDS;
}
else m_uiParalyticBiteTimer -= uiDiff;
if (m_uiPhase1Timer <= uiDiff)
{
DoCast(me, SPELL_SUBMERGE);
m_uiPhase = 1;
m_uiPhase2Timer = 50*IN_MILLISECONDS;
m_uiPhase1Timer = 50*IN_MILLISECONDS;
m_uiRemoveSubmergedTimer = 10000;
}
else m_uiPhase1Timer -= uiDiff;
DoMeleeAttackIfReady();
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (!me->HasAura(SPELL_SHROUD_OF_SORROW))
DoCast(me, SPELL_SHROUD_OF_SORROW);
if(m_uiPhase == 1)
{
if (m_uiPactofDarkfallenTimer <= uiDiff)
{
// PactFallen();
DoScriptText(SAY_PACT_DARKFALLEN, me);
m_uiPactofDarkfallenExplosionCount = 0;
m_uiPactofDarkfallenExplodeTimer = 2*IN_MILISECONDS;
m_uiPactofDarkfallenTimer = 25*IN_MILISECONDS;
}
else m_uiPactofDarkfallenTimer -= uiDiff;
if (m_uiSwarmingShadowsTimer < uiDiff)
{
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SWARMING_SHADOWS);
m_uiSwarmingShadowsTimer = 30*IN_MILISECONDS;
}
else m_uiSwarmingShadowsTimer -= uiDiff;
if (m_uiTwilightBloodboltTimer < uiDiff)
{
if (Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_TWILIGHT_BLOODBOLT);
m_uiTwilightBloodboltTimer = urand(6*IN_MILISECONDS,12*IN_MILISECONDS);
}
else m_uiTwilightBloodboltTimer -= uiDiff;
if (m_uiVampBiteTimer < uiDiff)
{
DoScriptText(RAND(SAY_VAMP_BITE_1,SAY_VAMP_BITE_2), me);
if (Unit* target = SelectUnit(SELECT_TARGET_TOPAGGRO/*SELECT_TARGET_RANDOM*/, 0))
DoCast(target, SPELL_VAMPIRIC_BITE);
m_uiVampBiteTimer = urand(15*IN_MILISECONDS,60*IN_MILISECONDS);
}
else m_uiVampBiteTimer -= uiDiff;
if (m_uiPhaseTimer < uiDiff)
{
DoScriptText(SAY_AIR_PHASE, me);
DoCast(me, SPELL_INCITE_TERROR);
me->GetMotionMaster()->MovePoint(0, Phase2Position);
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
m_uiPhase = 2;
m_uiPhaseTimer = 90*IN_MILISECONDS;
m_uiSetHoverTimer = 5*IN_MILISECONDS;
m_uiBloodboldSplashTimer = 10*IN_MILISECONDS;
m_uiLandingTimer = 26*IN_MILISECONDS;
m_uiFlyingFalseTimer = 30*IN_MILISECONDS;
}
else m_uiPhaseTimer -= uiDiff;
}
if(m_uiPhase == 2)
{
if (m_uiSetHoverTimer < uiDiff)
{
me->GetMotionMaster()->MovePoint(0, FlyPosition);
me->SetUnitMovementFlags(MOVEMENTFLAG_JUMPING);
me->SetFlying(true);
m_uiSetHoverTimer = 90*IN_MILISECONDS;
}
else m_uiSetHoverTimer -= uiDiff;
if (m_uiBloodboldSplashTimer < uiDiff)
{
std::list<Unit*> pTargets;
SelectTargetList(pTargets, 5, SELECT_TARGET_RANDOM, 80, true);
for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.end(); ++i)
DoCast(*i, RAID_MODE(SPELL_TWILIGHT_BLOODBOLT,SPELL_TWILIGHT_BLOODBOLT));
m_uiBloodboldSplashTimer = 2*IN_MILISECONDS;
}
else m_uiBloodboldSplashTimer -= uiDiff;
if (m_uiLandingTimer < uiDiff)
{
me->GetMotionMaster()->MovePoint(0, Phase2Position);
me->SetUnitMovementFlags(MOVEMENTFLAG_JUMPING);
m_uiLandingTimer = 900*IN_MILISECONDS;
m_uiBloodboldSplashTimer = 900*IN_MILISECONDS;
}
else m_uiLandingTimer -= uiDiff;
if (m_uiFlyingFalseTimer < uiDiff)
{
me->SetFlying(false);
me->RemoveAllAuras();
me->SetReactState(REACT_AGGRESSIVE);
me->GetMotionMaster()->MoveChase(me->getVictim());
m_uiPhase = 1;
m_uiFlyingFalseTimer = 900*IN_MILISECONDS;
}
else m_uiFlyingFalseTimer -= uiDiff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (m_uiEnrageTimer <= uiDiff && !m_bIsEnrage)
{
if(!me->FindNearestCreature(NPC_ACIDMAW, 300, true))
{
DoCast(me, SPELL_ENRAGE );
m_bIsEnrage = true;
}
m_uiEnrageTimer = 2000;
}
else m_uiEnrageTimer -= uiDiff;
if(m_uiPhase == 1)
{
if (me->HasAura(SPELL_ROOT))
me->RemoveAurasDueToSpell(SPELL_ROOT);
if (m_uiMoltenSpewTimer <= uiDiff)
{
DoCast(me->getVictim(), SPELL_MOLTEN_SPEW);
m_uiMoltenSpewTimer = 20*IN_MILLISECONDS;
}
else m_uiMoltenSpewTimer -= uiDiff;
if (m_uiBurningBiteTimer <= uiDiff)
{
DoCast(me->getVictim(), SPELL_BURNING_BITE);
m_uiBurningBiteTimer = 8*IN_MILLISECONDS;
}
else m_uiBurningBiteTimer -= uiDiff;
if (m_uiPhase2Timer <= uiDiff)
{
m_uiPhase = 2;
m_uiPhase2Timer = 40*IN_MILLISECONDS;
m_uiPhase1Timer = 40*IN_MILLISECONDS;
}
else m_uiPhase2Timer -= uiDiff;
DoMeleeAttackIfReady();
}
if(m_uiPhase == 2)
{
if (!me->HasAura(SPELL_ROOT))
DoCast(me, SPELL_ROOT);
if (m_uiBurningSprayTimer <= uiDiff)
{
std::list<Unit*> pTargets;
SelectTargetList(pTargets, 5, SELECT_TARGET_RANDOM, 80, true);
for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.end(); ++i)
DoCast(*i, SPELL_BURNING_SPRAY);
m_uiBurningSprayTimer = 15*IN_MILLISECONDS;
}
else m_uiBurningSprayTimer -= uiDiff;
if (m_uiFireSpitTimer <= uiDiff)
{
DoCast(me->getVictim(), SPELL_FIRE_SPIT);
m_uiFireSpitTimer = 5*IN_MILLISECONDS;
}
else m_uiFireSpitTimer -= uiDiff;
if (m_uiSweapTimer <= uiDiff)
{
DoCast(me, SPELL_SWEAP);
m_uiSweapTimer = 20*IN_MILLISECONDS;
}
else m_uiSweapTimer -= uiDiff;
if (m_uiPhase1Timer <= uiDiff)
{
m_uiPhase = 1;
m_uiPhase1Timer = 40*IN_MILLISECONDS;
m_uiPhase2Timer = 40*IN_MILLISECONDS;
}
else m_uiPhase1Timer -= uiDiff;
}
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
return;
if (!phase)
return;
if (m_uiPowerTimer <= diff)
{
instance->NormaliseAltPower();
}
else m_uiPowerTimer -= diff;
events.Update(diff);
if (phase == PHASE_GROUND) // Ground phase
{
ThreatContainer::StorageType const &threatlist = me->getThreatManager().getThreatList();
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_AGGRO_NEF:
if (Creature* nefarianHelperheroic = me->FindNearestCreature(NPC_NEFARIAN_HELPER_HEROIC, 150.0f, true))
nefarianHelperheroic->AI()->Talk(28);
return;
case EVENT_SONAR_PULSE:
DoCast(me, SPELL_SONAR_PULSE);
me->SummonCreature(NPC_SONAR_PULSES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 1.5f, TEMPSUMMON_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_SONAR_PULSES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 3.0f, TEMPSUMMON_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_SONAR_PULSES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 4.5f, TEMPSUMMON_TIMED_DESPAWN, 30000);
me->SummonCreature(NPC_SONAR_PULSES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 6.0f, TEMPSUMMON_TIMED_DESPAWN, 30000);
events.ScheduleEvent(EVENT_SONAR_PULSE, 50000);
break;
case EVENT_MODULATION:
DoCast(me, SPELL_MODULATION);
for (ThreatContainer::StorageType::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
if (Unit* unit = Unit::GetUnit(*me, (*itr)->getUnitGuid()))
unit->SetPower(POWER_ALTERNATE_POWER, unit->GetPower(POWER_ALTERNATE_POWER) + 7);
events.ScheduleEvent(EVENT_MODULATION, 20000);
break;
case EVENT_SONIC_BREATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
{
target->AddAura(SPELL_TRACKING, target);
DoCast(target, SPELL_SONIC_BREATH);
}
events.ScheduleEvent(EVENT_REMOVE_TRACKING, 8500);
events.ScheduleEvent(EVENT_SONIC_BREATH, 40000);
break;
case EVENT_REMOVE_TRACKING:
if(instance)
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_TRACKING);
return;
case EVENT_SEARING_FLAMES:
Talk(SAY_SEARING);
DoCast(me, SPELL_SEARING_FLAMES);
events.ScheduleEvent(EVENT_SEARING_FLAMES, 50000);
break;
case EVENT_LIFTOFF:
Talk(SAY_AIR_PHASE);
me->HandleEmote(EMOTE_ONESHOT_LIFTOFF);
me->SetDisableGravity(true);
events.ScheduleEvent(EVENT_FLIGHT, 1500);
events.ScheduleEvent(EVENT_AIR, 2000);
return;
case EVENT_FLIGHT:
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
me->GetMotionMaster()->MovePoint(1, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ() + 20.0f);
return;
case EVENT_AIR:
EnterPhaseAir();
return;
case EVENT_FIEND:
me->SummonCreature(NPC_OBNOXIOUS_FIEND, 93.767f, -224.105f, 74.911f, 6.26f, TEMPSUMMON_CORPSE_DESPAWN, 3000);
if (Creature* nefarianHelperheroic = me->FindNearestCreature(NPC_NEFARIAN_HELPER_HEROIC, 150.0f, true))
nefarianHelperheroic->AI()->Talk(27);
events.ScheduleEvent(EVENT_FIEND, 38500);
break;
}
}
DoMeleeAttackIfReady();
}
else if (phase == PHASE_FLIGHT) // Air phase
{
std::list<Unit*> targets;
ThreatContainer::StorageType const &m_threatlist = me->getThreatManager().getThreatList();
// if has vertigo, remove all roaring flame npc's wait 8 sec then get player who rang gong.
if (me->HasAura(SPELL_VERTIGO))
events.ScheduleEvent(EVENT_ROARING_FLAME_SUMMON, 8000, PHASE_FLIGHT);
if (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ROARING_FLAME_SUMMON:
for (ThreatContainer::StorageType::const_iterator i = m_threatlist.begin(); i != m_threatlist.end(); ++i)
{
Unit* unit = Unit::GetUnit(*me, (*i)->getUnitGuid());
if (unit && unit->HasAura(SPELL_NOISY)) // You rang? :)
{
me->SummonCreature(NPC_ROARING_FLAME_TARGET, unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
}
else
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
me->SummonCreature(NPC_ROARING_FLAME_TARGET, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
}
}
events.ScheduleEvent(EVENT_ROARING_FLAME, 500);
return;
case EVENT_ROARING_FLAME:
if (Unit* roaring = me->FindNearestCreature(NPC_ROARING_FLAME_TARGET, 100.0f))
DoCast(roaring, SPELL_ROARING_FLAME_BREATH_DUMMY);
return;
case EVENT_SONAR_BOMB:
SelectTargetList(targets, RAID_MODE(3, 6), SELECT_TARGET_RANDOM, 100.0f, true);
if (!targets.empty())
for (std::list<Unit*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_SONAR_BOMB);
events.ScheduleEvent(EVENT_SONAR_BOMB, 18000);
break;
case EVENT_LAND:
me->HandleEmote(EMOTE_ONESHOT_LAND);
me->SetDisableGravity(false);
events.ScheduleEvent(EVENT_RETURN, 1000);
events.ScheduleEvent(EVENT_GROUND, 1500);
return;
case EVENT_RETURN:
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
me->GetMotionMaster()->MovePoint(1, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ() - 20.0f);
return;
case EVENT_GROUND:
EnterPhaseGround();
return;
}
}
}
}
void UpdateAI(uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
switch (Phase)
{
case SKELETAL:
if (uiCurseOfLifeTimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_CURSE_OF_LIFE);
uiCurseOfLifeTimer = urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS);
} else uiCurseOfLifeTimer -= diff;
if (uiShadowVolleyTimer < diff)
{
DoCastVictim(SPELL_SHADOW_VOLLEY);
uiShadowVolleyTimer = urand(8*IN_MILLISECONDS, 10*IN_MILLISECONDS);
} else uiShadowVolleyTimer -= diff;
if (uiRainOfFireTimer < diff)
{
DoCastAOE(SPELL_RAIN_OF_FIRE);
uiRainOfFireTimer = urand(14*IN_MILLISECONDS, 18*IN_MILLISECONDS);
} else uiRainOfFireTimer -= diff;
if (uiPhaseTimer < diff)
{
DoCast(SPELL_DECAY_FLESH);
Phase = GOING_FLESH;
uiPhaseTimer = 6*IN_MILLISECONDS;
} else uiPhaseTimer -= diff;
DoMeleeAttackIfReady();
break;
case GOING_FLESH:
if (uiPhaseTimer < diff)
{
Talk(SAY_FLESH);
me->SetDisplayId(MODEL_FLESH);
std::list<Unit*> playerList;
SelectTargetList(playerList, 5, SELECT_TARGET_TOPAGGRO, 0, true);
for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
Unit* temp = (*itr);
me->AddAura(SPELL_GIFT_OF_THARON_JA, temp);
temp->SetDisplayId(MODEL_SKELETON);
}
uiPhaseTimer = 20*IN_MILLISECONDS;
uiLightningBreathTimer = urand(3*IN_MILLISECONDS, 4*IN_MILLISECONDS);
uiEyeBeamTimer = urand(4*IN_MILLISECONDS, 8*IN_MILLISECONDS);
uiPoisonCloudTimer = urand(6*IN_MILLISECONDS, 7*IN_MILLISECONDS);
Phase = FLESH;
} else uiPhaseTimer -= diff;
break;
case FLESH:
if (uiLightningBreathTimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_LIGHTNING_BREATH);
uiLightningBreathTimer = urand(6*IN_MILLISECONDS, 7*IN_MILLISECONDS);
} else uiLightningBreathTimer -= diff;
if (uiEyeBeamTimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_EYE_BEAM);
uiEyeBeamTimer = urand(4*IN_MILLISECONDS, 6*IN_MILLISECONDS);
} else uiEyeBeamTimer -= diff;
if (uiPoisonCloudTimer < diff)
{
DoCastAOE(SPELL_POISON_CLOUD);
uiPoisonCloudTimer = urand(10*IN_MILLISECONDS, 12*IN_MILLISECONDS);
} else uiPoisonCloudTimer -= diff;
if (uiPhaseTimer < diff)
{
DoCast(SPELL_RETURN_FLESH);
Phase = GOING_SKELETAL;
uiPhaseTimer = 6*IN_MILLISECONDS;
} else uiPhaseTimer -= diff;
DoMeleeAttackIfReady();
break;
case GOING_SKELETAL:
if (uiPhaseTimer < diff)
{
Talk(SAY_SKELETON);
me->DeMorph();
Phase = SKELETAL;
uiPhaseTimer = 20*IN_MILLISECONDS;
uiCurseOfLifeTimer = 1*IN_MILLISECONDS;
uiRainOfFireTimer = urand(14*IN_MILLISECONDS, 18*IN_MILLISECONDS);
uiShadowVolleyTimer = urand(8*IN_MILLISECONDS, 10*IN_MILLISECONDS);
std::list<Unit*> playerList;
SelectTargetList(playerList, 5, SELECT_TARGET_TOPAGGRO, 0, true);
for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
Unit* temp = (*itr);
if (temp->HasAura(SPELL_GIFT_OF_THARON_JA))
temp->RemoveAura(SPELL_GIFT_OF_THARON_JA);
temp->DeMorph();
}
} else uiPhaseTimer -= diff;
break;
}
}
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)
{
if (!UpdateVictim() && phase != PHASE_NONE || me->HasUnitState(UNIT_STATE_CASTING))
return;
if (phase == PHASE_SCORPION && me->GetPower(POWER_ENERGY) == 100)
{
DoCast(me, RAID_MODE(SPELL_FLAME_SCYTE_10N,SPELL_FLAME_SCYTE_25N,SPELL_FLAME_SCYTE_10H,SPELL_FLAME_SCYTE_25H));
Talk(SAY_SCYTE);
}
if (phase == PHASE_CAT && me->GetPower(POWER_ENERGY) == 100)
{
DoCast(me, SPELL_LEAPING_FLAMES_SUMMON);
if (Unit* tempTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500.0f, true))
{
DoCast(tempTarget, SPELL_LEAPING_FLAMES);
DoCast(tempTarget, RAID_MODE(SPELL_LEAP_FLAMES_DMG_10N,SPELL_LEAP_FLAMES_DMG_25N,SPELL_LEAP_FLAMES_DMG_10H,SPELL_LEAP_FLAMES_DMG_25H));
}
Talk(SAY_LEAP);
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CHECK_FORM:
{
uint8 numb = 0;
Map::PlayerList const& players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
if (Player* player = itr->getSource())
if (me->GetDistance(player) <= 7.0f)
++numb;
if ((numb >= (Is25ManRaid() ? 18 : 7)) && phase != PHASE_SCORPION && phase != PHASE_DRUID)
{
if (transformcount == 3)
{
transformcount = 0;
TransformToDruid();
}
else
{
transformcount += 1;
TransformToScorpion();
}
}
else if ((numb < (Is25ManRaid() ? 18 : 7)) && phase != PHASE_CAT && phase != PHASE_DRUID)
{
if (transformcount == 3)
{
transformcount = 0;
TransformToDruid();
}
else
{
transformcount += 1;
TransformToCat();
}
}
events.ScheduleEvent(EVENT_CHECK_FORM, 1000);
break;
}
case EVENT_ENERGY_REGEN:
{
if (phase == PHASE_CAT || phase == PHASE_SCORPION)
{
int32 power = 5;
if (me->HasAura(SPELL_ADRENALINE))
power += power * (me->GetAura(SPELL_ADRENALINE)->GetStackAmount() * 20) / 100;
me->SetPower(POWER_ENERGY, me->GetPower(POWER_ENERGY)+power);
}
events.ScheduleEvent(EVENT_ENERGY_REGEN, 1000);
break;
}
case EVENT_INTRO_1:
Talk(SAY_INTRO_1);
break;
case EVENT_INTRO_2:
Talk(SAY_INTRO_2);
break;
case EVENT_INTRO_3:
Talk(SAY_INTRO_3);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
me->SetReactState(REACT_DEFENSIVE);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
break;
case EVENT_SUMMON_ORBS:
{
std::list<Unit*> targets;
SelectTargetList(targets, RAID_MODE(2, 3, 2, 3), SELECT_TARGET_RANDOM, 200.0f, true);
if (!targets.empty())
for (std::list<Unit*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_BURNING_ORBS_SUMMON);
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();
}
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(const uint32 diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING) || !phase)
return;
if (m_uiPowerTimer <= diff)
{
if(instance)
instance->NormaliseAltPower();
}
else m_uiPowerTimer -= diff;
if (m_berserkTimer <= diff)
{
DoCast(me, SPELL_BERSERK);
m_berserkTimer = 600000;
}
else m_berserkTimer -= diff;
if (Creature* firelord = me->FindNearestCreature(NPC_FIRE_LORD, 5.0f, true)) // Flame Lord near.
{
DoCast(me, SPELL_ABSORB_FIRE);
firelord->DespawnOrUnsummon();
}
if (Creature* shadowlord = me->FindNearestCreature(NPC_SHADOW_LORD, 5.0f, true)) // Shadow Lord near.
{
DoCast(me, SPELL_ABSORB_SHADOW);
shadowlord->DespawnOrUnsummon();
}
if (me->HealthBelowPct(26) && !phaseTwo) // Switch phase.
{
EnterPhaseTwo();
phaseTwo = true;
}
if (me->HealthBelowPct(3) && IsHeroic()&& !movedMid) // Heroic move mid before platform breaks.
{
movedMid = true;
events.CancelEvent(EVENT_FURY_OF_CHOGALL);
events.CancelEvent(EVENT_DARK_CREATIONS);
events.CancelEvent(EVENT_CORR_OLD_GOD);
events.CancelEvent(EVENT_SUMMON_TENTACLES);
me->GetMotionMaster()->MovePoint(1, -1162.254f, -798.731f, 835.844f);
}
events.Update(diff);
if (phase == PHASE_ONE) // First phase
{
std::list<Unit*> targets;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CONVERSION:
Talk(RAND(SAY_CONV_1, SAY_CONV_2, SAY_CONV_3));
SelectTargetList(targets, NonTankTargetSelector(me), RAID_MODE(1, 2, 2, 4), SELECT_TARGET_RANDOM);
if (!targets.empty())
for (std::list<Unit*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
(*itr)->CastSpell(me, SPELL_WORSHIPPING, true);
events.ScheduleEvent(EVENT_CONVERSION, urand(30000, 35000), PHASE_ONE);
break;
case EVENT_FLAME_ORDERS:
DoCast(me, SPELL_FLAME_ORDERS); // just once.
DoCast(me, SPELL_F_O_PERIODIC); // every 50 sec.
break;
case EVENT_SHADOW_ORDERS:
DoCast(me, SPELL_SHADOW_ORDERS); // just once.
DoCast(me, SPELL_S_O_PERIODIC); // every 50 sec.
break;
case EVENT_FURY_OF_CHOGALL:
DoCast(me->GetVictim(), SPELL_FURY_OF_CHOGALL);
events.ScheduleEvent(EVENT_FURY_OF_CHOGALL, urand(45000, 49000), PHASE_ONE);
break;
case EVENT_SUMMON_ADHERENT:
Talk(SAY_ADHERENT);
Talk(RAND(SAY_ADHER_1, SAY_ADHER_2, SAY_ADHER_3));
DoCast(me, SPELL_SUM_ADHER_SE); // Needs script.
events.ScheduleEvent(EVENT_SUMMON_ADHERENT, 90000, PHASE_ONE);
break;
case EVENT_FESTER_BLOOD:
DoCast(me, SPELL_FESTER_BLOOD); // Needs script.
events.ScheduleEvent(EVENT_FESTER_BLOOD, 130000, PHASE_ONE);
break;
}
}
}
else if (phase == PHASE_TWO) // Second phase
{
std::list<Unit*> targets;
if (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FURY_OF_CHOGALL:
DoCast(me->GetVictim(), SPELL_FURY_OF_CHOGALL);
events.ScheduleEvent(EVENT_FURY_OF_CHOGALL, urand(45000, 49000), PHASE_TWO);
break;
case EVENT_DARK_CREATIONS:
Talk(RAND(SAY_DARKCR_1, SAY_DARKCR_2, SAY_DARKCR_3, SAY_DARKCR_4, SAY_DARKCR_5));
DoCast(me, SPELL_DARK_CREAT_VIS);
for (int i = 0; i < 4; i++)
me->SummonCreature(NPC_DARKENED_CREATION, TentacleLocations[i].GetPositionX(), TentacleLocations[i].GetPositionY(), TentacleLocations[i].GetPositionZ(), TEMPSUMMON_CORPSE_DESPAWN);
events.ScheduleEvent(EVENT_DARK_CREATIONS, urand(28000, 34000), PHASE_TWO);
break;
case EVENT_CORR_OLD_GOD: // Needs script.
if(Creature* trigger = me->FindNearestCreature(NPC_CHOGALL_COG_TRIGGER, 200.0f, true))
trigger->CastSpell(trigger, SPELL_CORR_OLD_GOD, true);
break;
case EVENT_SUMMON_TENTACLES:
if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, NonTankTargetSelector(me)))
me->SummonCreature(NPC_SPIKED_TENTACLE, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0.0f, TEMPSUMMON_MANUAL_DESPAWN);
events.ScheduleEvent(EVENT_SUMMON_TENTACLES, urand(30000, 35000), PHASE_TWO);
break;
}
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (instance && !instance->GetData(TYPE_MOROES))
{
EnterEvadeMode();
return;
}
if (!Enrage && HealthBelowPct(30))
{
DoCast(me, SPELL_FRENZY);
Enrage = true;
}
if (CheckAdds_Timer <= diff)
{
for (uint8 i = 0; i < 4; ++i)
{
Creature* Temp = NULL;
if (AddGUID[i])
{
Temp = Unit::GetCreature((*me), AddGUID[i]);
if (Temp && Temp->isAlive())
if (!Temp->getVictim())
Temp->AI()->AttackStart(me->getVictim());
}
}
CheckAdds_Timer = 5000;
} else CheckAdds_Timer -= diff;
if (!Enrage)
{
//Cast Vanish, then Garrote random victim
if (Vanish_Timer <= diff)
{
DoCast(me, SPELL_VANISH);
InVanish = true;
Vanish_Timer = 30000;
Wait_Timer = 5000;
} else Vanish_Timer -= diff;
if (Gouge_Timer <= diff)
{
DoCastVictim(SPELL_GOUGE);
Gouge_Timer = 40000;
} else Gouge_Timer -= diff;
if (Blind_Timer <= diff)
{
std::list<Unit*> targets;
SelectTargetList(targets, 5, SELECT_TARGET_RANDOM, me->GetMeleeReach()*5, true);
for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)
if (!me->IsWithinMeleeRange(*i))
{
DoCast(*i, SPELL_BLIND);
break;
}
Blind_Timer = 40000;
} else Blind_Timer -= diff;
}
if (InVanish)
{
if (Wait_Timer <= diff)
{
DoScriptText(RAND(SAY_SPECIAL_1, SAY_SPECIAL_2), me);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
target->CastSpell(target, SPELL_GARROTE, true);
InVanish = false;
} else Wait_Timer -= diff;
}
if (!InVanish)
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim())
return;
if (_enwrapping)
{
if (_enwrapTimer <= diff)
{
if (Unit* target = Unit::GetUnit(*me, _wrapTarget))
{
target->CastSpell(target, SPELL_WEB_WRAP_STUN, true);
_wrapTarget = NULL;
}
_enwrapping = false;
_enwrapTimer = 3*IN_MILLISECONDS;
}
else
_enwrapTimer -= diff;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (_webWrapTimer <= diff)
{
Unit* target = NULL;
std::list<Unit *> playerList;
SelectTargetList(playerList, 5, SELECT_TARGET_RANDOM, 40, true);
for (std::list<Unit*>::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
target = (*itr);
if (!target->HasAura(SPELL_WEB_WRAP) && !target->HasAura(SPELL_WEB_WRAP_STUN))
break; // found someone
target = NULL;
}
// if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 40, true, -SPELL_WEB_WRAP_STUN)
if (target)
{
_enwrapping = true;
_wrapTarget = target->GetGUID();
DoCast(target, SPELL_WEB_WRAP, false);
}
_webWrapTimer = 15*IN_MILLISECONDS;
}
else
_webWrapTimer -= diff;
if (_infectedBiteTimer <= diff)
{
DoCastVictim(SPELL_INFECTED_BITE, true);
_infectedBiteTimer = 15*IN_MILLISECONDS;
}
else
_infectedBiteTimer -= diff;
if (_specialSpell)
if (_specialSpellTimer <= diff)
{
DoCast(_specialSpell);
_specialSpellTimer = 20*IN_MILLISECONDS;
}
else
_specialSpellTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
return;
if ((!me->HasAura(SPELL_DECIMATION_BLADE_10) && !me->HasAura(SPELL_DECIMATION_BLADE_25)) && !me->HasAura(SPELL_INFERNO_BLADE)) //set normal 2 blade equip
SetEquipmentSlots(false, EQUIPMENT_ID_SWORD_1H, EQUIPMENT_ID_SWORD_1H, 0);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
break;
case EVENT_BLAZE_OF_GLORY:
DoCastVictim(SPELL_BLAZE_OF_GLORY);
DoCast(me, SPELL_INCENDIARY_SOUL);
events.ScheduleEvent(EVENT_BLAZE_OF_GLORY, 20000);
break;
case EVENT_SHARDS_OF_TORMENT:
Talk(SAY_CRY_ANN);
DoCast(me, SPELL_SHARDS_OF_TORMENT);
events.ScheduleEvent(EVENT_SUMMON_SHARDS, 1000);
break;
case EVENT_DECIMATION_BLADE:
Talk(SAY_DECIMATION);
Talk(SAY_DECI_ANN);
DoCast(me, (Is25ManRaid() ? SPELL_DECIMATION_BLADE_25 : SPELL_DECIMATION_BLADE_10));
SetEquipmentSlots(false, EQUIPMENT_ID_SWORD_2H, 0, 0); //set one blade equip
events.ScheduleEvent(EVENT_INFERNO_BLADE, 30000);
break;
case EVENT_INFERNO_BLADE:
Talk(SAY_INFERNO);
Talk(SAY_INFE_ANN);
DoCast(me, SPELL_INFERNO_BLADE);
SetEquipmentSlots(false, EQUIPMENT_ID_SWORD_2H, 0, 0); //set one blade equip
events.ScheduleEvent(EVENT_DECIMATION_BLADE, 30000);
break;
case EVENT_COUNTDOWN:
Talk(SAY_COUNTDOWN);
CastCountDown();
events.ScheduleEvent(EVENT_COUNTDOWN, 40000);
break;
case EVENT_SUMMON_SHARDS:
std::list<Unit*> players;
SelectTargetList(players, Is25ManRaid() ? 2 : 1, SELECT_TARGET_RANDOM, 500.0f, true);
if (!players.empty())
for (std::list<Unit*>::iterator itr = players.begin(); itr != players.end(); ++itr)
DoCast(*itr, SPELL_SHARDS_OF_TORMENT_SUMMON);
events.ScheduleEvent(EVENT_SHARDS_OF_TORMENT, 35000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
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();
}
