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 EnterCombat(Unit *who)
{
DoZoneInCombat();
ForceSpellCast(me, SPELL_SPELLSHIELD, INTERRUPT_AND_CAST);
StartAutocast();
}
void KilledUnit(Unit* pVictim)
{
if (pVictim->ToPlayer())
return;
if (!HealthBelowPct(1))
ForceSpellCast(SPELL_CAPTURESOUL, CAST_SELF);
DoScriptText(RAND(SAY_KILL1, SAY_KILL2, SAY_KILL3), me);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (CheckTimer < diff)
{
if (!m_creature->IsWithinDistInMap(&wLoc, 20.0f))
EnterEvadeMode();
me->SetSpeed(MOVE_WALK, 2.0f, true);
me->SetSpeed(MOVE_RUN, 2.0f, true);
CheckTimer = 2000;
}
else
CheckTimer -= diff;
if (AvatarTimer < diff)
{
ForceSpellCast(m_creature->getVictim(), SPELL_AVATAR);
AvatarTimer = urand(15000, 20000);
}
else
AvatarTimer -= diff;
if (ThunderclapTimer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_THUNDERCLAP);
ThunderclapTimer = urand(5000, 15000);
}
else
ThunderclapTimer -= diff;
if (StormboltTimer < diff)
{
Unit * victim = SelectUnit(SELECT_TARGET_RANDOM, 1, 30.0f, true);
if (victim)
AddSpellToCast(victim, SPELL_STORMBOLT);
StormboltTimer = urand(10000, 25000);
}
else
StormboltTimer -= diff;
if (YellTimer < diff)
{
DoScriptText(RAND(YELL_RANDOM1, YELL_RANDOM2, YELL_RANDOM3, YELL_RANDOM4, YELL_RANDOM5, YELL_RANDOM6, YELL_RANDOM7), m_creature);
YellTimer = urand(20000, 30000); //20 to 30 seconds
}
else
YellTimer -= diff;
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void IsSummonedBy(Unit *pSummoner)
{
ForceSpellCast(SPELL_IMAGE_VISUAL, CAST_SELF, INTERRUPT_AND_CAST_INSTANTLY);
DoZoneInCombat();
//if (Unit *pTarget = SelectUnit(SELECT_TARGET_FARTHEST, urand(0, 4), 400, true))
if(Creature* Alythess = me->GetCreature(pInstance->GetData64(DATA_ALYTHESS)))
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 400, true, Alythess->getVictimGUID(), 10.0f))
AttackStart(pTarget);
}
}
void EnterPhase(PhaseHalazzi NextPhase)
{
switch(NextPhase)
{
case PHASE_LYNX:
case PHASE_ENRAGE:
if(Phase == PHASE_MERGE)
{
ForceSpellCast(m_creature, SPELL_TRANSFORM_MERGE, INTERRUPT_AND_CAST_INSTANTLY, true);
m_creature->Attack(m_creature->getVictim(), true);
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
}
if(Unit *Lynx = Unit::GetUnit(*m_creature, LynxGUID))
{
Lynx->SetVisibility(VISIBILITY_OFF);
Lynx->setDeathState(JUST_DIED);
}
m_creature->SetMaxHealth(600000);
m_creature->SetHealth(600000 - 150000 * TransformCount);
FrenzyTimer = 16000;
SaberlashTimer = 5000;
ShockTimer = 10000;
TotemTimer = 12000;
break;
case PHASE_SPLIT:
AddSpellToCastWithScriptText(m_creature, SPELL_TRANSFORM_SPLIT, YELL_SPLIT, true);
break;
case PHASE_HUMAN:
//DoCast(m_creature, SPELL_SUMMON_LYNX, true);
DoSpawnCreature(MOB_SPIRIT_LYNX, 5,5,0,0, TEMPSUMMON_CORPSE_DESPAWN, 0);
m_creature->SetMaxHealth(400000);
m_creature->SetHealth(400000);
ShockTimer = 10000;
TotemTimer = 12000;
break;
case PHASE_MERGE:
if(Unit *Lynx = Unit::GetUnit(*m_creature, LynxGUID))
{
DoScriptText(YELL_MERGE, m_creature);
Lynx->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Lynx->GetMotionMaster()->Clear();
Lynx->GetMotionMaster()->MoveFollow(m_creature, 0, 0);
m_creature->GetMotionMaster()->Clear();
m_creature->GetMotionMaster()->MoveFollow(Lynx, 0, 0);
TransformCount++;
}break;
default:
break;
}
Phase = NextPhase;
}
void Reset()
{
events.Reset();
ClearCastQueue();
_phase = PHASE_ONE;
instance->SetData(DATA_MAULGAREVENT, NOT_STARTED);
events.ScheduleEvent(EVENT_MIGHTY_BLOW, urand(15000, 25000));
events.ScheduleEvent(EVENT_ARCING_SMASH, urand(8000, 14000));
events.ScheduleEvent(EVENT_WHIRLWIND, 30000);
ForceSpellCast(me, SPELL_DUAL_WIELD);
}
void Reset()
{
SlashTimer = 11000;
StompTimer = 30000;
BurnTimer = 20000;
BerserkTimer = 360000;
CheckTimer = 1000;
CheckGroundTimer = 500;
IntroPhase = 0;
IntroPhaseTimer = 0;
IntroFrostBoltTimer = 0;
Enraged = false;
ForceSpellCast(me, SPELL_DUAL_WIELD, INTERRUPT_AND_CAST_INSTANTLY);
pInstance->SetData(DATA_BRUTALLUS_EVENT, NOT_STARTED);
me->CombatStop();
}
void UpdateAI(const uint32 diff)
{
if(!me->isInCombat())
if(yelltimer < diff)
{
me->Yell(RAND(YELL_OOC1,YELL_OOC2,YELL_OOC3,YELL_OOC4,YELL_OOC5,YELL_OOC6),0,0);
yelltimer = urand(60000,120000);
}
else
yelltimer -=diff;
if(!UpdateVictim())
return;
if(hamstringtimer < diff)
{
AddSpellToCast(SPELL_DISARM);
hamstringtimer = 9000;
}
else
hamstringtimer -= diff;
if(headcracktimer < diff)
{
AddSpellToCast(SPELL_GEYSER);
headcracktimer = urand(20000,25000);
}
else
headcracktimer -= diff;
if (HealthBelowPct(20.0f) && !frenzy)
{
ForceSpellCast(me, SPELL_FRENZY, INTERRUPT_AND_CAST_INSTANTLY);
frenzy = true;
}
DoMeleeAttackIfReady();
CastNextSpellIfAnyAndReady(diff);
}
void EnterCombat(Unit *pWho)
{
if (Creature *pController = pInstance->GetCreature(pInstance->GetData64(DATA_ILLIDARICOUNCIL)))
((mob_illidari_councilAI*)pController->AI())->StartEvent(pWho);
DoZoneInCombat();
if (me->GetEntry() == 22950) // Zerevor
{
ClearCastQueue();
ForceSpellCast(me, SPELL_DAMPEN_MAGIC);
AddSpellToCast(pWho, SPELL_ARCANE_BOLT);
StartAutocast();
}
if (!loadedGUIDs)
{
m_council[0] = pInstance->GetData64(DATA_LADYMALANDE);
m_council[1] = pInstance->GetData64(DATA_HIGHNETHERMANCERZEREVOR);
m_council[2] = pInstance->GetData64(DATA_GATHIOSTHESHATTERER);
m_council[3] = pInstance->GetData64(DATA_VERASDARKSHADOW);
loadedGUIDs = true;
}
}
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)
{
if (!UpdateVictim())
return;
if (m_checkTimer < diff)
{
if (me->IsWithinDistInMap(&wLoc, 100.0f))
DoZoneInCombat();
else
{
EnterEvadeMode();
return;
}
me->SetSpeed(MOVE_RUN, 2.0);
uint32 damage = 0;
SharedRule(damage);
m_checkTimer = 1000;
}
else
m_checkTimer -= diff;
if (m_blessingTimer < diff)
{
if (Unit *pUnit = SelectCouncil())
{
AddSpellToCast(pUnit, RAND(SPELL_BLESS_SPELLWARD, SPELL_BLESS_PROTECTION));
m_blessingTimer = RAND(urand(15000, 20000), urand(25000, 35000));
}
}
else
m_blessingTimer -= diff;
if (m_consecrationTimer < diff)
{
AddSpellToCast(me, SPELL_CONSECRATION);
m_consecrationTimer = urand(30000, 35000);
}
else
m_consecrationTimer -= diff;
if (m_hammerTimer < diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 40, true, 0, 10.0f))
{
AddSpellToCast(pTarget, SPELL_HAMMER_OF_JUSTICE);
m_hammerTimer = urand(10000, 20000);
}
}
else
m_hammerTimer -= diff;
if (m_sealTimer < diff)
{
AddSpellToCast(me, RAND(SPELL_SEAL_OF_COMMAND, SPELL_SEAL_OF_BLOOD));
m_sealTimer = urand(17000, 20000);
}
else
m_sealTimer -= diff;
if (m_judgementTimer < diff)
{
RegenMana();
ForceSpellCast(me->getVictim(), SPELL_GATHIOS_JUDGEMENT, INTERRUPT_AND_CAST);
m_judgementTimer = 15000;
}
else
m_judgementTimer -= diff;
if (m_auraTimer < diff)
{
AddSpellToCast(RAND(SPELL_DEVOTION_AURA, SPELL_CHROMATIC_AURA), CAST_SELF);
m_auraTimer = 60000;
}
else
m_auraTimer -= diff;
DoMeleeAttackIfReady();
CastNextSpellIfAnyAndReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (CheckTimer < diff)
{
if (!m_creature->IsWithinDistInMap(&wLoc, 20))
{
m_creature->InterruptNonMeleeSpells(false);
EnterEvadeMode();
return;
}
CheckTimer = 2000;
}
else
CheckTimer -= diff;
if (WaterElementalTimer < diff)
{
ForceSpellCast(m_creature, SPELL_WATER_ELEMENTAL);
WaterElementalTimer = 90000; // 90s
}
else
WaterElementalTimer -= diff;
if (IceBlockTimer < diff)
{
if (!m_creature->HasAura(SPELL_HYPOTHERMIA, 0))
{
uint32 negativeAuras = m_creature->GetAurasAmountByType(SPELL_AURA_PERIODIC_DAMAGE) + m_creature->GetAurasAmountByType(SPELL_AURA_PERIODIC_LEECH);
// cast if no hypothermia && has 3 or more dot/leech auras
if (negativeAuras >= 3)
{
m_creature->InterruptNonMeleeSpells(false);
ForceSpellCast(m_creature, SPELL_HYPOTHERMIA, DONT_INTERRUPT, true);
ForceSpellCast(m_creature, SPELL_ICE_BLOCK);
IceBlockTimer = 60000; // 60s
}
}
}
else
IceBlockTimer -= diff;
// update CoC timer
if (CoCTimer > diff)
CoCTimer -= diff;
else
CoCTimer = 0;
// select spell
if (CastTimer < diff)
{
// if victim is in range of 6.5 yards and there are 3 attackers cast explosion or CoC if ready
if (m_creature->getAttackers().size() >= 3 && m_creature->IsWithinDistInMap(m_creature->getVictim(), 6.5f, false))
{
if (!CoCTimer)
{
ForceSpellCast(me->getVictim(), SPELL_CONE_OF_COLD);
CoCTimer = urand(8000, 12000);
CastTimer = 0;
}
else
{
ForceSpellCast(me->getVictim(), SPELL_ARCANE_EXPLOSION);
CastTimer = 2000;
}
}
else
{
AddSpellToCast(m_creature->getVictim(), RAND(SPELL_FROSTBOLT, SPELL_FIREBALL));
CastTimer = 2500;
}
}
else
CastTimer -= diff;
CastNextSpellIfAnyAndReady();
//DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
{
if(check_Timer < diff)
{
if (!m_creature->IsNonMeleeSpellCasted(false))
{
float x, y, z;
me->GetRespawnCoord(x, y, z);
me->GetMotionMaster()->MovePoint(1, x, y, z);
}
check_Timer = 5000;
}
else
check_Timer -= diff;
return;
}
if (Firenova)
{
if (Firenova_Timer < diff)
{
ForceSpellCast(me, SPELL_FIRE_NOVA, INTERRUPT_AND_CAST_INSTANTLY);
Firenova = false;
ShadowVolley_Timer = 2000;
}
else
Firenova_Timer -=diff;
return;
}
if (ShadowVolley_Timer < diff)
{
AddSpellToCast(m_creature, SPELL_SHADOW_BOLT_VOLLEY);
ShadowVolley_Timer = urand(5000, 13000);
}
else
ShadowVolley_Timer -=diff;
if (Corruption_Timer < diff)
{
AddSpellToCast(me,SPELL_CORRUPTION);
Corruption_Timer = urand(30000, 50000);
}
else
Corruption_Timer -=diff;
if (BurningNova_Timer < diff)
{
if (m_creature->IsNonMeleeSpellCasted(false))
m_creature->InterruptNonMeleeSpells(true);
DoScriptText(SAY_NOVA, m_creature);
if (HeroicMode)
ForceSpellCast(me, SPELL_VORTEX, INTERRUPT_AND_CAST_INSTANTLY);
if (SpellEntry *nova = (SpellEntry*)GetSpellStore()->LookupEntry(SPELL_BURNING_NOVA))
{
for (uint32 i = 0; i < 3; ++i)
{
if (nova->Effect[i] == SPELL_EFFECT_APPLY_AURA)
{
Aura *Aur = new BurningNovaAura(nova, i, m_creature, m_creature);
m_creature->AddAura(Aur);
}
}
}
BurningNova_Timer = urand(20000, 28000);
Firenova_Timer= 5000;
Firenova = true;
}
else
BurningNova_Timer -= diff;
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
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;
if (m_checkTimer < diff)
{
if (me->IsWithinDistInMap(&wLoc, 100.0f))
DoZoneInCombat();
else
{
EnterEvadeMode();
return;
}
if (me->GetDistance2d(me->getVictim()) <= 40.0f)
me->GetMotionMaster()->MoveIdle();
else
me->GetMotionMaster()->MoveChase(me->getVictim(), 40);
// On front stairs, do not let boss to go into textures;
//CheckStairsPos();
uint32 damage = 0;
SharedRule(damage);
me->SetSpeed(MOVE_RUN, 2.0);
m_checkTimer = 1000;
}
else
m_checkTimer -= diff;
if (m_immunityTimer < diff)
{
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_INTERRUPT, false);
m_immunityTimer = 60000;
}
else
m_immunityTimer -= diff;
if (m_dampenTimer < diff)
{
ForceSpellCast(me, SPELL_DAMPEN_MAGIC);
m_dampenTimer = 67200; // almost 1,12 minutes (??)
}
else
m_dampenTimer -= diff;
if (m_blizzardTimer < diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 200, true))
{
AddSpellToCast(pTarget, SPELL_BLIZZARD, true);
m_blizzardTimer = urand(12000, 17000);
}
}
else
m_blizzardTimer -= diff;
if (m_flamestrikeTimer < diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 200, true))
{
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_INTERRUPT, true);
AddSpellToCast(pTarget, SPELL_FLAMESTRIKE);
m_flamestrikeTimer = 12000;
m_immunityTimer = 3000;
}
}
else
m_flamestrikeTimer -= diff;
if (m_aexpTimer < diff)
{
std::list<HostilReference*>& m_threatlist = me->getThreatManager().getThreatList();
for (std::list<HostilReference*>::iterator i = m_threatlist.begin(); i!= m_threatlist.end();++i)
{
if (Unit* pUnit = Unit::GetUnit((*me), (*i)->getUnitGuid()))
{
if (pUnit->IsWithinDistInMap(me, 5) && pUnit->GetTypeId() == TYPEID_PLAYER && pUnit->isAlive() && !pUnit->IsImmunedToDamage(SPELL_SCHOOL_MASK_ARCANE))
{
ForceSpellCast(SPELL_ARCANE_EXPLOSION, CAST_SELF);
m_aexpTimer = 3000;
break;
}
else
m_aexpTimer = 1000;
}
}
}
else
m_aexpTimer -= diff;
CastNextSpellIfAnyAndReady(diff);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() )
return;
//Check_Timer
if (Check_Timer < diff)
{
if (!m_creature->IsWithinDistInMap(&wLoc, 135.0f))
EnterEvadeMode();
else
DoZoneInCombat();
Check_Timer = 3000;
}
else
Check_Timer -= diff;
// Pounding
if (Pounding_Timer < diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_POUNDING, RAND(SAY_POUNDING1, SAY_POUNDING2));
if (KnockAway_Timer < 3100)
KnockAway_Timer = 3100;
Pounding_Timer = 12000;
}
else
Pounding_Timer -= diff;
// Arcane Orb
if (ArcaneOrb_Timer < diff)
{
Unit * target = SelectUnit(SELECT_TARGET_RANDOM, 0, 200.0f, true, 0, 18.0f);
if (!target)
target = m_creature->getVictim();
if (target)
if (Creature* t = DoSpawnCreature(TRIGGER, 0.0f, 0.0f, 10.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN, 40000))
t->CastSpell(target, SPELL_ARCANE_ORB, false, 0, 0, m_creature->GetGUID());
ArcaneOrb_Timer = urand(3000, 4000);
}
else
ArcaneOrb_Timer -= diff;
// Single Target knock back, reduces aggro
if (KnockAway_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_KNOCK_AWAY);
KnockAway_Timer = 30000;
}
else
KnockAway_Timer -= diff;
//Berserk
if (Berserk_Timer < diff)
{
ForceSpellCast(m_creature, SPELL_BERSERK);
Berserk_Timer = 600000;
}
else
Berserk_Timer -= diff;
m_creature->RemoveAurasWithDispelType(DISPEL_POISON);
CastNextSpellIfAnyAndReady();
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 (!UpdateVictim())
return;
if (m_checkTimer < diff)
{
if (me->IsWithinDistInMap(&wLoc, 100.0f))
DoZoneInCombat();
else
{
EnterEvadeMode();
return;
}
uint32 damage = 0;
SharedRule(damage);
me->SetSpeed(MOVE_RUN, 2.0);
// move always after stun recovery
if (!me->hasUnitState(UNIT_STAT_STUNNED) && !me->HasAura(SPELL_VANISH, 1))
DoStartMovement(me->getVictim());
m_checkTimer = 1000;
}
else
m_checkTimer -= diff;
if (m_vanishTimer < diff)
{
if (me->HasAuraType(SPELL_AURA_MOD_STUN)) // remove stun
me->RemoveSpellsCausingAura(SPELL_AURA_MOD_STUN);
if (me->HasAuraType(SPELL_AURA_MOD_STALKED)) // remove Hunter's Marks and similar trackers
me->RemoveSpellsCausingAura(SPELL_AURA_MOD_STALKED);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_STUN, true);
ForceSpellCast(me, SPELL_VANISH, INTERRUPT_AND_CAST_INSTANTLY);
ForceSpellCast(me, SPELL_DEADLY_POISON, INTERRUPT_AND_CAST_INSTANTLY);
Position dest;
if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM, 0, 35.0f, true))
target->GetValidPointInAngle(dest, 5.0f, frand(0.0f, 2*M_PI), true);
else
me->GetValidPointInAngle(dest, 30.0f, frand(0.0f, 2*M_PI), true);
DoTeleportTo(dest.x, dest.y, dest.z);
// drop movement :P
me->GetMotionMaster()->MoveIdle();
m_vanishTimer = 60000;
}
else
m_vanishTimer -= diff;
if (me->HasAura(SPELL_VANISH, 1))
return;
DoMeleeAttackIfReady();
CastNextSpellIfAnyAndReady();
}
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)
{
//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 JustRespawned()
{
ForceSpellCast(me, SPELL_DEATH_CLOUD, INTERRUPT_AND_CAST_INSTANTLY);
Phase = 1;
SummonTimer = Timer = CalculateSummonTimer();
}
void UpdateAI(const uint32 diff)
{
if (m_creature->getVictim() && m_creature->getVictim()->GetTypeId() == TYPEID_PLAYER)
{
switch (m_creature->GetEntry())
{
case C_RKEEP:
{
if (Type) //mage
{
if (Spell_Timer1 < diff) //frostbolt
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?38534:36279);
Spell_Timer1 = urand(8000, HeroicMode ? 10000 : 16000);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff) //pyroblast
{
Spell_Timer1 = 8000;
Unit* target = SelectUnit(SELECT_TARGET_NEAREST, 0, 70, true, m_creature->getVictimGUID());
if (!target)
target = m_creature->getVictim();
if (target)
AddSpellToCast(target, HeroicMode?38535:36277);
Spell_Timer2 = HeroicMode ? urand(14000, 24000) : urand(12000, 17000);
}
else
Spell_Timer2 -= diff;
if (Spell_Timer3 < diff) //blast wave
{
ForceSpellCast(m_creature, HeroicMode?38536:36278, DONT_INTERRUPT, true);
Spell_Timer3 = HeroicMode ? urand(15000, 25000) : 13000;
}
else
Spell_Timer3 -= diff;
if (HeroicMode && Spell_Timer4 < diff) //polymorph
{
Unit* target = SelectUnit(SELECT_TARGET_NEAREST, 0, 70, true, m_creature->getVictimGUID());
if (target)
AddSpellToCast(target, 13323);
Spell_Timer4 = 30000;
}
else
Spell_Timer4 -= diff;
}
else //warlock
{
if (Spell_Timer1 < diff) //shadow bolt volley
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?38533:36275);
Spell_Timer1 = HeroicMode ? Spell_Timer2+1500 : urand(10000, 25000);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff) //curse of vulnerability
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0,70,true);
if (target)
AddSpellToCast(target, 36276, true);
Spell_Timer2 = HeroicMode ? urand(9000, 14000) : Spell_Timer1+2000;
}
else
Spell_Timer2 -= diff;
if (Spell_Timer3 < diff) //fear
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 70, true);
if (target)
AddSpellToCast(target, 12542);
Spell_Timer3 = urand(15000, 25000);
}
else
Spell_Timer3 -= diff;
if (!frenzy && m_creature->GetHealth()*100 / m_creature->GetMaxHealth() < 30)
{
AddSpellToCast(m_creature, 8269, true);
frenzy = true;
}
}
break;
}
case C_RLORD:
{
if(Type) //protection type
{
if (Spell_Timer1 < diff) //sunder armor
{
AddSpellToCast(m_creature->getVictim(), 16145, true);
Spell_Timer1 = urand(6000, 9000);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff) //thunderclap
{
AddSpellToCast(m_creature, HeroicMode?38537:36214, true);
Spell_Timer2 = HeroicMode ? urand(12000, 17000) : urand(10000, 25000);
}
else
Spell_Timer2 -= diff;
}
else //fury-arms
{
if (Spell_Timer1 < diff) //knockback
{
AddSpellToCast(m_creature->getVictim(), 11428, true);
Spell_Timer1 = HeroicMode ? urand(13300, 19100) : urand(18100, 38500);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff) //mortal strike
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?35054:15708, true);
Spell_Timer2 = HeroicMode ? urand(10300, 14500) : urand(10800, 15800);
}
else
Spell_Timer2 -= diff;
if (Spell_Timer3 < diff) //harmstring
{
AddSpellToCast(m_creature->getVictim(), 9080, true);
Spell_Timer3 = HeroicMode ? urand(11600, 18100) : urand(15500, 26500);
}
else
Spell_Timer3 -= diff;
}
if (!frenzy && m_creature->GetHealth()*100 / m_creature->GetMaxHealth() < 30)
{
AddSpellToCast(m_creature, 8269, true);
frenzy = true;
}
break;
}
case C_ASSAS:
{
if (Type) //combat
{
if (Spell_Timer1 < diff) //sinister strike
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?15667:14873, true);
Spell_Timer1 = HeroicMode ? urand(3500, 14500) : urand(4500, 15300);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff) //rupture
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?15583:14874, true);
Spell_Timer2 = HeroicMode ? urand(10100, 20500) : urand(10400, 21600);
}
else
Spell_Timer2 -= diff;
if (Spell_Timer3 && Spell_Timer3 <= diff) //crippling poison
{
AddSpellToCast(m_creature->getVictim(), 9080, true);
Spell_Timer3 = HeroicMode ? urand(12200, 62800) : 0;
}
else
Spell_Timer3 -= diff;
}
else //assasin
{
if (Spell_Timer1 < diff) //kidney shot
{
AddSpellToCast(m_creature->getVictim(), 30832, true);
Spell_Timer1 = urand(20100, 24900);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 && Spell_Timer2 <= diff) //deadly poison
{
AddSpellToCast(m_creature->getVictim(), 38520, true);
Spell_Timer2 = HeroicMode ? urand(12300, 24200) : 0;
}
else
Spell_Timer2 -= diff;
if (Spell_Timer3 < diff) //backstab
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?15657:7159, true);
Spell_Timer3 = urand(4800, 7200);
}
else
Spell_Timer3 -= diff;
}
break;
}
case C_WHELP:
break;
case C_CHRON:
{
if (m_creature->GetPower(POWER_MANA)*100/m_creature->GetMaxPower(POWER_MANA) > 15)
{
if (Type) //frost
{
if (Spell_Timer1 < diff) //frostbolt
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?12675:15497);
Spell_Timer1 = urand(2900, 5400);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff && m_creature->IsWithinCombatRange(m_creature->getVictim(), 10)) //frost nova
{
AddSpellToCast(m_creature, HeroicMode?15531:15063, true);
Spell_Timer2 = HeroicMode ? urand(22200, 25700) : urand(33800, 39800);
}
else
Spell_Timer2 -= diff;
}
else //arcane
{
if (Spell_Timer1 < diff) //arcane bolt
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?15230:15124);
Spell_Timer1 = HeroicMode ? urand(1200, 3400) : urand(2900, 5400);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff && m_creature->IsWithinCombatRange(m_creature->getVictim(), 10)) //arcane explosion
{
AddSpellToCast(m_creature, HeroicMode?33623:33860, true);
Spell_Timer2 = HeroicMode ? urand(8000, 10100) : urand(9500, 10100);
}
else
Spell_Timer2 -= diff;
}
}
break;
}
case C_EXECU:
{
if (Spell_Timer1 < diff) //cleave
{
AddSpellToCast(m_creature->getVictim(), 15496, true);
Spell_Timer1 = HeroicMode ? urand(6000, 11700) : urand(7300, 14000);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff) //strike
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?34920:15580, true);
Spell_Timer2 = HeroicMode ? urand(3900, 9700) : urand(9700, 20300);
}
else
Spell_Timer2 -= diff;
if (Spell_Timer3 && Spell_Timer3 < diff) //harmstring
{
AddSpellToCast(m_creature->getVictim(), 9080, true);
Spell_Timer3 = HeroicMode ? urand(10800, 15800) : 0;
}
else
Spell_Timer3 -= diff;
break;
}
case C_VANQU:
{
if (m_creature->GetPower(POWER_MANA)*100/m_creature->GetMaxPower(POWER_MANA) > 15)
{
if (Spell_Timer1 < diff) //scorch + shadow bolt
{
bool fire = urand(0,1);
if (fire)
AddSpellToCast(m_creature->getVictim(), HeroicMode?36807:15241);
else
AddSpellToCast(m_creature->getVictim(), HeroicMode?15472:12739);
Spell_Timer1 = urand(3500, 4500);
}
else
Spell_Timer1 -= diff;
if (Spell_Timer2 < diff) //fire blast
{
AddSpellToCast(m_creature->getVictim(), HeroicMode?38526:13341, true);
Spell_Timer2 = urand(5900, 6000);
}
else
Spell_Timer2 -= diff;
}
break;
}
default:
break;
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
if (pInstance->GetData(TYPE_MEDIVH) == FAIL)
{
m_creature->Kill(m_creature, false);
m_creature->RemoveCorpse();
}
}
void UpdateAI(const uint32 diff)
{
if(!me->IsNonMeleeSpellCasted(false) && !me->isInCombat())
{
if(OOCTimer < diff)
{
HandleOffCombatEffects();
OOCTimer = 10000;
}
else
OOCTimer -= diff;
}
if(!UpdateVictim())
return;
if(Check_Timer < diff)
{
if(HealthBelowPct(51) && canShield)
{
canShield = false;
ForceSpellCast(SPELL_MANA_SHIELD, CAST_SELF);
}
Check_Timer = 1500;
}
else
Check_Timer -= diff;
if(Shoot_Timer < diff)
{
if(me->GetMotionMaster()->GetCurrentMovementGeneratorType() == IDLE_MOTION_TYPE)
{
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 30.0f, true, 5.0f))
AddSpellToCast(target, SPELL_SHOOT);
}
Shoot_Timer = 3000;
}
else
Shoot_Timer -= diff;
if(FrostArrow_Timer < diff)
{
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 50.0f, true))
AddSpellToCast(target, SPELL_FROST_ARROW);
FrostArrow_Timer = urand(9000, 12000);
}
else
FrostArrow_Timer -= diff;
if(ForkedLightning_Timer < diff)
{
AddSpellToCast(SPELL_FORKED_LIGHTNING, CAST_NULL);
ForkedLightning_Timer = urand(12000, 18000);
}
else
ForkedLightning_Timer -= diff;
CheckShooterNoMovementInRange(diff);
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
