void UpdateAI(const uint32 diff)
{
//Inhibitmagic_Timer
if (Inhibitmagic_Timer <= diff)
{
float dist;
Map* pMap = me->GetMap();
Map::PlayerList const &PlayerList = pMap->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player* i_pl = i->getSource())
if (i_pl->isAlive() && (dist = i_pl->IsWithinDist(me, 45)))
{
i_pl->RemoveAurasDueToSpell(SPELL_INHIBITMAGIC);
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 35)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 25)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 15)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
}
Inhibitmagic_Timer = 3000+(rand()%1000);
} else Inhibitmagic_Timer -= diff;
//Return since we have no target
if (!UpdateVictim())
return;
//Attractmagic_Timer
if (Attractmagic_Timer <= diff)
{
DoCast(me, SPELL_ATTRACTMAGIC);
Attractmagic_Timer = 30000;
Carnivorousbite_Timer = 1500;
} else Attractmagic_Timer -= diff;
//Carnivorousbite_Timer
if (Carnivorousbite_Timer <= diff)
{
DoCast(me, SPELL_CARNIVOROUSBITE);
Carnivorousbite_Timer = 10000;
} else Carnivorousbite_Timer -= diff;
//FocusFire_Timer
if (FocusFire_Timer <= diff)
{
// Summon Focus Fire & Emote
Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM,1);
if (pTarget && pTarget->GetTypeId() == TYPEID_PLAYER && pTarget->isAlive())
{
FocusedTargetGUID = pTarget->GetGUID();
me->SummonCreature(ENTRY_FOCUS_FIRE,pTarget->GetPositionX(),pTarget->GetPositionY(),pTarget->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,5500);
// TODO: Find better way to handle emote
// Emote
std::string *emote = new std::string(EMOTE_FOCUSES_ON);
emote->append(pTarget->GetName());
emote->append("!");
const char* text = emote->c_str();
me->MonsterTextEmote(text, 0, true);
delete emote;
}
FocusFire_Timer = 15000+(rand()%5000);
} else FocusFire_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
//Only if not incombat check if the event is started
if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
{
if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
AttackStart(target);
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (!instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//WaterBoltVolley_Timer
if (WaterBoltVolley_Timer <= diff)
{
DoCastVictim(SPELL_WATER_BOLT_VOLLEY);
WaterBoltVolley_Timer = 30000;
} else WaterBoltVolley_Timer -= diff;
//TidalSurge_Timer
if (TidalSurge_Timer <= diff)
{
DoCastVictim(SPELL_TIDAL_SURGE);
// Hacky way to do it - won't trigger elseways
if (me->GetVictim())
me->EnsureVictim()->CastSpell(me->GetVictim(), SPELL_TIDAL_SURGE_FREEZE, true);
TidalSurge_Timer = 15000 + rand32() % 5000;
} else TidalSurge_Timer -= diff;
//Cyclone_Timer
if (Cyclone_Timer <= diff)
{
//DoCast(me, SPELL_SUMMON_CYCLONE); // Doesn't work
Cyclone_Timer = 30000 + rand32() % 10000;
if (Creature* Cyclone = me->SummonCreature(CREATURE_CYCLONE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), float(rand32() % 5), TEMPSUMMON_TIMED_DESPAWN, 15000))
{
Cyclone->SetObjectScale(3.0f);
Cyclone->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Cyclone->setFaction(me->getFaction());
Cyclone->CastSpell(Cyclone, SPELL_CYCLONE_CYCLONE, true);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
Cyclone->AI()->AttackStart(target);
}
}
else
Cyclone_Timer -= diff;
//Heal_Timer
if (Heal_Timer <= diff)
{
// It can be cast on any of the mobs
Unit* unit = NULL;
while (unit == NULL || !unit->IsAlive())
unit = selectAdvisorUnit();
if (unit && unit->IsAlive())
DoCast(unit, SPELL_HEAL);
Heal_Timer = 60000;
}
else
Heal_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
if (Assassins_Timer)
{
if (Assassins_Timer <= diff)
{
SpawnAssassin();
Assassins_Timer = 0;
}
else
Assassins_Timer -= diff;
}
if (InBlade)
{
if (Wait_Timer)
{
if (Wait_Timer <= diff)
{
if (target_num <= 0)
{
// stop bladedance
InBlade = false;
me->SetSpeed(MOVE_RUN, 2);
me->GetMotionMaster()->MoveChase(me->getVictim());
Blade_Dance_Timer = 30000;
Wait_Timer = 0;
if (IsHeroic())
Charge_timer = 5000;
}
else
{
//move in bladedance
float x, y, randx, randy;
randx = 0.0f + rand()%40;
randy = 0.0f + rand()%40;
x = 210+ randx ;
y = -60- randy ;
me->GetMotionMaster()->MovePoint(1, x, y, me->GetPositionZ());
Wait_Timer = 0;
}
}
else
Wait_Timer -= diff;
}
}
else
{
if (Blade_Dance_Timer)
{
if (Blade_Dance_Timer <= diff)
{
target_num = TARGET_NUM;
Wait_Timer = 1;
InBlade = true;
Blade_Dance_Timer = 0;
me->SetSpeed(MOVE_RUN, 4);
return;
}
else
Blade_Dance_Timer -= diff;
}
if (Charge_timer)
{
if (Charge_timer <= diff)
{
DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), H_SPELL_CHARGE);
Charge_timer = 0;
}
else
Charge_timer -= diff;
}
if (Summon_Assistant_Timer <= diff)
{
for (uint8 i = 0; i < summoned; ++i)
{
switch (urand(0, 2))
{
case 0:
me->SummonCreature(MOB_HEARTHEN_GUARD, AddsEntrance[0], AddsEntrance[1], AddsEntrance[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
break;
case 1:
me->SummonCreature(MOB_SHARPSHOOTER_GUARD, AddsEntrance[0], AddsEntrance[1], AddsEntrance[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
break;
case 2:
me->SummonCreature(MOB_REAVER_GUARD, AddsEntrance[0], AddsEntrance[1], AddsEntrance[2], 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
break;
}
}
if (urand(0, 9) < 2)
++summoned;
Summon_Assistant_Timer = urand(25000, 35000);
}
else
Summon_Assistant_Timer -= diff;
DoMeleeAttackIfReady();
}
if (resetcheck_timer <= diff)
{
uint32 tempx, tempy;
tempx = uint32(me->GetPositionX());
tempy = uint32(me->GetPositionY());
if (tempx > 255 || tempx < 205)
{
EnterEvadeMode();
return;
}
resetcheck_timer = 5000;
}
else
resetcheck_timer -= diff;
}
void UpdateAI(const uint32 diff)
{
if (IsEvent)
{
//Must update npc_escortAI
npc_escortAI::UpdateAI(diff);
if (!pGo)
{
pGo = true;
if (pInstance)
{
AddWaypoint(0, 4896.08, -1576.35, 1333.65);
AddWaypoint(1, 4898.68, -1615.02, 1329.48);
AddWaypoint(2, 4907.12, -1667.08, 1321.00);
AddWaypoint(3, 4963.18, -1699.35, 1340.51);
AddWaypoint(4, 4989.16, -1716.67, 1335.74);
AddWaypoint(5, 5026.27, -1736.89, 1323.02);
AddWaypoint(6, 5037.77, -1770.56, 1324.36);
AddWaypoint(7, 5067.23, -1789.95, 1321.17);
Start(false, true);
SetDespawnAtEnd(false);
}
}
}
//Return since we have no target
if (!UpdateVictim())
return;
if (SwarmTimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM,0,100,true))
DoCast(target,SPELL_CARRION_SWARM);
SwarmTimer = 45000+rand()%15000;
switch(rand()%2)
{
case 0:
DoPlaySoundToSet(m_creature, SOUND_SWARM1);
m_creature->MonsterYell(SAY_SWARM1, LANG_UNIVERSAL, 0);
break;
case 1:
DoPlaySoundToSet(m_creature, SOUND_SWARM2);
m_creature->MonsterYell(SAY_SWARM2, LANG_UNIVERSAL, 0);
break;
}
}else SwarmTimer -= diff;
if (SleepTimer < diff)
{
for(uint8 i=0;i<3; ++i)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM,0,100,true))
target->CastSpell(target,SPELL_SLEEP,true);
}
SleepTimer = 60000;
switch(rand()%2)
{
case 0:
DoPlaySoundToSet(m_creature, SOUND_SLEEP1);
m_creature->MonsterYell(SAY_SLEEP1, LANG_UNIVERSAL, 0);
break;
case 1:
DoPlaySoundToSet(m_creature, SOUND_SLEEP2);
m_creature->MonsterYell(SAY_SLEEP2, LANG_UNIVERSAL, 0);
break;
}
}else SleepTimer -= diff;
if (AuraTimer < diff)
{
DoCast(m_creature, SPELL_VAMPIRIC_AURA,true);
AuraTimer = 10000+rand()%10000;
}else AuraTimer -= diff;
if (InfernoTimer < diff)
{
DoCast(SelectTarget(SELECT_TARGET_RANDOM,0,100,true), SPELL_INFERNO);
InfernoTimer = 45000;
switch(rand()%2)
{
case 0:
DoPlaySoundToSet(m_creature, SOUND_INFERNO1);
m_creature->MonsterYell(SAY_INFERNO1, LANG_UNIVERSAL, 0);
break;
case 1:
DoPlaySoundToSet(m_creature, SOUND_INFERNO2);
m_creature->MonsterYell(SAY_INFERNO2, LANG_UNIVERSAL, 0);
break;
}
}else InfernoTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
//Only if not incombat check if the event is started
if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
{
if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
{
AttackStart(target);
GetAdvisors();
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (!instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//CataclysmicBolt_Timer
if (CataclysmicBolt_Timer <= diff)
{
//select a random unit other than the main tank
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
//if there aren't other units, cast on the tank
if (!target)
target = me->GetVictim();
if (target)
DoCast(target, SPELL_CATACLYSMIC_BOLT);
CataclysmicBolt_Timer = 10000;
} else CataclysmicBolt_Timer -= diff;
//SearNova_Timer
if (SearNova_Timer <= diff)
{
DoCastVictim(SPELL_SEAR_NOVA);
SearNova_Timer = 20000 + rand32() % 40000;
} else SearNova_Timer -= diff;
//Enrage_Timer
if (Enrage_Timer <= diff)
{
DoCast(me, SPELL_ENRAGE);
Enrage_Timer = 90000;
} else Enrage_Timer -= diff;
//Blessing of Tides Trigger
if (!HealthAbovePct(75) && !BlessingOfTides)
{
BlessingOfTides = true;
bool continueTriggering = false;
for (uint8 i = 0; i < MAX_ADVISORS; ++i)
{
if (!Advisors[i].IsEmpty())
{
Creature* advisor = ObjectAccessor::GetCreature(*me, Advisors[i]);
if (advisor && advisor->IsAlive())
{
continueTriggering = true;
break;
}
}
}
if (continueTriggering)
{
DoCast(me, SPELL_BLESSING_OF_THE_TIDES);
me->Yell(SAY_GAIN_BLESSING_OF_TIDES, LANG_UNIVERSAL);
DoPlaySoundToSet(me, SOUND_GAIN_BLESSING_OF_TIDES);
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!CanStartEvent) // boss is invisible, don't attack
{
if (CheckCanStart())
{
if (Submerged)
{
me->SetVisible(true);
Submerged = false;
WaitTimer2 = 500;
}
if (!Submerged && WaitTimer2 <= diff) // wait 500ms before emerge anim
{
me->RemoveAllAuras();
me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
DoCast(me, SPELL_EMERGE, false);
WaitTimer2 = 60000; // never reached
WaitTimer = 3000;
}
else
WaitTimer2 -= diff;
if (WaitTimer <= diff) // wait 3secs for emerge anim, then attack
{
WaitTimer = 3000;
CanStartEvent = true; // fresh fished from pool
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
else
WaitTimer -= diff;
}
return;
}
if (me->getThreatManager().getThreatList().empty()) // check if should evade
{
if (me->isInCombat())
EnterEvadeMode();
return;
}
if (!Submerged)
{
if (PhaseTimer <= diff)
{
me->InterruptNonMeleeSpells(false);
DoCast(me, SPELL_SUBMERGE);
PhaseTimer = 60000; // 60secs submerged
Submerged = true;
} else PhaseTimer-=diff;
if (SpoutTimer <= diff)
{
me->MonsterTextEmote(EMOTE_SPOUT, 0, true);
me->SetReactState(REACT_PASSIVE);
me->GetMotionMaster()->MoveRotate(20000, urand(0, 1) ? ROTATE_DIRECTION_LEFT : ROTATE_DIRECTION_RIGHT);
SpoutTimer = 45000;
WhirlTimer = 20000; // whirl directly after spout
RotTimer = 20000;
return;
} else SpoutTimer -= diff;
// Whirl directly after a Spout and at random times
if (WhirlTimer <= diff)
{
WhirlTimer = 18000;
DoCast(me, SPELL_WHIRL);
} else WhirlTimer -= diff;
if (CheckTimer <= diff)//check if there are players in melee range
{
InRange = false;
Map* map = me->GetMap();
Map::PlayerList const &PlayerList = map->GetPlayers();
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
if (me->IsWithinMeleeRange(i->getSource()))
InRange = true;
}
}
CheckTimer = 2000;
} else CheckTimer -= diff;
if (RotTimer)
{
Map* map = me->GetMap();
if (map->IsDungeon())
{
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
if (i->getSource() && i->getSource()->isAlive() && me->HasInArc(float(diff/20000*M_PI*2), i->getSource()) && me->IsWithinDist(i->getSource(), SPOUT_DIST) && !i->getSource()->IsInWater())
DoCast(i->getSource(), SPELL_SPOUT, true); // only knock back players in arc, in 100yards, not in water
}
}
if (SpoutAnimTimer <= diff)
{
DoCast(me, SPELL_SPOUT_ANIM, true);
SpoutAnimTimer = 1000;
} else SpoutAnimTimer -= diff;
if (RotTimer <= diff)
{
RotTimer = 0;
} else RotTimer -= diff;
return;
}
if (GeyserTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target && me->getVictim())
target = me->getVictim();
if (target)
DoCast(target, SPELL_GEYSER, true);
GeyserTimer = rand()%5000 + 15000;
} else GeyserTimer -= diff;
if (!InRange) // if on players in melee range cast Waterbolt
{
if (WaterboltTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (!target && me->getVictim())
target = me->getVictim();
if (target)
DoCast(target, SPELL_WATERBOLT, true);
WaterboltTimer = 3000;
} else WaterboltTimer -= diff;
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
else // submerged
{
if (PhaseTimer <= diff)
{
Submerged = false;
me->InterruptNonMeleeSpells(false); // shouldn't be any
me->RemoveAllAuras();
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
me->RemoveFlag(UNIT_NPC_EMOTESTATE, EMOTE_STATE_SUBMERGED);
DoCast(me, SPELL_EMERGE, true);
Spawned = false;
SpoutTimer = 3000; // directly cast Spout after emerging!
PhaseTimer = 120000;
return;
} else PhaseTimer-=diff;
if (me->getThreatManager().getThreatList().empty()) // check if should evade
{
EnterEvadeMode();
return;
}
if (!me->isInCombat())
DoZoneInCombat();
if (!Spawned)
{
me->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
// spawn adds
for (uint8 i = 0; i < 9; ++i)
if (Creature* summoned = me->SummonCreature(i < 6 ? MOB_COILFANG_AMBUSHER : MOB_COILFANG_GUARDIAN, AddPos[i][0], AddPos[i][1], AddPos[i][2], 0, TEMPSUMMON_CORPSE_DESPAWN, 0))
Summons.Summon(summoned);
Spawned = true;
}
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim()) return;
if (instanceScript && instanceScript->GetData(TYPE_NORTHREND_BEASTS) == SNAKES_SPECIAL && !enraged)
{
DoScriptText(SAY_EMERGE, me);
me->RemoveAurasDueToSpell(SPELL_SUBMERGE_0);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
DoCast(SPELL_ENRAGE);
enraged = true;
DoScriptText(SAY_BERSERK, me);
switch (stage)
{
case 0:
break;
case 4:
stage = 5;
submergeTimer = 5*IN_MILLISECONDS;
break;
default:
stage = 7;
}
}
switch (stage)
{
case 0: // Mobile
if (biteTimer <= uiDiff)
{
DoCastVictim(biteSpell);
biteTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else biteTimer -= uiDiff;
if (spewTimer <= uiDiff)
{
DoCastAOE(spewSpell);
spewTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else spewTimer -= uiDiff;
if (slimePoolTimer <= uiDiff)
{
/* Spell summon has only 30s duration */
DoCast(me, SUMMON_SLIME_POOL);
slimePoolTimer = 30*IN_MILLISECONDS;
} else slimePoolTimer -= uiDiff;
if (submergeTimer <= uiDiff && !enraged)
{
stage = 1;
submergeTimer = 5*IN_MILLISECONDS;
} else submergeTimer -= uiDiff;
DoMeleeAttackIfReady();
break;
case 1: // Submerge
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
DoCast(me, SPELL_SUBMERGE_0);
DoScriptText(SAY_SUBMERGE, me);
me->GetMotionMaster()->MovePoint(0, ToCCommonLoc[1].GetPositionX()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionY()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionZ());
stage = 2;
case 2: // Wait til emerge
if (submergeTimer <= uiDiff)
{
stage = 3;
submergeTimer = 50*IN_MILLISECONDS;
} else submergeTimer -= uiDiff;
break;
case 3: // Emerge
me->SetDisplayId(modelStationary);
DoScriptText(SAY_EMERGE, me);
me->RemoveAurasDueToSpell(SPELL_SUBMERGE_0);
DoCast(me, SPELL_EMERGE_0);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
SetCombatMovement(false);
me->GetMotionMaster()->MoveIdle();
stage = 4;
break;
case 4: // Stationary
if (sprayTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, spraySpell);
sprayTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else sprayTimer -= uiDiff;
if (sweepTimer <= uiDiff)
{
DoCastAOE(SPELL_SWEEP_0);
sweepTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else sweepTimer -= uiDiff;
if (submergeTimer <= uiDiff)
{
stage = 5;
submergeTimer = 10*IN_MILLISECONDS;
} else submergeTimer -= uiDiff;
DoSpellAttackIfReady(spitSpell);
break;
case 5: // Submerge
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
DoCast(me, SPELL_SUBMERGE_0);
DoScriptText(SAY_SUBMERGE, me);
me->GetMotionMaster()->MovePoint(0, ToCCommonLoc[1].GetPositionX()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionY()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionZ());
stage = 6;
case 6: // Wait til emerge
if (submergeTimer <= uiDiff)
{
stage = 7;
submergeTimer = 45*IN_MILLISECONDS;
} else submergeTimer -= uiDiff;
break;
case 7: // Emerge
me->SetDisplayId(modelMobile);
DoScriptText(SAY_EMERGE, me);
me->RemoveAurasDueToSpell(SPELL_SUBMERGE_0);
DoCast(me, SPELL_EMERGE_0);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
SetCombatMovement(true);
me->GetMotionMaster()->MoveChase(me->getVictim());
stage = 0;
break;
}
}
void UpdateAI(const uint32 Diff)
{
if (!UpdateVictim())
return;
//START NOT TRANSFORMED
if (!_bTransformed)
{
//MindBlast
if (MindBlast_Timer <= Diff)
{
DoCast(me->getVictim(), SPELL_MINDBLAST);
MindBlast_Timer = urand(15000, 20000);
} else MindBlast_Timer -= Diff;
//CrusadersHammer
if (CrusadersHammer_Timer <= Diff)
{
DoCast(me->getVictim(), SPELL_CRUSADERSHAMMER);
CrusadersHammer_Timer = 12000;
} else CrusadersHammer_Timer -= Diff;
//CrusaderStrike
if (CrusaderStrike_Timer <= Diff)
{
DoCast(me->getVictim(), SPELL_CRUSADERSTRIKE);
CrusaderStrike_Timer = 15000;
} else CrusaderStrike_Timer -= Diff;
//HolyStrike
if (HolyStrike_Timer <= Diff)
{
DoCast(me->getVictim(), SPELL_HOLYSTRIKE);
HolyStrike_Timer = 15000;
} else HolyStrike_Timer -= Diff;
//BalnazzarTransform
if (HealthBelowPct(40))
{
if (me->IsNonMeleeSpellCasted(false))
me->InterruptNonMeleeSpells(false);
//restore hp, mana and stun
DoCast(me, SPELL_BALNAZZARTRANSFORM);
me->UpdateEntry(NPC_BALNAZZAR);
_bTransformed = true;
}
}
else
{
//MindBlast
if (MindBlast_Timer <= Diff)
{
DoCast(me->getVictim(), SPELL_MINDBLAST);
MindBlast_Timer = urand(15000, 20000);
} else MindBlast_Timer -= Diff;
//ShadowShock
if (ShadowShock_Timer <= Diff)
{
DoCast(me->getVictim(), SPELL_SHADOWSHOCK);
ShadowShock_Timer = 11000;
} else ShadowShock_Timer -= Diff;
//PsychicScream
if (PsychicScream_Timer <= Diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_PSYCHICSCREAM);
PsychicScream_Timer = 20000;
} else PsychicScream_Timer -= Diff;
//DeepSleep
if (DeepSleep_Timer <= Diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SLEEP);
DeepSleep_Timer = 15000;
} else DeepSleep_Timer -= Diff;
//MindControl
if (MindControl_Timer <= Diff)
{
DoCast(me->getVictim(), SPELL_MINDCONTROL);
MindControl_Timer = 15000;
} else MindControl_Timer -= Diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!me->isInCombat())
{
if (instance)
{
// Do not let the raid skip straight to Archimonde. Visible and hostile ONLY if Azagalor is finished.
if ((instance->GetData(DATA_AZGALOREVENT) < DONE) && (me->IsVisible() || (me->getFaction() != 35)))
{
me->SetVisible(false);
me->setFaction(35);
}
else if ((instance->GetData(DATA_AZGALOREVENT) >= DONE) && (!me->IsVisible() || (me->getFaction() == 35)))
{
me->setFaction(1720);
me->SetVisible(true);
}
}
if (DrainNordrassilTimer <= diff)
{
if (!IsChanneling)
{
Creature* temp = me->SummonCreature(CREATURE_CHANNEL_TARGET, NordrassilLoc, TEMPSUMMON_TIMED_DESPAWN, 1200000);
if (temp)
WorldTreeGUID = temp->GetGUID();
if (Unit* Nordrassil = Unit::GetUnit(*me, WorldTreeGUID))
{
Nordrassil->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Nordrassil->SetDisplayId(11686);
DoCast(Nordrassil, SPELL_DRAIN_WORLD_TREE);
IsChanneling = true;
}
}
if (Unit* Nordrassil = Unit::GetUnit(*me, WorldTreeGUID))
{
Nordrassil->CastSpell(me, SPELL_DRAIN_WORLD_TREE_2, true);
DrainNordrassilTimer = 1000;
}
} else DrainNordrassilTimer -= diff;
}
if (!UpdateVictim())
return;
if (me->HealthBelowPct(10) && !BelowTenPercent && !Enraged)
// Evita que salgan add y que tire el dedo de la muerte para que se puedan sacar el logro.
//BelowTenPercent = true;
if (!Enraged)
{
if (EnrageTimer <= diff)
{
if (HealthAbovePct(10))
{
me->GetMotionMaster()->Clear(false);
me->GetMotionMaster()->MoveIdle();
Enraged = true;
Talk(SAY_ENRAGE);
}
} else EnrageTimer -= diff;
if (CheckDistanceTimer <= diff)
{
// To simplify the check, we simply summon a Creature in the location and then check how far we are from the creature
Creature* Check = me->SummonCreature(CREATURE_CHANNEL_TARGET, NordrassilLoc, TEMPSUMMON_TIMED_DESPAWN, 2000);
if (Check)
{
Check->SetVisible(false);
if (me->IsWithinDistInMap(Check, 75))
{
me->GetMotionMaster()->Clear(false);
me->GetMotionMaster()->MoveIdle();
Enraged = true;
Talk(SAY_ENRAGE);
}
}
CheckDistanceTimer = 5000;
} else CheckDistanceTimer -= diff;
}
if (BelowTenPercent)
{
if (!HasProtected)
{
me->GetMotionMaster()->Clear(false);
me->GetMotionMaster()->MoveIdle();
//all members of raid must get this buff
DoCastVictim(SPELL_PROTECTION_OF_ELUNE, true);
HasProtected = true;
Enraged = true;
}
if (SummonWispTimer <= diff)
{
DoSpawnCreature(CREATURE_ANCIENT_WISP, float(rand()%40), float(rand()%40), 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
SummonWispTimer = 1500;
++WispCount;
} else SummonWispTimer -= diff;
if (WispCount >= 30)
me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
}
if (Enraged)
{
if (HandOfDeathTimer <= diff)
{
DoCast(me->getVictim(), SPELL_HAND_OF_DEATH);
HandOfDeathTimer = 2000;
} else HandOfDeathTimer -= diff;
return; // Don't do anything after this point.
}
if (SoulChargeCount)
{
if (SoulChargeTimer <= diff)
UnleashSoulCharge();
else SoulChargeTimer -= diff;
}
if (GripOfTheLegionTimer <= diff)
{
DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_GRIP_OF_THE_LEGION);
GripOfTheLegionTimer = urand(5000, 25000);
} else GripOfTheLegionTimer -= diff;
if (AirBurstTimer <= diff)
{
Talk(SAY_AIR_BURST);
DoCast(SelectTarget(SELECT_TARGET_RANDOM, 1), SPELL_AIR_BURST);//not on tank
AirBurstTimer = urand(25000, 40000);
} else AirBurstTimer -= diff;
if (FearTimer <= diff)
{
DoCast(me->getVictim(), SPELL_FEAR);
FearTimer = 42000;
} else FearTimer -= diff;
if (DoomfireTimer <= diff)
{
Talk(SAY_DOOMFIRE);
Unit* temp = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!temp)
temp = me->getVictim();
//replace with spell cast 31903 once implicitTarget 73 implemented
SummonDoomfire(temp);
//supposedly three doomfire can be up at the same time
DoomfireTimer = 20000;
} else DoomfireTimer -= diff;
if (MeleeRangeCheckTimer <= diff)
{
if (CanUseFingerOfDeath())
{
DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_FINGER_OF_DEATH);
MeleeRangeCheckTimer = 1000;
}
MeleeRangeCheckTimer = 5000;
} else MeleeRangeCheckTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if(!UpdateVictim())
return;
events.Update(diff);
if(me->HasUnitState(UNIT_STAT_CASTING))
return;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_BERSERK:
DoScriptText(SAY_MOLGEIM_BERSERK, me);
DoCast(SPELL_BERSERK);
events.CancelEvent(EVENT_BERSERK);
break;
case EVENT_RUNE_OF_POWER: // Improve target selection; random alive friendly
{
Unit* target = NULL;
switch(urand(0, 2))
{
case 0:
target = me;
break;
case 1:
if(Creature* Steelbreaker = ObjectAccessor::GetCreature(*me, instance->GetData64(BOSS_STEELBREAKER)))
if(Steelbreaker->isAlive())
target = Steelbreaker;
break;
case 2:
if(Creature* Brundir = ObjectAccessor::GetCreature(*me, instance->GetData64(BOSS_STEELBREAKER)))
if(Brundir->isAlive())
target = Brundir;
break;
}
DoCast(target, SPELL_SUMMON_RUNE_OF_POWER);
events.ScheduleEvent(EVENT_RUNE_OF_POWER, 60000);
break;
}
case EVENT_SHIELD_OF_RUNES:
DoCast(me, SPELL_SHIELD_OF_RUNES);
events.ScheduleEvent(EVENT_SHIELD_OF_RUNES, urand(27000, 34000));
break;
case EVENT_RUNE_OF_DEATH:
DoScriptText(SAY_MOLGEIM_RUNE_DEATH, me);
if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_RUNE_OF_DEATH);
events.ScheduleEvent(EVENT_RUNE_OF_DEATH, urand(30000, 40000));
break;
case EVENT_RUNE_OF_SUMMONING:
DoScriptText(SAY_MOLGEIM_SUMMON, me);
if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_RUNE_OF_SUMMONING);
events.ScheduleEvent(EVENT_RUNE_OF_SUMMONING, urand(30000, 45000));
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if(!UpdateVictim())
return;
events.Update(diff);
if(me->HasUnitState(UNIT_STAT_CASTING))
return;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_BERSERK:
DoScriptText(SAY_BRUNDIR_BERSERK, me);
DoCast(SPELL_BERSERK);
events.CancelEvent(EVENT_BERSERK);
break;
case EVENT_CHAIN_LIGHTNING:
if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CHAIN_LIGHTNING);
events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, urand(7000, 10000));
break;
case EVENT_OVERLOAD:
me->MonsterTextEmote(EMOTE_OVERLOAD, 0, true);
DoScriptText(SAY_BRUNDIR_SPECIAL, me);
DoCast(SPELL_OVERLOAD);
events.ScheduleEvent(EVENT_OVERLOAD, urand(60000, 120000));
break;
case EVENT_LIGHTNING_WHIRL:
DoCast(SPELL_LIGHTNING_WHIRL);
events.ScheduleEvent(EVENT_LIGHTNING_WHIRL, urand(15000, 20000));
break;
case EVENT_LIGHTNING_TENDRILS:
DoScriptText(SAY_BRUNDIR_FLIGHT, me);
DoCast(SPELL_LIGHTNING_TENDRILS);
me->AttackStop();
me->AddUnitMovementFlag(MOVEMENTFLAG_LEVITATING);
DoCast(SPELL_LIGHTNING_TENDRILS_SELF_VISUAL);
me->GetMotionMaster()->Initialize();
me->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), FINAL_FLIGHT_Z);
events.DelayEvents(35000);
events.ScheduleEvent(EVENT_FLIGHT, 2500);
events.ScheduleEvent(EVENT_ENDFLIGHT, 32500);
events.ScheduleEvent(EVENT_LIGHTNING_TENDRILS, 90000);
break;
case EVENT_FLIGHT:
if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->GetMotionMaster()->MovePoint(0, target->GetPositionX(), target->GetPositionY(), FINAL_FLIGHT_Z);
events.ScheduleEvent(EVENT_FLIGHT, 6000);
break;
case EVENT_ENDFLIGHT:
me->GetMotionMaster()->Initialize();
me->GetMotionMaster()->MovePoint(0, 1586.920166f, 119.848984f, FINAL_FLIGHT_Z);
events.CancelEvent(EVENT_FLIGHT);
events.CancelEvent(EVENT_ENDFLIGHT);
events.ScheduleEvent(EVENT_LAND, 4000);
break;
case EVENT_LAND:
me->GetMotionMaster()->Initialize();
me->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), FLOOR_Z);
events.CancelEvent(EVENT_LAND);
events.ScheduleEvent(EVENT_GROUND, 2500);
break;
case EVENT_GROUND:
me->RemoveUnitMovementFlag(MOVEMENTFLAG_LEVITATING);
me->RemoveAurasDueToSpell(SPELL_LIGHTNING_TENDRILS);
me->RemoveAurasDueToSpell(SPELL_LIGHTNING_TENDRILS_SELF_VISUAL);
DoStartMovement(me->getVictim());
events.CancelEvent(EVENT_GROUND);
break;
case EVENT_MOVE_POSITION:
if(me->IsWithinMeleeRange(me->getVictim()))
{
float x = (float)irand(-25, 25);
float y = (float)irand(-25, 25);
me->GetMotionMaster()->MovePoint(0, me->GetPositionX() + x, me->GetPositionY() + y, FLOOR_Z);
// Prevention to go outside the room or into the walls
if(Creature* trigger = me->FindNearestCreature(NPC_WORLD_TRIGGER, 100.0f, true))
if(me->GetDistance(trigger) >= 50.0f)
me->GetMotionMaster()->MovePoint(0, trigger->GetPositionX(), trigger->GetPositionY(), FLOOR_Z);
}
events.ScheduleEvent(EVENT_MOVE_POSITION, urand(7500, 10000));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
//Return since we have no target or casting
if (!UpdateVictim() || me->IsNonMeleeSpellCasted(false))
return;
// Sonic Boom
if (SonicBoom)
{
DoCast(me, SPELL_SONIC_BOOM_EFFECT, true);
SonicBoomEffect();
SonicBoom = false;
Resonance_Timer = 1500;
}
if (SonicBoom_Timer <= diff)
{
Talk(EMOTE_SONIC_BOOM);
DoCast(me, SPELL_SONIC_BOOM_CAST);
SonicBoom_Timer = 30000;
SonicBoom = true;
return;
} else SonicBoom_Timer -= diff;
// Murmur's Touch
if (MurmursTouch_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 80, true))
DoCast(target, SPELL_MURMURS_TOUCH);
MurmursTouch_Timer = urand(25000, 35000);
} else MurmursTouch_Timer -= diff;
// Resonance
if (!SonicBoom && !(me->IsWithinMeleeRange(me->GetVictim())))
{
if (Resonance_Timer <= diff)
{
DoCast(me, SPELL_RESONANCE);
Resonance_Timer = 5000;
} else Resonance_Timer -= diff;
}
// Magnetic Pull
if (MagneticPull_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
if (target->GetTypeId() == TYPEID_PLAYER && target->IsAlive())
{
DoCast(target, SPELL_MAGNETIC_PULL);
MagneticPull_Timer = 15000+rand()%15000;
return;
}
MagneticPull_Timer = 500;
} else MagneticPull_Timer -= diff;
if (IsHeroic())
{
// Thundering Storm
if (ThunderingStorm_Timer <= diff)
{
ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
for (ThreatContainer::StorageType::const_iterator i = threatlist.begin(); i != threatlist.end(); ++i)
if (Unit* target = Unit::GetUnit(*me, (*i)->getUnitGuid()))
if (target->IsAlive() && !me->IsWithinDist(target, 35, false))
DoCast(target, SPELL_THUNDERING_STORM, true);
ThunderingStorm_Timer = 15000;
} else ThunderingStorm_Timer -= diff;
// Sonic Shock
if (SonicShock_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 20, false))
if (target->IsAlive())
DoCast(target, SPELL_SONIC_SHOCK);
SonicShock_Timer = 10000+rand()%10000;
} else SonicShock_Timer -= diff;
}
// Select nearest most aggro target if top aggro too far
if (!me->isAttackReady())
return;
if (!me->IsWithinMeleeRange(me->GetVictim()))
{
ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
for (ThreatContainer::StorageType::const_iterator i = threatlist.begin(); i != threatlist.end(); ++i)
if (Unit* target = Unit::GetUnit(*me, (*i)->getUnitGuid()))
if (target->IsAlive() && me->IsWithinMeleeRange(target))
{
me->TauntApply(target);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FEL_EXPLOSION:
DoCastAOE(SPELL_FEL_EXPLOSION);
events.ScheduleEvent(EVENT_FEL_EXPLOSION, 2s, 0, PHASE_NORMAL);
break;
case EVENT_DRAIN_CRYSTAL:
SelectNearestCrystal();
_scheduledEvents = false;
break;
case EVENT_DRAIN_MANA:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 45.0f, true))
DoCast(target, SPELL_DRAIN_MANA);
events.ScheduleEvent(EVENT_DRAIN_MANA, 10s, 0, PHASE_NORMAL);
break;
case EVENT_DRAIN_LIFE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 20.0f, true))
DoCast(target, SPELL_DRAIN_LIFE);
events.ScheduleEvent(EVENT_DRAIN_LIFE, 10s, 0, PHASE_NORMAL);
break;
case EVENT_EMPOWER:
{
Talk(SAY_EMPOWERED);
Creature* CrystalChosen = ObjectAccessor::GetCreature(*me, CrystalGUID);
if (CrystalChosen && CrystalChosen->IsAlive())
CrystalChosen->KillSelf();
CrystalGUID.Clear();
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MoveChase(me->GetVictim());
break;
}
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
if (me->GetPower(POWER_MANA) * 100 / me->GetMaxPower(POWER_MANA) < 10)
{
if (events.IsInPhase(PHASE_NORMAL) && !_scheduledEvents)
{
_scheduledEvents = true;
uint32 timer = urand(3000, 7000);
events.ScheduleEvent(EVENT_DRAIN_LIFE, timer, 0, PHASE_NORMAL);
if (IsHeroic())
{
events.ScheduleEvent(EVENT_DRAIN_CRYSTAL, urand(10000, 15000), 0, PHASE_NORMAL);
events.ScheduleEvent(EVENT_DRAIN_MANA, timer + 5000, 0, PHASE_NORMAL);
}
else
events.ScheduleEvent(EVENT_DRAIN_CRYSTAL, urand(20000, 25000), 0, PHASE_NORMAL);
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if(!UpdateVictim())
return;
// Void Zone
if(VoidZoneTimer < diff)
{
DoCast(SelectTarget(SELECT_TARGET_RANDOM,1,45,true),SPELL_VOIDZONE,true);
VoidZoneTimer = 15000;
}else VoidZoneTimer -= diff;
// NetherInfusion Berserk
if(!Berserk && NetherInfusionTimer < diff)
{
m_creature->AddAura(SPELL_NETHER_INFUSION, m_creature);
DoCast(m_creature, SPELL_NETHERSPITE_ROAR);
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)
{
DoCast(m_creature, SPELL_EMPOWERMENT);
m_creature->AddAura(SPELL_NETHERBURN_AURA, m_creature);
EmpowermentTimer = 90000;
}else EmpowermentTimer -= diff;
if(PhaseTimer < diff)
{
if(!m_creature->IsNonMeleeSpellCasted(false))
{
SwitchToBanishPhase();
return;
}
}else PhaseTimer -= diff;
}
else // BANISH PHASE
{
// Netherbreath
if(NetherbreathTimer < diff)
{
if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM,0,40,true))
DoCast(target,SPELL_NETHERBREATH);
NetherbreathTimer = 5000+rand()%2000;
}else NetherbreathTimer -= diff;
if(PhaseTimer < diff)
{
if(!m_creature->IsNonMeleeSpellCasted(false))
{
SwitchToPortalPhase();
return;
}
}else PhaseTimer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (questPhase == 1)
{
if (timer <= diff)
{
me->SetUInt32Value(UNIT_FIELD_BYTES_1, UNIT_STAND_STATE_STAND);
me->setFaction(FACTION_HOSTILE);
questPhase = 0;
if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
me->AddThreat(pTarget, 5000000.0f);
AttackStart(pTarget);
}
}
else
timer -= diff;
}
if (!UpdateVictim())
return;
// healer
if (spellFlashLight)
{
if (me->GetHealth() * 100 / me->GetMaxHealth() < 70)
{
if (timerFlashLight <= diff)
{
DoCast(me, SPELL_FLASH_OF_LIGHT);
timerFlashLight = TIMER_FLASH_OF_LIGHT + rand() % TIMER_FLASH_OF_LIGHT;
}
else
timerFlashLight -= diff;
}
}
if (spellJustice)
{
if (timerJustice <= diff)
{
DoCast(me, SPELL_SEAL_OF_JUSTICE);
timerJustice = TIMER_SEAL_OF_JUSTICE + rand() % TIMER_SEAL_OF_JUSTICE;
}
else
timerJustice -= diff;
}
if (spellJudLight)
{
if (timerJudLight <= diff)
{
DoCast(me, SPELL_JUDGEMENT_OF_LIGHT);
timerJudLight = TIMER_JUDGEMENT_OF_LIGHT + rand() % TIMER_JUDGEMENT_OF_LIGHT;
}
else
timerJudLight -= diff;
}
if (spellCommand)
{
if (timerCommand <= diff)
{
DoCast(me, TIMER_SEAL_OF_COMMAND);
timerCommand = TIMER_SEAL_OF_COMMAND + rand() % TIMER_SEAL_OF_COMMAND;
}
else
timerCommand -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_PYROBLAST:
DoCastVictim(SPELL_PYROBLAST);
events.ScheduleEvent(EVENT_PYROBLAST, urand(3500, 4500));
break;
case EVENT_FLARECORE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_FLARECORE_MISSILE);
events.ScheduleEvent(EVENT_FLARECORE, urand(19000, 21000));
break;
case EVENT_BLINK:
Talk(SAY_BLINK);
DoCast(me, SPELL_BLINK);
if (Creature* blink = me->FindNearestCreature(NPC_BLINK_TARGT, 200.0f, true))
me->NearTeleportTo(blink->GetPositionX(), blink->GetPositionY(), blink->GetPositionZ(), blink->GetOrientation());
events.CancelEvent(EVENT_PYROBLAST);
events.CancelEvent(EVENT_FLARECORE);
events.ScheduleEvent(EVENT_FROST_BLADES, 1500);
events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 2000);
events.ScheduleEvent(EVENT_BLINK, 31500);
break;
case EVENT_FROSTBOLT_VOLLEY:
if(VolleyCount < 3)
{
DoCast(me, SPELL_FROSTBOLT_VOLLEY);
events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 2200);
VolleyCount++;
}
else
{
Talk(SAY_FROSTBOLT_VOLLEY);
DoCast(me, SPELL_FROSTBOLT_VOLLEY);
events.CancelEvent(EVENT_FROSTBOLT_VOLLEY);
VolleyCount = 0;
events.ScheduleEvent(EVENT_PYROBLAST, urand(3000, 3500));
events.ScheduleEvent(EVENT_FLARECORE, urand (7500, 8500));
}
break;
case EVENT_FROST_BLADES:
Talk(SAY_FROST_BLADES);
me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation() - 0.1f, TEMPSUMMON_TIMED_DESPAWN, 10000);
me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation(), TEMPSUMMON_TIMED_DESPAWN, 10000);
me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation() + 0.1f, TEMPSUMMON_TIMED_DESPAWN, 10000);
break;
}
}
}
void DoSplit(int atPercent /* 75 50 25 */)
{
DoScriptText(SAY_SPLIT, me);
ov_mycoordinates *place1 = new ov_mycoordinates(-8340.782227,2083.814453,125.648788,0);
ov_mycoordinates *place2 = new ov_mycoordinates(-8341.546875,2118.504639,133.058151,0);
ov_mycoordinates *place3 = new ov_mycoordinates(-8318.822266,2058.231201,133.058151,0);
ov_mycoordinates *bossc=place1, *i1=place2, *i2=place3;
switch (urand(0,2))
{
case 0:
bossc=place1;
i1=place2;
i2=place3;
break;
case 1:
bossc=place2;
i1=place1;
i2=place3;
break;
case 2:
bossc=place3;
i1=place1;
i2=place2;
break;
}
for (uint16 i = 0; i < 41; ++i)
{
if (Player *pTarget = CAST_PLR(SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true)))
{
if (Group *pGrp = pTarget->GetGroup())
for (uint8 ico = 0; ico < TARGETICONCOUNT; ++ico)
{
//if (grp->m_targetIcons[ico] == me->GetGUID()) -- private member :(
pGrp->SetTargetIcon(ico, 0, 0);
}
break;
}
}
me->RemoveAllAuras();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetVisibility(VISIBILITY_OFF);
me->GetMap()->CreatureRelocation(me, bossc->x, bossc->y, bossc->z, bossc->r);
Invisible = true;
delete place1;
delete place2;
delete place3;
DoResetThreat();
DoStopAttack();
switch (atPercent)
{
case 75: Images75 = true; break;
case 50: Images50 = true; break;
case 25: Images25 = true; break;
}
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);
Creature *Image1 = me->SummonCreature(15263, i1->x, i1->y, i1->z, i1->r, TEMPSUMMON_CORPSE_DESPAWN, 30000);
if (Image1)
{
Image1->SetMaxHealth(me->GetMaxHealth() / 5);
Image1->SetHealth(me->GetHealth() / 5);
if (pTarget)
Image1->AI()->AttackStart(pTarget);
CAST_AI(boss_skeramAI, Image1->AI())->IsImage = true;
}
Creature *Image2 = me->SummonCreature(15263,i2->x, i2->y, i2->z, i2->r, TEMPSUMMON_CORPSE_DESPAWN, 30000);
if (Image2)
{
Image2->SetMaxHealth(me->GetMaxHealth() / 5);
Image2->SetHealth(me->GetHealth() / 5);
if (pTarget)
Image2->AI()->AttackStart(pTarget);
CAST_AI(boss_skeramAI, Image2->AI())->IsImage = true;
}
Invisible = true;
}
void UpdateAI(const uint32 uiDiff)
{
if (bDone && uiResetTimer <= uiDiff)
{
me->GetMotionMaster()->MovePoint(0, 746.87f, 665.87f, 411.75f);
bDone = false;
} else uiResetTimer -= uiDiff;
if (!UpdateVictim())
return;
if (uiHolyFireTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 250, true))
{
if (target && target->isAlive())
DoCast(target, SPELL_HOLY_FIRE);
}
if (me->HasAura(SPELL_SHIELD))
uiHolyFireTimer = 13000;
else
uiHolyFireTimer = urand(9000, 12000);
} else uiHolyFireTimer -= uiDiff;
if (uiHolySmiteTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 250, true))
{
if (target && target->isAlive())
DoCast(target, SPELL_SMITE);
}
if (me->HasAura(SPELL_SHIELD))
uiHolySmiteTimer = 9000;
else
uiHolySmiteTimer = urand(5000, 7000);
} else uiHolySmiteTimer -= uiDiff;
if (me->HasAura(SPELL_SHIELD))
{
if (uiRenewTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(true);
uint8 uiTarget = urand(0, 1);
switch (uiTarget)
{
case 0:
DoCast(me, SPELL_RENEW);
break;
case 1:
if (Creature* pMemory = Unit::GetCreature(*me, MemoryGUID))
if (pMemory->isAlive())
DoCast(pMemory, SPELL_RENEW);
break;
}
uiRenewTimer = urand(15000, 17000);
} else uiRenewTimer -= uiDiff;
}
if (!bHealth && !HealthAbovePct(25))
{
me->InterruptNonMeleeSpells(true);
DoCastAOE(SPELL_HOLY_NOVA, false);
DoCast(me, SPELL_SHIELD);
DoCastAOE(SPELL_SUMMON_MEMORY, false);
DoCastAOE(SPELL_CONFESS, false);
bHealth = true;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//Invisible_Timer
if (Invisible_Timer <= diff)
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
SetEquipmentSlots(false, EQUIP_UNEQUIP, EQUIP_NO_CHANGE, EQUIP_NO_CHANGE);
me->SetDisplayId(11686);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Invisible = true;
Invisible_Timer = 15000 + rand()%15000;
} else Invisible_Timer -= diff;
if (Invisible)
{
if (Ambush_Timer <= diff)
{
Unit* target = NULL;
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
{
DoTeleportTo(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
DoCast(target, SPELL_AMBUSH);
}
Ambushed = true;
Ambush_Timer = 3000;
} else Ambush_Timer -= diff;
}
if (Ambushed)
{
if (Visible_Timer <= diff)
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
me->SetDisplayId(15268);
SetEquipmentSlots(false, EQUIP_ID_MAIN_HAND, EQUIP_NO_CHANGE, EQUIP_NO_CHANGE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Invisible = false;
Visible_Timer = 4000;
} else Visible_Timer -= diff;
}
//Resetting some aggro so he attacks other gamers
if (!Invisible)
{
if (Aggro_Timer <= diff)
{
Unit* target = NULL;
target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (DoGetThreat(me->getVictim()))
DoModifyThreatPercent(me->getVictim(), -50);
if (target)
AttackStart(target);
Aggro_Timer = 7000 + rand()%13000;
} else Aggro_Timer -= diff;
}
if (!Invisible)
{
if (ThousandBlades_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_THOUSANDBLADES);
ThousandBlades_Timer = 7000 + rand()%5000;
} else ThousandBlades_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_CASTING))
return;
if(ShouldSummonAdds)
{
// Despawns the Stalker
DespawnCreatures(NPC_SHADOW_GALE_STALKER);
RemoveShadowGaleDebuffFromPlayers();
me->SetReactState(REACT_AGGRESSIVE);
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MoveChase(me->getVictim());
if ((rand()%2))
me->MonsterYell(SAY_SUMMON, LANG_UNIVERSAL, NULL);
//Adds a visual portal effect to the Stalker
FacelessPortalStalker->GetAI()->DoCast(FacelessPortalStalker,SPELL_TWILIGHT_PORTAL_VISUAL,true);
events.ScheduleEvent(EVENT_REMOVE_TWILIGHT_PORTAL, 7000);
//Summons Faceless over the Spell
FacelessPortalStalker->GetAI()->DoCast(FacelessPortalStalker,SPELL_SPAWN_FACELESS,true);
ShouldSummonAdds = false;
// DBM says that the Spell has 40s CD
events.ScheduleEvent(EVENT_SHADOW_GALE, urand(40000,44000));
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ENFEEBLING_BLOW:
DoCastVictim(SPELL_ENFEEBLING_BLOW);
events.ScheduleEvent(EVENT_ENFEEBLING_BLOW, urand(19000,24000));
break;
case EVENT_SHADOW_GALE:
ShadowGaleTrigger = me->SummonCreature(NPC_SHADOW_GALE_STALKER,-739.665f/*+(urand(0,20)-10)*/,-827.024f/*+(urand(0,20)-10)*/,232.412f,3.1f,TEMPSUMMON_CORPSE_DESPAWN);
me->SetReactState(REACT_PASSIVE);
me->GetMotionMaster()->MovePoint(POINT_ERUDAX_IS_AT_STALKER,ShadowGaleTrigger->GetPositionX(),ShadowGaleTrigger->GetPositionY(),ShadowGaleTrigger->GetPositionZ());
DoScriptText(SAY_GALE, me);
break;
case EVENT_REMOVE_TWILIGHT_PORTAL:
//Removes Portal effect from Stalker
FacelessPortalStalker->RemoveAllAuras();
break;
case EVENT_BINDING_SHADOWS:
if (Unit* tempTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500.0f, true))
DoCast(tempTarget,SPELL_BINDING_SHADOWS);
events.ScheduleEvent(EVENT_BINDING_SHADOWS, urand(12000,17000));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
switch (m_uiStage)
{
case 0:
if (m_uiFerociousButtTimer <= uiDiff)
{
DoCastVictim(SPELL_FEROCIOUS_BUTT);
m_uiFerociousButtTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else m_uiFerociousButtTimer -= uiDiff;
if (m_uiArticBreathTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_ARCTIC_BREATH);
m_uiArticBreathTimer = urand(25*IN_MILLISECONDS, 40*IN_MILLISECONDS);
} else m_uiArticBreathTimer -= uiDiff;
if (m_uiWhirlTimer <= uiDiff)
{
DoCastAOE(SPELL_WHIRL);
m_uiWhirlTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else m_uiWhirlTimer -= uiDiff;
if (m_uiMassiveCrashTimer <= uiDiff)
{
me->GetMotionMaster()->MoveJump(ToCCommonLoc[1].GetPositionX(), ToCCommonLoc[1].GetPositionY(), ToCCommonLoc[1].GetPositionZ(), 10.0f, 20.0f); // 1: Middle of the room
m_uiStage = 7; //Invalid (Do nothing more than move)
m_uiMassiveCrashTimer = 30*IN_MILLISECONDS;
} else m_uiMassiveCrashTimer -= uiDiff;
DoMeleeAttackIfReady();
break;
case 1:
DoCastAOE(SPELL_MASSIVE_CRASH);
m_uiStage = 2;
break;
case 2:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0, true))
{
m_uiTrampleTargetGUID = target->GetGUID();
me->SetTarget(m_uiTrampleTargetGUID);
DoScriptText(SAY_TRAMPLE_STARE, me, target);
m_bTrampleCasted = false;
SetCombatMovement(false);
me->GetMotionMaster()->MoveIdle();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_uiTrampleTimer = 4*IN_MILLISECONDS;
m_uiStage = 3;
} else m_uiStage = 6;
break;
case 3:
if (m_uiTrampleTimer <= uiDiff)
{
if (Unit* target = Unit::GetPlayer(*me, m_uiTrampleTargetGUID))
{
m_bTrampleCasted = false;
m_bMovementStarted = true;
m_fTrampleTargetX = target->GetPositionX();
m_fTrampleTargetY = target->GetPositionY();
m_fTrampleTargetZ = target->GetPositionZ();
me->GetMotionMaster()->MoveJump(2*me->GetPositionX()-m_fTrampleTargetX,
2*me->GetPositionY()-m_fTrampleTargetY,
me->GetPositionZ(),
10.0f, 20.0f); // 2: Hop Backwards
m_uiStage = 7; //Invalid (Do nothing more than move)
} else m_uiStage = 6;
} else m_uiTrampleTimer -= uiDiff;
break;
case 4:
DoScriptText(SAY_TRAMPLE_START, me);
me->GetMotionMaster()->MoveCharge(m_fTrampleTargetX, m_fTrampleTargetY, m_fTrampleTargetZ+2, 42, 1);
me->SetTarget(0);
m_uiStage = 5;
break;
case 5:
if (m_bMovementFinish)
{
if (m_uiTrampleTimer <= uiDiff) DoCastAOE(SPELL_TRAMPLE);
m_bMovementFinish = false;
m_uiStage = 6;
return;
}
if (m_uiTrampleTimer <= uiDiff)
{
Map::PlayerList const &lPlayers = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator itr = lPlayers.begin(); itr != lPlayers.end(); ++itr)
{
if (Unit* player = itr->getSource())
if (player->isAlive() && player->IsWithinDistInMap(me, 6.0f))
{
DoCastAOE(SPELL_TRAMPLE);
m_uiTrampleTimer = IN_MILLISECONDS;
break;
}
}
} else m_uiTrampleTimer -= uiDiff;
break;
case 6:
if (!m_bTrampleCasted)
{
DoCast(me, SPELL_STAGGERED_DAZE);
DoScriptText(SAY_TRAMPLE_FAIL, me);
}
m_bMovementStarted = false;
me->GetMotionMaster()->MovementExpired();
me->GetMotionMaster()->MoveChase(me->getVictim());
SetCombatMovement(true);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_uiStage = 0;
break;
}
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
//Earthquake_Timer
if (Earthquake_Timer <= diff)
{
if (!Earthquake)
{
DoCast(me->getVictim(), SPELL_EARTHQUAKE);
Earthquake = true;
Earthquake_Timer = 10000;
}
else
{
DoScriptText(RAND(SAY_SUMMON1, SAY_SUMMON2), me);
for (uint8 i = 0; i < 10; ++i)
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
Creature* Murloc = me->SummonCreature(NPC_TIDEWALKER_LURKER, MurlocCords[i][0], MurlocCords[i][1], MurlocCords[i][2], MurlocCords[i][3], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 10000);
if (pTarget && Murloc)
Murloc->AI()->AttackStart(pTarget);
}
DoScriptText(EMOTE_EARTHQUAKE, me);
Earthquake = false;
Earthquake_Timer = 40000+rand()%5000;
}
} else Earthquake_Timer -= diff;
//TidalWave_Timer
if (TidalWave_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_TIDAL_WAVE);
TidalWave_Timer = 20000;
} else TidalWave_Timer -= diff;
if (!Phase2)
{
//WateryGrave_Timer
if (WateryGrave_Timer <= diff)
{
//Teleport 4 players under the waterfalls
Unit *pTarget;
std::set<uint64> list;
std::set<uint64>::const_iterator itr;
for (uint8 i = 0; i < 4; ++i)
{
counter = 0;
do
{
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 50, true); //target players only
if (counter < Playercount)
break;
if (pTarget)
itr = list.find(pTarget->GetGUID());
++counter;
} while (itr != list.end());
if (pTarget)
{
list.insert(pTarget->GetGUID());
ApplyWateryGrave(pTarget, i);
}
}
DoScriptText(RAND(SAY_SUMMON_BUBL1, SAY_SUMMON_BUBL2), me);
DoScriptText(EMOTE_WATERY_GRAVE, me);
WateryGrave_Timer = 30000;
} else WateryGrave_Timer -= diff;
//Start Phase2
if (HealthBelowPct(25))
Phase2 = true;
}
else
{
//WateryGlobules_Timer
if (WateryGlobules_Timer <= diff)
{
Unit* pGlobuleTarget;
std::set<uint64> globulelist;
std::set<uint64>::const_iterator itr;
for (uint8 g = 0; g < 4; g++) //one unit can't cast more than one spell per update, so some players have to cast for us XD
{
counter = 0;
do
{
pGlobuleTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true);
if (pGlobuleTarget)
itr = globulelist.find(pGlobuleTarget->GetGUID());
if (counter > Playercount)
break;
++counter;
} while (itr != globulelist.end());
if (pGlobuleTarget)
{
globulelist.insert(pGlobuleTarget->GetGUID());
pGlobuleTarget->CastSpell(pGlobuleTarget, globulespell[g], true);
}
}
DoScriptText(EMOTE_WATERY_GLOBULES, me);
WateryGlobules_Timer = 25000;
} else WateryGlobules_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (pInstance && !pInstance->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*> pTargets;
SelectTargetList(pTargets, 5, SELECT_TARGET_RANDOM, me->GetMeleeReach()*5, true);
for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.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 *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
pTarget->CastSpell(pTarget, SPELL_GARROTE,true);
InVanish = false;
} else Wait_Timer -= diff;
}
if (!InVanish)
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (!HasVanished)
{
if (DeadlyPoisonTimer <= diff)
{
DoCastVictim(SPELL_DEADLY_POISON);
DeadlyPoisonTimer = urand(15, 46) * 1000;
} else DeadlyPoisonTimer -= diff;
if (AppearEnvenomTimer <= diff) // Cast Envenom. This is cast 4 seconds after Vanish is over
{
DoCastVictim(SPELL_ENVENOM);
AppearEnvenomTimer = 90000;
} else AppearEnvenomTimer -= diff;
if (VanishTimer <= diff) // Disappear and stop attacking, but follow a random unit
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
VanishTimer = 30000;
AppearEnvenomTimer= 28000;
HasVanished = true;
me->SetVisible(false);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DoResetThreat();
// Chase a unit. Check before DoMeleeAttackIfReady prevents from attacking
me->AddThreat(target, 500000.0f);
me->GetMotionMaster()->MoveChase(target);
}
} else VanishTimer -= diff;
DoMeleeAttackIfReady();
}
else
{
if (VanishTimer <= diff) // Become attackable and poison current target
{
Unit* target = me->GetVictim();
DoCast(target, SPELL_DEADLY_POISON);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
DoResetThreat();
me->AddThreat(target, 3000.0f); // Make Veras attack his target for a while, he will cast Envenom 4 seconds after.
DeadlyPoisonTimer += 6000;
VanishTimer = 90000;
AppearEnvenomTimer = 4000;
HasVanished = false;
} else VanishTimer -= diff;
if (AppearEnvenomTimer <= diff) // Appear 2 seconds before becoming attackable (Shifting out of vanish)
{
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MoveChase(me->GetVictim());
me->SetVisible(true);
AppearEnvenomTimer = 6000;
} else AppearEnvenomTimer -= diff;
}
}
void UpdateAI(uint32 diff) override
{
//Only if not incombat check if the event is started
if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
{
if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
AttackStart(target);
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (!instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//LeechingThrow_Timer
if (LeechingThrow_Timer <= diff)
{
DoCastVictim(SPELL_LEECHING_THROW);
LeechingThrow_Timer = 20000;
} else LeechingThrow_Timer -= diff;
//Multishot_Timer
if (Multishot_Timer <= diff)
{
DoCastVictim(SPELL_MULTISHOT);
Multishot_Timer = 20000;
} else Multishot_Timer -= diff;
//TheBeastWithin_Timer
if (TheBeastWithin_Timer <= diff)
{
DoCast(me, SPELL_THE_BEAST_WITHIN);
Creature* Pet = ObjectAccessor::GetCreature(*me, SummonedPet);
if (Pet && Pet->IsAlive())
Pet->CastSpell(Pet, SPELL_PET_ENRAGE, true);
TheBeastWithin_Timer = 30000;
} else TheBeastWithin_Timer -= diff;
//Pet_Timer
if (Pet_Timer < diff && pet == false)
{
pet = true;
//uint32 spell_id;
uint32 pet_id;
if (!urand(0, 1))
{
//spell_id = SPELL_SUMMON_FATHOM_LURKER;
pet_id = CREATURE_FATHOM_LURKER;
}
else
{
//spell_id = SPELL_SUMMON_FATHOM_SPOREBAT;
pet_id = CREATURE_FATHOM_SPOREBAT;
}
//DoCast(me, spell_id, true);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
if (Creature* Pet = DoSpawnCreature(pet_id, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000))
{
Pet->AI()->AttackStart(target);
SummonedPet = Pet->GetGUID();
}
}
} else Pet_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
// Evade if too far
if (check_Timer <= diff)
{
float x,y,z,o;
me->GetHomePosition(x,y,z,o);
if (me->GetDistance(x,y,z) > 60)
{
EnterEvadeMode();
return;
}
check_Timer = 1000;
} else check_Timer -= diff;
// Spore Striders
if (HeroicMode && SporeStriders_Timer <= diff)
{
DoCast(me,SPELL_SUMMON_SPORE_STRIDER);
SporeStriders_Timer = 10000+rand()%5000;
} else SporeStriders_Timer -= diff;
// Levitate
if (LevitatedTarget)
{
if (LevitatedTarget_Timer <= diff)
{
if (Unit *pTarget = (Unit*)Unit::GetUnit(*me, LevitatedTarget))
{
if (!pTarget->HasAura(SPELL_LEVITATE,0))
{
LevitatedTarget = 0;
return;
}
if (InAir)
{
pTarget->AddAura(SPELL_SUSPENSION, pTarget);
LevitatedTarget = 0;
}
else
{
pTarget->CastSpell(pTarget, SPELL_MAGNETIC_PULL, true);
InAir = true;
LevitatedTarget_Timer = 1500;
}
}
else
LevitatedTarget = 0;
} else LevitatedTarget_Timer -= diff;
}
if (Levitate_Timer <= diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,1))
{
DoCast(pTarget, SPELL_LEVITATE);
LevitatedTarget = pTarget->GetGUID();
LevitatedTarget_Timer = 2000;
InAir = false;
}
Levitate_Timer = 12000+rand()%3000;
} else Levitate_Timer -= diff;
// Chain Lightning
if (ChainLightning_Timer <= diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
DoCast(pTarget, SPELL_CHAIN_LIGHTNING);
ChainLightning_Timer = 7000;
} else ChainLightning_Timer -= diff;
// Static Charge
if (StaticCharge_Timer <= diff)
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM,0,30,true))
DoCast(pTarget, SPELL_STATIC_CHARGE);
StaticCharge_Timer = 10000;
} else StaticCharge_Timer -= diff;
DoMeleeAttackIfReady();
}
void hyjalAI::UpdateAI(uint32 diff)
{
if (IsDummy)
{
if (MassTeleportTimer < diff && DoMassTeleport)
{
DoCast(me, SPELL_MASS_TELEPORT, false);
DoMassTeleport = false;
} else MassTeleportTimer -= diff;
return;
}
if (DoHide)
{
DoHide = false;
switch (me->GetEntry())
{
case JAINA:
if (instance && instance->GetData(DATA_ALLIANCE_RETREAT))
{
me->SetVisible(false);
HideNearPos(me->GetPositionX(), me->GetPositionY());
HideNearPos(5037.76f, -1889.71f);
for (uint8 i = 0; i < 92; ++i)//summon fires
me->SummonGameObject(FLAMEOBJECT, AllianceFirePos[i][0], AllianceFirePos[i][1], AllianceFirePos[i][2], AllianceFirePos[i][3], AllianceFirePos[i][4], AllianceFirePos[i][5], AllianceFirePos[i][6], AllianceFirePos[i][7], 0);
}
else me->SetVisible(true);
break;
case THRALL: //thrall
if (instance && instance->GetData(DATA_HORDE_RETREAT))
{
me->SetVisible(false);
HideNearPos(me->GetPositionX(), me->GetPositionY());
HideNearPos(5563, -2763.19f);
HideNearPos(5542.2f, -2629.36f);
for (uint8 i = 0; i < 65; ++i)//summon fires
me->SummonGameObject(FLAMEOBJECT, HordeFirePos[i][0], HordeFirePos[i][1], HordeFirePos[i][2], HordeFirePos[i][3], HordeFirePos[i][4], HordeFirePos[i][5], HordeFirePos[i][6], HordeFirePos[i][7], 0);
}
else me->SetVisible(true);
break;
}
}
if (DoRespawn)
{
if (RespawnTimer <= diff)
{
DoRespawn = false;
RespawnNearPos(me->GetPositionX(), me->GetPositionY());
if (Faction == 0)
{
RespawnNearPos(5037.76f, -1889.71f);
} else if (Faction == 1)
{
RespawnNearPos(5563, -2763.19f);
RespawnNearPos(5542.2f, -2629.36f);
}
me->SetVisible(true);
}else{
RespawnTimer -= diff;
me->SetVisible(false);
}
return;
}
if (Overrun)
DoOverrun(Faction, diff);
if (bRetreat)
{
if (RetreatTimer <= diff)
{
IsDummy = true;
bRetreat = false;
HideNearPos(me->GetPositionX(), me->GetPositionY());
switch (me->GetEntry())
{
case JAINA://jaina
HideNearPos(5037.76f, -1889.71f);
break;
case THRALL://thrall
HideNearPos(5563, -2763.19f);
HideNearPos(5542.2f, -2629.36f);
HideNearPos(5603.75f, -2853.12f);
break;
}
me->SetVisible(false);
} else RetreatTimer -= diff;
}
if (!EventBegun)
return;
if (Summon)
{
if (instance && EnemyCount)
{
EnemyCount = instance->GetData(DATA_TRASH);
if (!EnemyCount)
NextWaveTimer = 5000;
}
if (NextWaveTimer <= diff)
{
if (Faction == 0)
SummonNextWave(AllianceWaves, WaveCount, AllianceBase);
else if (Faction == 1)
SummonNextWave(HordeWaves, WaveCount, HordeBase);
++WaveCount;
} else NextWaveTimer -= diff;
}
if (CheckTimer <= diff)
{
for (uint8 i = 0; i < 2; ++i)
{
if (BossGUID[i])
{
Unit* unit = Unit::GetUnit(*me, BossGUID[i]);
if (unit && (!unit->isAlive()))
{
if (BossGUID[i] == BossGUID[0])
{
Talk(INCOMING);
FirstBossDead = true;
}
else if (BossGUID[i] == BossGUID[1])
{
Talk(SUCCESS);
SecondBossDead = true;
}
EventBegun = false;
CheckTimer = 0;
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
BossGUID[i] = 0;
if (instance)
instance->DoUpdateWorldState(WORLD_STATE_ENEMY, 0); // Reset world state for enemies to disable it
}
}
}
CheckTimer = 5000;
} else CheckTimer -= diff;
if (!UpdateVictim())
return;
for (uint8 i = 0; i < HYJAL_AI_MAX_SPELLS; ++i)
{
if (Spells[i].SpellId)
{
if (SpellTimer[i] <= diff)
{
if (me->IsNonMeleeSpellCasted(false))
me->InterruptNonMeleeSpells(false);
Unit* target = NULL;
switch (Spells[i].TargetType)
{
case TARGETTYPE_SELF:
target = me;
break;
case TARGETTYPE_RANDOM:
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
break;
case TARGETTYPE_VICTIM:
target = me->getVictim();
break;
}
if (target && target->isAlive())
{
DoCast(target, Spells[i].SpellId);
SpellTimer[i] = Spells[i].Cooldown;
}
} else SpellTimer[i] -= diff;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (HealthBelowPct(10) && !Enraged)
{
Enraged = true;
DoCast(me, SPELL_ENRAGE, true);
DoScriptText(SAY_ENRAGE, me);
}
//Randomly cast one beam.
if (BeamTimer <= diff)
{
Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (!pTarget || !pTarget->isAlive())
return;
BeamTimer = 9000;
switch(CurrentBeam)
{
case 0:
DoCast(pTarget, SPELL_BEAM_SINISTER);
break;
case 1:
DoCast(pTarget, SPELL_BEAM_VILE);
break;
case 2:
DoCast(pTarget, SPELL_BEAM_WICKED);
break;
case 3:
DoCast(pTarget, SPELL_BEAM_SINFUL);
break;
}
++BeamCount;
uint32 Beam = CurrentBeam;
if (BeamCount > 3)
while (CurrentBeam == Beam)
CurrentBeam = rand()%3;
} else BeamTimer -= diff;
// Random Prismatic Shield every 15 seconds.
if (PrismaticShieldTimer <= diff)
{
uint32 random = rand()%6;
if (PrismaticAuras[random])
DoCast(me, PrismaticAuras[random]);
PrismaticShieldTimer = 15000;
} else PrismaticShieldTimer -= diff;
// Select 3 random targets (can select same target more than once), teleport to a random location then make them cast explosions until they get away from each other.
if (FatalAttractionTimer <= diff)
{
ExplosionCount = 0;
TeleportPlayers();
DoScriptText(RAND(SAY_SPELL2, SAY_SPELL3), me);
FatalAttractionExplodeTimer = 2000;
FatalAttractionTimer = 40000 + rand()%31 * 1000;
} else FatalAttractionTimer -= diff;
if (FatalAttractionExplodeTimer <= diff)
{
// Just make them explode three times... they're supposed to keep exploding while they are in range, but it'll take too much code. I'll try to think of an efficient way for it later.
if (ExplosionCount < 3)
{
for (uint8 i = 0; i < 3; ++i)
{
Unit* pUnit = NULL;
if (TargetGUID[i])
{
pUnit = Unit::GetUnit((*me), TargetGUID[i]);
if (pUnit)
pUnit->CastSpell(pUnit, SPELL_ATTRACTION, true);
TargetGUID[i] = 0;
}
}
++ExplosionCount;
FatalAttractionExplodeTimer = 1000;
}
else
{
FatalAttractionExplodeTimer = FatalAttractionTimer + 2000;
ExplosionCount = 0;
}
} else FatalAttractionExplodeTimer -= diff;
if (ShriekTimer <= diff)
{
DoCast(me->getVictim(), SPELL_SILENCING_SHRIEK);
ShriekTimer = 25000+rand()%10 * 1000;
} else ShriekTimer -= diff;
if (SaberTimer <= diff)
{
DoCast(me->getVictim(), SPELL_SABER_LASH);
SaberTimer = 25000+rand()%10 * 1000;
} else SaberTimer -= diff;
//Enrage
if (!me->HasAura(SPELL_BERSERK))
{
if (EnrageTimer <= diff)
{
DoCast(me, SPELL_BERSERK);
DoScriptText(SAY_ENRAGE, me);
} else EnrageTimer -= diff;
}
//Random taunts
if (RandomYellTimer <= diff)
{
DoScriptText(RAND(SAY_TAUNT1, SAY_TAUNT2, SAY_TAUNT3), me);
RandomYellTimer = 60000 + rand()%91 * 1000;
} else RandomYellTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && instance && instance->GetData(DATA_MAULGAREVENT))
{
Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_MAULGAREVENT_TANK));
if (target)
{
AttackStart(target);
GetCouncil();
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (instance && !instance->GetData(DATA_MAULGAREVENT))
{
EnterEvadeMode();
return;
}
//ArcingSmash_Timer
if (ArcingSmash_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_ARCING_SMASH);
ArcingSmash_Timer = 10000;
} else ArcingSmash_Timer -= diff;
//Whirlwind_Timer
if (Whirlwind_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_WHIRLWIND);
Whirlwind_Timer = 55000;
} else Whirlwind_Timer -= diff;
//MightyBlow_Timer
if (MightyBlow_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_MIGHTY_BLOW);
MightyBlow_Timer = 30000+rand()%10000;
} else MightyBlow_Timer -= diff;
//Entering Phase 2
if (!Phase2 && HealthBelowPct(50))
{
Phase2 = true;
Talk(SAY_ENRAGE);
DoCast(me, SPELL_DUAL_WIELD, true);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, 0);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID+1, 0);
}
if (Phase2)
{
//Charging_Timer
if (Charging_Timer <= diff)
{
Unit* target = NULL;
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
{
AttackStart(target);
DoCast(target, SPELL_BERSERKER_C);
}
Charging_Timer = 20000;
} else Charging_Timer -= diff;
//Intimidating Roar
if (Roar_Timer <= diff)
{
DoCast(me, SPELL_ROAR);
Roar_Timer = 40000+(rand()%10000);
} else Roar_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (DelayTimer && DelayTimer > 5000)
DelayEventStart();
else DelayTimer+=diff;
switch (Phase)
{
case PHASE_UNDERGROUND:
if (ImpaleTimer <= diff)
{
switch (ImpalePhase)
{
case IMPALE_PHASE_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
if (Creature* impaleTarget = DoSummonImpaleTarget(target))
impaleTarget->CastSpell(impaleTarget, SPELL_IMPALE_SHAKEGROUND, true);
ImpaleTimer = 3*IN_MILLISECONDS;
ImpalePhase = IMPALE_PHASE_ATTACK;
}
break;
case IMPALE_PHASE_ATTACK:
if (Creature* impaleTarget = Unit::GetCreature(*me, ImpaleTarget))
{
impaleTarget->CastSpell(impaleTarget, SPELL_IMPALE_SPIKE, false);
impaleTarget->RemoveAurasDueToSpell(SPELL_IMPALE_SHAKEGROUND);
}
ImpalePhase = IMPALE_PHASE_DMG;
ImpaleTimer = 1*IN_MILLISECONDS;
break;
case IMPALE_PHASE_DMG:
if (Creature* impaleTarget = Unit::GetCreature(*me, ImpaleTarget))
me->CastSpell(impaleTarget, DUNGEON_MODE(SPELL_IMPALE_DMG, SPELL_IMPALE_DMG_H), true);
ImpalePhase = IMPALE_PHASE_TARGET;
ImpaleTimer = 9*IN_MILLISECONDS;
break;
}
} else ImpaleTimer -= diff;
if (!GuardianSummoned)
{
for (uint8 i = 0; i < 2; ++i)
{
if (Creature* Guardian = me->SummonCreature(CREATURE_GUARDIAN, SpawnPointGuardian[i], TEMPSUMMON_CORPSE_DESPAWN, 0))
{
Guardian->AddThreat(me->getVictim(), 0.0f);
DoZoneInCombat(Guardian);
}
}
GuardianSummoned = true;
}
if (!VenomancerSummoned)
{
if (VenomancerTimer <= diff)
{
if (UndergroundPhase > 1)
{
for (uint8 i = 0; i < 2; ++i)
{
if (Creature* Venomancer = me->SummonCreature(CREATURE_VENOMANCER, SpawnPoint[i], TEMPSUMMON_CORPSE_DESPAWN, 0))
{
Venomancer->AddThreat(me->getVictim(), 0.0f);
DoZoneInCombat(Venomancer);
}
}
VenomancerSummoned = true;
}
} else VenomancerTimer -= diff;
}
if (!DatterSummoned)
{
if (DatterTimer <= diff)
{
if (UndergroundPhase > 2)
{
for (uint8 i = 0; i < 2; ++i)
{
if (Creature* Datter = me->SummonCreature(CREATURE_DATTER, SpawnPoint[i], TEMPSUMMON_CORPSE_DESPAWN, 0))
{
Datter->AddThreat(me->getVictim(), 0.0f);
DoZoneInCombat(Datter);
}
}
DatterSummoned = true;
}
} else DatterTimer -= diff;
if (me->HasAura(SPELL_LEECHING_SWARM))
me->RemoveAurasDueToSpell(SPELL_LEECHING_SWARM);
}
if (UndergroundTimer <= diff)
{
me->RemoveAura(SPELL_SUBMERGE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
Phase = PHASE_MELEE;
} else UndergroundTimer -= diff;
break;
case PHASE_MELEE:
if (((UndergroundPhase == 0 && HealthBelowPct(75))
|| (UndergroundPhase == 1 && HealthBelowPct(50))
|| (UndergroundPhase == 2 && HealthBelowPct(25)))
&& !me->HasUnitState(UNIT_STATE_CASTING))
{
GuardianSummoned = false;
VenomancerSummoned = false;
DatterSummoned = false;
UndergroundTimer = 40*IN_MILLISECONDS;
VenomancerTimer = 25*IN_MILLISECONDS;
DatterTimer = 32*IN_MILLISECONDS;
ImpalePhase = 0;
ImpaleTimer = 9*IN_MILLISECONDS;
DoCast(me, SPELL_SUBMERGE, false);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
Phase = PHASE_UNDERGROUND;
++UndergroundPhase;
}
if (Channeling == true)
{
for (uint8 i = 0; i < 8; ++i)
DoCast(me->getVictim(), SPELL_SUMMON_CARRION_BEETLES, true);
Channeling = false;
}
else if (CarrionBeetlesTimer <= diff)
{
Channeling = true;
DoCastVictim(SPELL_CARRION_BEETLES);
CarrionBeetlesTimer = 25*IN_MILLISECONDS;
} else CarrionBeetlesTimer -= diff;
if (LeechingSwarmTimer <= diff)
{
DoCast(me, SPELL_LEECHING_SWARM, true);
LeechingSwarmTimer = 19*IN_MILLISECONDS;
} else LeechingSwarmTimer -= diff;
if (PoundTimer <= diff)
{
if (Unit* target = me->getVictim())
{
if (Creature* pImpaleTarget = DoSummonImpaleTarget(target))
me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_POUND, SPELL_POUND_H), false);
}
PoundTimer = 16500;
} else PoundTimer -= diff;
DoMeleeAttackIfReady();
break;
}
}
