void boss_attumen::boss_attumenAI::UpdateAI(uint32 diff)
{
if (ResetTimer)
{
if (ResetTimer <= diff)
{
ResetTimer = 0;
Unit* pMidnight = ObjectAccessor::GetUnit(*me, Midnight);
if (pMidnight)
{
pMidnight->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
pMidnight->SetVisible(true);
}
Midnight.Clear();
me->SetVisible(false);
me->KillSelf();
} else ResetTimer -= diff;
}
//Return since we have no target
if (!UpdateVictim())
return;
if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE))
return;
if (CleaveTimer <= diff)
{
DoCastVictim(SPELL_SHADOWCLEAVE);
CleaveTimer = urand(10000, 15000);
} else CleaveTimer -= diff;
if (CurseTimer <= diff)
{
DoCastVictim(SPELL_INTANGIBLE_PRESENCE);
CurseTimer = 30000;
} else CurseTimer -= diff;
if (RandomYellTimer <= diff)
{
Talk(SAY_RANDOM);
RandomYellTimer = urand(30000, 60000);
} else RandomYellTimer -= diff;
if (me->GetUInt32Value(UNIT_FIELD_DISPLAYID) == MOUNTED_DISPLAYID)
{
if (ChargeTimer <= diff)
{
Unit* target = NULL;
ThreatContainer::StorageType const &t_list = me->getThreatManager().getThreatList();
std::vector<Unit*> target_list;
for (ThreatContainer::StorageType::const_iterator itr = t_list.begin(); itr != t_list.end(); ++itr)
{
target = ObjectAccessor::GetUnit(*me, (*itr)->getUnitGuid());
if (target && !target->IsWithinDist(me, ATTACK_DISTANCE, false))
target_list.push_back(target);
target = NULL;
}
if (!target_list.empty())
target = *(target_list.begin() + rand32() % target_list.size());
DoCast(target, SPELL_BERSERKER_CHARGE);
ChargeTimer = 20000;
} else ChargeTimer -= diff;
}
else
{
if (HealthBelowPct(25))
{
Creature* pMidnight = ObjectAccessor::GetCreature(*me, Midnight);
if (pMidnight && pMidnight->GetTypeId() == TYPEID_UNIT)
{
ENSURE_AI(boss_midnight::boss_midnightAI, (pMidnight->AI()))->Mount(me);
me->SetHealth(pMidnight->GetHealth());
DoResetThreat();
}
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_INHALE_BLIGHT:
{
RemoveBlight();
if (_inhaleCounter == 3)
{
Talk(EMOTE_WARN_PUNGENT_BLIGHT);
Talk(SAY_PUNGENT_BLIGHT);
DoCast(me, SPELL_PUNGENT_BLIGHT);
_inhaleCounter = 0;
if (Creature* professor = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_PROFESSOR_PUTRICIDE)))
professor->AI()->DoAction(ACTION_FESTERGUT_GAS);
events.RescheduleEvent(EVENT_GAS_SPORE, urand(20000, 25000));
}
else
{
DoCast(me, SPELL_INHALE_BLIGHT);
// just cast and dont bother with target, conditions will handle it
++_inhaleCounter;
if (_inhaleCounter < 3)
me->CastSpell(me, gaseousBlight[_inhaleCounter], true, NULL, NULL, me->GetGUID());
}
events.ScheduleEvent(EVENT_INHALE_BLIGHT, urand(33500, 35000));
break;
}
case EVENT_VILE_GAS:
{
std::list<Unit*> targets;
uint32 minTargets = RAID_MODE<uint32>(3, 8, 3, 8);
SelectTargetList(targets, minTargets, SELECT_TARGET_RANDOM, -5.0f, true);
float minDist = 0.0f;
if (targets.size() >= minTargets)
minDist = -5.0f;
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, minDist, true))
DoCast(target, SPELL_VILE_GAS);
events.ScheduleEvent(EVENT_VILE_GAS, urand(28000, 35000));
break;
}
case EVENT_GAS_SPORE:
Talk(EMOTE_WARN_GAS_SPORE);
Talk(EMOTE_GAS_SPORE);
me->CastCustomSpell(SPELL_GAS_SPORE, SPELLVALUE_MAX_TARGETS, RAID_MODE<int32>(2, 3, 2, 3), me);
events.ScheduleEvent(EVENT_GAS_SPORE, urand(40000, 45000));
events.RescheduleEvent(EVENT_VILE_GAS, urand(28000, 35000));
break;
case EVENT_GASTRIC_BLOAT:
DoCastVictim(SPELL_GASTRIC_BLOAT);
events.ScheduleEvent(EVENT_GASTRIC_BLOAT, urand(15000, 17500));
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK2);
Talk(SAY_BERSERK);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
// I have a feeling this isn't blizzlike, but owell, I'm only passing by and cleaning up.
if (!_hasAura)
{
for (uint8 i = 0; i < MAX_SPELL_PAIRS; ++i)
if (_auraPairs[i].npcEntry == me->GetEntry())
DoCast(me, _auraPairs[i].spellId);
_hasAura = true;
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CHARGE_TARGET:
DoCastVictim(SPELL_CHARGE);
events.ScheduleEvent(EVENT_CHARGE, urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS));
break;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, urand(10 * IN_MILLISECONDS, 16 * IN_MILLISECONDS));
break;
case EVENT_DEMORALIZING_SHOUT:
DoCast(me, SPELL_DEMORALIZING_SHOUT);
events.ScheduleEvent(EVENT_DEMORALIZING_SHOUT, urand(10 * IN_MILLISECONDS, 15 * IN_MILLISECONDS));
break;
case EVENT_WHIRLWIND:
DoCast(me, SPELL_WHIRLWIND);
events.ScheduleEvent(EVENT_WHIRLWIND, urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS));
break;
case EVENT_ENRAGE:
DoCast(me, SPELL_ENRAGE);
events.ScheduleEvent(EVENT_ENRAGE, urand(10 * IN_MILLISECONDS, 30 * IN_MILLISECONDS));
break;
case EVENT_CHECK_RESET:
{
Position const& _homePosition = me->GetHomePosition();
if (me->GetDistance2d(_homePosition.GetPositionX(), _homePosition.GetPositionY()) > 50.0f)
{
EnterEvadeMode();
return;
}
events.ScheduleEvent(EVENT_CHECK_RESET, 5000);
break;
}
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
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_SHIMMER:
{
// Remove old vulnerabilty spell
if (CurrentVurln_Spell)
me->RemoveAurasDueToSpell(CurrentVurln_Spell);
// Cast new random vulnerabilty on self
uint32 spell = RAND(SPELL_FIRE_VULNERABILITY, SPELL_FROST_VULNERABILITY, SPELL_SHADOW_VULNERABILITY, SPELL_NATURE_VULNERABILITY, SPELL_ARCANE_VULNERABILITY);
DoCast(me, spell);
CurrentVurln_Spell = spell;
Talk(EMOTE_SHIMMER);
events.ScheduleEvent(EVENT_SHIMMER, 45000);
break;
}
case EVENT_BREATH_1:
DoCastVictim(Breath1_Spell);
events.ScheduleEvent(EVENT_BREATH_1, 60000);
break;
case EVENT_BREATH_2:
DoCastVictim(Breath2_Spell);
events.ScheduleEvent(EVENT_BREATH_2, 60000);
break;
case EVENT_AFFLICTION:
{
Map::PlayerList const &players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
if (Player* player = itr->GetSource()->ToPlayer())
{
DoCast(player, RAND(SPELL_BROODAF_BLUE, SPELL_BROODAF_BLACK, SPELL_BROODAF_RED, SPELL_BROODAF_BRONZE, SPELL_BROODAF_GREEN), true);
if (player->HasAura(SPELL_BROODAF_BLUE) &&
player->HasAura(SPELL_BROODAF_BLACK) &&
player->HasAura(SPELL_BROODAF_RED) &&
player->HasAura(SPELL_BROODAF_BRONZE) &&
player->HasAura(SPELL_BROODAF_GREEN))
{
DoCast(player, SPELL_CHROMATIC_MUT_1);
}
}
}
}
events.ScheduleEvent(EVENT_AFFLICTION, 10000);
break;
case EVENT_FRENZY:
DoCast(me, SPELL_FRENZY);
events.ScheduleEvent(EVENT_FRENZY, urand(10000, 15000));
break;
}
}
// Enrage if not already enraged and below 20%
if (!Enraged && HealthBelowPct(20))
{
DoCast(me, SPELL_ENRAGE);
Enraged = true;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (!_phase)
return;
events.Update(diff);
if ((_phase != PHASE_BIRTH && !UpdateVictim()) || !CheckInRoom())
return;
if (_canTheHundredClub)
{
if (_checkFrostResistTimer <= diff)
{
CheckPlayersFrostResist();
_checkFrostResistTimer = 5 * IN_MILLISECONDS;
}
else
_checkFrostResistTimer -= diff;
}
if (_phase == PHASE_GROUND)
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
Talk(EMOTE_ENRAGE);
DoCast(me, SPELL_BERSERK);
return;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, urand(5, 15) * IN_MILLISECONDS, 0, PHASE_GROUND);
return;
case EVENT_TAIL:
DoCastAOE(SPELL_TAIL_SWEEP);
events.ScheduleEvent(EVENT_TAIL, urand(5, 15) * IN_MILLISECONDS, 0, PHASE_GROUND);
return;
case EVENT_DRAIN:
DoCastAOE(SPELL_LIFE_DRAIN);
events.ScheduleEvent(EVENT_DRAIN, 24 * IN_MILLISECONDS, 0, PHASE_GROUND);
return;
case EVENT_BLIZZARD:
{
//DoCastAOE(SPELL_SUMMON_BLIZZARD);
if (Creature* summon = DoSummon(NPC_BLIZZARD, me, 0.0f, urand(25, 30) * IN_MILLISECONDS, TEMPSUMMON_TIMED_DESPAWN))
summon->GetMotionMaster()->MoveRandom(40);
events.ScheduleEvent(EVENT_BLIZZARD, RAID_MODE(20, 7) * IN_MILLISECONDS, 0, PHASE_GROUND);
break;
}
case EVENT_FLIGHT:
if (HealthAbovePct(10))
{
_phase = PHASE_FLIGHT;
events.SetPhase(PHASE_FLIGHT);
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
float x, y, z, o;
me->GetHomePosition(x, y, z, o);
me->GetMotionMaster()->MovePoint(1, x, y, z);
return;
}
break;
}
}
DoMeleeAttackIfReady();
}
else
{
if (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_LIFTOFF:
Talk(EMOTE_AIR_PHASE);
me->SetDisableGravity(true);
me->SendMovementFlagUpdate();
events.ScheduleEvent(EVENT_ICEBOLT, 1500);
_iceboltCount = RAID_MODE(2, 3);
return;
case EVENT_ICEBOLT:
{
std::vector<Unit*> targets;
std::list<HostileReference*>::const_iterator i = me->getThreatManager().getThreatList().begin();
for (; i != me->getThreatManager().getThreatList().end(); ++i)
if ((*i)->getTarget()->GetTypeId() == TYPEID_PLAYER && !(*i)->getTarget()->HasAura(SPELL_ICEBOLT))
targets.push_back((*i)->getTarget());
if (targets.empty())
_iceboltCount = 0;
else
{
std::vector<Unit*>::const_iterator itr = targets.begin();
advance(itr, rand()%targets.size());
_iceblocks.insert(std::make_pair((*itr)->GetGUID(), 0));
DoCast(*itr, SPELL_ICEBOLT);
--_iceboltCount;
}
if (_iceboltCount)
events.ScheduleEvent(EVENT_ICEBOLT, 1 * IN_MILLISECONDS);
else
events.ScheduleEvent(EVENT_BREATH, 1 * IN_MILLISECONDS);
return;
}
case EVENT_BREATH:
{
Talk(EMOTE_BREATH);
DoCastAOE(SPELL_FROST_MISSILE);
events.ScheduleEvent(EVENT_EXPLOSION, 8 * IN_MILLISECONDS);
return;
}
case EVENT_EXPLOSION:
CastExplosion();
ClearIceBlock();
events.ScheduleEvent(EVENT_LAND, 3 * IN_MILLISECONDS);
return;
case EVENT_LAND:
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
Talk(EMOTE_GROUND_PHASE);
me->SetDisableGravity(false);
me->SendMovementFlagUpdate();
events.ScheduleEvent(EVENT_GROUND, 1500);
return;
case EVENT_GROUND:
EnterPhaseGround();
return;
case EVENT_BIRTH:
me->SetVisible(true);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
return;
}
}
}
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (uiPhaseTimer <= diff)
{
switch (Phase)
{
case CASTING_FLAME_SPHERES:
{
Creature* pSpheres[3];
//DoCast(me, SPELL_FLAME_SPHERE_SUMMON_1);
pSpheres[0] = DoSpawnCreature(CREATURE_FLAME_SPHERE, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
Unit* pSphereTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
if (pSphereTarget && pSpheres[0])
{
float angle, x, y;
angle = pSpheres[0]->GetAngle(pSphereTarget);
x = pSpheres[0]->GetPositionX() + DATA_SPHERE_DISTANCE * cos(angle);
y = pSpheres[0]->GetPositionY() + DATA_SPHERE_DISTANCE * sin(angle);
pSpheres[0]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[0]->GetPositionZ());
}
if (IsHeroic())
{
//DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_1);
pSpheres[1] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_1, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
//DoCast(me, H_SPELL_FLAME_SPHERE_SUMMON_2);
pSpheres[2] = DoSpawnCreature(H_CREATURE_FLAME_SPHERE_2, 0, 0, 5, 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 10*IN_MILLISECONDS);
if (pSphereTarget && pSpheres[1] && pSpheres[2])
{
float angle, x, y;
angle = pSpheres[1]->GetAngle(pSphereTarget) + DATA_SPHERE_ANGLE_OFFSET;
x = pSpheres[1]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
y = pSpheres[1]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
pSpheres[1]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[1]->GetPositionZ());
angle = pSpheres[2]->GetAngle(pSphereTarget) - DATA_SPHERE_ANGLE_OFFSET;
x = pSpheres[2]->GetPositionX() + DATA_SPHERE_DISTANCE/2 * cos(angle);
y = pSpheres[2]->GetPositionY() + DATA_SPHERE_DISTANCE/2 * sin(angle);
pSpheres[2]->GetMotionMaster()->MovePoint(0, x, y, pSpheres[2]->GetPositionZ());
}
}
Phase = NORMAL;
uiPhaseTimer = 0;
break;
}
case JUST_VANISHED:
if (Unit* pEmbraceTarget = GetEmbraceTarget())
{
me->GetMotionMaster()->Clear();
me->SetSpeed(MOVE_WALK, 2.0f, true);
me->GetMotionMaster()->MoveChase(pEmbraceTarget);
}
Phase = VANISHED;
uiPhaseTimer = 1300;
break;
case VANISHED:
if (Unit* pEmbraceTarget = GetEmbraceTarget())
DoCast(pEmbraceTarget, DUNGEON_MODE(SPELL_EMBRACE_OF_THE_VAMPYR, H_SPELL_EMBRACE_OF_THE_VAMPYR));
Talk(SAY_FEED);
me->GetMotionMaster()->Clear();
me->SetSpeed(MOVE_WALK, 1.0f, true);
me->GetMotionMaster()->MoveChase(me->getVictim());
Phase = FEEDING;
uiPhaseTimer = 20*IN_MILLISECONDS;
break;
case FEEDING:
Phase = NORMAL;
uiPhaseTimer = 0;
uiEmbraceTarget = 0;
break;
case NORMAL:
if (uiBloodthirstTimer <= diff)
{
DoCast(me, SPELL_BLOODTHIRST);
uiBloodthirstTimer = 10*IN_MILLISECONDS;
} else uiBloodthirstTimer -= diff;
if (uiFlamesphereTimer <= diff)
{
// because TARGET_UNIT_TARGET_ENEMY we need a target selected to cast
DoCastVictim(SPELL_CONJURE_FLAME_SPHERE);
Phase = CASTING_FLAME_SPHERES;
uiPhaseTimer = 3*IN_MILLISECONDS + diff;
uiFlamesphereTimer = 15*IN_MILLISECONDS;
} else uiFlamesphereTimer -= diff;
if (uiVanishTimer <= diff)
{
//Count alive players
Unit* target = NULL;
std::list<HostileReference*> t_list = me->getThreatManager().getThreatList();
std::vector<Unit*> target_list;
for (std::list<HostileReference*>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
target = Unit::GetUnit(*me, (*itr)->getUnitGuid());
// exclude pets & totems
if (target && target->GetTypeId() == TYPEID_PLAYER && target->isAlive())
target_list.push_back(target);
target = NULL;
}
//He only vanishes if there are 3 or more alive players
if (target_list.size() > 2)
{
Talk(SAY_VANISH);
DoCast(me, SPELL_VANISH);
Phase = JUST_VANISHED;
uiPhaseTimer = 500;
if (Unit* pEmbraceTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
uiEmbraceTarget = pEmbraceTarget->GetGUID();
}
uiVanishTimer = urand(25*IN_MILLISECONDS, 35*IN_MILLISECONDS);
} else uiVanishTimer -= diff;
DoMeleeAttackIfReady();
break;
}
} else uiPhaseTimer -= diff;
}
void UpdateAI(const uint32 diff)
{
if ((!UpdateVictim() && !(events.GetPhaseMask() & PHASE_INTRO_MASK)) || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING) && !(events.GetPhaseMask() & PHASE_INTRO_MASK))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_INTRO_2:
Talk(SAY_INTRO_2);
break;
case EVENT_INTRO_3:
Talk(SAY_INTRO_3);
break;
case EVENT_INTRO_4:
Talk(SAY_INTRO_4);
break;
case EVENT_INTRO_5:
Talk(SAY_INTRO_5);
break;
case EVENT_INTRO_6:
Talk(SAY_INTRO_6);
break;
case EVENT_INTRO_7:
Talk(SAY_INTRO_7);
break;
case EVENT_INTRO_FINISH:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
break;
case EVENT_DEATH_AND_DECAY:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
DoCast(target, SPELL_DEATH_AND_DECAY);
events.ScheduleEvent(EVENT_DEATH_AND_DECAY, urand(10000, 12000));
break;
case EVENT_DOMINATE_MIND_H:
Talk(SAY_DOMINATE_MIND);
for (uint8 i = 0; i < dominateMindCount; i++)
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -SPELL_DOMINATE_MIND_H))
DoCast(target, SPELL_DOMINATE_MIND_H);
events.ScheduleEvent(EVENT_DOMINATE_MIND_H, urand(40000, 45000));
break;
case EVENT_P1_SUMMON_WAVE:
SummonWaveP1();
events.ScheduleEvent(EVENT_P1_SUMMON_WAVE, 60000, 0, PHASE_ONE);
break;
case EVENT_P1_SHADOW_BOLT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
DoCast(target, SPELL_SHADOW_BOLT);
events.ScheduleEvent(EVENT_P1_SHADOW_BOLT, urand(5000, 8000), 0, PHASE_ONE);
break;
case EVENT_P1_REANIMATE_CULTIST:
ReanimateCultist();
break;
case EVENT_P1_EMPOWER_CULTIST:
EmpowerCultist();
events.ScheduleEvent(EVENT_P1_EMPOWER_CULTIST, urand(18000, 25000));
break;
case EVENT_P2_FROSTBOLT:
DoCastVictim(SPELL_FROSTBOLT);
events.ScheduleEvent(EVENT_P2_FROSTBOLT, urand(10000, 11000), 0, PHASE_TWO);
break;
case EVENT_P2_FROSTBOLT_VOLLEY:
DoCastAOE(SPELL_FROSTBOLT_VOLLEY);
events.ScheduleEvent(EVENT_P2_FROSTBOLT_VOLLEY, urand(13000, 15000), 0, PHASE_TWO);
break;
case EVENT_P2_TOUCH_OF_INSIGNIFICANCE:
DoCastVictim(SPELL_TOUCH_OF_INSIGNIFICANCE);
events.ScheduleEvent(EVENT_P2_TOUCH_OF_INSIGNIFICANCE, urand(9000, 13000), 0, PHASE_TWO);
break;
case EVENT_P2_SUMMON_SHADE:
if (Unit* shadeTarget = SelectTarget(SELECT_TARGET_RANDOM, 1))
{
nextVengefulShadeTarget = shadeTarget->GetGUID();
DoCast(shadeTarget, SPELL_SUMMON_SHADE);
}
events.ScheduleEvent(EVENT_P2_SUMMON_SHADE, urand(18000, 23000), 0, PHASE_TWO);
break;
case EVENT_P2_SUMMON_WAVE:
SummonWaveP2();
events.ScheduleEvent(EVENT_P2_SUMMON_WAVE, 60000, 0, PHASE_TWO);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
Talk(SAY_BERSERK);
break;
}
}
// We should not melee attack when barrier is up
if (me->HasAura(SPELL_MANA_BARRIER))
return;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FEL_FIREBALL:
DoCastVictim(SPELL_FEL_FIREBALL);
events.ScheduleEvent(EVENT_FEL_FIREBALL, urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS));
return;
case EVENT_FEL_LIGHTNING:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true, -SPELL_LORD_HITTIN))
DoCast(target, SPELL_FEL_LIGHTING);
events.ScheduleEvent(EVENT_FEL_LIGHTNING, urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS));
return;
case EVENT_INCINERATE_FLESH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -SPELL_LORD_HITTIN))
{
Talk(EMOTE_INCINERATE, target->GetGUID());
Talk(SAY_INCINERATE);
DoCast(target, SPELL_INCINERATE_FLESH);
}
events.ScheduleEvent(EVENT_INCINERATE_FLESH, urand(20*IN_MILLISECONDS, 25*IN_MILLISECONDS));
return;
case EVENT_NETHER_POWER:
me->CastCustomSpell(SPELL_NETHER_POWER, SPELLVALUE_AURA_STACK, RAID_MODE<uint32>(5, 10, 5,10), me, true);
events.ScheduleEvent(EVENT_NETHER_POWER, 40*IN_MILLISECONDS);
return;
case EVENT_LEGION_FLAME:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -SPELL_LORD_HITTIN))
{
Talk(EMOTE_LEGION_FLAME, target->GetGUID());
DoCast(target, SPELL_LEGION_FLAME);
}
events.ScheduleEvent(EVENT_LEGION_FLAME, 30*IN_MILLISECONDS);
return;
case EVENT_SUMMONO_NETHER_PORTAL:
Talk(EMOTE_NETHER_PORTAL);
Talk(SAY_MISTRESS_OF_PAIN);
DoCast(SPELL_NETHER_PORTAL);
events.ScheduleEvent(EVENT_SUMMONO_NETHER_PORTAL, 2*MINUTE*IN_MILLISECONDS);
return;
case EVENT_SUMMON_INFERNAL_ERUPTION:
Talk(EMOTE_INFERNAL_ERUPTION);
Talk(SAY_INFERNAL_ERUPTION);
DoCast(SPELL_INFERNAL_ERUPTION);
events.ScheduleEvent(EVENT_SUMMON_INFERNAL_ERUPTION, 2*MINUTE*IN_MILLISECONDS);
return;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() && !(events.GetPhaseMask() & (1 << PHASE_INTRO)))
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_INTRO_1:
//DoScriptText(SAY_GORKUN_INTRO_2, pGorkunOrVictus);
break;
case EVENT_INTRO_2:
DoScriptText(SAY_TYRANNUS_INTRO_3, me);
break;
case EVENT_INTRO_3:
me->ExitVehicle();
me->GetMotionMaster()->MovePoint(0, miscPos);
break;
case EVENT_COMBAT_START:
if (Creature* rimefang = me->GetCreature(*me, instance->GetData64(DATA_RIMEFANG)))
rimefang->AI()->DoAction(ACTION_START_RIMEFANG); //set rimefang also infight
events.SetPhase(PHASE_COMBAT);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
DoCast(me, SPELL_FULL_HEAL);
DoZoneInCombat();
events.ScheduleEvent(EVENT_OVERLORD_BRAND, urand(5000, 7000));
events.ScheduleEvent(EVENT_FORCEFUL_SMASH, urand(14000, 16000));
events.ScheduleEvent(EVENT_MARK_OF_RIMEFANG, urand(25000, 27000));
break;
case EVENT_OVERLORD_BRAND:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
DoCast(target, SPELL_OVERLORD_BRAND);
events.ScheduleEvent(EVENT_OVERLORD_BRAND, urand(11000, 12000));
break;
case EVENT_FORCEFUL_SMASH:
DoCastVictim(SPELL_FORCEFUL_SMASH);
events.ScheduleEvent(EVENT_UNHOLY_POWER, 1000);
break;
case EVENT_UNHOLY_POWER:
DoScriptText(SAY_DARK_MIGHT_1, me);
DoScriptText(SAY_DARK_MIGHT_2, me);
DoCast(me, SPELL_UNHOLY_POWER);
events.ScheduleEvent(EVENT_FORCEFUL_SMASH, urand(40000, 48000));
break;
case EVENT_MARK_OF_RIMEFANG:
DoScriptText(SAY_MARK_RIMEFANG_1, me);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
{
DoScriptText(SAY_MARK_RIMEFANG_2, me, target);
DoCast(target, SPELL_MARK_OF_RIMEFANG);
}
events.ScheduleEvent(EVENT_MARK_OF_RIMEFANG, urand(24000, 26000));
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
{
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_PATH_2:
me->GetMotionMaster()->MovePath(NEFARIUS_PATH_2, false);
events.ScheduleEvent(EVENT_CHAOS_1, 7000);
break;
case EVENT_CHAOS_1:
if (Creature* gyth = me->FindNearestCreature(NPC_GYTH, 75.0f, true))
{
me->SetFacingToObject(gyth);
Talk(SAY_CHAOS_SPELL);
}
events.ScheduleEvent(EVENT_CHAOS_2, 2000);
break;
case EVENT_CHAOS_2:
DoCast(SPELL_CHROMATIC_CHAOS);
me->SetFacingTo(1.570796f);
break;
case EVENT_SUCCESS_1:
if (Unit* player = me->SelectNearestPlayer(60.0f))
{
me->SetFacingToObject(player);
Talk(SAY_SUCCESS);
if (GameObject* portcullis1 = me->FindNearestGameObject(GO_PORTCULLIS_ACTIVE, 65.0f))
portcullis1->SetGoState(GO_STATE_ACTIVE);
if (GameObject* portcullis2 = me->FindNearestGameObject(GO_PORTCULLIS_TOBOSSROOMS, 80.0f))
portcullis2->SetGoState(GO_STATE_ACTIVE);
}
events.ScheduleEvent(EVENT_SUCCESS_2, 4000);
break;
case EVENT_SUCCESS_2:
DoCast(me, SPELL_VAELASTRASZZ_SPAWN);
me->DespawnOrUnsummon(1000);
break;
case EVENT_PATH_3:
me->GetMotionMaster()->MovePath(NEFARIUS_PATH_3, false);
break;
default:
break;
}
}
return;
}
// Only do this if we haven't spawned nefarian yet
if (UpdateVictim() && SpawnedAdds <= 42)
{
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHADOW_BOLT:
switch (urand(0, 1))
{
case 0:
DoCastVictim(SPELL_SHADOWBOLT_VOLLEY);
break;
case 1:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 40, true))
DoCast(target, SPELL_SHADOWBOLT);
break;
}
DoResetThreat();
events.ScheduleEvent(EVENT_SHADOW_BOLT, urand(3000, 10000));
break;
case EVENT_FEAR:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 40, true))
DoCast(target, SPELL_FEAR);
events.ScheduleEvent(EVENT_FEAR, urand(10000, 20000));
break;
case EVENT_MIND_CONTROL:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 40, true))
DoCast(target, SPELL_SHADOW_COMMAND);
events.ScheduleEvent(EVENT_MIND_CONTROL, urand(30000, 35000));
break;
case EVENT_SPAWN_ADD:
for (uint8 i=0; i<2; ++i)
{
uint32 CreatureID;
if (urand(0, 2) == 0)
CreatureID = NPC_CHROMATIC_DRAKANOID;
else
CreatureID = Entry[urand(0, 4)];
if (Creature* dragon = me->SummonCreature(CreatureID, DrakeSpawnLoc[i]))
{
dragon->setFaction(103);
dragon->AI()->AttackStart(me->GetVictim());
}
if (++SpawnedAdds >= 42)
{
if (Creature* nefarian = me->SummonCreature(NPC_NEFARIAN, NefarianLoc[0]))
{
nefarian->setActive(true);
nefarian->SetCanFly(true);
nefarian->SetDisableGravity(true);
nefarian->CastSpell((Unit*)NULL, SPELL_SHADOWFLAME_INITIAL);
nefarian->GetMotionMaster()->MovePoint(1, NefarianLoc[1]);
}
events.CancelEvent(EVENT_MIND_CONTROL);
events.CancelEvent(EVENT_FEAR);
events.CancelEvent(EVENT_SHADOW_BOLT);
me->SetVisible(false);
return;
}
}
events.ScheduleEvent(EVENT_SPAWN_ADD, 4000);
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
}
}
void UpdateAI(uint32 diff) override
{
if (canDespawn && DespawnTimer <= diff)
{
instance->SetBossState(DATA_NEFARIAN, FAIL);
std::list<Creature*> constructList;
me->GetCreatureListWithEntryInGrid(constructList, NPC_BONE_CONSTRUCT, 500.0f);
for (std::list<Creature*>::const_iterator itr = constructList.begin(); itr != constructList.end(); ++itr)
(*itr)->DespawnOrUnsummon();
} else DespawnTimer -= diff;
if (!UpdateVictim())
return;
if (canDespawn)
canDespawn = false;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHADOWFLAME:
DoCastVictim(SPELL_SHADOWFLAME);
events.ScheduleEvent(EVENT_SHADOWFLAME, 12000);
break;
case EVENT_FEAR:
DoCastVictim(SPELL_BELLOWINGROAR);
events.ScheduleEvent(EVENT_FEAR, urand(25000, 35000));
break;
case EVENT_VEILOFSHADOW:
DoCastVictim(SPELL_VEILOFSHADOW);
events.ScheduleEvent(EVENT_VEILOFSHADOW, urand(25000, 35000));
break;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, 7000);
break;
case EVENT_TAILLASH:
// Cast NYI since we need a better check for behind target
DoCastVictim(SPELL_TAILLASH);
events.ScheduleEvent(EVENT_TAILLASH, 10000);
break;
case EVENT_CLASSCALL:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
switch (target->getClass())
{
case CLASS_MAGE:
Talk(SAY_MAGE);
DoCast(me, SPELL_MAGE);
break;
case CLASS_WARRIOR:
Talk(SAY_WARRIOR);
DoCast(me, SPELL_WARRIOR);
break;
case CLASS_DRUID:
Talk(SAY_DRUID);
DoCast(target, SPELL_DRUID);
break;
case CLASS_PRIEST:
Talk(SAY_PRIEST);
DoCast(me, SPELL_PRIEST);
break;
case CLASS_PALADIN:
Talk(SAY_PALADIN);
DoCast(me, SPELL_PALADIN);
break;
case CLASS_SHAMAN:
Talk(SAY_SHAMAN);
DoCast(me, SPELL_SHAMAN);
break;
case CLASS_WARLOCK:
Talk(SAY_WARLOCK);
DoCast(me, SPELL_WARLOCK);
break;
case CLASS_HUNTER:
Talk(SAY_HUNTER);
DoCast(me, SPELL_HUNTER);
break;
case CLASS_ROGUE:
Talk(SAY_ROGUE);
DoCast(me, SPELL_ROGUE);
break;
case CLASS_DEATH_KNIGHT:
Talk(SAY_DEATH_KNIGHT);
DoCast(me, SPELL_DEATH_KNIGHT);
break;
default:
break;
}
events.ScheduleEvent(EVENT_CLASSCALL, urand(30000, 35000));
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
// Phase3 begins when health below 20 pct
if (!Phase3 && HealthBelowPct(20))
{
std::list<Creature*> constructList;
me->GetCreatureListWithEntryInGrid(constructList, NPC_BONE_CONSTRUCT, 500.0f);
for (std::list<Creature*>::const_iterator itr = constructList.begin(); itr != constructList.end(); ++itr)
if ((*itr) && !(*itr)->IsAlive())
{
(*itr)->Respawn();
(*itr)->SetInCombatWithZone();
(*itr)->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
(*itr)->SetReactState(REACT_AGGRESSIVE);
(*itr)->SetStandState(UNIT_STAND_STATE_STAND);
}
Phase3 = true;
Talk(SAY_RAISE_SKELETONS);
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
{
if (phase == PHASE_FLIGHT && !me->IsInEvadeMode())
EnterEvadeMode();
return;
}
events.Update(diff);
if (me->IsNonMeleeSpellCast(false))
return;
if (phase == PHASE_GROUND)
{
switch (events.ExecuteEvent())
{
case EVENT_BERSERK:
Talk(YELL_BERSERK);
DoCast(me, SPELL_BERSERK, true);
events.ScheduleEvent(EVENT_BERSERK, 10000);
break;
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE, false);
events.ScheduleEvent(EVENT_CLEAVE, urand(5000, 10000));
break;
case EVENT_CORROSION:
DoCastVictim(SPELL_CORROSION, false);
events.ScheduleEvent(EVENT_CORROSION, urand(20000, 30000));
break;
case EVENT_GAS_NOVA:
DoCast(me, SPELL_GAS_NOVA, false);
events.ScheduleEvent(EVENT_GAS_NOVA, urand(20000, 25000));
break;
case EVENT_ENCAPSULATE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true))
DoCast(target, SPELL_ENCAPSULATE_CHANNEL, false);
events.ScheduleEvent(EVENT_ENCAPSULATE, urand(25000, 30000));
break;
case EVENT_FLIGHT:
EnterPhase(PHASE_FLIGHT);
break;
default:
DoMeleeAttackIfReady();
break;
}
}
if (phase == PHASE_FLIGHT)
{
switch (events.ExecuteEvent())
{
case EVENT_BERSERK:
Talk(YELL_BERSERK);
DoCast(me, SPELL_BERSERK, true);
break;
case EVENT_FLIGHT_SEQUENCE:
HandleFlightSequence();
break;
case EVENT_SUMMON_FOG:
{
float x, y, z;
me->GetPosition(x, y, z);
me->UpdateGroundPositionZ(x, y, z);
if (Creature* Fog = me->SummonCreature(NPC_VAPOR_TRAIL, x, y, z, 0, TEMPSUMMON_TIMED_DESPAWN, 10000))
{
Fog->RemoveAurasDueToSpell(SPELL_TRAIL_TRIGGER);
Fog->CastSpell(Fog, SPELL_FOG_TRIGGER, true);
me->CastSpell(Fog, SPELL_FOG_FORCE, true);
}
}
events.ScheduleEvent(EVENT_SUMMON_FOG, 1000);
break;
}
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
switch (m_uiStage)
{
case 0:
if (m_uiFreezeSlashTimer <= uiDiff)
{
DoCastVictim(SPELL_FREEZE_SLASH);
m_uiFreezeSlashTimer = 15*IN_MILLISECONDS;
} else m_uiFreezeSlashTimer -= uiDiff;
if (m_uiPenetratingColdTimer <= uiDiff)
{
me->CastCustomSpell(RAID_MODE(SPELL_PENETRATING_COLD_10_N, SPELL_PENETRATING_COLD_25_N, SPELL_PENETRATING_COLD_10_H, SPELL_PENETRATING_COLD_25_H) , SPELLVALUE_MAX_TARGETS, RAID_MODE(2, 5));
m_uiPenetratingColdTimer = 20*IN_MILLISECONDS;
} else m_uiPenetratingColdTimer -= uiDiff;
if (m_uiSummonNerubianTimer <= uiDiff && (IsHeroic() || !m_bReachedPhase3))
{
me->CastCustomSpell(SPELL_SUMMON_BURROWER, SPELLVALUE_MAX_TARGETS, RAID_MODE(1, 2, 2, 4));
m_uiSummonNerubianTimer = 45*IN_MILLISECONDS;
} else m_uiSummonNerubianTimer -= uiDiff;
if (IsHeroic() && m_uiNerubianShadowStrikeTimer <= uiDiff)
{
Summons.DoAction(NPC_BURROWER, ACTION_SHADOW_STRIKE);
m_uiNerubianShadowStrikeTimer = 30*IN_MILLISECONDS;
} else m_uiNerubianShadowStrikeTimer -= uiDiff;
if (m_uiSubmergeTimer <= uiDiff && !m_bReachedPhase3 && !me->HasAura(SPELL_BERSERK))
{
m_uiStage = 1;
m_uiSubmergeTimer = 60*IN_MILLISECONDS;
} else m_uiSubmergeTimer -= uiDiff;
break;
case 1:
DoCast(me, SPELL_SUBMERGE_ANUBARAK);
DoCast(me, SPELL_CLEAR_ALL_DEBUFFS);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
DoScriptText(SAY_BURROWER, me);
m_uiScarabSummoned = 0;
m_uiSummonScarabTimer = 4*IN_MILLISECONDS;
m_uiStage = 2;
break;
case 2:
if (m_uiPursuingSpikeTimer <= uiDiff)
{
DoCast(SPELL_SPIKE_CALL);
// Just to make sure it won't happen again in this phase
m_uiPursuingSpikeTimer = 90*IN_MILLISECONDS;
} else m_uiPursuingSpikeTimer -= uiDiff;
if (m_uiSummonScarabTimer <= uiDiff)
{
/* WORKAROUND
* - The correct implementation is more likely the comment below but it needs spell knowledge
*/
std::list<uint64>::iterator i = m_vBurrowGUID.begin();
uint32 at = urand(0, m_vBurrowGUID.size()-1);
for (uint32 k = 0; k < at; k++)
++i;
if (Creature *pBurrow = Unit::GetCreature(*me, *i))
pBurrow->CastSpell(pBurrow, 66340, false);
m_uiScarabSummoned++;
m_uiSummonScarabTimer = 4*IN_MILLISECONDS;
if (m_uiScarabSummoned == 4) m_uiSummonScarabTimer = RAID_MODE(4, 20)*IN_MILLISECONDS;
/*It seems that this spell have something more that needs to be taken into account
//Need more sniff info
DoCast(SPELL_SUMMON_BEATLES);
// Just to make sure it won't happen again in this phase
m_uiSummonScarabTimer = 90*IN_MILLISECONDS;*/
} else m_uiSummonScarabTimer -= uiDiff;
if (m_uiSubmergeTimer <= uiDiff)
{
m_uiStage = 3;
m_uiSubmergeTimer = 80*IN_MILLISECONDS;
} else m_uiSubmergeTimer -= uiDiff;
break;
case 3:
m_uiStage = 0;
DoCast(SPELL_SPIKE_TELE);
Summons.DespawnEntry(NPC_SPIKE);
me->RemoveAurasDueToSpell(SPELL_SUBMERGE_ANUBARAK);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
DoCast(me, SPELL_EMERGE_ANUBARAK);
me->GetMotionMaster()->MoveChase(me->getVictim());
m_uiSummonNerubianTimer = 10*IN_MILLISECONDS;
m_uiNerubianShadowStrikeTimer = 30*IN_MILLISECONDS;
m_uiSummonScarabTimer = 2*IN_MILLISECONDS;
break;
}
if (!IsHeroic())
{
if (m_uiSummonFrostSphereTimer <= uiDiff)
{
uint8 startAt = urand(0, 5);
uint8 i = startAt;
do
{
if (Unit *pSphere = Unit::GetCreature(*me, m_aSphereGUID[i]))
{
if (!pSphere->HasAura(SPELL_FROST_SPHERE))
{
if (Creature *pSummon = me->SummonCreature(NPC_FROST_SPHERE, SphereSpawn[i]))
m_aSphereGUID[i] = pSummon->GetGUID();
break;
}
}
i = (i+1)%6;
} while (i != startAt);
m_uiSummonFrostSphereTimer = urand(20, 30)*IN_MILLISECONDS;
} else m_uiSummonFrostSphereTimer -= uiDiff;
}
if (HealthBelowPct(30) && m_uiStage == 0 && !m_bReachedPhase3)
{
m_bReachedPhase3 = true;
DoCastAOE(RAID_MODE(SPELL_LEECHING_SWARM_10_N, SPELL_LEECHING_SWARM_25_N, SPELL_LEECHING_SWARM_10_H, SPELL_LEECHING_SWARM_25_H));
DoScriptText(EMOTE_LEECHING_SWARM, me);
DoScriptText(SAY_LEECHING_SWARM, me);
}
if (m_uiBerserkTimer <= uiDiff && !me->HasAura(SPELL_BERSERK))
{
DoCast(me, SPELL_BERSERK);
} else m_uiBerserkTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
switch (uiPhase)
{
case PHASE_UNDERGROUND:
if (uiImpaleTimer <= diff)
{
switch(uiImpalePhase)
{
case IMPALE_PHASE_TARGET:
if (Unit *target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
if (Creature *pImpaleTarget = DoSummonImpaleTarget(target))
pImpaleTarget->CastSpell(pImpaleTarget, SPELL_IMPALE_SHAKEGROUND, true);
uiImpaleTimer = 3*IN_MILLISECONDS;
uiImpalePhase = IMPALE_PHASE_ATTACK;
}
break;
case IMPALE_PHASE_ATTACK:
if (Creature* pImpaleTarget = Unit::GetCreature(*me, uiImpaleTarget))
{
pImpaleTarget->CastSpell(pImpaleTarget, SPELL_IMPALE_SPIKE, false);
pImpaleTarget->RemoveAurasDueToSpell(SPELL_IMPALE_SHAKEGROUND);
}
uiImpalePhase = IMPALE_PHASE_DMG;
uiImpaleTimer = 1*IN_MILLISECONDS;
break;
case IMPALE_PHASE_DMG:
if (Creature* pImpaleTarget = Unit::GetCreature(*me, uiImpaleTarget))
me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_IMPALE_DMG, SPELL_IMPALE_DMG_H), true);
uiImpalePhase = IMPALE_PHASE_TARGET;
uiImpaleTimer = 9*IN_MILLISECONDS;
break;
}
} else uiImpaleTimer -= diff;
if (!bGuardianSummoned)
{
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);
}
}
bGuardianSummoned = true;
}
if (!bVenomancerSummoned)
{
if (uiVenomancerTimer <= diff)
{
if (uiUndergroundPhase > 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);
}
}
bVenomancerSummoned = true;
}
} else uiVenomancerTimer -= diff;
}
if (!bDatterSummoned)
{
if (uiDatterTimer <= diff)
{
if (uiUndergroundPhase > 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);
}
}
bDatterSummoned = true;
}
} else uiDatterTimer -= diff;
}
if (uiUndergroundTimer <= diff)
{
me->RemoveAura(SPELL_SUBMERGE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
uiPhase = PHASE_MELEE;
} else uiUndergroundTimer -= diff;
break;
case PHASE_MELEE:
if (((uiUndergroundPhase == 0 && HealthBelowPct(75))
|| (uiUndergroundPhase == 1 && HealthBelowPct(50))
|| (uiUndergroundPhase == 2 && HealthBelowPct(25)))
&& !me->HasUnitState(UNIT_STAT_CASTING))
{
bGuardianSummoned = false;
bVenomancerSummoned = false;
bDatterSummoned = false;
uiUndergroundTimer = 40*IN_MILLISECONDS;
uiVenomancerTimer = 25*IN_MILLISECONDS;
uiDatterTimer = 32*IN_MILLISECONDS;
uiImpalePhase = 0;
uiImpaleTimer = 9*IN_MILLISECONDS;
DoCast(me, SPELL_SUBMERGE, false);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
uiPhase = PHASE_UNDERGROUND;
++uiUndergroundPhase;
}
if (bChanneling == true)
{
for (uint8 i = 0; i < 8; ++i)
DoCast(me->getVictim(), SPELL_SUMMON_CARRION_BEETLES, true);
bChanneling = false;
}
else if (uiCarrionBeetlesTimer <= diff)
{
bChanneling = true;
DoCastVictim(SPELL_CARRION_BEETLES);
uiCarrionBeetlesTimer = 25*IN_MILLISECONDS;
} else uiCarrionBeetlesTimer -= diff;
if (uiLeechingSwarmTimer <= diff)
{
DoCast(me, SPELL_LEECHING_SWARM, true);
uiLeechingSwarmTimer = 19*IN_MILLISECONDS;
} else uiLeechingSwarmTimer -= diff;
if (uiPoundTimer <= diff)
{
if (Unit *target = me->getVictim())
{
if (Creature *pImpaleTarget = DoSummonImpaleTarget(target))
me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_POUND, SPELL_POUND_H), false);
}
uiPoundTimer = 16500;
} else uiPoundTimer -= diff;
DoMeleeAttackIfReady();
break;
}
}
void UpdateAI(const uint32 diff)
{
if (!beam)
{
SummonBeams();
beam=true;
}
if (!UpdateVictim())
return;
if (CorruptedForm)
{
if (MarkOfCorruptionTimer <= diff)
{
if (MarkOfCorruption_Count <= 5)
{
uint32 mark_spell = 0;
switch (MarkOfCorruption_Count)
{
case 0:
mark_spell = SPELL_MARK_OF_CORRUPTION1;
break;
case 1:
mark_spell = SPELL_MARK_OF_CORRUPTION2;
break;
case 2:
mark_spell = SPELL_MARK_OF_CORRUPTION3;
break;
case 3:
mark_spell = SPELL_MARK_OF_CORRUPTION4;
break;
case 4:
mark_spell = SPELL_MARK_OF_CORRUPTION5;
break;
case 5:
mark_spell = SPELL_MARK_OF_CORRUPTION6;
break;
}
DoCastVictim(mark_spell);
if (MarkOfCorruption_Count < 5)
++MarkOfCorruption_Count;
}
MarkOfCorruptionTimer = 15000;
}
else MarkOfCorruptionTimer -= diff;
if (VileSludgeTimer <= diff)
{
if (Unit* target = SelectTarget(TARGET_RANDOM, 0))
{
DoCast(target, SPELL_VILE_SLUDGE);
VileSludgeTimer = 15000;
}
}
else VileSludgeTimer -= diff;
if (PosCheckTimer <= diff)
{
if (me->IsWithinDist2d(HYDROSS_X, HYDROSS_Y, SWITCH_RADIUS))
{
// switch to clean form
me->SetDisplayId(MODEL_CLEAN);
CorruptedForm = false;
MarkOfHydross_Count = 0;
DoSendQuantumText(SAY_SWITCH_TO_CLEAN, me);
DoResetThreat();
SummonBeams();
// spawn 4 adds
DoSpawnCreature(NPC_PURE_SPAWN, SPAWN_X_DIFF1, SPAWN_Y_DIFF1, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoSpawnCreature(NPC_PURE_SPAWN, SPAWN_X_DIFF2, SPAWN_Y_DIFF2, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoSpawnCreature(NPC_PURE_SPAWN, SPAWN_X_DIFF3, SPAWN_Y_DIFF3, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoSpawnCreature(NPC_PURE_SPAWN, SPAWN_X_DIFF4, SPAWN_Y_DIFF4, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
me->SetMeleeDamageSchool(SPELL_SCHOOL_FROST);
me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, true);
me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, false);
}
PosCheckTimer = 2500;
}
else PosCheckTimer -=diff;
}
// clean form
else
{
if (MarkOfHydrossTimer <= diff)
{
if (MarkOfHydross_Count <= 5)
{
uint32 mark_spell = 0;
switch (MarkOfHydross_Count)
{
case 0:
mark_spell = SPELL_MARK_OF_HYDROSS1;
break;
case 1:
mark_spell = SPELL_MARK_OF_HYDROSS2;
break;
case 2:
mark_spell = SPELL_MARK_OF_HYDROSS3;
break;
case 3:
mark_spell = SPELL_MARK_OF_HYDROSS4;
break;
case 4:
mark_spell = SPELL_MARK_OF_HYDROSS5;
break;
case 5:
mark_spell = SPELL_MARK_OF_HYDROSS6;
break;
}
DoCastVictim(mark_spell);
if (MarkOfHydross_Count < 5)
++MarkOfHydross_Count;
}
MarkOfHydrossTimer = 15000;
}
else MarkOfHydrossTimer -= diff;
if (WaterTombTimer <= diff)
{
if (Unit* target = SelectTarget(TARGET_RANDOM, 0, 100, true))
{
DoCast(target, SPELL_WATER_TOMB);
WaterTombTimer = 7000;
}
}
else WaterTombTimer -= diff;
if (PosCheckTimer <= diff)
{
if (!me->IsWithinDist2d(HYDROSS_X, HYDROSS_Y, SWITCH_RADIUS))
{
me->SetDisplayId(MODEL_CORRUPT);
MarkOfCorruption_Count = 0;
CorruptedForm = true;
DoSendQuantumText(SAY_SWITCH_TO_CORRUPT, me);
DoResetThreat();
DeSummonBeams();
// spawn 4 adds
DoSpawnCreature(NPC_TAINTED_SPAWN, SPAWN_X_DIFF1, SPAWN_Y_DIFF1, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoSpawnCreature(NPC_TAINTED_SPAWN, SPAWN_X_DIFF2, SPAWN_Y_DIFF2, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoSpawnCreature(NPC_TAINTED_SPAWN, SPAWN_X_DIFF3, SPAWN_Y_DIFF3, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
DoSpawnCreature(NPC_TAINTED_SPAWN, SPAWN_X_DIFF4, SPAWN_Y_DIFF4, 3, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
me->SetMeleeDamageSchool(SPELL_SCHOOL_NATURE);
me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, true);
me->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, false);
}
PosCheckTimer = 2500;
}
else PosCheckTimer -=diff;
}
if (EnrageTimer <= diff)
{
DoCast(me, SPELL_ENRAGE);
EnrageTimer = 60000;
}
else EnrageTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
events.Update(diff);
if (!UpdateVictim())
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case INTRO_1:
me->GetMotionMaster()->MovePath(KIRTONOS_PATH, false);
break;
case INTRO_2:
me->GetMotionMaster()->MovePoint(0, PosMove[0]);
events.ScheduleEvent(INTRO_3, 1000);
break;
case INTRO_3:
if (GameObject* gate = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_READY);
me->SetFacingTo(0.01745329f);
events.ScheduleEvent(INTRO_4, 3000);
break;
case INTRO_4:
if (GameObject* brazier = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(GO_BRAZIER_OF_THE_HERALD)))
brazier->SetGoState(GO_STATE_READY);
me->SetWalk(true);
me->SetDisableGravity(false);
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetCanFly(false);
events.ScheduleEvent(INTRO_5, 1000);
break;
case INTRO_5:
me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(WEAPON_KIRTONOS_STAFF));
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
me->SetReactState(REACT_AGGRESSIVE);
events.ScheduleEvent(INTRO_6, 5000);
break;
case INTRO_6:
me->GetMotionMaster()->MovePoint(0, PosMove[1]);
break;
default:
break;
}
}
return;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SWOOP:
DoCast(me, SPELL_SWOOP);
events.ScheduleEvent(EVENT_SWOOP, 15s);
break;
case EVENT_WING_FLAP:
DoCast(me, SPELL_WING_FLAP);
events.ScheduleEvent(EVENT_WING_FLAP, 13s);
break;
case EVENT_PIERCE_ARMOR:
DoCastVictim(SPELL_PIERCE_ARMOR, true);
events.ScheduleEvent(EVENT_PIERCE_ARMOR, 12s);
break;
case EVENT_DISARM:
DoCastVictim(SPELL_DISARM, true);
events.ScheduleEvent(EVENT_DISARM, 11s);
break;
case EVENT_SHADOW_BOLT:
DoCastVictim(SPELL_SHADOW_BOLT, true);
events.ScheduleEvent(EVENT_SHADOW_BOLT, 42s);
break;
case EVENT_CURSE_OF_TONGUES:
DoCastVictim(SPELL_CURSE_OF_TONGUES, true);
events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 35s);
break;
case EVENT_DOMINATE_MIND:
DoCastVictim(SPELL_DOMINATE_MIND, true);
events.ScheduleEvent(EVENT_DOMINATE_MIND, 44s, 48s);
break;
case EVENT_KIRTONOS_TRANSFORM:
if (me->HasAura(SPELL_KIRTONOS_TRANSFORM))
{
me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(0));
me->SetCanFly(false);
}
else
{
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(WEAPON_KIRTONOS_STAFF));
me->SetCanFly(true);
}
events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 16s, 18s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if (_introEvent)
{
if (_introTimer <= diff)
{
switch (_introEvent)
{
case INTRO_1:
if (_currentPoint < POINT_KIRTONOS_LAND)
me->GetMotionMaster()->MovePoint(_currentPoint, kirtonosIntroWaypoint[_currentPoint]);
else
{
_introTimer = 1000;
_introEvent = INTRO_2;
}
break;
case INTRO_2:
me->SetWalk(true);
me->GetMotionMaster()->MovePoint(0, 299.4884f, 92.76137f, 105.6335f);
_introTimer = 1000;
_introEvent = INTRO_3;
break;
case INTRO_3:
if (GameObject* gate = me->GetMap()->GetGameObject(instance->GetData64(GO_GATE_KIRTONOS)))
gate->SetGoState(GO_STATE_READY);
me->SetFacingTo(0.01745329f);
_introTimer = 3000;
_introEvent = INTRO_4;
break;
case INTRO_4:
if (GameObject* brazier = me->GetMap()->GetGameObject(instance->GetData64(GO_BRAZIER_OF_THE_HERALD)))
brazier->SetGoState(GO_STATE_READY);
me->SetDisableGravity(false);
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
_introTimer = 1000;
_introEvent = INTRO_5;
break;
case INTRO_5:
me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(WEAPON_KIRTONOS_STAFF));
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
me->SetReactState(REACT_AGGRESSIVE);
_introTimer = 5000;
_introEvent = INTRO_6;
case INTRO_6:
me->GetMotionMaster()->MovePoint(0, 314.8673f, 90.3021f, 101.6459f);
_introTimer = 0;
_introEvent = 0;
break;
}
}
else
_introTimer -= diff;
}
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SWOOP:
DoCast(me, SPELL_SWOOP);
events.ScheduleEvent(EVENT_SWOOP, 15000);
break;
case EVENT_WING_FLAP:
DoCast(me, SPELL_WING_FLAP);
events.ScheduleEvent(EVENT_WING_FLAP, 13000);
break;
case EVENT_PIERCE_ARMOR:
DoCastVictim(SPELL_PIERCE_ARMOR, true);
events.ScheduleEvent(EVENT_PIERCE_ARMOR, 12000);
break;
case EVENT_DISARM:
DoCastVictim(SPELL_DISARM, true);
events.ScheduleEvent(EVENT_DISARM, 11000);
break;
case EVENT_SHADOW_BOLT:
DoCastVictim(SPELL_SHADOW_BOLT, true);
events.ScheduleEvent(EVENT_SHADOW_BOLT, 42000);
break;
case EVENT_CURSE_OF_TONGUES:
DoCastVictim(SPELL_CURSE_OF_TONGUES, true);
events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 35000);
break;
case EVENT_DOMINATE_MIND:
DoCastVictim(SPELL_DOMINATE_MIND, true);
events.ScheduleEvent(EVENT_DOMINATE_MIND, urand(44000, 48000));
break;
case EVENT_KIRTONOS_TRANSFORM:
if (me->HasAura(SPELL_KIRTONOS_TRANSFORM))
{
me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(0));
}
else
{
DoCast(me, SPELL_KIRTONOS_TRANSFORM);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(WEAPON_KIRTONOS_STAFF));
}
events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, urand(16000, 18000));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim())
return;
if (_stormboltTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (target)
{
DoCast(target, SPELL_STORM_BOLT);
_stormboltTimer = urand(7, 9) *IN_MILLISECONDS;
}
}
else
_stormboltTimer -= diff;
if (_avatarTimer <= diff)
{
DoCast(me, SPELL_AVATAR);
_avatarTimer = 45 *IN_MILLISECONDS;
}
else
_avatarTimer -= diff;
if (_knockawayTimer <= diff)
{
DoResetThreat(); // Threat Reset
DoCastVictim(SPELL_KNOCK_AWAY);
_knockawayTimer = 15 *IN_MILLISECONDS;
}
else
_knockawayTimer -= diff;
if (_chargeTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 25.0f);
if (target)
{
DoCast(target, SPELL_CHARGE);
_chargeTimer = 15 *IN_MILLISECONDS;
}
}
else
_chargeTimer -= diff;
if (_summonTimer <= diff)
{
for (uint8 i = 0; i < 6; ++i)
me->SummonCreature(ENTRY_IRONFORGE_GUARD, IronforgeGuard[i], TEMPSUMMON_CORPSE_DESPAWN , 0);
_summonTimer = urand(20, 40) *IN_MILLISECONDS;
}
else
_summonTimer -= diff;
if (_layonhandsTimer <= diff)
{
DoCast(me, SPELL_LAY_ON_HANDS);
_layonhandsTimer = 5 *MINUTE;
}
else
_layonhandsTimer -=diff;
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_INTRO_MOVE:
me->GetMotionMaster()->MoveJump(GroundPos, me->GetSpeed(MOVE_FLIGHT), 1.918408f, POINT_INTRO_MOVE);
break;
case EVENT_CURSE_OF_BLOOD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_CURSE_OF_BLOOD);
events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, urand(13000, 15000));
break;
case EVENT_FORCE_GRIP:
DoCastVictim(SPELL_FORCE_GRIP);
events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, urand(13000, 15000));
break;
case EVENT_SUMMON_GRAVITY_WELL:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_SUMMON_GRAVITY_WELL);
events.ScheduleEvent(EVENT_SUMMON_GRAVITY_WELL, urand(13000, 15000));
break;
case EVENT_ENERGY_SHIELD:
events.Reset();
DoCast(me, SPELL_EARTH_FURY_ENERGY_SHIELD);
events.ScheduleEvent(EVENT_EARTH_FURY, 0);
break;
case EVENT_EARTH_FURY:
countSeismicShard = 3;
me->SetReactState(REACT_PASSIVE);
me->SetFacingTo(5.862942f);
events.ScheduleEvent(EVENT_EARTH_FURY_FLY_UP, 1600);
break;
case EVENT_EARTH_FURY_FLY_UP:
Talk(SAY_PHASE_TWO);
me->GetMotionMaster()->MovePoint(POINT_FLY_UP, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ() + 5);
break;
case EVENT_EARTH_FURY_FLY_ABOVE_PLATFORM:
me->GetMotionMaster()->MovePoint(POINT_ABOVE_PLATFORM, AbovePlatformPos);
break;
case EVENT_EARTH_FURY_PREPARE_SHARD:
DoCast(me, SPELL_SEISMIC_SHARD_PREPARE);
events.ScheduleEvent(EVENT_EARTH_FURY_LAUNCH_SHARD, 1800);
break;
case EVENT_EARTH_FURY_LAUNCH_SHARD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
{
me->SetFacingToObject(target);
DoCast(target, SPELL_SEISMIC_SHARD_TARGETING);
DoCast(me, SPELL_SEISMIC_SHARD_LAUNCH);
countSeismicShard -= 1;
}
events.ScheduleEvent(countSeismicShard > 0 ? EVENT_EARTH_FURY_PREPARE_SHARD : EVENT_EARTH_FURY_FLY_DOWN, 4800);
break;
case EVENT_EARTH_FURY_FLY_DOWN:
{
me->RemoveAurasDueToSpell(SPELL_EARTH_FURY_CASTING_VISUAL);
me->RemoveAurasDueToSpell(SPELL_EARTH_FURY_ENERGY_SHIELD);
Position pos = me->GetPosition();
pos.m_positionZ = me->GetMap()->GetHeight(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ());
me->GetMotionMaster()->MovePoint(POINT_GROUND, pos);
break;
}
case EVENT_SUMMON_WAVE_SOUTH:
if (Creature* worldtrigger = me->FindNearestCreature(NPC_WORLDTRIGGER, 150.0f))
worldtrigger->CastSpell(worldtrigger, SPELL_SUMMON_WAVE_SOUTH);
events.ScheduleEvent(EVENT_SUMMON_WAVE_SOUTH, 12000);
break;
case EVENT_SUMMON_WAVE_WEST:
if (Creature* worldtrigger = me->FindNearestCreature(NPC_WORLDTRIGGER, 150.0f))
worldtrigger->CastSpell(worldtrigger, SPELL_SUMMON_WAVE_WEST);
events.ScheduleEvent(EVENT_SUMMON_WAVE_WEST, 20000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (instance->GetBossState(BOSS_MAJORDOMO_EXECUTUS) != DONE)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (!me->FindNearestCreature(NPC_FLAMEWAKER_HEALER, 100.0f) && !me->FindNearestCreature(NPC_FLAMEWAKER_ELITE, 100.0f))
{
instance->UpdateEncounterState(ENCOUNTER_CREDIT_KILL_CREATURE, me->GetEntry(), me);
me->setFaction(35);
EnterEvadeMode();
Talk(SAY_DEFEAT);
_JustDied();
events.ScheduleEvent(EVENT_OUTRO_1, 32000);
return;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (HealthBelowPct(50))
DoCast(me, SPELL_AEGIS_OF_RAGNAROS, true);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_MAGIC_REFLECTION:
DoCast(me, SPELL_MAGIC_REFLECTION);
events.ScheduleEvent(EVENT_MAGIC_REFLECTION, 30000);
break;
case EVENT_DAMAGE_REFLECTION:
DoCast(me, SPELL_DAMAGE_REFLECTION);
events.ScheduleEvent(EVENT_DAMAGE_REFLECTION, 30000);
break;
case EVENT_BLAST_WAVE:
DoCastVictim(SPELL_BLAST_WAVE);
events.ScheduleEvent(EVENT_BLAST_WAVE, 10000);
break;
case EVENT_TELEPORT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1))
DoCast(target, SPELL_TELEPORT);
events.ScheduleEvent(EVENT_TELEPORT, 20000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
else
{
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_OUTRO_1:
me->NearTeleportTo(RagnarosTelePos.GetPositionX(), RagnarosTelePos.GetPositionY(), RagnarosTelePos.GetPositionZ(), RagnarosTelePos.GetOrientation());
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
break;
case EVENT_OUTRO_2:
instance->instance->SummonCreature(NPC_RAGNAROS, RagnarosSummonPos);
break;
case EVENT_OUTRO_3:
Talk(SAY_ARRIVAL2_MAJ);
break;
default:
break;
}
}
}
}
void UpdateAI(uint32 diff)
{
switch (phase)
{
case PHASE_CHAINED:
if (!anchorGUID)
{
if (Creature* anchor = me->FindNearestCreature(29521, 30))
{
anchor->AI()->SetGUID(me->GetGUID());
anchor->CastSpell(me, SPELL_SOUL_PRISON_CHAIN, true);
anchorGUID = anchor->GetGUID();
}
else
TC_LOG_ERROR(LOG_FILTER_TSCR, "npc_unworthy_initiateAI: unable to find anchor!");
float dist = 99.0f;
GameObject* prison = NULL;
for (uint8 i = 0; i < 12; ++i)
{
if (GameObject* temp_prison = me->FindNearestGameObject(acherus_soul_prison[i], 30))
{
if (me->IsWithinDist(temp_prison, dist, false))
{
dist = me->GetDistance2d(temp_prison);
prison = temp_prison;
}
}
}
if (prison)
prison->ResetDoorOrButton();
else
TC_LOG_ERROR(LOG_FILTER_TSCR, "npc_unworthy_initiateAI: unable to find prison!");
}
break;
case PHASE_TO_EQUIP:
if (wait_timer)
{
if (wait_timer > diff)
wait_timer -= diff;
else
{
me->GetMotionMaster()->MovePoint(1, anchorX, anchorY, me->GetPositionZ());
//TC_LOG_DEBUG(LOG_FILTER_TSCR, "npc_unworthy_initiateAI: move to %f %f %f", anchorX, anchorY, me->GetPositionZ());
phase = PHASE_EQUIPING;
wait_timer = 0;
}
}
break;
case PHASE_TO_ATTACK:
if (wait_timer)
{
if (wait_timer > diff)
wait_timer -= diff;
else
{
me->setFaction(14);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
phase = PHASE_ATTACKING;
if (Player* target = Unit::GetPlayer(*me, playerGUID))
me->AI()->AttackStart(target);
wait_timer = 0;
}
}
break;
case PHASE_ATTACKING:
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ICY_TOUCH:
DoCastVictim(SPELL_ICY_TOUCH);
events.DelayEvents(1000, GCD_CAST);
events.ScheduleEvent(EVENT_ICY_TOUCH, 5000, GCD_CAST);
break;
case EVENT_PLAGUE_STRIKE:
DoCastVictim(SPELL_PLAGUE_STRIKE);
events.DelayEvents(1000, GCD_CAST);
events.ScheduleEvent(EVENT_PLAGUE_STRIKE, 5000, GCD_CAST);
break;
case EVENT_BLOOD_STRIKE:
DoCastVictim(SPELL_BLOOD_STRIKE);
events.DelayEvents(1000, GCD_CAST);
events.ScheduleEvent(EVENT_BLOOD_STRIKE, 5000, GCD_CAST);
break;
case EVENT_DEATH_COIL:
DoCastVictim(SPELL_DEATH_COIL);
events.DelayEvents(1000, GCD_CAST);
events.ScheduleEvent(EVENT_DEATH_COIL, 5000, GCD_CAST);
break;
}
}
DoMeleeAttackIfReady();
break;
default:
break;
}
}
void UpdateAI(const uint32 diff)
{
// Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_PHANTOM_BLAST:
DoCastVictim(SPELL_PHANTOM_BLAST);
events.ScheduleEvent(EVENT_PHANTOM_BLAST, 5000);
break;
case EVENT_MIRRORED_SOUL:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0, true))
{
mirroredSoulTarget = target->GetGUID();
DoCast(target, SPELL_MIRRORED_SOUL);
DoScriptText(EMOTE_MIRRORED_SOUL, me);
}
events.ScheduleEvent(EVENT_MIRRORED_SOUL, urand(15000, 30000));
break;
case EVENT_WELL_OF_SOULS:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_WELL_OF_SOULS);
events.ScheduleEvent(EVENT_WELL_OF_SOULS, 20000);
break;
case EVENT_UNLEASHED_SOULS:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_UNLEASHED_SOULS);
me->SetDisplayId(DISPLAY_SORROW);
DoScriptText(RAND(SAY_FACE_ANGER_UNLEASH_SOUL, SAY_FACE_SORROW_UNLEASH_SOUL, SAY_FACE_DESIRE_UNLEASH_SOUL), me);
DoScriptText(EMOTE_UNLEASH_SOUL, me);
events.ScheduleEvent(EVENT_UNLEASHED_SOULS, 30000);
events.ScheduleEvent(EVENT_FACE_ANGER, 5000);
break;
case EVENT_FACE_ANGER:
me->SetDisplayId(DISPLAY_ANGER);
break;
case EVENT_WAILING_SOULS:
me->SetDisplayId(DISPLAY_DESIRE);
DoScriptText(RAND(SAY_FACE_ANGER_WAILING_SOUL, SAY_FACE_DESIRE_WAILING_SOUL), me);
DoScriptText(EMOTE_WAILING_SOUL, me);
DoCast(me, SPELL_WAILING_SOULS_STARTING);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
me->SetOrientation(me->GetAngle(target));
me->SendMovementFlagUpdate();
DoCast(me, SPELL_WAILING_SOULS_BEAM);
}
beamAngle = me->GetOrientation();
beamAngleDiff = M_PI/30.0f; // PI/2 in 15 sec = PI/30 per tick
if (RAND(true, false))
beamAngleDiff = -beamAngleDiff;
me->InterruptNonMeleeSpells(false);
me->SetReactState(REACT_PASSIVE);
//Remove any target
me->SetTarget(0);
me->GetMotionMaster()->Clear();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
wailingSoulTick = 15;
events.DelayEvents(18000); // no other events during wailing souls
events.ScheduleEvent(EVENT_WAILING_SOULS_TICK, 3000); // first one after 3 secs.
break;
case EVENT_WAILING_SOULS_TICK:
beamAngle += beamAngleDiff;
me->SetOrientation(beamAngle);
me->SendMovementFlagUpdate();
me->StopMoving();
DoCast(me, SPELL_WAILING_SOULS);
if (--wailingSoulTick)
events.ScheduleEvent(EVENT_WAILING_SOULS_TICK, 1000);
else
{
me->SetReactState(REACT_AGGRESSIVE);
me->SetDisplayId(DISPLAY_ANGER);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
me->GetMotionMaster()->MoveChase(me->getVictim());
events.ScheduleEvent(EVENT_WAILING_SOULS, urand(60000, 70000));
}
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (IsIntroEvent)
{
if (instance->GetBossState(DATA_NETHEKURSE) == IN_PROGRESS)
{
if (IntroEvent_Timer <= diff)
DoTauntPeons();
else
IntroEvent_Timer -= diff;
}
}
if (!UpdateVictim())
return;
if (!IsMainEvent)
return;
if (Phase)
{
if (!SpinOnce)
{
DoCastVictim(SPELL_DARK_SPIN);
SpinOnce = true;
}
if (Cleave_Timer <= diff)
{
DoCastVictim(SPELL_SHADOW_CLEAVE);
Cleave_Timer = 6000 + rand32() % 2500;
}
else
Cleave_Timer -= diff;
}
else
{
if (ShadowFissure_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SHADOW_FISSURE);
ShadowFissure_Timer = urand(7500, 15000);
}
else
ShadowFissure_Timer -= diff;
if (DeathCoil_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_DEATH_COIL);
DeathCoil_Timer = urand(15000, 20000);
}
else
DeathCoil_Timer -= diff;
if (!HealthAbovePct(20))
Phase = true;
DoMeleeAttackIfReady();
}
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_CASTING))
return;
if(chainsOfWoe != NULL)
if(chainsOfWoe->isAlive())
{
/* Buggy!
Map::PlayerList const &PlayerList = me->GetMap()->GetPlayers();
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (!i->getSource()->HasAura(SPELL_CHAINS_OF_WOE_AURA))
me->CastSpell(i->getSource(),SPELL_CHAINS_OF_WOE_AURA,true);
}*/
}else
{
chainsOfWoe->DespawnOrUnsummon();
chainsOfWoe = NULL;
}
if(castSkullCracker)
{
me->MonsterYell("Stand still! Rom'ogg crack your skulls!", LANG_UNIVERSAL, NULL);
castSkullCracker = false;
DoCastAOE(SPELL_THE_SKULLCRACKER);
return;
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_QUAKE:
DoCastAOE(SPELL_QUAKE);
if(me->GetMap()->IsHeroic())
{ // Summon Angered Earth
Position myPos;
me->GetPosition(&myPos);
for(uint8 i=1; i<=5; i++)
me->SummonCreature(NPC_ANGERED_EARTH,myPos,TEMPSUMMON_CORPSE_DESPAWN);
}
events.ScheduleEvent(EVENT_QUAKE, 25000);
break;
case EVENT_CHAINS_OF_WOE:
DoCastAOE(SPELL_CHAINS_OF_WOE);
castSkullCracker = true;
events.ScheduleEvent(EVENT_CHAINS_OF_WOE, 20000);
break;
case EVENT_WOUNDING_STRIKE:
DoCastVictim(SPELL_WOUNDING_STRIKE);
events.ScheduleEvent(EVENT_WOUNDING_STRIKE, 15000);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_pInstance || !UpdateVictim())
return;
if (m_pInstance->GetData(DATA_HEALTH_TWIN_SHARED) != 0)
me->SetHealth(m_pInstance->GetData(DATA_HEALTH_TWIN_SHARED));
else
me->SetHealth(1);
switch (m_uiStage)
{
case 0:
break;
case 1: // Vortex
if (m_uiSpecialAbilityTimer <= uiDiff)
{
if (Creature* pSister = GetSister())
pSister->AI()->DoAction(ACTION_VORTEX);
DoScriptText(m_uiVortexEmote, me);
DoScriptText(m_uiVortexSay, me);
DoCastAOE(m_uiVortexSpellId);
m_uiStage = 0;
m_uiSpecialAbilityTimer = MINUTE*IN_MILLISECONDS;
}
else
m_uiSpecialAbilityTimer -= uiDiff;
break;
case 2: // Shield+Pact
if (m_uiSpecialAbilityTimer <= uiDiff)
{
if (Creature* pSister = GetSister())
pSister->AI()->DoAction(ACTION_PACT);
DoScriptText(EMOTE_SHIELD, me);
DoScriptText(SAY_SHIELD, me);
DoCast(me, m_uiShieldSpellId);
DoCast(me, m_uiTwinPactSpellId);
m_uiStage = 0;
m_uiSpecialAbilityTimer = MINUTE*IN_MILLISECONDS;
}
else
m_uiSpecialAbilityTimer -= uiDiff;
break;
default:
break;
}
if (m_uiSpikeTimer <= uiDiff)
{
DoCastVictim(m_uiSpikeSpellId);
m_uiSpikeTimer = 20*IN_MILLISECONDS;
}
else
m_uiSpikeTimer -= uiDiff;
if (IsHeroic() && m_uiTouchTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 200, true, m_uiOtherEssenceSpellId))
me->CastCustomSpell(m_uiTouchSpellId, SPELLVALUE_MAX_TARGETS, 1, target, false);
m_uiTouchTimer = urand(10, 15)*IN_MILLISECONDS;
}
else
m_uiTouchTimer -= uiDiff;
if (m_uiColorballsTimer <= uiDiff)
{
if (m_uiWaveCount >= 2)
{
SummonColorballs(12);
m_uiWaveCount = 0;
}
else
{
SummonColorballs(2);
m_uiWaveCount++;
}
m_uiColorballsTimer = 15*IN_MILLISECONDS;
}
else
m_uiColorballsTimer -= uiDiff;
if (!m_bIsBerserk && m_uiBerserkTimer <= uiDiff)
{
DoCast(me, SPELL_BERSERK);
DoScriptText(SAY_BERSERK, me);
m_bIsBerserk = true;
}
else
m_uiBerserkTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (!UpdateVictim() && !events.IsInPhase(PHASE_EVENT))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
// PHASE ONE
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, urand(6, 12)*IN_MILLISECONDS, 0, PHASE_HUMAN);
break;
case EVENT_STAGGERING_ROAR:
DoCast(me, SPELL_STAGGERING_ROAR);
events.ScheduleEvent(EVENT_STAGGERING_ROAR, urand(18, 22)*IN_MILLISECONDS, 0, PHASE_HUMAN);
break;
case EVENT_ENRAGE:
DoCast(me, SPELL_ENRAGE);
events.ScheduleEvent(EVENT_ENRAGE, urand(7, 14)*IN_MILLISECONDS, 0, PHASE_HUMAN);
break;
case EVENT_SMASH:
DoCastAOE(SPELL_SMASH);
events.ScheduleEvent(EVENT_SMASH, urand(12, 16)*IN_MILLISECONDS, 0, PHASE_HUMAN);
break;
case EVENT_JUST_TRANSFORMED:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
me->SetInCombatWithZone();
me->GetMotionMaster()->MoveChase(me->GetVictim());
ScheduleSecondPhase();
return;
case EVENT_SUMMON_BANSHEE:
DoCast(me, SPELL_SUMMON_BANSHEE);
return;
// PHASE TWO
case EVENT_DARK_SMASH:
DoCastVictim(SPELL_DARK_SMASH);
events.ScheduleEvent(EVENT_DARK_SMASH, urand(12, 16)*IN_MILLISECONDS, 0, PHASE_UNDEAD);
break;
case EVENT_DREADFUL_ROAR:
DoCast(me, SPELL_DREADFUL_ROAR);
events.ScheduleEvent(EVENT_DREADFUL_ROAR, urand(18, 22)*IN_MILLISECONDS, 0, PHASE_UNDEAD);
break;
case EVENT_WOE_STRIKE:
DoCastVictim(SPELL_WOE_STRIKE);
events.ScheduleEvent(EVENT_WOE_STRIKE, urand(10, 14)*IN_MILLISECONDS, 0, PHASE_UNDEAD);
break;
case EVENT_SHADOW_AXE:
if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1))
{
DoCast(target, SPELL_SHADOW_AXE_SUMMON);
}
events.ScheduleEvent(EVENT_SHADOW_AXE, 30*IN_MILLISECONDS, 0, PHASE_UNDEAD);
break;
}
}
DoMeleeAttackIfReady();
}
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_BERSERK:
DoScriptText(EMOTE_GENERIC_BERSERK_RAID, me);
Talk(SAY_BERSERK);
DoCast(me, SPELL_BERSERK);
break;
case EVENT_VAMPIRIC_BITE:
if (Player* target = SelectRandomTarget(false))
{
DoCast(target, SPELL_VAMPIRIC_BITE);
Talk(SAY_VAMPIRIC_BITE);
vampires.insert(target->GetGUID());
}
break;
case EVENT_BLOOD_MIRROR:
{
// victim can be NULL when this is processed in the same update tick as EVENT_AIR_PHASE
if (me->getVictim())
{
Player* newOfftank = SelectRandomTarget(true);
if (offtank != newOfftank)
{
offtank = newOfftank;
if (offtank)
{
offtank->CastSpell(me->getVictim(), SPELL_BLOOD_MIRROR_DAMAGE, true);
me->getVictim()->CastSpell(offtank, SPELL_BLOOD_MIRROR_DUMMY, true);
DoCastVictim(SPELL_BLOOD_MIRROR_VISUAL);
if (Item* shadowsEdge = offtank->GetWeaponForAttack(BASE_ATTACK, true))
if (!offtank->HasAura(SPELL_THIRST_QUENCHED) && shadowsEdge->GetEntry() == ITEM_SHADOW_S_EDGE && !offtank->HasAura(SPELL_GUSHING_WOUND))
offtank->CastSpell(offtank, SPELL_GUSHING_WOUND, true);
}
}
}
events.ScheduleEvent(EVENT_BLOOD_MIRROR, 2500, EVENT_GROUP_CANCELLABLE);
break;
}
case EVENT_DELIRIOUS_SLASH:
if (offtank && !me->HasByteFlag(UNIT_FIELD_BYTES_1, 3, 0x03))
DoCast(offtank, SPELL_DELIRIOUS_SLASH);
events.ScheduleEvent(EVENT_DELIRIOUS_SLASH, urand(20000, 24000), EVENT_GROUP_NORMAL);
break;
case EVENT_PACT_OF_THE_DARKFALLEN:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
uint32 targetCount = 2;
// do not combine these checks! we want it incremented TWICE when both conditions are met
if (IsHeroic())
++targetCount;
if (Is25ManRaid())
++targetCount;
Trinity::RandomResizeList<Player*>(targets, targetCount);
if (targets.size() > 1)
{
Talk(SAY_PACT_OF_THE_DARKFALLEN);
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_PACT_OF_THE_DARKFALLEN);
}
events.ScheduleEvent(EVENT_PACT_OF_THE_DARKFALLEN, 30500, EVENT_GROUP_NORMAL);
break;
}
case EVENT_SWARMING_SHADOWS:
if (Player* target = SelectRandomTarget(false))
{
Talk(EMOTE_SWARMING_SHADOWS, target->GetGUID());
Talk(SAY_SWARMING_SHADOWS);
DoCast(target, SPELL_SWARMING_SHADOWS);
}
events.ScheduleEvent(EVENT_SWARMING_SHADOWS, 30500, EVENT_GROUP_NORMAL);
break;
case EVENT_TWILIGHT_BLOODBOLT:
{
std::list<Player*> targets;
SelectRandomTarget(false, &targets);
Trinity::RandomResizeList<Player*>(targets, uint32(Is25ManRaid() ? 4 : 2));
for (std::list<Player*>::iterator itr = targets.begin(); itr != targets.end(); ++itr)
DoCast(*itr, SPELL_TWILIGHT_BLOODBOLT);
DoCast(me, SPELL_TWILIGHT_BLOODBOLT_TARGET);
events.ScheduleEvent(EVENT_TWILIGHT_BLOODBOLT, urand(10000, 15000), EVENT_GROUP_NORMAL);
break;
}
case EVENT_AIR_PHASE:
DoStopAttack();
me->SetReactState(REACT_PASSIVE);
events.DelayEvents(7000, EVENT_GROUP_NORMAL);
events.CancelEventsByGCD(EVENT_GROUP_CANCELLABLE);
me->GetMotionMaster()->MovePoint(POINT_CENTER, centerPos);
break;
case EVENT_AIR_START_FLYING:
me->AddUnitMovementFlag(MOVEMENTFLAG_LEVITATING);
me->SetByteFlag(UNIT_FIELD_BYTES_1, 3, 0x01);
me->SetFlying(true);
me->SendMovementFlagUpdate();
me->GetMotionMaster()->MovePoint(POINT_AIR, airPos);
break;
case EVENT_AIR_FLY_DOWN:
me->GetMotionMaster()->MovePoint(POINT_GROUND, centerPos);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (Invisible && Invisible_Timer <= diff)
{
//Become visible again
me->SetFaction(14);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(11073); //Jandice Model
Invisible = false;
}
else if (Invisible)
{
Invisible_Timer -= diff;
//Do nothing while invisible
return;
}
//Return since we have no target
if (!UpdateVictim())
return;
//CurseOfBlood_Timer
if (CurseOfBlood_Timer <= diff)
{
//Cast
DoCastVictim( SPELL_CURSEOFBLOOD);
//45 seconds
CurseOfBlood_Timer = 30000;
}
else CurseOfBlood_Timer -= diff;
//Illusion_Timer
if (!Invisible && Illusion_Timer <= diff)
{
//Inturrupt any spell casting
me->InterruptNonMeleeSpells(false);
me->SetFaction(35);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(11686); // Invisible Model
DoModifyThreatPercent(me->GetVictim(), -99);
//Summon 10 Illusions attacking random gamers
Unit* pTarget = NULL;
for (uint8 i = 0; i < 10; ++i)
{
pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (pTarget)
SummonIllusions(pTarget);
}
Invisible = true;
Invisible_Timer = 3000;
//25 seconds until we should cast this agian
Illusion_Timer = 25000;
}
else Illusion_Timer -= diff;
// //Illusion_Timer
// if (Illusion_Timer <= diff)
// {
// //Cast
// DoCastVictim( SPELL_ILLUSION);
//
// //3 Illusion will be summoned
// if (Illusioncounter < 3)
// {
// Illusion_Timer = 500;
// ++Illusioncounter;
// }
// else {
// //15 seconds until we should cast this again
// Illusion_Timer = 15000;
// Illusioncounter = 0;
// }
//
// } else Illusion_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (waitTimer && inMove)
{
if (waitTimer <= diff)
{
(*me).GetMotionMaster()->MovementExpired();
(*me).GetMotionMaster()->MovePoint(MovePhase, NalorakkWay[MovePhase][0], NalorakkWay[MovePhase][1], NalorakkWay[MovePhase][2]);
waitTimer = 0;
} else waitTimer -= diff;
}
if (!UpdateVictim())
return;
if (Berserk_Timer <= diff)
{
DoCast(me, SPELL_BERSERK, true);
me->Yell(YELL_BERSERK, LANG_UNIVERSAL);
DoPlaySoundToSet(me, SOUND_YELL_BERSERK);
Berserk_Timer = 600000;
} else Berserk_Timer -= diff;
if (ShapeShift_Timer <= diff)
{
if (inBearForm)
{
// me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, 5122);
me->Yell(YELL_SHIFTEDTOTROLL, LANG_UNIVERSAL);
DoPlaySoundToSet(me, SOUND_YELL_TOTROLL);
me->RemoveAurasDueToSpell(SPELL_BEARFORM);
Surge_Timer = urand(15000, 20000);
BrutalSwipe_Timer = urand(7000, 12000);
Mangle_Timer = urand(10000, 15000);
ShapeShift_Timer = urand(45000, 50000);
inBearForm = false;
}
else
{
// me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, 0);
me->Yell(YELL_SHIFTEDTOBEAR, LANG_UNIVERSAL);
DoPlaySoundToSet(me, SOUND_YELL_TOBEAR);
DoCast(me, SPELL_BEARFORM, true);
LaceratingSlash_Timer = 2000; // dur 18s
RendFlesh_Timer = 3000; // dur 5s
DeafeningRoar_Timer = urand(5000, 10000); // dur 2s
ShapeShift_Timer = urand(20000, 25000); // dur 30s
inBearForm = true;
}
} else ShapeShift_Timer -= diff;
if (!inBearForm)
{
if (BrutalSwipe_Timer <= diff)
{
DoCastVictim(SPELL_BRUTALSWIPE);
BrutalSwipe_Timer = urand(7000, 12000);
} else BrutalSwipe_Timer -= diff;
if (Mangle_Timer <= diff)
{
if (me->GetVictim() && !me->EnsureVictim()->HasAura(SPELL_MANGLEEFFECT))
{
DoCastVictim(SPELL_MANGLE);
Mangle_Timer = 1000;
}
else Mangle_Timer = urand(10000, 15000);
} else Mangle_Timer -= diff;
if (Surge_Timer <= diff)
{
me->Yell(YELL_SURGE, LANG_UNIVERSAL);
DoPlaySoundToSet(me, SOUND_YELL_SURGE);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 45, true);
if (target)
DoCast(target, SPELL_SURGE);
Surge_Timer = urand(15000, 20000);
} else Surge_Timer -= diff;
}
else
{
if (LaceratingSlash_Timer <= diff)
{
DoCastVictim(SPELL_LACERATINGSLASH);
LaceratingSlash_Timer = urand(18000, 23000);
} else LaceratingSlash_Timer -= diff;
if (RendFlesh_Timer <= diff)
{
DoCastVictim(SPELL_RENDFLESH);
RendFlesh_Timer = urand(5000, 10000);
} else RendFlesh_Timer -= diff;
if (DeafeningRoar_Timer <= diff)
{
DoCastVictim(SPELL_DEAFENINGROAR);
DeafeningRoar_Timer = urand(15000, 20000);
} else DeafeningRoar_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (!SummonedRend && HealthBelowPct(5))
{
DoCast(me, SPELL_SUMMON_REND);
me->RemoveAura(SPELL_REND_MOUNTS);
SummonedRend = true;
}
if (!UpdateVictim())
{
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SUMMONED_1:
me->AddAura(SPELL_REND_MOUNTS, me);
if (GameObject* portcullis = me->FindNearestGameObject(GO_DR_PORTCULLIS, 40.0f))
portcullis->UseDoorOrButton();
if (Creature* victor = me->FindNearestCreature(NPC_LORD_VICTOR_NEFARIUS, 75.0f, true))
victor->AI()->SetData(1, 1);
events.ScheduleEvent(EVENT_SUMMONED_2, 2000);
break;
case EVENT_SUMMONED_2:
me->GetMotionMaster()->MovePath(GYTH_PATH_1, false);
break;
default:
break;
}
}
return;
}
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CORROSIVE_ACID:
DoCast(me, SPELL_CORROSIVE_ACID);
events.ScheduleEvent(EVENT_CORROSIVE_ACID, urand(10000, 16000));
break;
case EVENT_FREEZE:
DoCast(me, SPELL_FREEZE);
events.ScheduleEvent(EVENT_FREEZE, urand(10000, 16000));
break;
case EVENT_FLAME_BREATH:
DoCast(me, SPELL_FLAMEBREATH);
events.ScheduleEvent(EVENT_FLAME_BREATH, urand(10000, 16000));
break;
case EVENT_KNOCK_AWAY:
DoCastVictim(SPELL_KNOCK_AWAY);
events.ScheduleEvent(EVENT_KNOCK_AWAY, urand(14000, 20000));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}