void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CONJURE_FIRE:
if (summons.size() >= RAID_MODE<uint64>(2, 4))
break;
DoCast(me, SPELL_CONJURE_FIRE, true);
events.ScheduleEvent(EVENT_CONJURE_FIRE, 15s, 20s);
break;
case EVENT_MELT_ICE:
if (Creature* FlashFreeze = me->FindNearestCreature(NPC_FLASH_FREEZE, 50.0f, true))
DoCast(FlashFreeze, SPELL_MELT_ICE, true);
events.ScheduleEvent(EVENT_MELT_ICE, 10s, 15s);
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoSpellAttackIfReady(SPELL_FIREBALL);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpellAttackIfReady(SPELL_CHAIN_LIGHTNING);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_STORM_CLOUD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_STORM_CLOUD, true);
events.ScheduleEvent(EVENT_STORM_CLOUD, urand(15000, 20000));
break;
default:
break;
}
}
DoSpellAttackIfReady(SPELL_LAVA_BURST);
}
void TurretAI::UpdateAI(uint32 /*diff*/)
{
if (!UpdateVictim())
return;
DoSpellAttackIfReady(me->m_spells[0]);
}
void UpdateAI(uint32 /*diff*/) override
{
if (!UpdateVictim())
return;
DoSpellAttackIfReady(SPELL_ERUPTION);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CONJURE_FIRE:
if (summons.size() >= RAID_MODE<uint64>(2, 4))
break;
// The fire is gets positioned at a random coordinate.
DoCast(me, SPELL_CONJURE_FIRE, true);
events.ScheduleEvent(EVENT_CONJURE_FIRE, urand(15*IN_MILLISECONDS, 20*IN_MILLISECONDS));
return;
case EVENT_MELT_ICE:
if (Creature* FlashFreeze = me->FindNearestCreature(NPC_FLASH_FREEZE, 50.0f, true))
DoCast(FlashFreeze, SPELL_MELT_ICE, true);
events.ScheduleEvent(EVENT_MELT_ICE, urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS));
return;
default:
return;
}
}
DoSpellAttackIfReady(SPELL_FIREBALL);
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
DoSpellAttackIfReady(DUNGEON_MODE(CLAW_PUNCTURE,CLAW_PUNCTURE_H));
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_STARLIGHT:
// This was somehow senseless - the spell persists ~1 min, thus refreshing it every half a minute is ... curious.
DoCast(me, SPELL_STARLIGHT, true);
events.ScheduleEvent(EVENT_STARLIGHT, urand(25*IN_MILLISECONDS, 35*IN_MILLISECONDS));
break;
default:
break;
}
}
if (!me->HasAura(AURA_MOONKIN))
me->AddAura(AURA_MOONKIN, me);
DoSpellAttackIfReady(SPELL_WRATH);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_STARLIGHT:
DoCast(me, SPELL_STARLIGHT, true);
events.ScheduleEvent(EVENT_STARLIGHT, urand(25000, 35000));
break;
default:
break;
}
}
DoSpellAttackIfReady(SPELL_WRATH);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CONJURE_FIRE:
DoCast(me, SPELL_CONJURE_FIRE, true);
events.ScheduleEvent(EVENT_CONJURE_FIRE, urand(35000, 40000));
break;
case EVENT_MELT_ICE:
if (Creature* FlashFreeze = me->FindNearestCreature(NPC_FLASH_FREEZE, 50.0f, true))
DoCast(FlashFreeze, SPELL_MELT_ICE, true);
events.ScheduleEvent(EVENT_MELT_ICE, urand(10000, 15000));
break;
}
}
DoSpellAttackIfReady(SPELL_FIREBALL);
}
void UpdateAI(const uint32 diff)
{
if (nextWP && movementStarted && !movementCompleted && !nextMovementStarted)
{
nextMovementStarted = true;
me->GetMotionMaster()->MovePoint(nextWP, WaypointPositions[nextWP]);
}
if (!UpdateVictim() || !CheckInRoom() || !movementCompleted)
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_MARK:
Talk(SAY_SPECIAL);
DoCastAOE(SPELL_MARK[id]);
events.ScheduleEvent(EVENT_MARK, 15000);
break;
case EVENT_CAST:
Talk(SAY_TAUNT);
if (caster)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 45.0f))
DoCast(target, SPELL_PRIMARY(id));
}
else
DoCast(me->getVictim(), SPELL_PRIMARY(id));
events.ScheduleEvent(EVENT_CAST, 15000);
break;
case EVENT_BERSERK:
Talk(SAY_SPECIAL);
DoCast(me, EVENT_BERSERK);
break;
}
}
if (punishTimer <= diff)
{
if (doDelayPunish)
{
DoCastAOE(SPELL_PUNISH[id], true);
doDelayPunish = false;
}
punishTimer = 2000;
} else punishTimer -= diff;
if (!caster)
DoMeleeAttackIfReady();
else if ((!DoSpellAttackIfReady(SPELL_SECONDARY(id)) || !me->IsWithinLOSInMap(me->getVictim())) && movementCompleted && !doDelayPunish)
doDelayPunish = true;
}
void ArchorAI::UpdateAI(const uint32 /*diff*/) {
if (!UpdateVictim())
return;
if (!me->IsWithinCombatRange(me->getVictim(), m_minRange))
DoSpellAttackIfReady(me->m_spells[0]);
else
DoMeleeAttackIfReady();
}
void TurretAI::UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpellAttackIfReady(me->m_spells[0]);
//if (!DoSpellAttackIfReady(me->m_spells[0]))
//if (HostileReference *ref = me->getThreatManager().getCurrentVictim())
//ref->removeReference();
}
void UpdateAI(uint32 diff) override
{
// Only update events if Millhouse is aggressive
if (me->GetReactState() != REACT_AGGRESSIVE)
return;
events.Update(diff);
// Impending Doom is exception because it needs to be interrupted.
if (me->HasUnitState(UNIT_STATE_CASTING) && !me->GetCurrentSpell(SPELL_IMPENDING_DOOM))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FROSTBOLT_VOLLEY:
DoCast(SPELL_FROSTBOLT_VOLLEY);
events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 7000);
break;
case EVENT_SHADOWFURY:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true))
DoCast(target, SPELL_SHADOWFURY);
events.ScheduleEvent(EVENT_SHADOWFURY, 7000);
break;
case EVENT_FEAR:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true))
DoCast(target, SPELL_FEAR);
events.ScheduleEvent(EVENT_FEAR, 18000);
break;
case EVENT_READY_FOR_COMBAT:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
me->SetReactState(REACT_AGGRESSIVE);
ScheduleEvents();
break;
case EVENT_CAST_IMPENDING_DOOM:
DoCast(SPELL_IMPENDING_DOOM);
DoCast(SPELL_IMPENDING_DOOM_CHANNEL);
events.ScheduleEvent(EVENT_INTERRUPT_IMPENDING_DOOM, urand(15000,20000));
break;
case EVENT_INTERRUPT_IMPENDING_DOOM:
me->InterruptNonMeleeSpells(true);
me->RemoveAllAuras();
me->HandleEmoteCommand(EMOTE_ONESHOT_KNOCKDOWN);
events.ScheduleEvent(EVENT_CAST_IMPENDING_DOOM, 3000);
break;
default:
break;
}
}
DoSpellAttackIfReady(SPELL_SHADOW_BOLT);
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
// Shadow Burst ad area e reset threat
if (BurstTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
me->DeleteThreatList();
DoCast(me->GetVictim(), SHADOW_BURST);
BurstTimer = urand(25000,35000);
} else BurstTimer -= uiDiff;
// Storm of Grief ogni 20 sec colpisce ad area
if (GriefTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM,0))
DoCast(pTarget, STORM_OF_GRIEF);
GriefTimer = 20000;
} else GriefTimer -= uiDiff;
// Ogni 10 sec casta Piercing Shadow sul target a maggior aggro dopo il tank
if (PiercingTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_TOPAGGRO,0))
DoCast(pTarget, PIERCING_SHADOW);
PiercingTimer = 10000;
} else PiercingTimer -= uiDiff;
// Ogni 15 sec casta Shadow Flame che fa danno a cono
if (FlameTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
DoCastAOE(SHADOW_FLAME);
FlameTimer = 15000;
} else FlameTimer -= uiDiff;
// Ogni 45 sec casta Harvest Soul su tutto il raid
if (HarvestTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
me->MonsterYell(SAY_PEROTHARN_SOUL, LANG_UNIVERSAL, 0);
DoCastAOE(HARVEST_SOUL);
HarvestTimer = 45000;
} else HarvestTimer -= uiDiff;
DoSpellAttackIfReady(SHADOW_BOLT);
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (StarlightTimer <= uiDiff)
{
DoCast(me, SPELL_STARLIGHT);
StarlightTimer = urand(25000, 35000);
}
else StarlightTimer -= uiDiff;
DoSpellAttackIfReady(SPELL_WRATH);
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (StormTimer <= uiDiff)
{
DoCast(me, RAID_MODE(SPELL_STORM_CLOUD_10, SPELL_STORM_CLOUD_25));
StormTimer = urand(25000, 30000);
}
else StormTimer -= uiDiff;
DoSpellAttackIfReady(SPELL_LAVA_BURST);
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (FireTimer <= uiDiff)
{
DoCast(me, SPELL_CONJURE_FIRE);
FireTimer = urand(25000, 35000);
}
else FireTimer -= uiDiff;
DoSpellAttackIfReady(SPELL_FIREBALL);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (HealthBelowPct(30))
DoCast(me, SPELL_GREATER_HEAL);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_HEAL:
DoCastAOE(SPELL_GREATER_HEAL);
events.ScheduleEvent(EVENT_HEAL, 7500ms, 10s);
break;
case EVENT_DISPEL_MAGIC:
{
std::list<Unit*> TargetList;
Trinity::AnyFriendlyUnitInObjectRangeCheck checker(me, me, 30.0f);
Trinity::UnitListSearcher<Trinity::AnyFriendlyUnitInObjectRangeCheck> searcher(me, TargetList, checker);
Cell::VisitAllObjects(me, searcher, 30.0f);
for (std::list<Unit*>::iterator itr = TargetList.begin(); itr != TargetList.end(); ++itr)
if ((*itr)->HasAura(SPELL_FREEZE))
DoCast(*itr, SPELL_DISPEL_MAGIC, true);
events.ScheduleEvent(EVENT_DISPEL_MAGIC, 15s, 20s);
break;
}
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoSpellAttackIfReady(SPELL_SMITE);
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (HealthBelowPct(35))
DoCastAOE(SPELL_GREATER_HEAL);
if (HealTimer <= uiDiff)
{
DoCastAOE(SPELL_GREATER_HEAL);
HealTimer = urand(12000, 14000);
}
else HealTimer -= uiDiff;
DoSpellAttackIfReady(SPELL_SMITE);
}
void UpdateAI(const uint32 diff)
{
if (tSeek <= diff)
{
if ((me->isAlive()) && (!me->isInCombat() && (me->GetDistance2d(me->GetHomePosition().GetPositionX(), me->GetHomePosition().GetPositionY()) <= 1.0f)))
if (Creature* enemy = me->FindNearestCreature(NPC_BLOODFANG_WORGEN, 5.0f, true))
me->AI()->AttackStart(enemy); //She should really only grab agro when npc Cleese is not there, so we will keep this range small
tSeek = urand(1000, 2000); //optimize cpu load, seeking only sometime between 1 and 2 seconds
}
else tSeek -= diff;
if (!UpdateVictim())
return;
if (dmgCount < 2)
DoSpellAttackIfReady(SPELL_FROSTBOLT_VISUAL_ONLY); //Dummy spell, visual only to prevent getting agro (Blizz-like)
}
void UpdateAI(const uint32 diff)
{
if(!me->isInCombat())
return;
if(me->getThreatManager().isThreatListEmpty())
{
EnterEvadeMode();
return;
}
events.Update(diff);
if(me->hasUnitState(UNIT_STAT_CASTING))
return;
uint32 eventId = events.GetEvent();
if(!me->getVictim())
eventId = EVENT_PURSUE;
switch(eventId)
{
case 0:
return;
case EVENT_PURSUE:
DoCastAOE(SPELL_PURSUED);
events.RepeatEvent(35000);
return;
case EVENT_MISSILE:
//TODO: without unittarget no visual effect
//DoCastAOE(SPELL_MISSILE_BARRAGE);
DoCast(me->getVictim(), SPELL_MISSILE_BARRAGE);
events.RepeatEvent(1500);
return;
case EVENT_VENT:
DoCastAOE(SPELL_FLAME_VENTS);
events.RepeatEvent(20000);
return;
default:
events.PopEvent();
break;
}
DoSpellAttackIfReady(SPELL_BATTERING_RAM);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_DEFLECTING_WINDS:
DoCast(me, SPELL_DEFLECTING_WINDS, true);
break;
case EVENT_STORM_BOLT_RANDOM:
DoCastRandom(SPELL_STORM_BOLT_RANDOM, 100.0f, true);
events.ScheduleEvent(EVENT_STORM_BOLT_RANDOM, urand(20000, 25000), 0, PHASE_ONE);
break;
case EVENT_SUMMON_NPC_SERVANT_OF_SIAMAT:
DoCast(SPELL_STATIC_SHOCK);
events.ScheduleEvent(EVENT_SUMMON_NPC_SERVANT_OF_SIAMAT, 20000, 0, PHASE_ONE);
break;
case EVENT_SUMMON_NPC_MINION_OF_SIAMAT:
Talk(SAY_EVENT);
DoCast(SPELL_CALL_OF_SKY);
events.ScheduleEvent(EVENT_SUMMON_NPC_MINION_OF_SIAMAT, 20000, 0, PHASE_ALL);
break;
case EVENT_ABSORB_STORMS:
DoCastAOE(SPELL_ABSORB_STORMS);
events.ScheduleEvent(EVENT_ABSORB_STORMS, 25 * IN_MILLISECONDS, 0, PHASE_TWO);
break;
case EVENT_CLOUD_BURST_SUMMON:
DoCastRandom(SPELL_CLOUD_BURST_SUMMON, 100.0f, true);
events.ScheduleEvent(EVENT_CLOUD_BURST_SUMMON, urand(15000, 20000), 0, PHASE_ALL);
break;
default:
break;
}
}
if (events.IsInPhase(PHASE_ONE))
DoSpellAttackIfReady(SPELL_STORM_BOLT);
else
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
// Army of the dead
if (ArmyTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_TOPAGGRO,0))
DoCast(pTarget, SPELL_ARMY_OF_THE_DEAD);
ArmyTimer = 45000;
} else ArmyTimer -= uiDiff;
// Mind Control
if (ControlTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM,0))
DoCast(pTarget, SPELL_MIND_CONTROL);
me->MonsterYell(SAY_LYS_LADIMORE_MIND_CONTROL, LANG_UNIVERSAL, 0);
ControlTimer = 30000;
} else ControlTimer -= uiDiff;
// Piercing shadow
if (PiercingTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(false);
if (Unit *pTarget = SelectTarget(SELECT_TARGET_TOPAGGRO,0))
DoCast(pTarget, SPELL_PIERCING_SHADOW);
PiercingTimer = 10000;
} else PiercingTimer -= uiDiff;
// AOE Shadow Bolt Volley
if (VolleyTimer <= uiDiff)
{
DoCastAOE(SPELL_SHADOW_BOLT_VOLLEY);
VolleyTimer = 15000;
} else VolleyTimer -= uiDiff;
DoSpellAttackIfReady(SPELL_SHADOW_BOLT);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
ExecuteEvent(eventId);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoSpellAttackIfReady(SPELL_EMPOWERED_SMITE);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (_phase == 0 && !CheckGuardAlive())
{
_phase = 1;
me->SetCanDualWield(true);
DoCast(me, SPELL_WINDFURY, true);
}
scheduler.Update(diff, [this]
{
if (_phase == 1)
DoSpellAttackIfReady(SPELL_STORMSTRIKE);
else
DoMeleeAttackIfReady();
});
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (HealthBelowPct(30))
DoCast(me, SPELL_GREATER_HEAL);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_HEAL:
DoCastAOE(SPELL_GREATER_HEAL);
events.ScheduleEvent(EVENT_HEAL, urand(7.5*IN_MILLISECONDS, 10*IN_MILLISECONDS));
return;
case EVENT_DISPEL_MAGIC:
{
std::list<Unit*> allies;
Trinity::AnyFriendlyUnitInObjectRangeCheck checker(me, me, 30.0f);
Trinity::UnitListSearcher<Trinity::AnyFriendlyUnitInObjectRangeCheck> searcher(me, allies, checker);
me->VisitNearbyObject(30.0f, searcher);
// TODO: Check if the below is intended: it will dispell freeze from every player
for (std::list<Unit*>::iterator itr = allies.begin(); itr != allies.end(); ++itr)
if ((*itr)->HasAura(SPELL_FREEZE))
DoCast(*itr, SPELL_DISPEL_MAGIC, true);
events.ScheduleEvent(EVENT_DISPEL_MAGIC, urand(15*IN_MILLISECONDS, 20*IN_MILLISECONDS));
return;
}
default:
break;
}
}
DoSpellAttackIfReady(SPELL_SMITE);
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->hasUnitState(UNIT_STAT_CASTING))
return;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_MARK:
if (!(rand()%5))
DoScriptText(SAY_SPECIAL[id], me);
DoCastAOE(SPELL_MARK[id]);
events.ScheduleEvent(EVENT_MARK, 15000);
return;
case EVENT_CAST:
if (!(rand()%5))
DoScriptText(SAY_TAUNT[rand()%3][id], me);
DoCast(SPELL_PRIMARY(id));
events.ScheduleEvent(EVENT_CAST, 15000);
return;
case EVENT_BERSERK:
DoScriptText(SAY_SPECIAL[id], me);
DoCast(me, EVENT_BERSERK);
return;
}
}
if (!caster)
DoMeleeAttackIfReady();
else if (!DoSpellAttackIfReady(SPELL_SECONDARY(id)))
DoCastAOE(SPELL_PUNISH[id]);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_STUNNED) || me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_STUNNED))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_STORM_CLOUD:
{
std::list<Unit*> allies;
Trinity::AnyFriendlyUnitInObjectRangeCheck checker(me, me, 30.0f);
Trinity::UnitListSearcher<Trinity::AnyFriendlyUnitInObjectRangeCheck> searcher(me, allies, checker);
me->VisitNearbyWorldObject(30.0f, searcher);
if (!allies.empty())
{
std::list<Unit*>::iterator iter = allies.begin();
DoCast((*iter), SPELL_STORM_CLOUD, true);
events.ScheduleEvent(EVENT_STORM_CLOUD, urand(15*IN_MILLISECONDS, 20*IN_MILLISECONDS));
}
else
events.ScheduleEvent(EVENT_STORM_CLOUD, urand(2*IN_MILLISECONDS, 3*IN_MILLISECONDS)); // No target found, check again in a short period of time
}
break;
default:
break;
}
}
DoSpellAttackIfReady(SPELL_LAVA_BURST);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_LAVA_SHOWER:
DoCast(me, SPELL_LAVA_SHOWER);
events.ScheduleEvent(EVENT_LAVA_SHOWER, urand(45000, 55000));
break;
}
}
DoSpellAttackIfReady(SPELL_LAVA_SPIT);
}
