void UpdateAI(uint32 diff) override
{
switch (Phase)
{
case COMBAT:
//Return since we have no target
if (!UpdateVictim())
return;
if (!bYelled && HealthBelowPct(30))
{
Talk(SAY_30HEALTH);
bYelled = true;
}
if (!bYelled2 && HealthBelowPct(15))
{
Talk(SAY_15HEALTH);
bYelled2 = true;
}
if (HealthBelowPct(1))
{
//Handle Escape Event: Don't forget to add Player::RewardPlayerAndGroupAtEvent
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
uiOutroStep = 1;
Phase = OUTRO;
return;
}
if (Creature* pArthas = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_ARTHAS)))
if (pArthas->isDead())
{
EnterEvadeMode();
me->DisappearAndDie();
instance->SetBossState(DATA_MAL_GANIS, FAIL);
}
if (uiCarrionSwarmTimer < diff)
{
DoCastVictim(SPELL_CARRION_SWARM);
uiCarrionSwarmTimer = 7000;
} else uiCarrionSwarmTimer -= diff;
if (uiMindBlastTimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_MIND_BLAST);
uiMindBlastTimer = 6000;
} else uiMindBlastTimer -= diff;
if (uiVampiricTouchTimer < diff)
{
DoCast(me, SPELL_VAMPIRIC_TOUCH);
uiVampiricTouchTimer = 32000;
} else uiVampiricTouchTimer -= diff;
if (uiSleepTimer < diff)
{
Talk(SAY_SLEEP);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_SLEEP);
uiSleepTimer = urand(15000, 20000);
} else uiSleepTimer -= diff;
DoMeleeAttackIfReady();
break;
case OUTRO:
if (uiOutroTimer < diff)
{
switch (uiOutroStep)
{
case 1:
Talk(SAY_OUTRO);
me->GetMotionMaster()->MoveTargetedHome();
++uiOutroStep;
uiOutroTimer = 8000;
break;
case 2:
me->SetTarget(instance->GetGuidData(DATA_ARTHAS));
me->HandleEmoteCommand(29);
Talk(SAY_ESCAPE_SPEECH_2);
++uiOutroStep;
uiOutroTimer = 9000;
break;
case 3:
Talk(SAY_OUTRO);
++uiOutroStep;
//uiOutroTimer = 16000;
break;
case 4:
me->HandleEmoteCommand(33);
++uiOutroStep;
uiOutroTimer = 500;
break;
case 5:
me->SetVisible(false);
me->Kill(me);
break;
}
} else uiOutroTimer -= diff;
break;
}
}
void SetInFace(bool isRight)
{
if (GameObject* go = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(isRight ? DATA_GO_CAVE_IN_RIGHT : DATA_GO_CAVE_IN_LEFT)))
me->SetFacingToObject(go);
}
void UpdateAI(uint32 diff) override
{
if (!EventBegun)
return;
if (EndEventTimer)
{
if (EndEventTimer <= diff)
{
if (DeathCount > 3)
{
if (Creature* VoiceTrigger = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_BLOOD_ELF_COUNCIL_VOICE)))
VoiceTrigger->DealDamage(VoiceTrigger, VoiceTrigger->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
instance->SetBossState(DATA_ILLIDARI_COUNCIL, DONE);
//me->SummonCreature(AKAMAID, 746.466980f, 304.394989f, 311.90208f, 6.272870f, TEMPSUMMON_DEAD_DESPAWN, 0);
me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
return;
}
Creature* pMember = (ObjectAccessor::GetCreature(*me, Council[DeathCount]));
if (pMember && pMember->IsAlive())
pMember->DealDamage(pMember, pMember->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
++DeathCount;
EndEventTimer = 1500;
} else EndEventTimer -= diff;
}
if (CheckTimer)
{
if (CheckTimer <= diff)
{
uint8 EvadeCheck = 0;
for (uint8 i = 0; i < 4; ++i)
{
if (!Council[i].IsEmpty())
{
if (Creature* Member = (ObjectAccessor::GetCreature((*me), Council[i])))
{
// This is the evade/death check.
if (Member->IsAlive() && !Member->GetVictim())
++EvadeCheck; //If all members evade, we reset so that players can properly reset the event
else if (!Member->IsAlive()) // If even one member dies, kill the rest, set instance data, and kill self.
{
EndEventTimer = 1000;
CheckTimer = 0;
return;
}
}
}
}
if (EvadeCheck > 3)
Reset();
CheckTimer = 2000;
} else CheckTimer -= diff;
}
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
//SweepingStrikes_Timer
if (SweepingStrikes_Timer <= diff)
{
DoCastVictim(SPELL_SWEEPINGSTRIKES);
SweepingStrikes_Timer = 22000 + rand32() % 4000;
} else SweepingStrikes_Timer -= diff;
//SinisterStrike_Timer
if (SinisterStrike_Timer <= diff)
{
DoCastVictim(SPELL_SINISTERSTRIKE);
SinisterStrike_Timer = 8000 + rand32() % 8000;
} else SinisterStrike_Timer -= diff;
//Gouge_Timer
if (Gouge_Timer <= diff)
{
DoCastVictim(SPELL_GOUGE);
if (GetThreat(me->GetVictim()))
ModifyThreatByPercent(me->GetVictim(), -100);
Gouge_Timer = 17000 + rand32() % 10000;
} else Gouge_Timer -= diff;
//Kick_Timer
if (Kick_Timer <= diff)
{
DoCastVictim(SPELL_KICK);
Kick_Timer = 15000 + rand32() % 10000;
} else Kick_Timer -= diff;
//Blind_Timer
if (Blind_Timer <= diff)
{
DoCastVictim(SPELL_BLIND);
Blind_Timer = 10000 + rand32() % 10000;
} else Blind_Timer -= diff;
//Check_Timer for the death of LorKhan and Zath.
if (!FakeDeath && Check_Timer <= diff)
{
if (instance->GetBossState(DATA_LORKHAN) == SPECIAL)
{
//Resurrect LorKhan
if (Unit* pLorKhan = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_LORKHAN)))
{
pLorKhan->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
pLorKhan->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pLorKhan->SetFaction(14);
pLorKhan->SetFullHealth();
}
}
if (instance->GetBossState(DATA_THEKAL) == SPECIAL)
{
//Resurrect Thekal
if (Unit* pThekal = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_THEKAL)))
{
pThekal->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
pThekal->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pThekal->SetFaction(14);
pThekal->SetFullHealth();
}
}
Check_Timer = 5000;
} else Check_Timer -= diff;
if (!HealthAbovePct(5))
{
me->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE_PERCENT);
me->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
me->RemoveAurasByType(SPELL_AURA_PERIODIC_LEECH);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetStandState(UNIT_STAND_STATE_SLEEP);
me->SetFaction(35);
me->AttackStop();
instance->SetBossState(DATA_ZATH, SPECIAL);
FakeDeath = true;
}
DoMeleeAttackIfReady();
}
bool OnUse(Player* player, Item* /*item*/, SpellCastTargets const& targets) override
{
InstanceScript* instance = player->GetInstanceScript();
if (!instance)
{
player->GetSession()->SendNotification(TEXT_NOT_INITIALIZED);
return true;
}
Creature* vashj = ObjectAccessor::GetCreature((*player), instance->GetGuidData(DATA_LADYVASHJ));
if (vashj && (ENSURE_AI(boss_lady_vashj::boss_lady_vashjAI, vashj->AI())->Phase == 2))
{
if (GameObject* gObj = targets.GetGOTarget())
{
uint32 identifier;
uint8 channelIdentifier;
switch (gObj->GetEntry())
{
case 185052:
identifier = DATA_SHIELDGENERATOR1;
channelIdentifier = 0;
break;
case 185053:
identifier = DATA_SHIELDGENERATOR2;
channelIdentifier = 1;
break;
case 185051:
identifier = DATA_SHIELDGENERATOR3;
channelIdentifier = 2;
break;
case 185054:
identifier = DATA_SHIELDGENERATOR4;
channelIdentifier = 3;
break;
default:
return true;
}
if (instance->GetData(identifier))
{
player->GetSession()->SendNotification(TEXT_ALREADY_DEACTIVATED);
return true;
}
// get and remove channel
if (Unit* channel = ObjectAccessor::GetCreature(*vashj, ENSURE_AI(boss_lady_vashj::boss_lady_vashjAI, vashj->AI())->ShieldGeneratorChannel[channelIdentifier]))
channel->setDeathState(JUST_DIED); // call Unsummon()
instance->SetData(identifier, 1);
// remove this item
player->DestroyItemCount(31088, 1, true);
return true;
}
else if (targets.GetUnitTarget()->GetTypeId() == TYPEID_UNIT)
return false;
else if (targets.GetUnitTarget()->GetTypeId() == TYPEID_PLAYER)
{
player->DestroyItemCount(31088, 1, true);
player->CastSpell(targets.GetUnitTarget(), 38134, true);
return true;
}
}
return true;
}
void HandleFlightSequence()
{
switch (uiFlightCount)
{
case 0:
//me->AttackStop();
me->GetMotionMaster()->Clear(false);
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->StopMoving();
Talk(YELL_TAKEOFF);
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 2000);
break;
case 1:
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()+1, me->GetPositionY(), me->GetPositionZ()+10);
break;
case 2:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if (!target)
target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_PLAYER_GUID));
if (!target)
{
EnterEvadeMode();
return;
}
if (Creature* Vapor = me->SummonCreature(NPC_VAPOR, target->GetPositionX() - 5 + rand32() % 10, target->GetPositionY() - 5 + rand32() % 10, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 9000))
{
Vapor->AI()->AttackStart(target);
me->InterruptNonMeleeSpells(false);
DoCast(Vapor, SPELL_VAPOR_CHANNEL, false); // core bug
Vapor->CastSpell(Vapor, SPELL_VAPOR_TRIGGER, true);
}
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 10000);
break;
}
case 3:
{
DespawnSummons(NPC_VAPOR_TRAIL);
//DoCast(me, SPELL_VAPOR_SELECT); need core support
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if (!target)
target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_PLAYER_GUID));
if (!target)
{
EnterEvadeMode();
return;
}
//target->CastSpell(target, SPELL_VAPOR_SUMMON, true); need core support
if (Creature* pVapor = me->SummonCreature(NPC_VAPOR, target->GetPositionX() - 5 + rand32() % 10, target->GetPositionY() - 5 + rand32() % 10, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 9000))
{
if (pVapor->AI())
pVapor->AI()->AttackStart(target);
me->InterruptNonMeleeSpells(false);
DoCast(pVapor, SPELL_VAPOR_CHANNEL, false); // core bug
pVapor->CastSpell(pVapor, SPELL_VAPOR_TRIGGER, true);
}
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 10000);
break;
}
case 4:
DespawnSummons(NPC_VAPOR_TRAIL);
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 1);
break;
case 5:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if (!target)
target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_PLAYER_GUID));
if (!target)
{
EnterEvadeMode();
return;
}
breathX = target->GetPositionX();
breathY = target->GetPositionY();
float x, y, z;
target->GetContactPoint(me, x, y, z, 70);
me->GetMotionMaster()->MovePoint(0, x, y, z+10);
break;
}
case 6:
me->SetFacingTo(me->GetAngle(breathX, breathY));
//DoTextEmote("takes a deep breath.", NULL);
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 10000);
break;
case 7:
{
DoCast(me, SPELL_FOG_BREATH, true);
float x, y, z;
me->GetPosition(x, y, z);
x = 2 * breathX - x;
y = 2 * breathY - y;
me->GetMotionMaster()->MovePoint(0, x, y, z);
events.ScheduleEvent(EVENT_SUMMON_FOG, 1);
break;
}
case 8:
me->CastStop(SPELL_FOG_BREATH);
me->RemoveAurasDueToSpell(SPELL_FOG_BREATH);
++uiBreathCount;
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 1);
if (uiBreathCount < 3)
uiFlightCount = 4;
break;
case 9:
if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
DoStartMovement(target);
else
{
EnterEvadeMode();
return;
}
break;
case 10:
me->SetDisableGravity(false);
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
EnterPhase(PHASE_GROUND);
AttackStart(SelectTarget(SELECT_TARGET_TOPAGGRO));
break;
}
++uiFlightCount;
}
void WaypointReached(uint32 waypointId) override
{
switch (waypointId)
{
case 8:
SetRun(false);
me->SummonCreature(18764, 2181.87f, 112.46f, 89.45f, 0.26f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
break;
case 9:
Talk(SAY_TH_ARMORY);
me->SetVirtualItem(0, THRALL_WEAPON_ITEM);
//me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO, THRALL_WEAPON_INFO);
//me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO+1, 781);
me->SetVirtualItem(1, THRALL_SHIELD_ITEM);
//me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO+2, THRALL_SHIELD_INFO);
//me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO+3, 1038);
break;
case 10:
me->SetDisplayId(THRALL_MODEL_EQUIPPED);
break;
case 11:
SetRun();
break;
case 15:
me->SummonCreature(NPC_RIFLE, 2200.28f, 137.37f, 87.93f, 5.07f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_WARDEN, 2197.44f, 131.83f, 87.93f, 0.78f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_VETERAN, 2203.62f, 135.40f, 87.93f, 3.70f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_VETERAN, 2200.75f, 130.13f, 87.93f, 1.48f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
break;
case 21:
me->SummonCreature(NPC_RIFLE, 2135.80f, 154.01f, 67.45f, 4.98f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_WARDEN, 2144.36f, 151.87f, 67.74f, 4.46f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_VETERAN, 2142.12f, 154.41f, 67.12f, 4.56f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_VETERAN, 2138.08f, 155.38f, 67.24f, 4.60f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
break;
case 25:
me->SummonCreature(NPC_RIFLE, 2102.98f, 192.17f, 65.24f, 6.02f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_WARDEN, 2108.48f, 198.75f, 65.18f, 5.15f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_VETERAN, 2106.11f, 197.29f, 65.18f, 5.63f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_VETERAN, 2104.18f, 194.82f, 65.18f, 5.75f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
break;
case 29:
Talk(SAY_TH_SKARLOC_MEET);
me->SummonCreature(ENTRY_SCARLOC, 2036.48f, 271.22f, 63.43f, 5.27f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000);
//temporary, skarloc should rather be triggered to walk up to thrall
break;
case 30:
SetEscortPaused(true);
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
SetRun(false);
break;
case 31:
Talk(SAY_TH_MOUNTS_UP);
DoMount();
SetRun();
break;
case 37:
//possibly regular patrollers? If so, remove this and let database handle them
me->SummonCreature(NPC_WATCHMAN, 2124.26f, 522.16f, 56.87f, 3.99f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_WATCHMAN, 2121.69f, 525.37f, 57.11f, 4.01f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_SENTRY, 2124.65f, 524.55f, 56.63f, 3.98f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
break;
case 59:
me->SummonCreature(SKARLOC_MOUNT, 2488.64f, 625.77f, 58.26f, 4.71f, TEMPSUMMON_TIMED_DESPAWN, 10000);
DoUnmount();
HadMount = false;
SetRun(false);
break;
case 60:
me->HandleEmoteCommand(EMOTE_ONESHOT_EXCLAMATION);
//make horsie run off
SetEscortPaused(true);
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
instance->SetData(TYPE_THRALL_PART2, DONE);
SetRun();
break;
case 64:
SetRun(false);
break;
case 68:
me->SummonCreature(NPC_BARN_PROTECTOR, 2500.22f, 692.60f, 55.50f, 2.84f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_BARN_LOOKOUT, 2500.13f, 696.55f, 55.51f, 3.38f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_BARN_GUARDSMAN, 2500.55f, 693.64f, 55.50f, 3.14f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_BARN_GUARDSMAN, 2500.94f, 695.81f, 55.50f, 3.14f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
break;
case 71:
SetRun();
break;
case 81:
SetRun(false);
break;
case 83:
me->SummonCreature(NPC_CHURCH_PROTECTOR, 2627.33f, 646.82f, 56.03f, 4.28f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 5000);
me->SummonCreature(NPC_CHURCH_LOOKOUT, 2624.14f, 648.03f, 56.03f, 4.50f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 5000);
me->SummonCreature(NPC_CHURCH_GUARDSMAN, 2625.32f, 649.60f, 56.03f, 4.38f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 5000);
me->SummonCreature(NPC_CHURCH_GUARDSMAN, 2627.22f, 649.00f, 56.03f, 4.34f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 5000);
break;
case 84:
Talk(SAY_TH_CHURCH_END);
SetRun();
break;
case 91:
me->SetWalk(true);
SetRun(false);
break;
case 93:
me->SummonCreature(NPC_INN_PROTECTOR, 2652.71f, 660.31f, 61.93f, 1.67f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_INN_LOOKOUT, 2648.96f, 662.59f, 61.93f, 0.79f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_INN_GUARDSMAN, 2657.36f, 662.34f, 61.93f, 2.68f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
me->SummonCreature(NPC_INN_GUARDSMAN, 2656.39f, 659.77f, 61.93f, 2.61f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
break;
case 94:
if (Creature* Taretha = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_TARETHA)))
Taretha->AI()->Talk(SAY_TA_ESCAPED, me);
break;
case 95:
Talk(SAY_TH_MEET_TARETHA);
instance->SetData(TYPE_THRALL_PART3, DONE);
SetEscortPaused(true);
break;
case 96:
Talk(SAY_TH_EPOCH_WONDER);
break;
case 97:
Talk(SAY_TH_EPOCH_KILL_TARETHA);
SetRun();
break;
case 98:
//trigger epoch Yell("Thrall! Come outside and face your fate! ....")
//from here, thrall should not never be allowed to move to point 106 which he currently does.
break;
case 106:
{
//trigger taretha to run down outside
if (Creature* Taretha = instance->instance->GetCreature(instance->GetGuidData(DATA_TARETHA)))
{
if (Player* player = GetPlayerForEscort())
ENSURE_AI(npc_escortAI, (Taretha->AI()))->Start(false, true, player->GetGUID());
}
//kill credit Creature for quest
Map::PlayerList const& players = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
if (Player* player = itr->GetSource())
player->KilledMonsterCredit(20156);
}
//alot will happen here, thrall and taretha talk, erozion appear at spot to explain
me->SummonCreature(EROZION_ENTRY, 2646.47f, 680.416f, 55.38f, 4.16f, TEMPSUMMON_TIMED_DESPAWN, 120000);
}
break;
case 108:
//last waypoint, just set Thrall invisible, respawn is turned off
me->SetVisible(false);
break;
}
}
void UpdateAI(uint32 diff) override
{
//Only if not incombat check if the event is started
if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
{
if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
AttackStart(target);
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (!instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
if (!me->HasAura(SPELL_WINDFURY_WEAPON))
{
DoCast(me, SPELL_WINDFURY_WEAPON);
}
//FrostShock_Timer
if (FrostShock_Timer <= diff)
{
DoCastVictim(SPELL_FROST_SHOCK);
FrostShock_Timer = 25000 + rand32() % 5000;
} else FrostShock_Timer -= diff;
//Spitfire_Timer
if (Spitfire_Timer <= diff)
{
DoCast(me, SPELL_SPITFIRE_TOTEM);
if (Unit* SpitfireTotem = me->FindNearestCreature(CREATURE_SPITFIRE_TOTEM, 100.0f))
SpitfireTotem->ToCreature()->AI()->AttackStart(me->GetVictim());
Spitfire_Timer = 60000;
}
else
Spitfire_Timer -= diff;
//PoisonCleansing_Timer
if (PoisonCleansing_Timer <= diff)
{
DoCast(me, SPELL_POISON_CLEANSING_TOTEM);
PoisonCleansing_Timer = 30000;
}
else
PoisonCleansing_Timer -= diff;
//Earthbind_Timer
if (Earthbind_Timer <= diff)
{
DoCast(me, SPELL_EARTHBIND_TOTEM);
Earthbind_Timer = 45000;
}
else
Earthbind_Timer -= diff;
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/) override
{
if (Creature* Karathress = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_KARATHRESS)))
ENSURE_AI(boss_fathomlord_karathress::boss_fathomlord_karathressAI, Karathress->AI())->EventCaribdisDeath();
}
void UpdateAI(uint32 diff) override
{
//Only if not incombat check if the event is started
if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
{
if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
{
AttackStart(target);
GetAdvisors();
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (!instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//CataclysmicBolt_Timer
if (CataclysmicBolt_Timer <= diff)
{
//select a random unit other than the main tank
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
//if there aren't other units, cast on the tank
if (!target)
target = me->GetVictim();
if (target)
DoCast(target, SPELL_CATACLYSMIC_BOLT);
CataclysmicBolt_Timer = 10000;
} else CataclysmicBolt_Timer -= diff;
//SearNova_Timer
if (SearNova_Timer <= diff)
{
DoCastVictim(SPELL_SEAR_NOVA);
SearNova_Timer = 20000 + rand32() % 40000;
} else SearNova_Timer -= diff;
//Enrage_Timer
if (Enrage_Timer <= diff)
{
DoCast(me, SPELL_ENRAGE);
Enrage_Timer = 90000;
} else Enrage_Timer -= diff;
//Blessing of Tides Trigger
if (!HealthAbovePct(75) && !BlessingOfTides)
{
BlessingOfTides = true;
bool continueTriggering = false;
for (uint8 i = 0; i < MAX_ADVISORS; ++i)
{
if (!Advisors[i].IsEmpty())
{
Creature* advisor = ObjectAccessor::GetCreature(*me, Advisors[i]);
if (advisor && advisor->IsAlive())
{
continueTriggering = true;
break;
}
}
}
if (continueTriggering)
{
DoCast(me, SPELL_BLESSING_OF_THE_TIDES);
me->Yell(SAY_GAIN_BLESSING_OF_TIDES, LANG_UNIVERSAL);
DoPlaySoundToSet(me, SOUND_GAIN_BLESSING_OF_TIDES);
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
//Only if not incombat check if the event is started
if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
{
if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
AttackStart(target);
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (!instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//LeechingThrow_Timer
if (LeechingThrow_Timer <= diff)
{
DoCastVictim(SPELL_LEECHING_THROW);
LeechingThrow_Timer = 20000;
} else LeechingThrow_Timer -= diff;
//Multishot_Timer
if (Multishot_Timer <= diff)
{
DoCastVictim(SPELL_MULTISHOT);
Multishot_Timer = 20000;
} else Multishot_Timer -= diff;
//TheBeastWithin_Timer
if (TheBeastWithin_Timer <= diff)
{
DoCast(me, SPELL_THE_BEAST_WITHIN);
Creature* Pet = ObjectAccessor::GetCreature(*me, SummonedPet);
if (Pet && Pet->IsAlive())
Pet->CastSpell(Pet, SPELL_PET_ENRAGE, true);
TheBeastWithin_Timer = 30000;
} else TheBeastWithin_Timer -= diff;
//Pet_Timer
if (Pet_Timer < diff && pet == false)
{
pet = true;
//uint32 spell_id;
uint32 pet_id;
if (!urand(0, 1))
{
//spell_id = SPELL_SUMMON_FATHOM_LURKER;
pet_id = CREATURE_FATHOM_LURKER;
}
else
{
//spell_id = SPELL_SUMMON_FATHOM_SPOREBAT;
pet_id = CREATURE_FATHOM_SPOREBAT;
}
//DoCast(me, spell_id, true);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
if (Creature* Pet = DoSpawnCreature(pet_id, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000))
{
Pet->AI()->AttackStart(target);
SummonedPet = Pet->GetGUID();
}
}
} else Pet_Timer -= diff;
DoMeleeAttackIfReady();
}
void GetAdvisors()
{
Advisors[0] = instance->GetGuidData(DATA_SHARKKIS);
Advisors[1] = instance->GetGuidData(DATA_TIDALVESS);
Advisors[2] = instance->GetGuidData(DATA_CARIBDIS);
}
void EnterCombat(Unit* /*who*/) override
{
Talk(SAY_AGGRO);
instance->HandleGameObject(instance->GetGuidData(DATA_GO_NETHER_DOOR), false); // Open the door leading further in
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (CloseDoorTimer)
{
if (CloseDoorTimer <= diff)
{
instance->HandleGameObject(instance->GetGuidData(DATA_GO_LIBRARY_DOOR), false);
CloseDoorTimer = 0;
} else CloseDoorTimer -= diff;
}
//Cooldowns for casts
if (ArcaneCooldown)
{
if (ArcaneCooldown >= diff)
ArcaneCooldown -= diff;
else ArcaneCooldown = 0;
}
if (FireCooldown)
{
if (FireCooldown >= diff)
FireCooldown -= diff;
else FireCooldown = 0;
}
if (FrostCooldown)
{
if (FrostCooldown >= diff)
FrostCooldown -= diff;
else FrostCooldown = 0;
}
if (!Drinking && me->GetMaxPower(POWER_MANA) && (me->GetPower(POWER_MANA)*100 / me->GetMaxPower(POWER_MANA)) < 20)
{
Drinking = true;
me->InterruptNonMeleeSpells(false);
Talk(SAY_DRINK);
if (!DrinkInturrupted)
{
DoCast(me, SPELL_MASS_POLY, true);
DoCast(me, SPELL_CONJURE, false);
DoCast(me, SPELL_DRINK, false);
me->SetStandState(UNIT_STAND_STATE_SIT);
DrinkInterruptTimer = 10000;
}
}
//Drink Interrupt
if (Drinking && DrinkInturrupted)
{
Drinking = false;
me->RemoveAurasDueToSpell(SPELL_DRINK);
me->SetStandState(UNIT_STAND_STATE_STAND);
me->SetPower(POWER_MANA, me->GetMaxPower(POWER_MANA)-32000);
DoCast(me, SPELL_POTION, false);
}
//Drink Interrupt Timer
if (Drinking && !DrinkInturrupted)
{
if (DrinkInterruptTimer >= diff)
DrinkInterruptTimer -= diff;
else
{
me->SetStandState(UNIT_STAND_STATE_STAND);
DoCast(me, SPELL_POTION, true);
DoCast(me, SPELL_AOE_PYROBLAST, false);
DrinkInturrupted = true;
Drinking = false;
}
}
//Don't execute any more code if we are drinking
if (Drinking)
return;
//Normal casts
if (NormalCastTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true);
if (!target)
return;
uint32 Spells[3];
uint8 AvailableSpells = 0;
//Check for what spells are not on cooldown
if (!ArcaneCooldown)
{
Spells[AvailableSpells] = SPELL_ARCMISSLE;
++AvailableSpells;
}
if (!FireCooldown)
{
Spells[AvailableSpells] = SPELL_FIREBALL;
++AvailableSpells;
}
if (!FrostCooldown)
{
Spells[AvailableSpells] = SPELL_FROSTBOLT;
++AvailableSpells;
}
//If no available spells wait 1 second and try again
if (AvailableSpells)
{
CurrentNormalSpell = Spells[rand32() % AvailableSpells];
DoCast(target, CurrentNormalSpell);
}
}
NormalCastTimer = 1000;
} else NormalCastTimer -= diff;
if (SecondarySpellTimer <= diff)
{
switch (urand(0, 1))
{
case 0:
DoCast(me, SPELL_AOE_CS);
break;
case 1:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_CHAINSOFICE);
break;
}
SecondarySpellTimer = urand(5000, 20000);
} else SecondarySpellTimer -= diff;
if (SuperCastTimer <= diff)
{
uint8 Available[2];
switch (LastSuperSpell)
{
case SUPER_AE:
Available[0] = SUPER_FLAME;
Available[1] = SUPER_BLIZZARD;
break;
case SUPER_FLAME:
Available[0] = SUPER_AE;
Available[1] = SUPER_BLIZZARD;
break;
case SUPER_BLIZZARD:
Available[0] = SUPER_FLAME;
Available[1] = SUPER_AE;
break;
default:
Available[0] = 0;
Available[1] = 0;
break;
}
LastSuperSpell = Available[urand(0, 1)];
switch (LastSuperSpell)
{
case SUPER_AE:
Talk(SAY_EXPLOSION);
DoCast(me, SPELL_BLINK_CENTER, true);
DoCast(me, SPELL_PLAYERPULL, true);
DoCast(me, SPELL_MASSSLOW, true);
DoCast(me, SPELL_AEXPLOSION, false);
break;
case SUPER_FLAME:
Talk(SAY_FLAMEWREATH);
FlameWreathTimer = 20000;
FlameWreathCheckTime = 500;
FlameWreathTarget[0].Clear();
FlameWreathTarget[1].Clear();
FlameWreathTarget[2].Clear();
FlameWreathEffect();
break;
case SUPER_BLIZZARD:
Talk(SAY_BLIZZARD);
if (Creature* pSpawn = me->SummonCreature(CREATURE_ARAN_BLIZZARD, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN, 25000))
{
pSpawn->setFaction(me->getFaction());
pSpawn->CastSpell(pSpawn, SPELL_CIRCULAR_BLIZZARD, false);
}
break;
}
SuperCastTimer = urand(35000, 40000);
} else SuperCastTimer -= diff;
if (!ElementalsSpawned && HealthBelowPct(40))
{
ElementalsSpawned = true;
for (uint32 i = 0; i < 4; ++i)
{
if (Creature* unit = me->SummonCreature(CREATURE_WATER_ELEMENTAL, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN, 90000))
{
unit->Attack(me->GetVictim(), true);
unit->setFaction(me->getFaction());
}
}
Talk(SAY_ELEMENTALS);
}
if (BerserkTimer <= diff)
{
for (uint32 i = 0; i < 5; ++i)
{
if (Creature* unit = me->SummonCreature(CREATURE_SHADOW_OF_ARAN, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000))
{
unit->Attack(me->GetVictim(), true);
unit->setFaction(me->getFaction());
}
}
Talk(SAY_TIMEOVER);
BerserkTimer = 60000;
} else BerserkTimer -= diff;
//Flame Wreath check
if (FlameWreathTimer)
{
if (FlameWreathTimer >= diff)
FlameWreathTimer -= diff;
else FlameWreathTimer = 0;
if (FlameWreathCheckTime <= diff)
{
for (uint8 i = 0; i < 3; ++i)
{
if (!FlameWreathTarget[i])
continue;
Unit* unit = ObjectAccessor::GetUnit(*me, FlameWreathTarget[i]);
if (unit && !unit->IsWithinDist2d(FWTargPosX[i], FWTargPosY[i], 3))
{
unit->CastSpell(unit, 20476, true, 0, 0, me->GetGUID());
unit->CastSpell(unit, 11027, true);
FlameWreathTarget[i].Clear();
}
}
FlameWreathCheckTime = 500;
} else FlameWreathCheckTime -= diff;
}
if (ArcaneCooldown && FireCooldown && FrostCooldown)
DoMeleeAttackIfReady();
}
void HandleTerraceDoors(bool open)
{
instance->HandleGameObject(instance->GetGuidData(DATA_MASTERS_TERRACE_DOOR_1), open);
instance->HandleGameObject(instance->GetGuidData(DATA_MASTERS_TERRACE_DOOR_2), open);
}
void UpdateAI(uint32 diff) override
{
//Only if not incombat check if the event is started
if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT))
{
if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER)))
AttackStart(target);
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (!instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//WaterBoltVolley_Timer
if (WaterBoltVolley_Timer <= diff)
{
DoCastVictim(SPELL_WATER_BOLT_VOLLEY);
WaterBoltVolley_Timer = 30000;
} else WaterBoltVolley_Timer -= diff;
//TidalSurge_Timer
if (TidalSurge_Timer <= diff)
{
DoCastVictim(SPELL_TIDAL_SURGE);
// Hacky way to do it - won't trigger elseways
if (me->GetVictim())
me->EnsureVictim()->CastSpell(me->GetVictim(), SPELL_TIDAL_SURGE_FREEZE, true);
TidalSurge_Timer = 15000 + rand32() % 5000;
} else TidalSurge_Timer -= diff;
//Cyclone_Timer
if (Cyclone_Timer <= diff)
{
//DoCast(me, SPELL_SUMMON_CYCLONE); // Doesn't work
Cyclone_Timer = 30000 + rand32() % 10000;
if (Creature* Cyclone = me->SummonCreature(CREATURE_CYCLONE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), float(rand32() % 5), TEMPSUMMON_TIMED_DESPAWN, 15000))
{
Cyclone->SetObjectScale(3.0f);
Cyclone->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Cyclone->setFaction(me->getFaction());
Cyclone->CastSpell(Cyclone, SPELL_CYCLONE_CYCLONE, true);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
Cyclone->AI()->AttackStart(target);
}
}
else
Cyclone_Timer -= diff;
//Heal_Timer
if (Heal_Timer <= diff)
{
// It can be cast on any of the mobs
Unit* unit = NULL;
while (unit == NULL || !unit->IsAlive())
unit = selectAdvisorUnit();
if (unit && unit->IsAlive())
DoCast(unit, SPELL_HEAL);
Heal_Timer = 60000;
}
else
Heal_Timer -= diff;
DoMeleeAttackIfReady();
}
void Reset() override
{
SathGUID = instance->GetGuidData(DATA_SATHROVARR);
Initialize();
}
Creature* GetOtherBoss()
{
return ObjectAccessor::GetCreature(*me, instance->GetGuidData(IAmVeklor() ? DATA_VEKNILASH : DATA_VEKLOR));
}
void JustDied(Unit* /*killer*/) override
{
Creature* Terestian = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_TERESTIAN));
if (Terestian && Terestian->IsAlive())
DoCast(Terestian, SPELL_BROKEN_PACT, true);
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (_bCanResurrect)
{
//When casting resuruction make sure to delay so on rez when reinstate battle deepsleep runs out
if (Wait_Timer <= diff)
{
if (Creature* mograine = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_MOGRAINE)))
{
DoCast(mograine, SPELL_SCARLETRESURRECTION);
Talk(SAY_WH_RESURRECT);
_bCanResurrect = false;
}
}
else Wait_Timer -= diff;
}
//Cast Deep sleep when health is less than 50%
if (!_bCanResurrectCheck && !HealthAbovePct(50))
{
if (me->IsNonMeleeSpellCast(false))
me->InterruptNonMeleeSpells(false);
DoCastVictim(SPELL_DEEPSLEEP);
_bCanResurrectCheck = true;
_bCanResurrect = true;
return;
}
//while in "resurrect-mode", don't do anything
if (_bCanResurrect)
return;
//If we are <75% hp cast healing spells at self or Mograine
if (Heal_Timer <= diff)
{
Creature* target = NULL;
if (!HealthAbovePct(75))
target = me;
if (Creature* mograine = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_MOGRAINE)))
{
// checking _bCanResurrectCheck prevents her healing Mograine while he is "faking death"
if (_bCanResurrectCheck && mograine->IsAlive() && !mograine->HealthAbovePct(75))
target = mograine;
}
if (target)
DoCast(target, SPELL_HEAL);
Heal_Timer = 13000;
}
else Heal_Timer -= diff;
//PowerWordShield_Timer
if (PowerWordShield_Timer <= diff)
{
DoCast(me, SPELL_POWERWORDSHIELD);
PowerWordShield_Timer = 15000;
}
else PowerWordShield_Timer -= diff;
//HolySmite_Timer
if (HolySmite_Timer <= diff)
{
DoCastVictim(SPELL_HOLYSMITE);
HolySmite_Timer = 6000;
}
else HolySmite_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
//Shield_Timer
if (Shield_Timer <= diff)
{
DoCast(me, SPELL_SHIELD);
Shield_Timer = 61000;
} else Shield_Timer -= diff;
//BloodLust_Timer
if (BloodLust_Timer <= diff)
{
DoCast(me, SPELL_BLOODLUST);
BloodLust_Timer = 20000 + rand32() % 8000;
} else BloodLust_Timer -= diff;
//Casting Greaterheal to Thekal or Zath if they are in meele range.
if (GreaterHeal_Timer <= diff)
{
Unit* pThekal = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_THEKAL));
Unit* pZath = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_ZATH));
if (!pThekal || !pZath)
return;
switch (urand(0, 1))
{
case 0:
if (me->IsWithinMeleeRange(pThekal))
DoCast(pThekal, SPELL_GREATERHEAL);
break;
case 1:
if (me->IsWithinMeleeRange(pZath))
DoCast(pZath, SPELL_GREATERHEAL);
break;
}
GreaterHeal_Timer = 15000 + rand32() % 5000;
} else GreaterHeal_Timer -= diff;
//Disarm_Timer
if (Disarm_Timer <= diff)
{
DoCastVictim(SPELL_DISARM);
Disarm_Timer = 15000 + rand32() % 10000;
} else Disarm_Timer -= diff;
//Check_Timer for the death of LorKhan and Zath.
if (!FakeDeath && Check_Timer <= diff)
{
if (instance->GetBossState(DATA_THEKAL) == SPECIAL)
{
//Resurrect Thekal
if (Unit* pThekal = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_THEKAL)))
{
pThekal->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
pThekal->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pThekal->SetFaction(FACTION_MONSTER);
pThekal->SetFullHealth();
}
}
if (instance->GetBossState(DATA_ZATH) == SPECIAL)
{
//Resurrect Zath
if (Unit* pZath = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_ZATH)))
{
pZath->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
pZath->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pZath->SetFaction(FACTION_MONSTER);
pZath->SetFullHealth();
}
}
Check_Timer = 5000;
} else Check_Timer -= diff;
if (!HealthAbovePct(5))
{
me->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE_PERCENT);
me->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
me->RemoveAurasByType(SPELL_AURA_PERIODIC_LEECH);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetStandState(UNIT_STAND_STATE_SLEEP);
me->SetFaction(FACTION_FRIENDLY);
me->AttackStop();
instance->SetBossState(DATA_LORKHAN, SPECIAL);
FakeDeath = true;
}
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*killer*/) override
{
if (Creature* sjonnir = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SJONNIR)))
sjonnir->AI()->DoAction(ACTION_OOZE_DEAD);
}
void JustDied(Unit* /*killer*/) override
{
if (Creature* vashj = ObjectAccessor::GetCreature((*me), instance->GetGuidData(DATA_LADYVASHJ)))
ENSURE_AI(boss_lady_vashj::boss_lady_vashjAI, vashj->AI())->EventTaintedElementalDeath();
}
void UpdateAI(uint32 uiDiff) override
{
if (!UpdateVictim())
return;
/*START ACID-AI*/
if (uiTrashTimer <= uiDiff)
{
if (bCheckChances())
DoCast(me, SPELL_TRASH);
uiTrashTimer = urand(6000, 15500);
} else uiTrashTimer -= uiDiff;
if (uiSlamTimer <= uiDiff)
{
if (bCheckChances())
DoCastVictim(SPELL_SMITE_SLAM);
uiSlamTimer = 11000;
} else uiSlamTimer -= uiDiff;
if (uiNimbleReflexesTimer <= uiDiff)
{
if (bCheckChances())
DoCast(me, SPELL_NIMBLE_REFLEXES);
uiNimbleReflexesTimer = urand(27300, 60100);
} else uiNimbleReflexesTimer -= uiDiff;
/*END ACID-AI*/
if ((uiHealth == 0 && !HealthAbovePct(66)) || (uiHealth == 1 && !HealthAbovePct(33)))
{
++uiHealth;
DoCastAOE(SPELL_SMITE_STOMP, false);
SetCombatMovement(false);
if (GameObject* go = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(DATA_SMITE_CHEST)))
{
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MovePoint(1, go->GetPositionX() - 3.0f, go->GetPositionY(), go->GetPositionZ());
}
}
if (uiPhase)
{
if (uiTimer <= uiDiff)
{
switch (uiPhase)
{
case 1:
me->HandleEmoteCommand(EMOTE_STATE_KNEEL); //dosen't work?
uiTimer = 1000;
uiPhase = 2;
break;
case 2:
if (uiHealth == 1)
SetEquipmentSlots(false, EQUIP_SWORD, EQUIP_SWORD, EQUIP_NO_CHANGE);
else
SetEquipmentSlots(false, EQUIP_MACE, EQUIP_UNEQUIP, EQUIP_NO_CHANGE);
uiTimer = 500;
uiPhase = 3;
break;
case 3:
SetCombatMovement(true);
me->GetMotionMaster()->MoveChase(me->GetVictim(), me->m_CombatDistance);
uiPhase = 0;
break;
}
} else uiTimer -= uiDiff;
}
DoMeleeAttackIfReady();
}
void HandleDoors(bool open) // Massive Door switcher
{
if (GameObject* Door = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(DATA_GO_MASSIVE_DOOR) ))
Door->SetGoState(open ? GO_STATE_ACTIVE : GO_STATE_READY);
}
void UpdateAI(uint32 diff) override
{
if (!SisterDeath)
{
Unit* Temp = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_ALYTHESS));
if (Temp && Temp->isDead())
{
Talk(YELL_SISTER_ALYTHESS_DEAD);
DoCast(me, SPELL_EMPOWER);
me->InterruptSpell(CURRENT_GENERIC_SPELL);
SisterDeath = true;
}
}
if (!UpdateVictim())
return;
if (SisterDeath)
{
if (ConflagrationTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CONFLAGRATION);
ConflagrationTimer = 30000 + (rand32() % 5000);
}
} else ConflagrationTimer -= diff;
}
else
{
if (ShadownovaTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
DoCast(target, SPELL_SHADOW_NOVA);
if (!SisterDeath)
{
if (target)
Talk(EMOTE_SHADOW_NOVA, target);
Talk(YELL_SHADOW_NOVA);
}
ShadownovaTimer = 30000 + (rand32() % 5000);
}
} else ShadownovaTimer -=diff;
}
if (ConfoundingblowTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CONFOUNDING_BLOW);
ConfoundingblowTimer = 20000 + (rand32() % 5000);
}
} else ConfoundingblowTimer -=diff;
if (ShadowimageTimer <= diff)
{
Unit* target = NULL;
Creature* temp = NULL;
for (uint8 i = 0; i<3; ++i)
{
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
temp = DoSpawnCreature(NPC_SHADOW_IMAGE, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN, 10000);
if (temp && target)
{
temp->AddThreat(target, 1000000); //don't change target(healers)
temp->AI()->AttackStart(target);
}
}
ShadowimageTimer = 20000;
} else ShadowimageTimer -=diff;
if (ShadowbladesTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
DoCast(me, SPELL_SHADOW_BLADES);
ShadowbladesTimer = 10000;
}
} else ShadowbladesTimer -=diff;
if (EnrageTimer < diff && !Enraged)
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
Talk(YELL_ENRAGE);
DoCast(me, SPELL_ENRAGE);
Enraged = true;
} else EnrageTimer -= diff;
if (me->isAttackReady() && !me->IsNonMeleeSpellCast(false))
{
//If we are within range melee the target
if (me->IsWithinMeleeRange(me->GetVictim()))
{
HandleTouchedSpells(me->GetVictim(), SPELL_DARK_TOUCHED);
me->AttackerStateUpdate(me->GetVictim());
me->resetAttackTimer();
}
}
}
void UpdateEscortAI(uint32 uiDiff) override
{
if (uiPhase)
{
if (uiTimer <= uiDiff)
{
switch (uiPhase)
{
case 1:
Talk(SAY_BLASTMASTER_1);
NextStep(2000, true);
break;
case 2:
SetEscortPaused(false);
NextStep(0, false, 0);
break;
case 3:
Talk(SAY_BLASTMASTER_2);
SetEscortPaused(false);
NextStep(0, false, 0);
break;
case 4:
Talk(SAY_BLASTMASTER_3);
NextStep(3000, true);
break;
case 5:
Talk(SAY_BLASTMASTER_4);
NextStep(3000, true);
break;
case 6:
SetInFace(true);
Talk(SAY_BLASTMASTER_5);
Summon(1);
if (GameObject* go = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(DATA_GO_CAVE_IN_RIGHT)))
instance->HandleGameObject(ObjectGuid::Empty, true, go);
NextStep(3000, true);
break;
case 7:
Talk(SAY_BLASTMASTER_6);
SetEscortPaused(false);
NextStep(0, false, 0);
break;
case 8:
me->HandleEmoteCommand(EMOTE_STATE_USE_STANDING);
NextStep(25000, true);
break;
case 9:
Summon(2);
NextStep(0, false);
break;
case 10:
Summon(4);
Talk(SAY_BLASTMASTER_8);
NextStep(0, false);
break;
case 11:
Talk(SAY_BLASTMASTER_9);
NextStep(5000, true);
break;
case 12:
Talk(SAY_BLASTMASTER_10);
NextStep(5000, true);
break;
case 13:
Talk(SAY_BLASTMASTER_11);
CaveDestruction(true);
NextStep(8000, true);
break;
case 14:
Talk(SAY_BLASTMASTER_12);
NextStep(8500, true);
break;
case 15:
Talk(SAY_BLASTMASTER_13);
NextStep(2000, true);
break;
case 16:
Talk(SAY_BLASTMASTER_14);
SetInFace(false);
if (GameObject* go = ObjectAccessor::GetGameObject(*me, instance->GetGuidData(DATA_GO_CAVE_IN_LEFT)))
instance->HandleGameObject(ObjectGuid::Empty, true, go);
NextStep(2000, true);
break;
case 17:
SetEscortPaused(false);
Talk(SAY_BLASTMASTER_15);
Summon(5);
NextStep(0, false);
break;
case 18:
Summon(6);
NextStep(0, false);
break;
case 19:
SetInFace(false);
Summon(7);
Talk(SAY_BLASTMASTER_16);
NextStep(0, false);
break;
case 20:
Talk(SAY_BLASTMASTER_18);
NextStep(2000, true);
break;
case 21:
Summon(8);
NextStep(0, false);
break;
case 22:
CaveDestruction(false);
Talk(SAY_BLASTMASTER_11);
NextStep(3000, true);
break;
case 23:
Summon(9);
Talk(SAY_BLASTMASTER_19);
NextStep(0, false);
break;
}
} else uiTimer -= uiDiff;
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (IntroStepCounter < 9)
{
if (IntroYellTimer <= diff)
{
IntroYellTimer = IntroStep(++IntroStepCounter);
} else IntroYellTimer -= diff;
}
if (!SisterDeath)
{
Unit* Temp = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_SACROLASH));
if (Temp && Temp->isDead())
{
Talk(YELL_SISTER_SACROLASH_DEAD);
DoCast(me, SPELL_EMPOWER);
me->InterruptSpell(CURRENT_GENERIC_SPELL);
SisterDeath = true;
}
}
if (!me->GetVictim())
{
Creature* sisiter = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SACROLASH));
if (sisiter && !sisiter->isDead() && sisiter->GetVictim())
{
me->AddThreat(sisiter->GetVictim(), 0.0f);
DoStartNoMovement(sisiter->GetVictim());
me->Attack(sisiter->GetVictim(), false);
}
}
if (!UpdateVictim())
return;
if (SisterDeath)
{
if (ShadownovaTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SHADOW_NOVA);
ShadownovaTimer = 30000 + (rand32() % 5000);
}
} else ShadownovaTimer -=diff;
}
else
{
if (ConflagrationTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
DoCast(target, SPELL_CONFLAGRATION);
ConflagrationTimer = 30000 + (rand32() % 5000);
if (!SisterDeath)
{
if (target)
Talk(EMOTE_CONFLAGRATION, target);
Talk(YELL_CANFLAGRATION);
}
BlazeTimer = 4000;
}
} else ConflagrationTimer -= diff;
}
if (FlamesearTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
DoCast(me, SPELL_FLAME_SEAR);
FlamesearTimer = 15000;
}
} else FlamesearTimer -=diff;
if (PyrogenicsTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
DoCast(me, SPELL_PYROGENICS, true);
PyrogenicsTimer = 15000;
}
} else PyrogenicsTimer -= diff;
if (BlazeTimer <= diff)
{
if (!me->IsNonMeleeSpellCast(false))
{
DoCastVictim(SPELL_BLAZE);
BlazeTimer = 3800;
}
} else BlazeTimer -= diff;
if (EnrageTimer < diff && !Enraged)
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
Talk(YELL_BERSERK);
DoCast(me, SPELL_ENRAGE);
Enraged = true;
} else EnrageTimer -= diff;
}
void UpdateAI(uint32 uiDiff) override
{
// we're still doing awaken animation
if (bWakingUp && iAwakenTimer >= 0)
{
iAwakenTimer -= uiDiff;
return; // dont do anything until we are done
} else if (bWakingUp && iAwakenTimer <= 0)
{
bWakingUp = false;
AttackStart(ObjectAccessor::GetUnit(*me, instance->GetGuidData(0)));
return; // dont want to continue until we finish the AttackStart method
}
//Return since we have no target
if (!UpdateVictim())
return;
// wake a wall minion
if (uiWallMinionTimer <= uiDiff)
{
instance->SetData(DATA_MINIONS, IN_PROGRESS);
uiWallMinionTimer = 10000;
} else uiWallMinionTimer -= uiDiff;
//If we are <66 summon the guardians
if (!bGuardiansAwake && !HealthAbovePct(66))
{
ActivateMinion(instance->GetGuidData(5), true); // EarthenGuardian1
ActivateMinion(instance->GetGuidData(6), true); // EarthenGuardian2
ActivateMinion(instance->GetGuidData(7), true); // EarthenGuardian3
ActivateMinion(instance->GetGuidData(8), true); // EarthenGuardian4
ActivateMinion(instance->GetGuidData(9), true); // EarthenGuardian5
ActivateMinion(instance->GetGuidData(10), false); // EarthenGuardian6
Talk(SAY_SUMMON_GUARDIANS);
bGuardiansAwake = true;
}
//If we are <33 summon the vault walkers
if (!bVaultWalkersAwake && !HealthAbovePct(33))
{
ActivateMinion(instance->GetGuidData(1), true); // VaultWalker1
ActivateMinion(instance->GetGuidData(2), true); // VaultWalker2
ActivateMinion(instance->GetGuidData(3), true); // VaultWalker3
ActivateMinion(instance->GetGuidData(4), false); // VaultWalker4
Talk(SAY_SUMMON_VAULT_WALKERS);
bVaultWalkersAwake = true;
}
if (uiTremorTimer <= uiDiff)
{
//Cast
DoCastVictim(SPELL_GROUND_TREMOR);
//45 seconds until we should cast this agian
uiTremorTimer = 45000;
} else uiTremorTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (IsIntro)
{
if (IntroPhaseTimer <= diff)
DoIntro();
else IntroPhaseTimer -= diff;
if (IntroPhase == 3 + 1)
{
if (IntroFrostBoltTimer <= diff)
{
if (Creature* Madrigosa = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_MADRIGOSA)))
{
Madrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, true);
IntroFrostBoltTimer = 2000;
}
}
else
IntroFrostBoltTimer -= diff;
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}
if (!UpdateVictim() || IsIntro)
return;
if (SlashTimer <= diff)
{
DoCastVictim(SPELL_METEOR_SLASH);
SlashTimer = 11000;
} else SlashTimer -= diff;
if (StompTimer <= diff)
{
Talk(YELL_LOVE);
DoCastVictim(SPELL_STOMP);
StompTimer = 30000;
} else StompTimer -= diff;
if (BurnTimer <= diff)
{
std::list<Unit*> targets;
SelectTargetList(targets, 10, SELECT_TARGET_RANDOM, 100, true);
for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)
if (!(*i)->HasAura(SPELL_BURN))
{
(*i)->CastSpell((*i), SPELL_BURN, true);
break;
}
BurnTimer = urand(60000, 180000);
} else BurnTimer -= diff;
if (BerserkTimer < diff && !Enraged)
{
Talk(YELL_BERSERK);
DoCast(me, SPELL_BERSERK);
Enraged = true;
} else BerserkTimer -= diff;
DoMeleeAttackIfReady();
}
