void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_IMPALE:
//Cast Impale on a random target
//Do NOT cast it when we are afflicted by locust swarm
if (!me->HasAura(RAID_MODE(SPELL_LOCUST_SWARM_10,SPELL_LOCUST_SWARM_25)))
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
DoCast(pTarget, RAID_MODE(SPELL_IMPALE_10,SPELL_IMPALE_25));
events.ScheduleEvent(EVENT_IMPALE, urand(10000,20000));
break;
case EVENT_LOCUST:
// TODO : Add Text
DoCast(me, RAID_MODE(SPELL_LOCUST_SWARM_10,SPELL_LOCUST_SWARM_25));
DoSummon(MOB_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);
events.ScheduleEvent(EVENT_LOCUST, 90000);
break;
case EVENT_SPAWN_GUARDIAN_NORMAL:
// TODO : Add Text
DoSummon(MOB_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
events.ScheduleEvent(EVENT_BERSERK, 600000);
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_SLIME_SPRAY:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
{
DoSummon(NPC_OOZE_SPRAY_STALKER, *target, 8000, TEMPSUMMON_TIMED_DESPAWN);
Talk(EMOTE_SLIME_SPRAY);
DoCast(me, SPELL_SLIME_SPRAY);
}
events.ScheduleEvent(EVENT_SLIME_SPRAY, 20000);
break;
case EVENT_HASTEN_INFECTIONS:
if (infectionStage++ < 4)
{
infectionCooldown -= 2000;
events.ScheduleEvent(EVENT_HASTEN_INFECTIONS, 90000);
}
break;
case EVENT_MUTATED_INFECTION:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -MUTATED_INFECTION);
if (!target)
target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true, -MUTATED_INFECTION);
if (target)
{
me->CastCustomSpell(SPELL_MUTATED_INFECTION, SPELLVALUE_MAX_TARGETS, 1, target, false);
Talk(EMOTE_MUTATED_INFECTION, target->GetGUID());
}
events.ScheduleEvent(EVENT_MUTATED_INFECTION, infectionCooldown);
break;
}
default:
break;
}
}
DoMeleeAttackIfReady();
}
void EnterCombat(Unit* /*who*/) override
{
for (uint32 i = 0; i < POS_LIVE; ++i)
if (Creature* trigger = DoSummon(WORLD_TRIGGER, PosSummonLive[i]))
LiveTriggerGUID.push_back(trigger->GetGUID());
for (uint32 i = 0; i < POS_DEAD; ++i)
if (Creature* trigger = DoSummon(WORLD_TRIGGER, PosSummonDead[i]))
DeadTriggerGUID.push_back(trigger->GetGUID());
if (LiveTriggerGUID.size() < POS_LIVE || DeadTriggerGUID.size() < POS_DEAD)
{
TC_LOG_ERROR("scripts", "Script Gothik: cannot summon triggers!");
EnterEvadeMode();
return;
}
_EnterCombat();
waveCount = 0;
events.ScheduleEvent(EVENT_SUMMON, 30000);
DoTeleportTo(PosPlatform);
Talk(SAY_SPEECH);
instance->SetData(DATA_GOTHIK_GATE, GO_STATE_READY);
}
void DoGothikSummon(uint32 entry)
{
if (getDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
{
switch(entry)
{
case MOB_LIVE_TRAINEE:
DoSummon(MOB_LIVE_TRAINEE, liveTrigger[0], 1);
DoSummon(MOB_LIVE_TRAINEE, liveTrigger[1], 1);
DoSummon(MOB_LIVE_TRAINEE, liveTrigger[2], 1);
break;
case MOB_LIVE_KNIGHT:
DoSummon(MOB_LIVE_KNIGHT, liveTrigger[3], 1);
DoSummon(MOB_LIVE_KNIGHT, liveTrigger[5], 1);
break;
case MOB_LIVE_RIDER:
DoSummon(MOB_LIVE_RIDER, liveTrigger[4], 1);
break;
}
}
else
{
switch(entry)
{
case MOB_LIVE_TRAINEE:
DoSummon(MOB_LIVE_TRAINEE, liveTrigger[0], 1);
DoSummon(MOB_LIVE_TRAINEE, liveTrigger[1], 1);
break;
case MOB_LIVE_KNIGHT:
DoSummon(MOB_LIVE_KNIGHT, liveTrigger[5], 1);
break;
case MOB_LIVE_RIDER:
DoSummon(MOB_LIVE_RIDER, liveTrigger[4], 1);
break;
}
}
}
void UpdateAI(const uint32 diff)
{
if (pInstance && pInstance->GetData(DATA_REMOVE_NPC) == 1)
{
me->ForcedDespawn();
pInstance->SetData(DATA_REMOVE_NPC, 0);
}
if (uiSpawnTimer <= diff)
{
if (bPortalGuardianOrKeeperSpawn)
{
uint8 k = pInstance && pInstance->GetData(DATA_WAVE_COUNT) < 12 ? 2 : 3;
for (uint8 i = 0; i < k; ++i)
{
uint32 entry = RAND(CREATURE_AZURE_CAPTAIN,CREATURE_AZURE_RAIDER,CREATURE_AZURE_STALKER,CREATURE_AZURE_SORCEROR);
if (Creature* pSummon = DoSummon(entry, me, 2.0f, 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT))
pSummon->GetMotionMaster()->MovePoint(0, DoorPosition);
}
}
else
{
bPortalGuardianOrKeeperSpawn = true;
uint32 entry = RAND(CREATURE_PORTAL_GUARDIAN, CREATURE_PORTAL_KEEPER);
if (Creature *pPortalKeeper = DoSummon(entry, me, 2.0f, 0, TEMPSUMMON_DEAD_DESPAWN))
me->CastSpell(pPortalKeeper, SPELL_PORTAL_CHANNEL, false);
}
uiSpawnTimer = SPAWN_TIME;
} else uiSpawnTimer -= diff;
if (bPortalGuardianOrKeeperSpawn && !me->IsNonMeleeSpellCasted(false))
{
me->Kill(me, false);
me->RemoveCorpse();
return;
}
}
void UpdateAI(const uint32 uiDiff) override
{
if (m_uiTimer < uiDiff)
{
switch (m_uiWave)
{
case 0:
DoSummon(0);
m_uiTimer = 15000;
++m_uiWave;
break;
case 1:
DoSummon(1);
DoSummon(2);
m_uiTimer = 15000;
++m_uiWave;
break;
case 2:
{
DoSummon(3);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_PACIFIED | UNIT_FLAG_PASSIVE);
m_creature->SetVisibility(VISIBILITY_ON);
if (auto pPlayer = m_creature->GetMap()->GetPlayer(m_PlayerGuid))
{
if (pPlayer->isAlive())
m_creature->AI()->AttackStart(pPlayer);
}
++m_uiWave;
}
break;
}
}
else
m_uiTimer -= uiDiff;
ScriptedAI::UpdateAI(uiDiff);
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
if (uiSpawnTimer <= diff)
{
uint32 spawnNumber = urand(2, DUNGEON_MODE(3, 5));
for (uint8 i = 0; i < spawnNumber; ++i)
DoSummon(RAND(NPC_DRAKKARI_INVADER_1, NPC_DRAKKARI_INVADER_2), AddSpawnPoint, 0, TEMPSUMMON_DEAD_DESPAWN);
uiSpawnTimer = urand(30*IN_MILLISECONDS, 40*IN_MILLISECONDS);
} else uiSpawnTimer -= diff;
if (uiConsumeTimer <= diff)
{
DoScriptText(SAY_CONSUME, me);
DoCast(SPELL_CONSUME);
uiConsumeTimer = 15*IN_MILLISECONDS;
} else uiConsumeTimer -= diff;
if (consumptionJunction)
{
Aura* ConsumeAura = me->GetAura(DUNGEON_MODE(SPELL_CONSUME_AURA, H_SPELL_CONSUME_AURA));
if (ConsumeAura && ConsumeAura->GetStackAmount() > 9)
consumptionJunction = false;
}
if (uiCrushTimer <= diff)
{
DoCastVictim(SPELL_CRUSH);
uiCrushTimer = urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS);
} else uiCrushTimer -= diff;
if (uiInfectedWoundTimer <= diff)
{
DoCastVictim(SPELL_INFECTED_WOUND);
uiInfectedWoundTimer = urand(25*IN_MILLISECONDS, 35*IN_MILLISECONDS);
} else uiInfectedWoundTimer -= diff;
if (uiExplodeCorpseTimer <= diff)
{
DoCast(SPELL_CORPSE_EXPLODE);
DoScriptText(SAY_EXPLODE, me);
uiExplodeCorpseTimer = urand(15*IN_MILLISECONDS, 19*IN_MILLISECONDS);
} else uiExplodeCorpseTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictimWithGaze() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_WOUND:
DoCast(me->getVictim(), SPELL_MORTAL_WOUND);
events.ScheduleEvent(EVENT_WOUND, 10000);
break;
case EVENT_ENRAGE:
// TODO : Add missing text
DoCast(me, SPELL_ENRAGE);
events.ScheduleEvent(EVENT_ENRAGE, 15000);
break;
case EVENT_DECIMATE:
// TODO : Add missing text
DoCastAOE(SPELL_DECIMATE);
events.ScheduleEvent(EVENT_DECIMATE, 105000);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
events.ScheduleEvent(EVENT_BERSERK, 5*60000);
break;
case EVENT_SUMMON:
for (int32 i = 0; i < RAID_MODE(1, 2); ++i)
DoSummon(MOB_ZOMBIE, PosSummon[rand() % RAID_MODE(1, 3)]);
events.ScheduleEvent(EVENT_SUMMON, 10000);
break;
}
}
if (me->getVictim() && me->getVictim()->GetEntry() == MOB_ZOMBIE)
{
if (me->IsWithinMeleeRange(me->getVictim()))
{
me->Kill(me->getVictim());
me->ModifyHealth(int32(me->CountPctFromMaxHealth(5)));
}
}
else
DoMeleeAttackIfReady();
}
void Tomb()
{
for (uint8 i = 1; i <= count; i++)
{
if (marked[i] && marked[i]->isAlive())
{
DoCast(marked[i], SPELL_ICE_TOMB);
DoCast(marked[i], SPELL_ASPHYXATION);
marked[i]->RemoveAurasDueToSpell(SPELL_FROST_BEACON);
float x, y, z;
marked[i]->GetPosition(x, y, z);
if (Unit* tomb = DoSummon(CREATURE_ICE_TOMB, marked[i]))
tomb->AddThreat(marked[i], 5000.0f);
}
}
}
boss_flame_leviathanAI(Creature *pCreature) : BossAI(pCreature, BOSS_LEVIATHAN), vehicle(me->GetVehicleKit())
{
assert(vehicle);
pInstance = pCreature->GetInstanceScript();
ColossusCount = 0;
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK, true);
me->ApplySpellImmune(0, IMMUNITY_ID, 49560, true); // Death Grip
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_STUNNED);
me->SetReactState(REACT_PASSIVE);
// Summon Ulduar Colossus
if (me->isAlive())
for(uint32 i = 0; i < 2; ++i)
DoSummon(MOB_COLOSSUS, PosColossus[i], 7000, TEMPSUMMON_CORPSE_TIMED_DESPAWN);
}
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_SLIME_SPRAY:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))
{
DoSummon(NPC_OOZE_SPRAY_STALKER, *target, 8000, TEMPSUMMON_TIMED_DESPAWN);
Talk(EMOTE_SLIME_SPRAY);
DoCast(me, SPELL_SLIME_SPRAY);
}
events.ScheduleEvent(EVENT_SLIME_SPRAY, 20000);
break;
case EVENT_HASTEN_INFECTIONS:
if (infectionStage++ < 4)
{
infectionCooldown -= 2000;
events.ScheduleEvent(EVENT_HASTEN_INFECTIONS, 90000);
}
break;
case EVENT_MUTATED_INFECTION:
DoCastAOE(SPELL_MUTATED_INFECTION);
events.ScheduleEvent(EVENT_MUTATED_INFECTION, infectionCooldown);
break;
case EVENT_VILE_GAS:
DoCastAOE(SPELL_VILE_GAS_TRIGGER);
events.ScheduleEvent(EVENT_VILE_GAS, urand(30000, 35000));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictimWithGaze() || !CheckInRoom())
return;
events.Update(diff);
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_WOUND:
DoCast(me->getVictim(), SPELL_MORTAL_WOUND);
events.ScheduleEvent(EVENT_WOUND, 10000);
return;
case EVENT_ENRAGE:
DoCast(me, SPELL_ENRAGE);
events.ScheduleEvent(EVENT_ENRAGE, 30000);
return;
case EVENT_DECIMATE:
DoCastAOE(SPELL_DECIMATE);
events.ScheduleEvent(EVENT_DECIMATE, 105000);
return;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
return;
case EVENT_SUMMON:
for(uint32 i = 0; i < HEROIC(1,2); ++i)
DoSummon(MOB_ZOMBIE, triggers[rand()%3]);
events.ScheduleEvent(EVENT_SUMMON, 10000);
return;
}
}
if (me->getVictim()->GetEntry() == MOB_ZOMBIE)
{
if (me->IsWithinMeleeRange(me->getVictim()))
{
me->Kill(me->getVictim());
me->ModifyHealth(me->GetMaxHealth() * 0.05f);
}
}
else
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictimWithGaze() || !CheckInRoom())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_WOUND:
DoCastVictim(SPELL_MORTAL_WOUND);
events.ScheduleEvent(EVENT_WOUND, 10000);
break;
case EVENT_ENRAGE:
Talk(EMOTE_ENRAGE);
DoCast(me, SPELL_ENRAGE);
events.ScheduleEvent(EVENT_ENRAGE, 15000);
break;
case EVENT_DECIMATE:
Talk(EMOTE_DECIMATE);
DoCastAOE(SPELL_DECIMATE);
events.ScheduleEvent(EVENT_DECIMATE, 105000);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK);
events.ScheduleEvent(EVENT_BERSERK, 5*60000);
break;
case EVENT_SUMMON:
for (int32 i = 0; i < RAID_MODE(1, 2); ++i)
DoSummon(NPC_ZOMBIE, PosSummon[rand32() % RAID_MODE(1, 3)]);
// There's probably a better way to handle this
for (SummonList::iterator itr = summons.begin(); itr != summons.end(); ++itr)
if(Unit* unit = ObjectAccessor::GetUnit(*me, *itr))
if (unit->GetEntry() == NPC_ZOMBIE)
unit->ToCreature()->AI()->AttackStart(me);
events.ScheduleEvent(EVENT_SUMMON, 10000);
break;
}
}
DoMeleeAttackIfReady();
}
void EnterCombat(Unit *who)
{
for(uint32 i = 0; i < 3; ++i)
if (Creature *trigger = DoSummon(WORLD_TRIGGER, PosSummon[i]))
triggers.push_back(trigger);
if (triggers.size() < 3)
{
error_log("Script Gluth: cannot summon triggers!");
EnterEvadeMode();
return;
}
_EnterCombat();
events.ScheduleEvent(EVENT_WOUND, 10000);
events.ScheduleEvent(EVENT_ENRAGE, 30000);
events.ScheduleEvent(EVENT_DECIMATE, 105000);
events.ScheduleEvent(EVENT_BERSERK, 8*60000);
events.ScheduleEvent(EVENT_SUMMON, 10000);
}
void MovementInform(uint32 type, uint32 id) override
{
if (type != POINT_MOTION_TYPE)
return;
if (id < 10)
wpreached = true;
if (id == 8)
{
for (uint8 i = 0; i < 2; i++)
DoSummon(NPC_FOUL_PURGE, exorcismPos[8]);
}
if (id == 10)
{
wpreached = true;
point = 3;
}
}
void DoSummonAtRift(uint32 creature_entry)
{
if (!creature_entry)
return;
if (instance->GetData(TYPE_MEDIVH) != IN_PROGRESS)
{
me->InterruptNonMeleeSpells(true);
me->RemoveAllAuras();
return;
}
Position pos = me->GetRandomNearPosition(10.0f);
//normalize Z-level if we can, if rift is not at ground level.
pos.m_positionZ = std::max(me->GetMap()->GetHeight(pos.m_positionX, pos.m_positionY, MAX_HEIGHT), me->GetMap()->GetWaterLevel(pos.m_positionX, pos.m_positionY));
if (Unit* Summon = DoSummon(creature_entry, pos, 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT))
if (Unit* temp = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_MEDIVH)))
AddThreat(temp, 0.0f, Summon);
}
void SummonPlanarAnomaly()
{
std::list<HostileReference*>& m_threatlist = me->getThreatManager().getThreatList();
std::list<HostileReference*>::const_iterator i = m_threatlist.begin();
for (i = m_threatlist.begin(); i!= m_threatlist.end(); ++i)
{
Unit* pUnit = Unit::GetUnit((*me), (*i)->getUnitGuid());
if (pUnit )
{
Creature* summon = DoSummon(PLANAR_ANOMALY, me, 3.0f, 30000, TEMPSUMMON_DEAD_DESPAWN);
if(summon)
{
summon->Attack(pUnit,true);
printf("PLANAR_ANOMALY attack uinit %s \n",pUnit->GetName());
summon->SetVisibility(VISIBILITY_ON);
summon->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
summon->SetUnitMovementFlags(MOVEMENTFLAG_FLYING);
}
}
}
}
void JustSummoned(Creature* pSummoned)
{
switch(pSummoned->GetEntry())
{
case ENTRY_SARONIT_VARPOR:
VarporList.push_back(pSummoned->GetGUID());
if(!VarporKilled && VarporList.size() > 5)
{
DespawnVarpors();
if(Creature* animus = DoSummon(ENTRY_SARONIT_ANIMUS,me->GetHomePosition(),30000,TEMPSUMMON_MANUAL_DESPAWN))
animus->AI()->AttackStart(me->getVictim());
}
break;
case ENTRY_SARONIT_ANIMUS:
guidSaronitAnimus = pSummoned->GetGUID();
AnimusSummoned = true;
DoScriptText(SAY_HARDMODE_ON,me);
me->InterruptNonMeleeSpells(false);
DoCast(SPELL_SARONIT_BARRIER);
break;
}
}
void WaypointStart(uint32 pointId) override
{
switch (pointId)
{
case 27:
for (uint8 i = 0; i < 3; ++i)
{
const Position src = {147.927444f, -3851.513428f, 130.893f, 0};
Position dst = me->GetRandomPoint(src, 7.0f);
DoSummon(NPC_MARAUDING_OWL, dst, 25000, TEMPSUMMON_CORPSE_TIMED_DESPAWN);
}
break;
case 44:
for (uint8 i = 0; i < 3; ++i)
{
const Position src = {-141.151581f, -4291.213867f, 120.130f, 0};
Position dst = me->GetRandomPoint(src, 7.0f);
me->SummonCreature(NPC_VILE_AMBUSHER, dst, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 25000);
}
break;
}
}
void UpdateAI(const uint32 diff)
{
if (LamentEvent)
{
if (LamentEvent_Timer <= diff)
{
DoSummon(ENTRY_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);
LamentEvent_Timer = 2000;
if (!me->HasAura(SPELL_SYLVANAS_CAST))
{
DoScriptText(SAY_LAMENT_END, me);
DoScriptText(EMOTE_LAMENT_END, me);
LamentEvent = false;
}
} else LamentEvent_Timer -= diff;
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
void RandomSpawn()
{
switch(m_uiStage)
{
case 1:
DoSummon(CREATURE_FANATIC, SpawnLoc[0]);
DoSummon(CREATURE_ADHERENT, SpawnLoc[1]);
DoSummon(CREATURE_FANATIC, SpawnLoc[2]);
++m_uiStage;
break;
case 2:
DoSummon(CREATURE_ADHERENT, SpawnLoc[3]);
DoSummon(CREATURE_FANATIC, SpawnLoc[4]);
DoSummon(CREATURE_ADHERENT, SpawnLoc[5]);
--m_uiStage;
break;
}
}
void OozesMeetCheck()
{
if (summons.empty() || summons.size()==1)
return;
for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
{
Creature* ooze = ObjectAccessor::GetCreatureOrPetOrVehicle((*me), (*itr));
if (!ooze || !ooze->isAlive())
continue;
if (ooze->GetEntry() != CREATURE_LITTLE_OOZE && ooze->GetEntry() != CREATURE_OOZE_BIG)
continue;
bool little = (ooze->GetEntry() == CREATURE_LITTLE_OOZE);
for(SummonList::const_iterator itr2 = summons.begin(); itr2 != summons.end(); ++itr2)
{
Creature* ooze2 = ObjectAccessor::GetCreatureOrPetOrVehicle((*me), (*itr2));
if (!ooze2 || !ooze2->isAlive())
continue;
if (ooze2->GetEntry() != CREATURE_LITTLE_OOZE && ooze2->GetEntry() != CREATURE_OOZE_BIG)
continue;
if (ooze2 == ooze)
continue;
if (ooze->GetDistance2d(ooze2) > 5.0f)
continue;
bool little2 = (ooze2->GetEntry() == CREATURE_LITTLE_OOZE);
//if first ooze is big ooze
if (!little)
{
//and if second ooze is little
if (little2)
{
ooze->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);
if (ooze->GetAura(SPELL_UNSTABLE_OOZE) && ooze->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)
ooze->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);
continue;
}
else //big ooze meet another big ooze, check wich one have more buff stack and despawn second one
{
uint8 stack1, stack2 = 0;
if (Aura* aura = ooze->GetAura(SPELL_UNSTABLE_OOZE))
stack1 = aura->GetStackAmount();
if (Aura* aura = ooze2->GetAura(SPELL_UNSTABLE_OOZE))
stack2 = aura->GetStackAmount();
if (stack1 < stack2)
{
ooze2->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);
ooze->ForcedDespawn();
if (ooze2->GetAura(SPELL_UNSTABLE_OOZE) && ooze2->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)
{
ooze2->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);
ooze2->ForcedDespawn();
}
break;
}
else
{
ooze->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);
ooze2->ForcedDespawn();
if (ooze->GetAura(SPELL_UNSTABLE_OOZE) && ooze->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)
{
ooze->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);
ooze->ForcedDespawn();
}
continue;
}
}
}
else //if first ooze is little
{
if (little2) //and second ooze is little, despawn both and summon big ooze
{
DoSummon(CREATURE_OOZE_BIG, (*ooze));
ooze->ForcedDespawn();
ooze2->ForcedDespawn();
break;
}
else
{
ooze2->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);
ooze->ForcedDespawn();
if (ooze2->GetAura(SPELL_UNSTABLE_OOZE) && ooze2->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)
{
ooze2->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);
ooze2->ForcedDespawn();
}
break;
}
}
}
}
}
void UpdateAI(const uint32 diff)
{
if (!phase)
return;
events.Update(diff);
if ((phase != PHASE_BIRTH && !UpdateVictim()) || !CheckInRoom())
return;
if (CanTheHundredClub)
{
if (CheckFrostResistTimer <= diff)
{
CheckPlayersFrostResist();
CheckFrostResistTimer = (rand() % 5 + 5) * 1000;
} else CheckFrostResistTimer -= diff;
}
if (phase == PHASE_GROUND)
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
DoScriptText(EMOTE_ENRAGE, me);
DoCast(me, SPELL_BERSERK);
return;
case EVENT_CLEAVE:
DoCast(me->getVictim(), SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, 5000+rand()%10000, 0, PHASE_GROUND);
return;
case EVENT_TAIL:
DoCastAOE(SPELL_TAIL_SWEEP);
events.ScheduleEvent(EVENT_TAIL, 5000+rand()%10000, 0, PHASE_GROUND);
return;
case EVENT_DRAIN:
DoCastAOE(SPELL_LIFE_DRAIN);
events.ScheduleEvent(EVENT_DRAIN, 24000, 0, PHASE_GROUND);
return;
case EVENT_BLIZZARD:
{
//DoCastAOE(SPELL_SUMMON_BLIZZARD);
if (Creature* summon = DoSummon(MOB_BLIZZARD, me, 0.0f, urand(25000, 30000), TEMPSUMMON_TIMED_DESPAWN))
summon->GetMotionMaster()->MoveRandom(40);
events.ScheduleEvent(EVENT_BLIZZARD, RAID_MODE(20000, 7000), 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:
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->SetLevitate(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, 1000);
else
events.ScheduleEvent(EVENT_BREATH, 1000);
return;
}
case EVENT_BREATH:
{
DoScriptText(EMOTE_BREATH, me);
DoCastAOE(SPELL_FROST_MISSILE);
events.ScheduleEvent(EVENT_EXPLOSION, 8000);
return;
}
case EVENT_EXPLOSION:
CastExplosion();
ClearIceBlock();
events.ScheduleEvent(EVENT_LAND, 3000);
return;
case EVENT_LAND:
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
me->SetLevitate(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;
}
}//if (uint32 eventId = events.ExecuteEvent())
}//if (phase == PHASE_GROUND)
}
void UpdateAI(uint32 uiDiff)
{
if (!UpdateVictim())
return;
if (!bIsFrenzy && !bIsExploded && HealthBelowPct(25))
{
Talk(SAY_ENRAGE);
me->CastSpell(me, SPELL_FRENZY, true);
bIsFrenzy = true;
}
if (!bIsFrenzy)
{
if (!bIsExploded)
{
if (!me->HasAura(SPELL_PROTECTIVE_BUBBLE))
{
me->InterruptNonMeleeSpells(false);
Talk(SAY_SHATTER);
DoZoneInCombat();
IchoronDoCastToAllHostilePlayers(SPELL_WATER_BLAST, true);
me->CastSpell(me, SPELL_DRAINED, true);
bIsExploded = true;
uiDrainedTimer = 15000;
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(11686);
for (uint8 i=0; i<MAX_SPAWN_LOC; ++i)
{
float angle = rand_norm()*2*M_PI;
Position p1(SpawnLoc[i]), p2(SpawnLoc[i]);
p1.m_positionX += 2.5f*cos(angle);
p1.m_positionY += 2.5f*sin(angle);
p2.m_positionX -= 2.5f*cos(angle);
p2.m_positionY -= 2.5f*sin(angle);
DoSummon(NPC_ICHOR_GLOBULE, p1, 60000, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN);
DoSummon(NPC_ICHOR_GLOBULE, p2, 60000, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN);
}
}
}
else
{
if (uiDrainedTimer <= uiDiff)
DoExplodeCompleted();
else
{
uiDrainedTimer -= uiDiff;
bool bIsWaterElementsAlive = false;
if (!globules.empty())
{
for (std::list<uint64>::const_iterator itr = globules.begin(); itr != globules.end(); ++itr)
if (Creature* pTemp = ObjectAccessor::GetCreature(*me, *itr))
if (pTemp->IsAlive())
{
bIsWaterElementsAlive = true;
break;
}
}
if (!bIsWaterElementsAlive)
DoExplodeCompleted();
}
}
}
if (!bIsExploded)
{
if (uiWaterBoltVolleyTimer <= uiDiff)
{
me->CastSpell((Unit*)NULL, SPELL_WATER_BOLT_VOLLEY, false);
uiWaterBoltVolleyTimer = urand(10000, 15000);
}
else uiWaterBoltVolleyTimer -= uiDiff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
EncounterTime += diff;
ConstructTimer += diff;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_JET:
me->MonsterTextEmote(EMOTE_JETS, 0, true);
DoCastAOE(SPELL_FLAME_JETS);
events.RescheduleEvent(EVENT_JET,urand(35000,40000));
break;
case EVENT_SLAG_POT:
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
DoScriptText(SAY_SLAG_POT, me);
SlagPotGUID = pTarget->GetGUID();
DoCast(pTarget, SPELL_GRAB);
events.DelayEvents(3000);
events.ScheduleEvent(EVENT_GRAB_POT, 500);
}
events.RescheduleEvent(EVENT_SLAG_POT,RAID_MODE(30000, 15000));
break;
case EVENT_GRAB_POT:
if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
{
SlagPotTarget->EnterVehicle(me, 0);
events.CancelEvent(EVENT_GRAB_POT);
events.ScheduleEvent(EVENT_CHANGE_POT, 1000);
}
break;
case EVENT_CHANGE_POT:
if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
{
SlagPotTarget->AddAura(SPELL_SLAG_POT, SlagPotTarget);
SlagPotTarget->EnterVehicle(me, 1);
events.CancelEvent(EVENT_CHANGE_POT);
events.ScheduleEvent(EVENT_END_POT, 10000);
}
break;
case EVENT_END_POT:
if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))
{
SlagPotTarget->ExitVehicle();
SlagPotTarget = NULL;
SlagPotGUID = NULL;
events.CancelEvent(EVENT_END_POT);
}
break;
case EVENT_SCORCH:
DoScriptText(RAND(SAY_SCORCH_1, SAY_SCORCH_2), me);
if (Unit *pTarget = me->getVictim())
me->SummonCreature(NPC_GROUND_SCORCH, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 45000);
DoCast(SPELL_SCORCH);
events.RescheduleEvent(EVENT_SCORCH,25000);
break;
case EVENT_CONSTRUCT:
DoScriptText(SAY_SUMMON, me);
DoSummon(NPC_IRON_CONSTRUCT, Pos[rand()%20], 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT);
DoCast(SPELL_STRENGHT);
DoCast(me, SPELL_ACTIVATE_CONSTRUCT);
events.RescheduleEvent(EVENT_CONSTRUCT,RAID_MODE(40000, 30000));
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
DoScriptText(SAY_BERSERK, me);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (LamentEvent)
{
if (LamentEvent_Timer <= diff)
{
DoSummon(ENTRY_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);
LamentEvent_Timer = 2000;
if (!me->HasAura(SPELL_SYLVANAS_CAST))
{
DoScriptText(SAY_LAMENT_END, me);
DoScriptText(EMOTE_LAMENT_END, me);
LamentEvent = false;
}
}
else
LamentEvent_Timer -= diff;
}
if (!UpdateVictim())
return;
if (_fadeTimer <= diff)
{
DoCast(SPELL_FADE);
_fadeTimer = 10 *IN_MILLISECONDS;
}
else
_fadeTimer -= diff;
if (_blackarrowTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
{
DoCast(target, SPELL_BLACK_ARROW);
_blackarrowTimer = urand(12, 15) *IN_MILLISECONDS;
}
}
else
_blackarrowTimer -= diff;
if (_multishotTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (target)
{
DoCast(target, SPELL_MULTI_SHOT);
_multishotTimer = urand(8, 10) *IN_MILLISECONDS;
}
}
else
_multishotTimer -= diff;
if (_shootTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (target)
{
DoCast(target, SPELL_SHOOT);
_shootTimer = urand(2, 4) *IN_MILLISECONDS;
}
}
else
_shootTimer -= diff;
if (_summonskeletonTimer <= diff)
{
DoCast(SPELL_SUMMON_SKELETON);
_summonskeletonTimer = 10 *IN_MILLISECONDS;
}
else
_summonskeletonTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->hasUnitState(UNIT_STAT_CASTING))
return;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_SHADOW_CRASH:
if (Unit *pTarget = SelectUnit(SELECT_TARGET_FARTHEST, 0))
if (!pTarget->IsWithinDist(me, 15))
DoCast(pTarget, SPELL_SHADOW_CRASH);
events.ScheduleEvent(EVENT_SHADOW_CRASH, urand(6000, 10000));
break;
case EVENT_SEARING_FLAMES:
DoCastAOE(SPELL_SEARING_FLAMES);
events.ScheduleEvent(EVENT_SEARING_FLAMES, urand(10000,20000));
break;
case EVENT_DARKNESS:
me->MonsterTextEmote(EMOTE_DARKNESS, 0, true);
DoScriptText(SAY_KITE, me);
DoCast(me, SPELL_SURGE_OF_DARKNESS);
events.ScheduleEvent(EVENT_DARKNESS, urand(60000, 70000));
break;
case EVENT_MARK:
if (Unit *pTarget = SelectUnit(SELECT_TARGET_FARTHEST, 0))
DoCast(pTarget, SPELL_MARK_OF_THE_FACELESS);
events.ScheduleEvent(EVENT_MARK, urand(35000, 40000));
break;
case EVENT_SARONITE_VAPORS:
me->MonsterTextEmote(EMOTE_VAPORS, 0, true);
DoSummon(MOB_SARONITE_VAPORS, VaporPos[rand()%6], 3000, TEMPSUMMON_CORPSE_TIMED_DESPAWN);
events.ScheduleEvent(EVENT_SARONITE_VAPORS, 30000);
VaporsCount++;
if (VaporsCount == 6 && HardMode)
{
me->MonsterTextEmote(EMOTE_ANIMUS, 0, true);
DoScriptText(SAY_HARDMODE_ON, me);
me->MonsterTextEmote(EMOTE_BARRIER, 0, true);
DoCast(SPELL_SARONITE_BARRIER);
DoCast(SPELL_SUMMON_SARONITE_ANIMUS);
me->AddLootMode(LOOT_MODE_HARD_MODE_1);
DespawnCreatures(MOB_SARONITE_VAPORS, 100);
events.CancelEvent(EVENT_SARONITE_VAPORS);
events.CancelEvent(EVENT_SEARING_FLAMES);
}
if (VaporsCount == 8)
events.CancelEvent(EVENT_SARONITE_VAPORS);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
DoScriptText(SAY_BERSERK, me);
events.CancelEvent(EVENT_BERSERK);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (LamentEvent)
{
if (LamentEventTimer <= diff)
{
DoSummon(ENTRY_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);
LamentEventTimer = 2000;
if (!me->HasAura(SPELL_SYLVANAS_CAST))
{
Talk(SAY_LAMENT_END);
Talk(EMOTE_LAMENT_END);
LamentEvent = false;
}
} else LamentEventTimer -= diff;
}
if (!UpdateVictim())
return;
// Combat spells
if (FadeTimer <= diff)
{
DoCast(me, SPELL_FADE);
// add a blink to simulate a stealthed movement and reappearing elsewhere
DoCast(me, SPELL_FADE_BLINK);
FadeTimer = 30000 + rand32() % 5000;
// if the victim is out of melee range she cast multi shot
if (Unit* victim = me->GetVictim())
if (me->GetDistance(victim) > 10.0f)
DoCast(victim, SPELL_MULTI_SHOT);
} else FadeTimer -= diff;
if (SummonSkeletonTimer <= diff)
{
DoCast(me, SPELL_SUMMON_SKELETON);
SummonSkeletonTimer = 20000 + rand32() % 10000;
} else SummonSkeletonTimer -= diff;
if (BlackArrowTimer <= diff)
{
if (Unit* victim = me->GetVictim())
{
DoCast(victim, SPELL_BLACK_ARROW);
BlackArrowTimer = 15000 + rand32() % 5000;
}
} else BlackArrowTimer -= diff;
if (ShotTimer <= diff)
{
if (Unit* victim = me->GetVictim())
{
DoCast(victim, SPELL_SHOT);
ShotTimer = 8000 + rand32() % 2000;
}
} else ShotTimer -= diff;
if (MultiShotTimer <= diff)
{
if (Unit* victim = me->GetVictim())
{
DoCast(victim, SPELL_MULTI_SHOT);
MultiShotTimer = 10000 + rand32() % 3000;
}
} else MultiShotTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() && !LamentEvent)
return;
_events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FADE:
DoCast(me, SPELL_FADE);
// add a blink to simulate a stealthed movement and reappearing elsewhere
DoCast(me, SPELL_FADE_BLINK);
// if the victim is out of melee range she cast multi shot
if (Unit* victim = me->GetVictim())
if (me->GetDistance(victim) > 10.0f)
DoCast(victim, SPELL_MULTI_SHOT);
_events.ScheduleEvent(EVENT_FADE, urand(30000, 35000));
break;
case EVENT_SUMMON_SKELETON:
DoCast(me, SPELL_SUMMON_SKELETON);
_events.ScheduleEvent(EVENT_SUMMON_SKELETON, urand(20000, 30000));
break;
case EVENT_BLACK_ARROW:
if (Unit* victim = me->GetVictim())
DoCast(victim, SPELL_BLACK_ARROW);
_events.ScheduleEvent(EVENT_BLACK_ARROW, urand(15000, 20000));
break;
case EVENT_SHOOT:
if (Unit* victim = me->GetVictim())
DoCast(victim, SPELL_SHOT);
_events.ScheduleEvent(EVENT_SHOOT, urand(8000, 10000));
break;
case EVENT_MULTI_SHOT:
if (Unit* victim = me->GetVictim())
DoCast(victim, SPELL_MULTI_SHOT);
_events.ScheduleEvent(EVENT_MULTI_SHOT, urand(10000, 13000));
break;
case EVENT_LAMENT_OF_THE_HIGHBORN:
if (!me->HasAura(SPELL_SYLVANAS_CAST))
{
Talk(SAY_LAMENT_END);
Talk(EMOTE_LAMENT_END);
LamentEvent = false;
me->HandleEmoteCommand(EMOTE_ONESHOT_KNEEL);
Reset();
}
else
{
DoSummon(NPC_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);
_events.ScheduleEvent(EVENT_LAMENT_OF_THE_HIGHBORN, 2000);
}
break;
case EVENT_SUNSORROW_WHISPER:
if (Creature* ambassador = me->FindNearestCreature(NPC_AMBASSADOR_SUNSORROW, 20.0f))
if (Player* player = ObjectAccessor::GetPlayer(*me, playerGUID))
ambassador->AI()->Talk(SAY_SUNSORROW_WHISPER, player);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (Phase == 1)
{
while (uint32 eventId = events.GetEvent())
{
switch (eventId)
{
case EVENT_WASTE:
DoSummon(NPC_WASTE, Pos[RAND(0, 3, 6, 9)]);
events.RepeatEvent(urand(2000, 5000));
break;
case EVENT_ABOMIN:
if (nAbomination < 8)
{
DoSummon(NPC_ABOMINATION, Pos[RAND(1, 4, 7, 10)]);
nAbomination++;
events.RepeatEvent(20000);
}
else
events.PopEvent();
break;
case EVENT_WEAVER:
if (nWeaver < 8)
{
DoSummon(NPC_WEAVER, Pos[RAND(0, 3, 6, 9)]);
nWeaver++;
events.RepeatEvent(25000);
}
else
events.PopEvent();
break;
case EVENT_TRIGGER:
if (GameObject* pKTTrigger = me->GetMap()->GetGameObject(KTTriggerGUID))
pKTTrigger->SetPhaseMask(2, true);
events.PopEvent();
break;
case EVENT_PHASE:
events.Reset();
DoScriptText(RAND(SAY_AGGRO_1, SAY_AGGRO_2, SAY_AGGRO_3), me);
spawns.DespawnAll();
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_DISABLE_MOVE | UNIT_FLAG_NOT_SELECTABLE);
me->CastStop();
DoStartMovement(me->getVictim());
events.ScheduleEvent(EVENT_BOLT, urand(5000, 10000));
events.ScheduleEvent(EVENT_NOVA, 15000);
events.ScheduleEvent(EVENT_DETONATE, urand(30000, 40000));
events.ScheduleEvent(EVENT_FISSURE, urand(10000, 30000));
events.ScheduleEvent(EVENT_BLAST, urand(60000, 120000));
if (GetDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)
events.ScheduleEvent(EVENT_CHAIN, urand(30000, 60000));
Phase = 2;
break;
default:
events.PopEvent();
break;
}
}
}
else
{
//start phase 3 when we are 45% health
if (Phase != 3)
{
if (HealthBelowPct(45))
{
Phase = 3;
DoScriptText(SAY_REQUEST_AID, me);
//here Lich King should respond to KelThuzad but I don't know which Creature to make talk
//so for now just make Kelthuzad says it.
DoScriptText(SAY_ANSWER_REQUEST, me);
for (uint8 i = 0; i <= 3; ++i)
{
if (GameObject* pPortal = me->GetMap()->GetGameObject(PortalsGUID[i]))
{
if (pPortal->getLootState() == GO_READY)
pPortal->UseDoorOrButton();
}
}
}
}
else if (nGuardiansOfIcecrownCount < RAID_MODE(2, 4))
{
if (uiGuardiansOfIcecrownTimer <= diff)
{
// TODO : Add missing text
if (Creature* pGuardian = DoSummon(NPC_ICECROWN, Pos[RAND(2, 5, 8, 11)]))
pGuardian->SetFloatValue(UNIT_FIELD_COMBATREACH, 2);
++nGuardiansOfIcecrownCount;
uiGuardiansOfIcecrownTimer = 5000;
}
else uiGuardiansOfIcecrownTimer -= diff;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (uint32 eventId = events.GetEvent())
{
switch (eventId)
{
case EVENT_BOLT:
DoCastVictim(RAID_MODE(SPELL_FROST_BOLT, H_SPELL_FROST_BOLT));
events.RepeatEvent(urand(5000, 10000));
break;
case EVENT_NOVA:
DoCastAOE(RAID_MODE(SPELL_FROST_BOLT_AOE, H_SPELL_FROST_BOLT_AOE));
events.RepeatEvent(urand(15000, 30000));
break;
case EVENT_CHAIN:
{
uint32 count = urand(1, 3);
for (uint8 i = 1; i <= count; i++)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 200, true);
if (target && !target->isCharmed() && (chained.find(target->GetGUID()) == chained.end()))
{
DoCast(target, SPELL_CHAINS_OF_KELTHUZAD);
float scale = target->GetFloatValue(OBJECT_FIELD_SCALE_X);
chained.insert(std::make_pair(target->GetGUID(), scale));
target->SetFloatValue(OBJECT_FIELD_SCALE_X, scale * 2);
events.ScheduleEvent(EVENT_CHAINED_SPELL, 2000); //core has 2000ms to set unit flag charm
}
}
if (!chained.empty())
DoScriptText(RAND(SAY_CHAIN_1, SAY_CHAIN_2), me);
events.RepeatEvent(urand(100000, 180000));
break;
}
case EVENT_CHAINED_SPELL:
{
std::map<uint64, float>::iterator itr;
for (itr = chained.begin(); itr != chained.end();)
{
if (Unit* player = Unit::GetPlayer(*me, (*itr).first))
{
if (!player->isCharmed())
{
player->SetFloatValue(OBJECT_FIELD_SCALE_X, (*itr).second);
std::map<uint64, float>::iterator next = itr;
++next;
chained.erase(itr);
itr = next;
continue;
}
if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO, 0, NotCharmedTargetSelector()))
{
switch (player->getClass())
{
case CLASS_DRUID:
if (urand(0, 1))
player->CastSpell(target, SPELL_MOONFIRE, false);
else
player->CastSpell(me, SPELL_LIFEBLOOM, false);
break;
case CLASS_HUNTER:
player->CastSpell(target, RAND(SPELL_MULTI_SHOT, SPELL_VOLLEY), false);
break;
case CLASS_MAGE:
player->CastSpell(target, RAND(SPELL_FROST_FIREBOLT, SPELL_ARCANE_MISSILES), false);
break;
case CLASS_WARLOCK:
player->CastSpell(target, RAND(SPELL_CURSE_OF_AGONY, SPELL_SHADOW_BOLT), true);
break;
case CLASS_WARRIOR:
player->CastSpell(target, RAND(SPELL_BLADESTORM, SPELL_CLEAVE), false);
break;
case CLASS_PALADIN:
if (urand(0, 1))
player->CastSpell(target, SPELL_HAMMER_OF_JUSTICE, false);
else
player->CastSpell(me, SPELL_HOLY_SHOCK, false);
break;
case CLASS_PRIEST:
if (urand(0, 1))
player->CastSpell(target, SPELL_VAMPIRIC_TOUCH, false);
else
player->CastSpell(me, SPELL_RENEW, false);
break;
case CLASS_SHAMAN:
if (urand(0, 1))
player->CastSpell(target, SPELL_EARTH_SHOCK, false);
else
player->CastSpell(me, SPELL_HEALING_WAVE, false);
break;
case CLASS_ROGUE:
player->CastSpell(target, RAND(SPELL_HEMORRHAGE, SPELL_MUTILATE), false);
break;
case CLASS_DEATH_KNIGHT:
if (urand(0, 1))
player->CastSpell(target, SPELL_PLAGUE_STRIKE, true);
else
player->CastSpell(target, SPELL_HOWLING_BLAST, true);
break;
}
}
}
++itr;
}
if (chained.empty())
events.PopEvent();
else
events.RepeatEvent(5000);
break;
}
case EVENT_DETONATE:
{
std::vector<Unit*> unitList;
std::list<HostileReference*> *threatList = &me->getThreatManager().getThreatList();
for (std::list<HostileReference*>::const_iterator itr = threatList->begin(); itr != threatList->end(); ++itr)
{
if ((*itr)->getTarget()->GetTypeId() == TYPEID_PLAYER
&& (*itr)->getTarget()->getPowerType() == POWER_MANA
&& (*itr)->getTarget()->GetPower(POWER_MANA))
unitList.push_back((*itr)->getTarget());
}
if (!unitList.empty())
{
std::vector<Unit*>::const_iterator itr = unitList.begin();
advance(itr, rand()%unitList.size());
DoCast(*itr, SPELL_MANA_DETONATION);
DoScriptText(RAND(SAY_SPECIAL_1, SAY_SPECIAL_2, SAY_SPECIAL_3), me);
}
events.RepeatEvent(urand(20000, 50000));
break;
}
case EVENT_FISSURE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SHADOW_FISURE);
events.RepeatEvent(urand(10000, 45000));
break;
case EVENT_BLAST:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, RAID_MODE(1, 0), 0, true))
DoCast(target, SPELL_FROST_BLAST);
if (rand()%2)
DoScriptText(SAY_FROST_BLAST, me);
events.RepeatEvent(urand(30000, 90000));
break;
default:
events.PopEvent();
break;
}
}
DoMeleeAttackIfReady();
}
}
