void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_SPEED, 200.0f, 1.6f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SPELL_SHIELD:
{
ForceSpellCast(me, SPELL_SPELLSHIELD);
events.ScheduleEvent(eventId, 31000);
break;
}
case EVENT_BLAST_WAVE:
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_NEAREST, 0, 15.0f, true))
ForceSpellCast(SPELL_BLAST_WAVE, CAST_SELF);
events.ScheduleEvent(eventId, urand(3000, 5000));
break;
}
}
}
CheckCasterNoMovementInRange(diff, 42.0f);
CastNextSpellIfAnyAndReady(diff);
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_SPEED, 200.0f, 1.6f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_HEAL:
{
AddSpellToCast(SPELL_HEAL, CAST_SELF);
events.ScheduleEvent(eventId, urand(10000, 35000));
break;
}
case EVENT_SHIELD:
{
AddSpellToCast(SPELL_GREATER_PW_SHIELD, CAST_SELF);
AddSpellToCast(SPELL_PRAYEROFHEALING, CAST_SELF);
events.ScheduleEvent(eventId, urand(30000, 40000));
break;
}
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (TransitionTimer)
{
if (TransitionTimer <= diff)
{
if(Unit* Muru = me->GetUnit(pInstance->GetData64(DATA_MURU)))
{
Muru->SetVisibility(VISIBILITY_OFF);
Muru->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
}
me->SetRooted(false);
AttackStart(me->getVictim());
DoCast(me, SPELL_NEGATIVE_ENERGY_PERIODIC_E);
TransitionTimer = 0;
}
else
TransitionTimer -= diff;
return;
}
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_EVADE, 100.0f);
if (EnrageTimer < diff)
{
AddSpellToCast(me, SPELL_ENRAGE);
EnrageTimer = 60000;
}
else
EnrageTimer -= diff;
if (DarknessTimer < diff)
{
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 100, true))
AddSpellToCast(target, SPELL_DARKNESS);
DarknessTimer = 15000;
}
else
DarknessTimer -= diff;
if (BlackHole < diff)
{
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 100, true, me->getVictimGUID(), 10.0))
AddSpellToCast(target, SPELL_BLACK_HOLE);
BlackHole = urand(15000, 18000);
}
else
BlackHole -= diff;
DoMeleeAttackIfReady();
CastNextSpellIfAnyAndReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CORRUPTED_MIND:
{
AddSpellToCast(SPELL_CORRUPTED_MIND, CAST_NULL);
events.ScheduleEvent(EVENT_CORRUPTED_MIND, 62000);
break;
}
case EVENT_POISON_AURA:
{
AddSpellToCast(SPELL_POISON_AURA, CAST_NULL);
events.ScheduleEvent(EVENT_POISON_AURA, 12000);
break;
}
case EVENT_INEVITABLE_DOOM_5MIN:
{
inevitableTimer = 15000;
break;
}
case EVENT_INEVITABLE_DOOM:
{
AddSpellToCast(SPELL_INEVITABLE_DOOM, CAST_NULL);
events.ScheduleEvent(EVENT_INEVITABLE_DOOM, inevitableTimer);
break;
}
case EVENT_REMOVE_CURSE:
{
AddSpellToCast(SPELL_REMOVE_CURSE, CAST_SELF);
events.ScheduleEvent(EVENT_REMOVE_CURSE, 30000);
break;
}
case EVENT_SUMMON_SPORE:
{
for (uint8 i = 0; i < 3; ++i)
m_creature->SummonCreature(16286, SporesLocations[i][0], SporesLocations[i][1], SporesLocations[i][2], 0, TEMPSUMMON_TIMED_DESPAWN, 12000);
break;
}
default:
break;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 60.0f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BLAU_MARK:
{
AddSpellToCast(SPELL_MARK_OF_BLAUMEUX, CAST_NULL);
events.ScheduleEvent(EVENT_BLAU_MARK, 12000);
break;
}
case EVENT_BLAU_VOID_ZONE:
{
if (Unit * tmpUnit = SelectUnit(SELECT_TARGET_RANDOM, 0, 45.0f))
AddSpellToCast(tmpUnit, SPELL_VOID_ZONE);
events.ScheduleEvent(EVENT_BLAU_VOID_ZONE, 12000);
break;
}
default:
break;
}
}
// Shield Wall - All 4 horsemen will shield wall at 50% hp and 20% hp for 20 seconds
if (!ShieldWall1)
{
if (HealthBelowPct(50))
{
AddSpellToCast(SPELL_SHIELDWALL, CAST_SELF);
ShieldWall1 = true;
}
}
else
{
if (!ShieldWall2 && HealthBelowPct(20))
{
AddSpellToCast(SPELL_SHIELDWALL, CAST_SELF);
ShieldWall2 = true;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 60.0f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ZELIEK_MARK:
{
AddSpellToCast(SPELL_MARK_OF_ZELIEK, CAST_NULL);
events.ScheduleEvent(EVENT_ZELIEK_MARK, 12000);
break;
}
case EVENT_ZELIEK_WRATH:
{
AddSpellToCast(SPELL_HOLY_WRATH, CAST_TANK);
events.ScheduleEvent(EVENT_ZELIEK_WRATH, 12000);
break;
}
default:
break;
}
}
// Shield Wall - All 4 horsemen will shield wall at 50% hp and 20% hp for 20 seconds
if (!ShieldWall1)
{
if (HealthBelowPct(50))
{
AddSpellToCast(SPELL_SHIELDWALL, CAST_SELF);
ShieldWall1 = true;
}
}
else
{
if (!ShieldWall2 && HealthBelowPct(20))
{
AddSpellToCast(SPELL_SHIELDWALL, CAST_SELF);
ShieldWall2 = true;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 120.0f);
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 (!m_creature->HasAura(SPELL_LOCUSTSWARM,1))
AddSpellToCast(SPELL_IMPALE, CAST_RANDOM);
events.ScheduleEvent(EVENT_IMPALE, 15000);
break;
}
case EVENT_SWARM:
{
AddSpellToCast(SPELL_LOCUSTSWARM, CAST_SELF);
events.ScheduleEvent(EVENT_SWARM, 90000);
break;
}
case EVENT_SUMMON:
{
AddSpellToCast(SPELL_SUMMONGUARD, CAST_SELF);
events.ScheduleEvent(EVENT_SUMMON, 45000);
break;
}
default:
break;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_EVADE, 100.0f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_UNBALANCING_STRIKE:
{
AddSpellToCast(SPELL_UNBALANCINGSTRIKE, CAST_TANK);
events.ScheduleEvent(EVENT_UNBALANCING_STRIKE, 30000);
break;
}
case EVENT_DISTRUPTING_SHOUT:
{
AddSpellToCast(SPELL_DISRUPTINGSHOUT, CAST_NULL);
events.ScheduleEvent(EVENT_DISTRUPTING_SHOUT, 25000);
break;
}
case EVENT_COMMAND_SOUND:
{
DoPlaySoundToSet(m_creature, RAND(SOUND_COMMND1, SOUND_COMMND2, SOUND_COMMND3, SOUND_COMMND4, SOUND_COMMND5));
events.ScheduleEvent(EVENT_COMMAND_SOUND, 40000);
break;
}
default:
break;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 120.0f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_POISONBOLT_VOLLEY:
{
AddSpellToCast(SPELL_POISONBOLT_VOLLEY, CAST_NULL);
events.ScheduleEvent(EVENT_POISONBOLT_VOLLEY, 11000);
break;
}
case EVENT_RAIN_OF_FIRE:
{
AddSpellToCast(SPELL_RAIN_OF_FIRE, CAST_RANDOM);
events.ScheduleEvent(EVENT_RAIN_OF_FIRE, 16000);
break;
}
case EVENT_ENRAGE:
{
AddSpellToCast(SPELL_ENRAGE, CAST_SELF);
events.ScheduleEvent(EVENT_ENRAGE, 61000);
break;
}
default:
break;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_SPEED, 200.0f, 1.6f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_POLYMORPH:
{
AddSpellToCast(SPELL_GREATER_POLYMORPH, CAST_TANK);
events.ScheduleEvent(eventId, urand(10000, 20000));
break;
}
case EVENT_ARCANE_SHOCK:
{
AddSpellToCast(SPELL_ARCANE_SHOCK);
events.ScheduleEvent(eventId, urand(15000, 20000));
break;
}
case EVENT_ARCANE_EXPLO:
{
AddSpellToCast(SPELL_ARCANE_EXPLOSION, CAST_SELF);
events.ScheduleEvent(eventId, 30000);
break;
}
}
}
CheckCasterNoMovementInRange(diff, 42.0f);
CastNextSpellIfAnyAndReady(diff);
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_SPEED, 200.0f, 2.0f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_DARK_DECAY:
{
AddSpellToCast(SPELL_DARK_DECAY);
events.ScheduleEvent(eventId, 20000);
break;
}
case EVENT_SUMMON:
{
AddSpellToCast(SPELL_SUMMON_WFH, CAST_SELF);
events.ScheduleEvent(eventId, 50000);
break;
}
case EVENT_DEATH_COIL:
{
AddSpellToCast(SPELL_DEATH_COIL, CAST_RANDOM);
events.ScheduleEvent(eventId, 20000);
break;
}
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 120.0f);
events.Update(diff);
uint32 eventId;
while (eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ICE_BOLT:
{
AddSpellToCast(SPELL_ICEBOLT, CAST_RANDOM);
if (++iceboltCount < 5)
events.ScheduleEvent(EVENT_ICE_BOLT, 4000);
else
events.ScheduleEvent(EVENT_FROST_BREATH, 2000);
break;
}
case EVENT_FROST_BREATH:
{
AddSpellToCastWithScriptText(SPELL_FROST_BREATH, CAST_SELF, EMOTE_BREATH);
events.ScheduleEvent(EVENT_PHASE_1, 2000);
break;
}
case EVENT_LIFE_DRAIN:
{
AddSpellToCast(SPELL_LIFE_DRAIN, CAST_RANDOM);
events.ScheduleEvent(EVENT_LIFE_DRAIN, 24000);
break;
}
case EVENT_BLIZZARD:
{
AddSpellToCast(SPELL_BLIZZARD, CAST_SELF);
events.ScheduleEvent(EVENT_BLIZZARD, 20000);
break;
}
case EVENT_PHASE_2:
{
if (HealthBelowPct(10))
break;
iceboltCount = 0;
phase = SAPPHIRON_AIR_PHASE;
events.CancelEvent(EVENT_BLIZZARD);
events.CancelEvent(EVENT_LIFE_DRAIN);
events.ScheduleEvent(EVENT_ICE_BOLT, 4000);
m_creature->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
m_creature->SetLevitate(true);
m_creature->GetMotionMaster()->Clear(false);
m_creature->GetMotionMaster()->MoveIdle();
break;
}
case EVENT_PHASE_1:
{
phase = SAPPHIRON_GROUND_PHASE;
events.ScheduleEvent(EVENT_BLIZZARD, urand(10000, 20000));
events.ScheduleEvent(EVENT_LIFE_DRAIN, urand(12000, 24000));
events.ScheduleEvent(EVENT_PHASE_2, 67000);
m_creature->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
m_creature->SetLevitate(false);
m_creature->GetMotionMaster()->Clear(false);
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
break;
}
}
}
if (!berserk && HealthBelowPct(10))
{
berserk = true;
ForceSpellCastWithScriptText(SPELL_BERSERK, CAST_SELF, EMOTE_ENRAGE);
}
CastNextSpellIfAnyAndReady();
if (phase == SAPPHIRON_GROUND_PHASE)
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 200.0f, 1.6f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ARCING_SMASH:
{
AddSpellToCast(SPELL_ARCING_SMASH);
events.ScheduleEvent(eventId, 10000);
break;
}
case EVENT_WHIRLWIND:
{
AddSpellToCast(SPELL_WHIRLWIND, CAST_SELF);
events.ScheduleEvent(eventId, 55000);
break;
}
case EVENT_MIGHTY_BLOW:
{
AddSpellToCast(SPELL_MIGHTY_BLOW);
events.ScheduleEvent(eventId, urand(30000, 40000));
break;
}
case EVENT_CHARGE_HKM:
{
AddSpellToCast(SPELL_BERSERKER_C, CAST_RANDOM);
events.ScheduleEvent(eventId, 20000);
break;
}
case EVENT_ROAR:
{
AddSpellToCast(SPELL_ROAR, CAST_SELF);
events.ScheduleEvent(eventId, 20000);
break;
}
}
}
//Entering Phase 2
if (_phase == PHASE_ONE && HealthBelowPct(50))
{
_phase = PHASE_TWO;
DoScriptText(SAY_ENRAGE, me);
events.RescheduleEvent(EVENT_WHIRLWIND, 30000);
events.ScheduleEvent(EVENT_CHARGE_HKM, 2000);
events.ScheduleEvent(EVENT_ROAR, 3000);
ForceSpellCast(me, SPELL_DUAL_WIELD);
ForceSpellCast(me, SPELL_FLURRY);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, 0);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY+1, 0);
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (instance->GetData(DATA_STRANGE_POOL) != IN_PROGRESS)
return;
if (me->GetVisibility() == VISIBILITY_OFF)
{
me->SetVisibility(VISIBILITY_ON);
me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_ATTACKABLE_2);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DoZoneInCombat();
}
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_PULSE_COMBAT);
Rotate(diff);//always check rotate things
events.Update(diff);
if(!m_submerged && RotType == NOROTATE)//is not spouting and not submerged
{
if(SpoutTimer < diff)
{
if(me->getVictim() && RotType == NOROTATE)
StartRotate(me->getVictim());//start spout and random rotate
SpoutTimer= 35000;
return;
} else SpoutTimer -= diff;
}
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
/*case LURKER_EVENT_SPOUT_EMOTE:
{
me->MonsterTextEmote(EMOTE_SPOUT, 0, true);
ForceSpellCast(me, SPELL_SPOUT_BREATH);
events.ScheduleEvent(LURKER_EVENT_SPOUT, 3000);
break;
}
case LURKER_EVENT_SPOUT:
{
me->SetReactState(REACT_PASSIVE);
me->SetSelection(0);
me->GetMotionMaster()->MoveRotate(20000, RAND(ROTATE_DIRECTION_LEFT, ROTATE_DIRECTION_RIGHT));
ForceSpellCast(me, SPELL_SPOUT_VISUAL, INTERRUPT_AND_CAST_INSTANTLY);
m_rotating = true;
events.DelayEvents(20000, 0);
events.ScheduleEvent(LURKER_EVENT_SPOUT_EMOTE, 45000);
events.RescheduleEvent(LURKER_EVENT_WHIRL, 21000);
break;
}*/
case LURKER_EVENT_WHIRL:
{
AddSpellToCast(me, SPELL_WHIRL);
events.ScheduleEvent(LURKER_EVENT_WHIRL, 18000);
break;
}
case LURKER_EVENT_GEYSER:
{
AddSpellToCast(SPELL_GEYSER, CAST_RANDOM);
events.ScheduleEvent(LURKER_EVENT_GEYSER, urand(15000, 20000));
break;
}
case LURKER_EVENT_SUBMERGE:
{
ForceSpellCast(me, SPELL_SUBMERGE, INTERRUPT_AND_CAST_INSTANTLY);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_ATTACKABLE_2);
SummonAdds();
m_submerged = true;
events.CancelEvent(LURKER_EVENT_SPOUT_EMOTE);
SpoutTimer = 4000; // directly cast Spout after emerging!
// events.CancelEvent(LURKER_EVENT_SPOUT);
events.CancelEvent(LURKER_EVENT_WHIRL);
events.CancelEvent(LURKER_EVENT_GEYSER);
events.ScheduleEvent(LURKER_EVENT_REEMERGE, 60000);
break;
}
case LURKER_EVENT_REEMERGE:
{
me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_ATTACKABLE_2);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
m_submerged = false;
events.ScheduleEvent(LURKER_EVENT_SPOUT_EMOTE, 0);
events.ScheduleEvent(LURKER_EVENT_WHIRL, 2000);
events.ScheduleEvent(LURKER_EVENT_GEYSER, urand(5000, 15000));
events.ScheduleEvent(LURKER_EVENT_SUBMERGE, 90000);
break;
}
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_EVADE, 135.0f);
if (!evocating && m_creature->GetPower(POWER_MANA) <= 1000)
{
evocating = true;
ForceSpellCastWithScriptText(SPELL_EVOCATION, CAST_SELF, SAY_EVOCATE);
}
if (!enraged && !evocating)
{
if (addTimer < diff)
{
//Summon Astral Flare
Creature* astralFlare = DoSpawnCreature(17096, rand()%37, rand()%37, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (astralFlare && target)
{
astralFlare->CastSpell(astralFlare, SPELL_ASTRAL_FLARE_PASSIVE, false);
astralFlare->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_ARCANE, true);
astralFlare->AI()->AttackStart(target);
}
//Reduce Mana by 10%
int32 mana = (int32)(0.1f*(m_creature->GetMaxPower(POWER_MANA)));
m_creature->ModifyPower(POWER_MANA, -mana);
DoScriptText(RAND(SAY_SUMMON1, SAY_SUMMON2, 0, 0), m_creature);
addTimer = 10000;
}
else
addTimer -= diff;
if (hatefulBoltTimer < diff)
{
AddSpellToCast(SPELL_HATEFUL_BOLT, CAST_THREAT_SECOND);
hatefulBoltTimer = enraged ? 7000 : 15000;
}
else
hatefulBoltTimer -= diff;
if (!enraged && HealthBelowPct(15))
{
enraged = true;
ForceSpellCastWithScriptText(SPELL_ENRAGE, CAST_SELF, SAY_ENRAGE);
}
}
if (berserkTimer < diff)
{
ForceSpellCastWithScriptText(SPELL_BERSERK, CAST_SELF, SAY_ENRAGE);
berserkTimer = 60000;
}
else
berserkTimer -= diff;
CastNextSpellIfAnyAndReady();
if (!evocating)
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if(ResetTimer)
{
if(ResetTimer <= diff)
{
me->SetVisibility(VISIBILITY_ON);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
ResetTimer = 0;
}
else
ResetTimer -= diff;
}
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_COMBAT_N_EVADE, 80.0f);
if (me->GetSelection())
me->SetSelection(NULL);
if (EnrageTimer < diff)
{
DoCast(me, SPELL_ENRAGE, true);
EnrageTimer = 60000;
}
else
EnrageTimer -= diff;
if(HumanoidStart)
{
if(HumanoidStart <= diff)
{
pInstance->SetData(DATA_MURU_EVENT, IN_PROGRESS);
// if anyone trapped outside front door, evade
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 400, true, 0, 60))
{
EnterEvadeMode();
return;
}
DoCast(me, SPELL_SUMMON_BLOOD_ELVES_PERIODIC, true);
HumanoidStart = 0;
}
else
HumanoidStart -= diff;
}
if(TransitionTimer)
{
if(TransitionTimer <= diff)
{
DoCast(me, SPELL_ENTROPIUS_COSMETIC_SPAWN);
DoCast(me, SPELL_SUMMON_ENTROPIUS);
me->RemoveAllAuras();
TransitionTimer = 0;
}
else
TransitionTimer -= diff;
}
}
void UpdateAI(const uint32 diff)
{
if(!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 125.0f, 1.5f);
// Void Zone
if(VoidZoneTimer < diff)
{
if(Unit *target = SelectUnit(SELECT_TARGET_RANDOM,1,GetSpellMaxRange(SPELL_VOIDZONE),true, m_creature->getVictimGUID()))
AddSpellToCast(target,SPELL_VOIDZONE,true);
VoidZoneTimer = 15000;
}
else
VoidZoneTimer -= diff;
// NetherInfusion Berserk
if(!Berserk && NetherInfusionTimer < diff)
{
m_creature->AddAura(SPELL_NETHER_INFUSION, m_creature);
ForceSpellCast(m_creature, SPELL_NETHERSPITE_ROAR, INTERRUPT_AND_CAST_INSTANTLY);
Berserk = true;
}
else
NetherInfusionTimer -= diff;
if(PortalPhase) // PORTAL PHASE
{
// Distribute beams and buffs
if(PortalTimer < diff)
{
UpdatePortals();
PortalTimer = 1000;
}
else
PortalTimer -= diff;
// Empowerment & Nether Burn
if(EmpowermentTimer < diff)
{
ForceSpellCast(m_creature, SPELL_EMPOWERMENT);
m_creature->AddAura(SPELL_NETHERBURN_AURA, m_creature);
EmpowermentTimer = 90000;
}
else
EmpowermentTimer -= diff;
if(PhaseTimer < diff)
{
if(!m_creature->IsNonMeleeSpellCast(false))
{
SwitchToBanishPhase();
return;
}
}
else
PhaseTimer -= diff;
DoMeleeAttackIfReady();
}
else // BANISH PHASE
{
if(m_creature->GetMotionMaster()->GetCurrentMovementGeneratorType() != IDLE_MOTION_TYPE)
{
m_creature->GetMotionMaster()->Clear();
m_creature->GetMotionMaster()->MoveIdle();
}
// Netherbreath
if(NetherbreathTimer < diff)
{
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0,GetSpellMaxRange(SPELL_NETHERBREATH),true))
AddSpellToCast(target,SPELL_NETHERBREATH);
NetherbreathTimer = 5000+rand()%2000;
}
else
NetherbreathTimer -= diff;
if(PhaseTimer < diff)
{
if(!m_creature->IsNonMeleeSpellCast(false))
{
SwitchToPortalPhase();
return;
}
}
else
PhaseTimer -= diff;
}
CastNextSpellIfAnyAndReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVADE_CHECK, 60.0f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHADOW_VOLLEY:
{
AddSpellToCast(SPELL_SHADOWVOLLEY, CAST_NULL);
events.ScheduleEvent(EVENT_SHADOW_VOLLEY, 3000);
break;
}
case EVENT_CLEAVE:
{
AddSpellToCast(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, urand(8000, 12000));
break;
}
case EVENT_THUNDER_CLAP:
{
AddSpellToCast(SPELL_THUNDERCLAP, CAST_SELF);
events.ScheduleEvent(EVENT_THUNDER_CLAP, urand(10000, 14000));
break;
}
case EVENT_MARKOFKAZZAK:
{
if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 60.0, true, POWER_MANA))
AddSpellToCast(pTarget, SPELL_MARKOFKAZZAK);
events.ScheduleEvent(EVENT_MARKOFKAZZAK, 20000);
break;
}
case EVENT_TWIST_REFLECT:
{
if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 100.0f, true))
AddSpellToCast(pTarget, SPELL_TWISTEDREFLECTION);
events.ScheduleEvent(EVENT_TWIST_REFLECT, 15000);
break;
}
case EVENT_VOID_BOLT:
{
AddSpellToCast(SPELL_VOIDBOLT);
events.ScheduleEvent(EVENT_VOID_BOLT, urand(15000, 18000));
break;
}
case EVENT_ENRAGE:
{
AddSpellToCastWithScriptText(me, SPELL_ENRAGE, EMOTE_FRENZY);
events.ScheduleEvent(EVENT_ENRAGE, 40000);
events.RescheduleEvent(EVENT_SHADOW_VOLLEY, 12000);
break;
}
default:
break;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 200.0f, 1.6f);
//Slow his movement speed while he whirls
//I'm not proud of this. Should be handled by the dbc,
//modaura slow of the spell only applied shortly (and once) in the beginning, afterwards he regains normal speed
if (me->HasAura(33238)) {
me->SetSpeed(MOVE_RUN, 0.80f);
}
else {
me->SetSpeed(MOVE_RUN, 1.71);
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ARCING_SMASH:
{
AddSpellToCast(SPELL_ARCING_SMASH);
events.ScheduleEvent(eventId, urand(8000, 12000));
break;
}
case EVENT_WHIRLWIND:
{
AddSpellToCast(SPELL_WHIRLWIND, CAST_SELF);
events.ScheduleEvent(eventId, urand(30000, 40000));
events.RescheduleEvent(EVENT_ARCING_SMASH, 16500);
break;
}
case EVENT_MIGHTY_BLOW:
{
AddSpellToCast(SPELL_MIGHTY_BLOW);
events.ScheduleEvent(eventId, urand(20000, 35000));
break;
}
case EVENT_CHARGE_HKM:
{
AddSpellToCast(SPELL_BERSERKER_C, CAST_RANDOM);
events.ScheduleEvent(eventId, urand(14000, 20000));
break;
}
case EVENT_ROAR:
{
AddSpellToCast(SPELL_ROAR, CAST_SELF);
events.ScheduleEvent(eventId, urand(20000, 35000));
break;
}
}
}
//Entering Phase 2
if (_phase == PHASE_ONE && HealthBelowPct(50))
{
_phase = PHASE_TWO;
DoScriptText(SAY_ENRAGE, me);
events.RescheduleEvent(EVENT_WHIRLWIND, urand(10000, 20000));
events.ScheduleEvent(EVENT_CHARGE_HKM, 3000);
events.ScheduleEvent(EVENT_ROAR, 2000);
ForceSpellCast(me, SPELL_DUAL_WIELD);
ForceSpellCast(me, SPELL_FLURRY);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, 0);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY+1, 0);
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (instance->GetData(DATA_LURKER_FISHING_EVENT) != DONE)
return;
//boss is invisible, don't attack
if (!CanStartEvent)
{
if (m_submerged)
{
m_submerged = false;
WaitTimer2 = 500;
}
//wait 500ms before emerge anim
if (!m_submerged && WaitTimer2 <= diff)
{
me->SetVisibility(VISIBILITY_ON);
me->RemoveAllAuras();
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
DoCast(me, SPELL_EMERGE, false);
WaitTimer2 = 60000;//never reached
WaitTimer = 3000;
}
else
WaitTimer2 -= diff;
//wait 3secs for emerge anim, then attack
if (WaitTimer <= diff)
{
//fresh fished from pool
WaitTimer = 3000;
CanStartEvent = true;
me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_ATTACKABLE_2);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DoZoneInCombat();
if (ConsecutiveSubmerge)
{
events.RescheduleEvent(LURKER_EVENT_WHIRL, 2000);
events.RescheduleEvent(LURKER_EVENT_GEYSER, urand(5000, 15000));
events.RescheduleEvent(LURKER_EVENT_SUBMERGE, 90000);
}
}
else
WaitTimer -= diff;
return;
}
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_PULSE_COMBAT);
Rotate(diff);//always check rotate things
events.Update(diff);
if(!m_submerged && RotType == NOROTATE)//is not spouting and not submerged
{
if(SpoutTimer < diff)
{
if(me->getVictim() && RotType == NOROTATE)
StartRotate(me->getVictim());//start spout and random rotate
SpoutTimer= 35000;
return;
} else SpoutTimer -= diff;
}
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case LURKER_EVENT_WHIRL:
{
if (m_submerged == false) {
AddSpellToCast(me, SPELL_WHIRL);
}
events.RescheduleEvent(LURKER_EVENT_WHIRL, 18000);
break;
}
case LURKER_EVENT_GEYSER:
{
AddSpellToCast(SPELL_GEYSER, CAST_RANDOM);
events.ScheduleEvent(LURKER_EVENT_GEYSER, urand(15000, 20000));
break;
}
case LURKER_EVENT_SUBMERGE:
{
ForceSpellCast(me, SPELL_SUBMERGE, INTERRUPT_AND_CAST_INSTANTLY);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_ATTACKABLE_2);
me->SetVisibility(VISIBILITY_OFF);
SummonAdds();
m_submerged = true;
// directly cast Spout after emerging!
SpoutTimer = 4000;
events.CancelEvent(LURKER_EVENT_WHIRL);
events.CancelEvent(LURKER_EVENT_GEYSER);
events.ScheduleEvent(LURKER_EVENT_REEMERGE, 60000);
break;
}
case LURKER_EVENT_REEMERGE:
{
me->SetVisibility(VISIBILITY_OFF);
DoStopAttack();
//Time values here is irrelevant, they just need to be set
WaitTimer = 60000;
WaitTimer2 = 60000;
CanStartEvent = false;
m_submerged = true;
ConsecutiveSubmerge = true;
break;
}
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim() )
return;
DoSpecialThings(diff, DO_EVERYTHING, 135.0f);
//Earthquake_Timer
if (Earthquake_Timer < diff)
{
if (!Earthquake)
{
AddSpellToCastWithScriptText(SPELL_EARTHQUAKE, CAST_NULL, EMOTE_EARTHQUAKE);
Earthquake = true;
Earthquake_Timer = 10000;
}
else
{
DoScriptText(RAND(SAY_SUMMON1, SAY_SUMMON2), m_creature);
for (uint8 i = 0; i < 10; ++i)
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0);
Creature* Murloc = m_creature->SummonCreature(MurlocCords[i][0], MurlocCords[i][1], MurlocCords[i][2], MurlocCords[i][3], MurlocCords[i][4], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 10000);
if (target && Murloc)
{
Murloc->setActive(true);
Murloc->AI()->AttackStart(target);
}
}
Earthquake = false;
Earthquake_Timer = urand(40000, 45000);
}
}
else
Earthquake_Timer -= diff;
//TidalWave_Timer
if (TidalWave_Timer < diff)
{
AddSpellToCast(SPELL_TIDAL_WAVE, CAST_NULL);
TidalWave_Timer = 20000;
}
else
TidalWave_Timer -= diff;
if (!Phase2)
{
//WateryGrave_Timer
if (WateryGrave_Timer < diff)
{
//Teleport 4 players under the waterfalls
std::list<Unit*> tmpList;
SelectUnitList(tmpList, 4, SELECT_TARGET_RANDOM, 200.0f, true, me->getVictimGUID());
int i = 0;
for (std::list<Unit*>::const_iterator itr = tmpList.begin(); itr != tmpList.end(); ++itr)
me->CastSpell(*itr, wateryGraves[i++], true);
DoScriptText(RAND(SAY_SUMMON_BUBL1, SAY_SUMMON_BUBL2), m_creature);
DoScriptText(EMOTE_WATERY_GRAVE, m_creature);
WateryGrave_Timer = 30000;
}
else
WateryGrave_Timer -= diff;
//Start Phase2
if (HealthBelowPct(25))
Phase2 = true;
}
else
{
//WateryGlobules_Timer
if (WateryGlobules_Timer < diff)
{
std::list<Unit*> tmpList;
SelectUnitList(tmpList, 4, SELECT_TARGET_RANDOM, 200.0f, true, me->getVictimGUID());
int i = 0;
for (std::list<Unit*>::const_iterator itr = tmpList.begin(); itr != tmpList.end(); ++itr)
(*itr)->CastSpell((*itr), summonGlobules[i++], true);
DoScriptText(EMOTE_WATERY_GLOBULES, m_creature);
WateryGlobules_Timer = 25000;
}
else
WateryGlobules_Timer -= diff;
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
