void KilledUnit(Unit* who)
{
if (who->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_BRUNDIR_SLAY);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
Talk(SAY_BRUNDIR_BERSERK);
DoCast(SPELL_BERSERK);
events.CancelEvent(EVENT_BERSERK);
break;
case EVENT_CHAIN_LIGHTNING:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CHAIN_LIGHTNING);
events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, urand(7000, 10000));
break;
case EVENT_OVERLOAD:
Talk(EMOTE_BRUNDIR_OVERLOAD);
Talk(SAY_BRUNDIR_SPECIAL);
DoCast(SPELL_OVERLOAD);
events.ScheduleEvent(EVENT_OVERLOAD, urand(60000, 120000));
break;
case EVENT_LIGHTNING_WHIRL:
DoCast(SPELL_LIGHTNING_WHIRL);
events.ScheduleEvent(EVENT_LIGHTNING_WHIRL, urand(15000, 20000));
break;
case EVENT_LIGHTNING_TENDRILS:
Talk(SAY_BRUNDIR_FLIGHT);
DoCast(RAID_MODE(SPELL_LIGHTNING_TENDRILS_10M, SPELL_LIGHTNING_TENDRILS_25M));
DoCast(SPELL_LIGHTNING_TENDRILS_VISUAL);
me->AttackStop();
//me->SetLevitate(true);
me->GetMotionMaster()->Initialize();
me->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), FINAL_FLIGHT_Z);
events.DelayEvents(35000);
events.ScheduleEvent(EVENT_FLIGHT, 2500);
events.ScheduleEvent(EVENT_ENDFLIGHT, 32500);
events.ScheduleEvent(EVENT_LIGHTNING_TENDRILS, 90000);
break;
case EVENT_FLIGHT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->GetMotionMaster()->MovePoint(0, target->GetPositionX(), target->GetPositionY(), FINAL_FLIGHT_Z);
events.ScheduleEvent(EVENT_FLIGHT, 6000);
break;
case EVENT_ENDFLIGHT:
me->GetMotionMaster()->Initialize();
me->GetMotionMaster()->MovePoint(0, 1586.920166f, 119.848984f, FINAL_FLIGHT_Z);
events.CancelEvent(EVENT_FLIGHT);
events.CancelEvent(EVENT_ENDFLIGHT);
events.ScheduleEvent(EVENT_LAND, 4000);
break;
case EVENT_LAND:
me->GetMotionMaster()->Initialize();
me->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), FLOOR_Z);
events.CancelEvent(EVENT_LAND);
events.ScheduleEvent(EVENT_GROUND, 2500);
break;
case EVENT_GROUND:
//me->SetLevitate(false);
me->RemoveAurasDueToSpell(RAID_MODE(SPELL_LIGHTNING_TENDRILS_10M, SPELL_LIGHTNING_TENDRILS_25M));
me->RemoveAurasDueToSpell(SPELL_LIGHTNING_TENDRILS_VISUAL);
DoStartMovement(me->GetVictim());
events.CancelEvent(EVENT_GROUND);
me->getThreatManager().resetAllAggro();
break;
case EVENT_MOVE_POSITION:
if (me->IsWithinMeleeRange(me->GetVictim()))
{
float x = float(irand(-25, 25));
float y = float(irand(-25, 25));
me->GetMotionMaster()->MovePoint(0, me->GetPositionX() + x, me->GetPositionY() + y, FLOOR_Z);
// Prevention to go outside the room or into the walls
if (Creature* trigger = me->FindNearestCreature(NPC_WORLD_TRIGGER, 100.0f, true))
if (me->GetDistance(trigger) >= 50.0f)
me->GetMotionMaster()->MovePoint(0, trigger->GetPositionX(), trigger->GetPositionY(), FLOOR_Z);
}
events.ScheduleEvent(EVENT_MOVE_POSITION, urand(7500, 10000));
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void KilledUnit(Unit* who)
{
if (who->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_MOLGEIM_SLAY);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
Talk(SAY_MOLGEIM_BERSERK);
DoCast(SPELL_BERSERK);
events.CancelEvent(EVENT_BERSERK);
break;
case EVENT_RUNE_OF_POWER:
{
Unit* target = me;
switch (urand(0, 2))
{
case 1:
if (Creature* Steelbreaker = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_STEELBREAKER)))
if (Steelbreaker->isAlive())
target = Steelbreaker;
break;
case 2:
if (Creature* Brundir = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_STEELBREAKER)))
if (Brundir->isAlive())
target = Brundir;
break;
default:
break;
}
DoCast(target, SPELL_SUMMON_RUNE_OF_POWER);
events.ScheduleEvent(EVENT_RUNE_OF_POWER, 60000);
break;
}
case EVENT_SHIELD_OF_RUNES:
DoCast(me, SPELL_SHIELD_OF_RUNES);
events.ScheduleEvent(EVENT_SHIELD_OF_RUNES, urand(27000, 34000));
break;
case EVENT_RUNE_OF_DEATH:
Talk(SAY_MOLGEIM_RUNE_DEATH);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_RUNE_OF_DEATH);
events.ScheduleEvent(EVENT_RUNE_OF_DEATH, urand(30000, 40000));
break;
case EVENT_RUNE_OF_SUMMONING:
Talk(SAY_MOLGEIM_SUMMON);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_RUNE_OF_SUMMONING);
events.ScheduleEvent(EVENT_RUNE_OF_SUMMONING, urand(30000, 45000));
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CHECK_PLAYERS:
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_TANK_MARKER);
events.ScheduleEvent(EVENT_CHECK_PLAYERS, 2000);
break;
case EVENT_PREPARE_BONE_SPIKE_GRAVEYARD:
events.CancelEvent(EVENT_CHECK_PLAYERS);
break;
case EVENT_BONE_SPIKE_GRAVEYARD:
if (IsHeroic() || !me->HasAura(SPELL_BONE_STORM))
DoCast(me, SPELL_BONE_SPIKE_GRAVEYARD);
events.ScheduleEvent(EVENT_PREPARE_BONE_SPIKE_GRAVEYARD, 12000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, 18000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_CHECK_PLAYERS, 4000);
break;
case EVENT_COLDFLAME:
_coldflameLastPos.Relocate(me);
_coldflameTarget = 0LL;
if (!me->HasAura(SPELL_BONE_STORM))
DoCastAOE(SPELL_COLDFLAME_NORMAL);
else
DoCast(me, SPELL_COLDFLAME_BONE_STORM);
events.ScheduleEvent(EVENT_COLDFLAME, 5000, EVENT_GROUP_SPECIAL);
break;
case EVENT_WARN_BONE_STORM:
_boneSlice = false;
Talk(EMOTE_BONE_STORM);
me->FinishSpell(CURRENT_MELEE_SPELL, false);
DoCast(me, SPELL_BONE_STORM);
events.DelayEvents(3000, EVENT_GROUP_SPECIAL);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
events.ScheduleEvent(EVENT_BONE_STORM_BEGIN, 3050);
events.ScheduleEvent(EVENT_WARN_BONE_STORM, 90000);
break;
case EVENT_BONE_STORM_BEGIN:
if (Aura* pStorm = me->GetAura(SPELL_BONE_STORM))
pStorm->SetDuration(int32(_boneStormDuration));
me->SetSpeed(MOVE_RUN, _baseSpeed*3.0f, true);
Talk(SAY_BONE_STORM);
events.ScheduleEvent(EVENT_BONE_STORM_END, _boneStormDuration+1);
// no break here
case EVENT_BONE_STORM_MOVE:
{
events.ScheduleEvent(EVENT_BONE_STORM_MOVE, IsHeroic() ? _boneStormDuration/5 : _boneStormDuration/4);
Unit* unit = SelectTarget(SELECT_TARGET_FARTHEST, 0, 60.0f);
if (!unit || unit->isPet() || unit->isTotem() || !me->IsWithinLOSInMap(unit))
unit = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
if (unit)
if (unit->isPet() || unit->isTotem() || !me->IsWithinLOSInMap(unit))
unit = SelectTarget(SELECT_TARGET_RANDOM, 1);
else
me->GetMotionMaster()->MovePoint(POINT_TARGET_BONESTORM_PLAYER, unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
break;
}
case EVENT_BONE_STORM_END:
if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
me->GetMotionMaster()->MovementExpired();
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
DoStartMovement(me->getVictim());
me->SetSpeed(MOVE_RUN, _baseSpeed, true);
events.CancelEvent(EVENT_BONE_STORM_MOVE);
events.ScheduleEvent(EVENT_ENABLE_BONE_SLICE, 10000);
if (!IsHeroic())
events.RescheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, 15000, EVENT_GROUP_SPECIAL);
break;
case EVENT_ENABLE_BONE_SLICE:
_boneSlice = true;
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
Talk(SAY_BERSERK);
break;
}
}
// We should not melee attack when storming
if (me->HasAura(SPELL_BONE_STORM))
return;
// 10 seconds since encounter start Bone Slice replaces melee attacks
if (_boneSlice && !me->GetCurrentSpell(CURRENT_MELEE_SPELL))
DoCastVictim(SPELL_BONE_SLICE);
DoMeleeAttackIfReady();
}
void EnterCombat(Unit* /*target*/)
{
Talk(SAY_LICH_KING_INTRO);
me->setActive(true);
}
void JustDied(Unit* /*killer*/) override
{
Talk(SAY_DIE);
instance->SetBossState(DATA_NETHEKURSE, DONE);
}
void JustDied(Unit* /*killer*/)
{
Talk(SAY_DEATH);
_JustDied();
}
void KilledUnit(Unit* /*who*/)
{
Talk(SAY_SLAY);
}
void UpdateAI(uint32 diff) override
{
if (!me->HasAura(AURA_SPECTRAL_INVISIBILITY))
me->CastSpell(me, AURA_SPECTRAL_INVISIBILITY, true);
if (!UpdateVictim())
return;
if (CheckTimer <= diff)
{
Creature* Kalec = ObjectAccessor::GetCreature(*me, KalecGUID);
if (!Kalec || !Kalec->IsAlive())
{
if (Creature* Kalecgos = ObjectAccessor::GetCreature(*me, KalecgosGUID))
Kalecgos->AI()->EnterEvadeMode();
return;
}
if (HealthBelowPct(10) && !isEnraged)
{
if (Creature* Kalecgos = ObjectAccessor::GetCreature(*me, KalecgosGUID))
Kalecgos->AI()->DoAction(DO_ENRAGE);
DoAction(DO_ENRAGE);
}
Creature* Kalecgos = ObjectAccessor::GetCreature(*me, KalecgosGUID);
if (Kalecgos && !Kalecgos->IsInCombat())
{
EnterEvadeMode();
return;
}
if (!isBanished && HealthBelowPct(1))
{
if (Kalecgos)
{
if (Kalecgos->HasAura(SPELL_BANISH))
{
me->DealDamage(me, me->GetHealth());
return;
}
DoAction(DO_BANISH);
}
else
{
me->TextEmote(EMOTE_UNABLE_TO_FIND);
EnterEvadeMode();
return;
}
}
CheckTimer = 1000;
} else CheckTimer -= diff;
if (ResetThreat <= diff)
{
ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
for (ThreatContainer::StorageType::const_iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
{
if (Unit* unit = ObjectAccessor::GetUnit(*me, (*itr)->getUnitGuid()))
if (unit->GetPositionZ() > me->GetPositionZ() + 5)
me->getThreatManager().modifyThreatPercent(unit, -100);
}
ResetThreat = 1000;
} else ResetThreat -= diff;
if (ShadowBoltTimer <= diff)
{
if (!(rand32() % 5))
Talk(SAY_SATH_SPELL1);
DoCast(me, SPELL_SHADOW_BOLT);
ShadowBoltTimer = 7000 + (rand32() % 3000);
} else ShadowBoltTimer -= diff;
if (AgonyCurseTimer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target)
target = me->GetVictim();
DoCast(target, SPELL_AGONY_CURSE);
AgonyCurseTimer = 20000;
} else AgonyCurseTimer -= diff;
if (CorruptionStrikeTimer <= diff)
{
if (!(rand32() % 5))Talk(SAY_SATH_SPELL2);
DoCastVictim(SPELL_CORRUPTION_STRIKE);
CorruptionStrikeTimer = 13000;
} else CorruptionStrikeTimer -= diff;
DoMeleeAttackIfReady();
}
void JustDied(Unit* /*who*/)
{
Talk(SAY_DEATH);
Summons.DespawnAll();
}
void UpdateAI(uint32 diff)
{
if(!UpdateVictim())
return;
ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList();
ThreatContainer::StorageType::const_iterator i = threatlist.begin();
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while(uint32 eventId = events.ExecuteEvent())
{
switch(eventId)
{
case EVENT_DISTANCE:
distanceMelee = true;
for (i = threatlist.begin(); i != threatlist.end(); ++i)
{
if (Unit* player = Unit::GetUnit(*me, (*i)->getUnitGuid()))
if (player && (player->GetTypeId() == TYPEID_PLAYER) && me->IsWithinMeleeRange(player, 5.0f))
{
distanceMelee = false;
break;
}
}
if (distanceMelee)
events.ScheduleEvent(EVENT_SEETHE, 2*IN_MILLISECONDS);
events.ScheduleEvent(EVENT_DISTANCE, 200);
break;
case EVENT_SEETHE:
me->CastSpell(me->getVictim(), SPELL_SEETHE);
distanceMelee = false;
break;
case EVENT_ENDLESS_RAGE:
me->CastSpell(me->getVictim(), SPELL_ENDLESS_RAGE);
Talk(SAY_ENDLESS_RAGE);
break;
case EVENT_GROWING_ANGER:
me->CastSpell(me, SPELL_GROWING_ANGER);
Talk(SAY_GROWING_ANGER);
break;
case EVENT_PHASE_GROWING_ANGER:
events.SetPhase(PHASE_GROWING_ANGER);
events.ScheduleEvent(EVENT_ENDLESS_RAGE, 20*IN_MILLISECONDS);
events.ScheduleEvent(EVENT_GROWING_ANGER, urand(30*IN_MILLISECONDS, 35*IN_MILLISECONDS));
events.ScheduleEvent(EVENT_UNLEASHED_WRATH, 50*IN_MILLISECONDS);
break;
case EVENT_UNLEASHED_WRATH:
DoCast(SPELL_UNLEASHED_WRATH);
events.SetPhase(PHASE_UNLEASHED_WRATH);
events.ScheduleEvent(EVENT_PHASE_GROWING_ANGER, 25*IN_MILLISECONDS, 0, PHASE_GROWING_ANGER);
events.ScheduleEvent(EVENT_ENDLESS_RAGE, 15*IN_MILLISECONDS);
break;
case EVENT_BERSERK:
DoCast(SPELL_BERSERK);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!phase)
return;
if (timer <= diff)
{
Player* player = Player::GetPlayer(*me, playerGUID);
Creature* orphan = Creature::GetCreature(*me, orphanGUID);
if (!orphan || !player)
{
Reset();
return;
}
switch (phase)
{
case 1:
orphan->GetMotionMaster()->MovePoint(0, me->GetPositionX() + cos(me->GetOrientation()) * 5, me->GetPositionY() + sin(me->GetOrientation()) * 5, me->GetPositionZ());
orphan->AI()->Talk(TEXT_ORACLE_ORPHAN_11);
timer = 5000;
break;
case 2:
orphan->SetFacingToObject(me);
orphan->AI()->Talk(TEXT_ORACLE_ORPHAN_12);
timer = 5000;
break;
case 3:
orphan->AI()->Talk(TEXT_ORACLE_ORPHAN_13);
timer = 5000;
break;
case 4:
Talk(TEXT_ALEXSTRASZA_2);
me->SetStandState(UNIT_STAND_STATE_KNEEL);
me->SetFacingToObject(orphan);
timer = 5000;
break;
case 5:
orphan->AI()->Talk(TEXT_ORACLE_ORPHAN_14);
timer = 5000;
break;
case 6:
me->SetStandState(UNIT_STAND_STATE_STAND);
me->SetOrientation(me->GetHomePosition().GetOrientation());
player->GroupEventHappens(QUEST_THE_DRAGON_QUEEN_ORACLE, me);
orphan->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
Reset();
return;
case 7:
orphan->GetMotionMaster()->MovePoint(0, me->GetPositionX() + cos(me->GetOrientation()) * 5, me->GetPositionY() + sin(me->GetOrientation()) * 5, me->GetPositionZ());
orphan->AI()->Talk(TEXT_WOLVAR_ORPHAN_11);
timer = 5000;
break;
case 8:
if(Creature* krasus = me->FindNearestCreature(NPC_KRASUS, 10.0f))
{
orphan->SetFacingToObject(krasus);
krasus->AI()->Talk(TEXT_KRASUS_8);
}
timer = 5000;
break;
case 9:
orphan->AI()->Talk(TEXT_WOLVAR_ORPHAN_12);
timer = 5000;
break;
case 10:
orphan->SetFacingToObject(me);
Talk(TEXT_ALEXSTRASZA_2);
timer = 5000;
break;
case 11:
orphan->AI()->Talk(TEXT_WOLVAR_ORPHAN_13);
timer = 5000;
break;
case 12:
player->GroupEventHappens(QUEST_THE_DRAGON_QUEEN_WOLVAR, me);
orphan->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, PET_FOLLOW_ANGLE);
Reset();
return;
}
++phase;
}
else
timer -= diff;
}
void EnterCombat(Unit* /*who*/) override
{
Talk(SAY_AGGRO);
}
void KilledUnit(Unit* /*victim*/) override
{
Talk(SAY_SLAY);
}
void JustDied(Unit* /*killer*/) override
{
_JustDied();
Talk(SAY_DEATH);
}
void UpdateAI(uint32 diff) override
{
events.Update(diff);
// Speech
if (!UpdateVictim())
{
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SPEECH_1:
Talk(SAY_LINE1);
me->SetStandState(UNIT_STAND_STATE_STAND);
me->HandleEmoteCommand(EMOTE_ONESHOT_TALK);
events.ScheduleEvent(EVENT_SPEECH_2, 12000);
break;
case EVENT_SPEECH_2:
Talk(SAY_LINE2);
me->HandleEmoteCommand(EMOTE_ONESHOT_TALK);
events.ScheduleEvent(EVENT_SPEECH_3, 12000);
break;
case EVENT_SPEECH_3:
Talk(SAY_LINE3);
me->HandleEmoteCommand(EMOTE_ONESHOT_TALK);
events.ScheduleEvent(EVENT_SPEECH_4, 16000);
break;
case EVENT_SPEECH_4:
me->setFaction(103);
if (PlayerGUID && ObjectAccessor::GetUnit(*me, PlayerGUID))
AttackStart(ObjectAccessor::GetUnit(*me, PlayerGUID));;
break;
}
}
return;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CLEAVE:
events.ScheduleEvent(EVENT_CLEAVE, 15000);
DoCastVictim(SPELL_CLEAVE);
break;
case EVENT_FLAMEBREATH:
DoCastVictim(SPELL_FLAMEBREATH);
events.ScheduleEvent(EVENT_FLAMEBREATH, urand(8000, 14000));
break;
case EVENT_FIRENOVA:
DoCastVictim(SPELL_FIRENOVA);
events.ScheduleEvent(EVENT_FIRENOVA, 15000);
break;
case EVENT_TAILSWIPE:
//Only cast if we are behind
/*if (!me->HasInArc(M_PI, me->GetVictim()))
{
DoCast(me->GetVictim(), SPELL_TAILSWIPE);
}*/
events.ScheduleEvent(EVENT_TAILSWIPE, 15000);
break;
case EVENT_BURNINGADRENALINE_CASTER:
{
Unit* target = NULL;
uint8 i = 0;
while (i < 3) // max 3 tries to get a random target with power_mana
{
++i;
target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true); // not aggro leader
if (target && target->getPowerType() == POWER_MANA)
i = 3;
}
if (target) // cast on self (see below)
target->CastSpell(target, SPELL_BURNINGADRENALINE, true);
}
events.ScheduleEvent(EVENT_BURNINGADRENALINE_CASTER, 15000);
break;
case EVENT_BURNINGADRENALINE_TANK:
// have the victim cast the spell on himself otherwise the third effect aura will be applied to Vael instead of the player
me->EnsureVictim()->CastSpell(me->GetVictim(), SPELL_BURNINGADRENALINE, true);
events.ScheduleEvent(EVENT_BURNINGADRENALINE_TANK, 45000);
break;
}
}
// Yell if hp lower than 15%
if (HealthBelowPct(15) && !HasYelled)
{
Talk(SAY_HALFLIFE);
HasYelled = true;
}
DoMeleeAttackIfReady();
}
void KilledUnit(Unit* victim)
{
if (victim->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_KILL);
}
void KilledUnit(Unit* who) override
{
if (who->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void KilledUnit(Unit* killed)
{
if (killed->GetTypeId() == TYPEID_PLAYER)
Talk(SAY_SLAY);
}
void hyjalAI::UpdateAI(uint32 diff)
{
if (IsDummy)
{
if (MassTeleportTimer < diff && DoMassTeleport)
{
DoCast(me, SPELL_MASS_TELEPORT, false);
DoMassTeleport = false;
} else MassTeleportTimer -= diff;
return;
}
if (DoHide)
{
DoHide = false;
switch (me->GetEntry())
{
case JAINA:
if (instance->GetData(DATA_ALLIANCE_RETREAT))
{
me->SetVisible(false);
HideNearPos(me->GetPositionX(), me->GetPositionY());
HideNearPos(5037.76f, -1889.71f);
for (uint8 i = 0; i < 92; ++i)//summon fires
me->SummonGameObject(GO_ROARING_FLAME, AllianceFirePos[i][0], AllianceFirePos[i][1], AllianceFirePos[i][2], AllianceFirePos[i][3], AllianceFirePos[i][4], AllianceFirePos[i][5], AllianceFirePos[i][6], AllianceFirePos[i][7], 0);
}
else me->SetVisible(true);
break;
case THRALL: //thrall
if (instance->GetData(DATA_HORDE_RETREAT))
{
me->SetVisible(false);
HideNearPos(me->GetPositionX(), me->GetPositionY());
HideNearPos(5563, -2763.19f);
HideNearPos(5542.2f, -2629.36f);
for (uint8 i = 0; i < 65; ++i)//summon fires
me->SummonGameObject(GO_ROARING_FLAME, HordeFirePos[i][0], HordeFirePos[i][1], HordeFirePos[i][2], HordeFirePos[i][3], HordeFirePos[i][4], HordeFirePos[i][5], HordeFirePos[i][6], HordeFirePos[i][7], 0);
}
else me->SetVisible(true);
break;
}
}
if (DoRespawn)
{
if (RespawnTimer <= diff)
{
DoRespawn = false;
RespawnNearPos(me->GetPositionX(), me->GetPositionY());
if (Faction == 0)
{
RespawnNearPos(5037.76f, -1889.71f);
} else if (Faction == 1)
{
RespawnNearPos(5563, -2763.19f);
RespawnNearPos(5542.2f, -2629.36f);
}
me->SetVisible(true);
}else{
RespawnTimer -= diff;
me->SetVisible(false);
}
return;
}
if (Overrun)
DoOverrun(Faction, diff);
if (bRetreat)
{
if (RetreatTimer <= diff)
{
IsDummy = true;
bRetreat = false;
HideNearPos(me->GetPositionX(), me->GetPositionY());
switch (me->GetEntry())
{
case JAINA://jaina
HideNearPos(5037.76f, -1889.71f);
break;
case THRALL://thrall
HideNearPos(5563, -2763.19f);
HideNearPos(5542.2f, -2629.36f);
HideNearPos(5603.75f, -2853.12f);
break;
}
me->SetVisible(false);
} else RetreatTimer -= diff;
}
if (!EventBegun)
return;
if (Summon)
{
if (EnemyCount)
{
EnemyCount = instance->GetData(DATA_TRASH);
if (!EnemyCount)
NextWaveTimer = 5000;
}
if (NextWaveTimer <= diff)
{
if (Faction == 0)
SummonNextWave(AllianceWaves, WaveCount, AllianceBase);
else if (Faction == 1)
SummonNextWave(HordeWaves, WaveCount, HordeBase);
++WaveCount;
} else NextWaveTimer -= diff;
}
if (CheckTimer <= diff)
{
for (uint8 i = 0; i < 2; ++i)
{
if (BossGUID[i])
{
Unit* unit = Unit::GetUnit(*me, BossGUID[i]);
if (unit && (!unit->IsAlive()))
{
if (BossGUID[i] == BossGUID[0])
{
Talk(INCOMING);
FirstBossDead = true;
}
else if (BossGUID[i] == BossGUID[1])
{
Talk(SUCCESS);
SecondBossDead = true;
}
EventBegun = false;
CheckTimer = 0;
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
BossGUID[i] = 0;
instance->DoUpdateWorldState(WORLD_STATE_ENEMY, 0); // Reset world state for enemies to disable it
}
}
}
CheckTimer = 5000;
} else CheckTimer -= diff;
if (!UpdateVictim())
return;
for (uint8 i = 0; i < HYJAL_AI_MAX_SPELLS; ++i)
{
if (Spells[i].SpellId)
{
if (SpellTimer[i] <= diff)
{
if (me->IsNonMeleeSpellCast(false))
me->InterruptNonMeleeSpells(false);
Unit* target = NULL;
switch (Spells[i].TargetType)
{
case TARGETTYPE_SELF:
target = me;
break;
case TARGETTYPE_RANDOM:
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
break;
case TARGETTYPE_VICTIM:
target = me->GetVictim();
break;
}
if (target && target->IsAlive())
{
DoCast(target, Spells[i].SpellId);
SpellTimer[i] = Spells[i].Cooldown;
}
} else SpellTimer[i] -= diff;
}
}
DoMeleeAttackIfReady();
}
