void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_FLAMESTRIKE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_FLAMESTRIKE);
Talk(SAY_COUNCIL_SPECIAL);
events.Repeat(Seconds(40));
break;
case EVENT_BLIZZARD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_BLIZZARD);
events.Repeat(Seconds(15), Seconds(40));
break;
case EVENT_ARCANE_EXPLOSION_CHECK:
_canUseArcaneExplosion = true;
break;
case EVENT_ARCANE_EXPLOSION:
if (_canUseArcaneExplosion && SelectTarget(SELECT_TARGET_RANDOM, 0, 10.0f))
{
DoCastSelf(SPELL_ARCANE_EXPLOSION);
_canUseArcaneExplosion = false;
events.ScheduleEvent(EVENT_ARCANE_EXPLOSION_CHECK, Seconds(5));
}
events.Repeat(Seconds(1));
break;
case EVENT_DAMPEN_MAGIC:
DoCastSelf(SPELL_DAMPEN_MAGIC);
break;
default:
break;
}
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SOUL_DRAIN:
DoCastSelf(SPELL_SOUL_DRAIN, { SPELLVALUE_MAX_TARGETS, 5 });
events.Repeat(Seconds(30), Seconds(35));
break;
case EVENT_FRENZY:
Talk(SUFF_SAY_ENRAGE);
DoCastSelf(SPELL_FRENZY);
events.Repeat(Seconds(45), Seconds(50));
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CHECK_TANKER:
{
Unit* target = me->GetVictim();
if (!_targetGUID || !target)
return;
if (target->GetGUID() != _targetGUID)
{
Talk(ANGER_SAY_SEETHE);
Talk(ANGER_EMOTE_SEETHE, me);
_targetGUID = target->GetGUID();
DoCastSelf(SPELL_SEETHE, true);
}
break;
}
case EVENT_SOUL_SCREAM:
DoCastSelf(SPELL_SOUL_SCREAM);
events.Repeat(Seconds(11));
break;
case EVENT_SPITE:
Talk(ANGER_SAY_SPITE);
DoCastSelf(SPELL_SPITE, { SPELLVALUE_MAX_TARGETS, 3 });
events.Repeat(Seconds(20));
break;
case EVENT_START_CHECK_TANKER:
if (Unit* target = me->GetVictim())
{
_targetGUID = target->GetGUID();
events.ScheduleEvent(EVENT_CHECK_TANKER, 1s);
}
else
events.Repeat(Seconds(1));
break;
case EVENT_FREED_2:
Talk(ANGER_SAY_FREED_2);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void Emerge()
{
me->UpdateSpeed(MOVE_RUN);
uint32 submergeSpell = wasMobile ? SPELL_SUBMERGE : SPELL_SUBMERGE_2;
me->RemoveAurasDueToSpell(submergeSpell);
me->RemoveAurasDueToSpell(SPELL_GROUND_VISUAL_0);
DoCastSelf(SPELL_EMERGE);
DoCastAOE(SPELL_HATE_TO_ZERO, true);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
me->SetReactState(REACT_AGGRESSIVE);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
AttackStart(target);
// if the worm was mobile before submerging, make him stationary now
if (wasMobile)
{
me->SetControlled(true, UNIT_STATE_ROOT);
me->SetDisplayId(modelStationary);
DoCastSelf(SPELL_GROUND_VISUAL_1, true);
events.SetPhase(PHASE_STATIONARY);
}
else
{
if (Unit* target = me->GetVictim())
me->GetMotionMaster()->MoveChase(target);
me->SetDisplayId(modelMobile);
events.SetPhase(PHASE_MOBILE);
}
wasMobile = !wasMobile;
ScheduleTasks();
}
void Submerge()
{
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
if (wasMobile)
{
me->HandleEmoteCommand(EMOTE_ONESHOT_SUBMERGE);
DoCastSelf(SPELL_SUBMERGE);
me->SetSpeedRate(MOVE_RUN, 8.0f);
DoCastSelf(SPELL_GROUND_VISUAL_0, true);
events.SetPhase(PHASE_SUBMERGED);
events.ScheduleEvent(EVENT_EMERGE, 5s, 0, PHASE_SUBMERGED);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
}
else
{
me->HandleEmoteCommand(EMOTE_ONESHOT_SUBMERGE);
DoCastSelf(SPELL_SUBMERGE_2);
me->RemoveAurasDueToSpell(SPELL_GROUND_VISUAL_1);
me->SetSpeedRate(MOVE_RUN, 1.1111f);
DoCastSelf(SPELL_GROUND_VISUAL_0, true);
events.SetPhase(PHASE_SUBMERGED);
me->SetControlled(false, UNIT_STATE_ROOT);
events.ScheduleEvent(EVENT_EMERGE, 6s, 0, PHASE_SUBMERGED);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
}
me->GetMotionMaster()->MovePoint(0, ToCCommonLoc[1].GetPositionX() + frand(-40.0f, 40.0f), ToCCommonLoc[1].GetPositionY() + frand(-40.0f, 40.0f), ToCCommonLoc[1].GetPositionZ() + me->GetCollisionHeight());
}
void MovementInform(uint32 type, uint32 pointId) override
{
if (type != POINT_MOTION_TYPE && type != EFFECT_MOTION_TYPE && type != SPLINE_CHAIN_MOTION_TYPE)
return;
switch (pointId)
{
case POINT_INITIAL_MOVEMENT:
events.ScheduleEvent(EVENT_ENGAGE, 3s);
break;
case POINT_MIDDLE:
DoCastSelf(SPELL_MASSIVE_CRASH);
events.ScheduleEvent(EVENT_SELECT_CHARGE_TARGET, 4s);
break;
case POINT_ICEHOWL_CHARGE:
events.Reset();
events.SetPhase(PHASE_COMBAT);
RescheduleTasks();
me->SetReactState(REACT_AGGRESSIVE);
DoCastSelf(SPELL_TRAMPLE);
break;
default:
break;
}
}
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_SUBMERGE:
DoCastSelf(SPELL_SUBMERGE_VISUAL, true);
events.ScheduleEvent(EVENT_SUMMON_ESSENCE, 3s);
break;
case EVENT_SUMMON_ESSENCE:
{
EntryCheckPredicate pred(NPC_ENSLAVED_SOUL);
summons.DoAction(ACTION_KILL_SELF, pred);
DoCastSelf(GetSummonSpell());
break;
}
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_RANDOM_BEAM:
DoCastSelf(BeamTriggers[urand(0, 3)]);
events.Repeat(Seconds(30));
break;
case EVENT_PRISMATIC_SHIELD:
DoCastSelf(PrismaticAuras[urand(0, 5)]);
events.Repeat(Seconds(15));
break;
case EVENT_FATAL_ATTRACTION:
Talk(SAY_SPELL);
me->CastCustomSpell(SPELL_FATAL_ATTACTION_TELEPORT, SPELLVALUE_MAX_TARGETS, 3, me);
events.Repeat(Seconds(30));
break;
case EVENT_SILENCING_SHRIEK:
DoCastVictim(SPELL_SILENCING_SHRIEK);
events.Repeat(Seconds(18), Seconds(30));
break;
case EVENT_TAUNT:
Talk(SAY_TAUNT);
events.Repeat(Seconds(30), Seconds(40));
break;
case EVENT_BERSERK:
Talk(EMOTE_BERSERK, me);
DoCastSelf(SPELL_BERSERK);
break;
default:
break;
}
}
void Reset() override
{
me->m_Events.AddEventAtOffset([this]()
{
DoCastSelf(SPELL_SLIME_POOL_EFFECT, true);
DoCastSelf(SPELL_PACIFY_SELF, true);
}, 1s);
}
void UpdateAI(uint32 diff) override
{
if (!events.IsInPhase(PHASE_INTRO) && (!UpdateVictim() || !CheckInRoom()))
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ANRAPHET_APPEAR:
me->GetMotionMaster()->MoveSmoothPath(POINT_ANRAPHET_ACTIVATE, AnraphetPath, AnraphetPathSize);
break;
case EVENT_ANRAPHET_ACTIVATE:
Talk(ANRAPHET_SAY_INTRO);
events.ScheduleEvent(EVENT_ANRAPHET_DESTRUCTION, Seconds(10), 0, PHASE_INTRO); // Note: 10800 ms
break;
case EVENT_ANRAPHET_DESTRUCTION:
DoCastAOE(SPELL_DESTRUCTION_PROTOCOL);
events.ScheduleEvent(EVENT_ANRAPHET_READY, Seconds(6), 0, PHASE_INTRO); // Note: 6400 ms
break;
case EVENT_ANRAPHET_READY:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
events.SetPhase(PHASE_COMBAT);
ScheduleCombatEvents();
break;
case EVENT_ANRAPHET_NEMESIS_STRIKE:
DoCastVictim(SPELL_NEMESIS_STRIKE);
events.ScheduleEvent(EVENT_ANRAPHET_NEMESIS_STRIKE, Seconds(21), 0, PHASE_COMBAT);
break;
case EVENT_ANRAPHET_ALPHA_BEAMS:
DoCastSelf(SPELL_ALPHA_BEAMS);
events.ScheduleEvent(EVENT_ANRAPHET_CRUMBLING_RUIN, Seconds(12), 0, PHASE_COMBAT);
events.ScheduleEvent(EVENT_ANRAPHET_ALPHA_BEAMS, Seconds(40), Seconds(45), 0, PHASE_COMBAT);
break;
case EVENT_ANRAPHET_OMEGA_STANCE:
DoCastSelf(SPELL_OMEGA_STANCE_SUMMON);
DoCastSelf(SPELL_OMEGA_STANCE);
Talk(ANRAPHET_SAY_OMEGA_STANCE);
events.ScheduleEvent(EVENT_ANRAPHET_OMEGA_STANCE, Seconds(45), Seconds(50), 0, PHASE_COMBAT);
events.ScheduleEvent(EVENT_ANRAPHET_CRUMBLING_RUIN, Seconds(13), 0, PHASE_COMBAT);
break;
case EVENT_ANRAPHET_CRUMBLING_RUIN:
DoCastSelf(SPELL_CRUMBLING_RUIN);
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
if (UpdateVictim())
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_FLIGHT:
{
me->SetCanFly(true);
me->SetDisableGravity(true);
me->SetByteFlag(UNIT_FIELD_BYTES_1, UNIT_BYTES_1_OFFSET_ANIM_TIER, UNIT_BYTE1_FLAG_ALWAYS_STAND | UNIT_BYTE1_FLAG_HOVER);
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
Position pos;
pos.Relocate(me);
pos.m_positionZ += 10.0f;
me->GetMotionMaster()->MoveTakeoff(POINT_TAKEOFF, pos);
events.CancelEventGroup(EVENT_GROUP_LAND_PHASE);
break;
}
case EVENT_CONFLAGRATION:
DoCastSelf(SPELL_CONFLAGRATION, true);
break;
case EVENT_ENRAGE:
DoCastSelf(SPELL_ENRAGE);
Talk(EMOTE_ENRAGED);
events.Repeat(Seconds(24));
break;
case EVENT_FLAME_BREATH:
DoCastVictim(SPELL_FLAME_BREATH);
events.Repeat(Seconds(20), Seconds(30));
break;
case EVENT_AIR_MOVEMENT:
me->GetMotionMaster()->MovePoint(POINT_FLIGHT, SavianaRagefireFlyOutPos);
break;
case EVENT_LAND_GROUND:
me->GetMotionMaster()->MoveLand(POINT_LAND_GROUND, SavianaRagefireLandPos);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SEARING_LIGHT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SEARING_LIGHT);
events.ScheduleEvent(EVENT_SEARING_LIGHT, TIMER_SEARING_LIGHT);
break;
case EVENT_GRAVITY_BOMB:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_GRAVITY_BOMB);
events.ScheduleEvent(EVENT_GRAVITY_BOMB, TIMER_GRAVITY_BOMB);
break;
case EVENT_TYMPANIC_TANTRUM:
Talk(SAY_TYMPANIC_TANTRUM);
Talk(EMOTE_TYMPANIC_TANTRUM);
DoCast(SPELL_TYMPANIC_TANTRUM);
events.ScheduleEvent(EVENT_TYMPANIC_TANTRUM, urand(TIMER_TYMPANIC_TANTRUM_MIN, TIMER_TYMPANIC_TANTRUM_MAX));
break;
case EVENT_DISPOSE_HEART:
SetPhaseOne();
break;
case EVENT_ENRAGE:
Talk(SAY_BERSERK);
DoCastSelf(SPELL_ENRAGE);
break;
case EVENT_ENTER_HARD_MODE:
me->SetFullHealth();
DoCastSelf(SPELL_HEARTBREAK, true);
me->AddLootMode(LOOT_MODE_HARD_MODE_1);
_hardMode = true;
SetPhaseOne();
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
if (_phase == 1)
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!events.IsInPhase(PHASE_INTRO) && !UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ENRAGE:
DoCast(SPELL_BERSERK);
break;
case EVENT_INCINERATE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_INCINERATE);
Talk(SAY_INCINERATE);
events.Repeat(Seconds(12), Seconds(20));
break;
case EVENT_SUMMON_DOOM_BLOSSOM:
DoCastSelf(SPELL_SUMMON_DOOM_BLOSSOM, true);
Talk(SAY_BLOSSOM);
events.Repeat(Seconds(30), Seconds(40));
break;
case EVENT_SHADOW_DEATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100.0f, true, true, -SPELL_SPIRITUAL_VENGEANCE))
DoCast(target, SPELL_SHADOW_OF_DEATH);
events.Repeat(Seconds(30), Seconds(35));
break;
case EVENT_CRUSHING_SHADOWS:
DoCastSelf(SPELL_CRUSHING_SHADOWS, { SPELLVALUE_MAX_TARGETS, 5 });
Talk(SAY_CRUSHING);
events.Repeat(Seconds(18), Seconds(30));
break;
case EVENT_FINISH_INTRO:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
me->SetReactState(REACT_AGGRESSIVE);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void IsSummonedBy(Unit* summoner) override
{
_summonerGUID = summoner->GetGUID();
_scheduler.Schedule(Milliseconds(3650), [this](TaskContext /*context*/)
{
DoCastSelf(SPELL_ICICLE_FALL_TRIGGER, true);
DoCastSelf(SPELL_ICICLE_FALL_VISUAL);
if (Unit* caster = ObjectAccessor::GetUnit(*me, _summonerGUID))
caster->RemoveDynObject(SPELL_ICICLE_SUMMON);
});
}
void DoAction(int32 action) override
{
if (action == ACTION_ENRAGE)
{
DoCastSelf(SPELL_FROTHING_RAGE, true);
Talk(EMOTE_TRAMPLE_ENRAGE);
}
else if (action == ACTION_TRAMPLE_FAIL)
{
DoCastSelf(SPELL_STAGGERED_DAZE, true);
Talk(EMOTE_TRAMPLE_FAIL);
events.DelayEvents(15s);
}
}
void InitializeAI() override
{
float x, y, z;
me->GetNearPoint(me, x, y, z, 1, 100.0f, frand(0.f, 2.f * float(M_PI)));
me->GetMotionMaster()->MovePoint(0, x, y, z);
DoCastSelf(SPELL_MOLTEN_FLAME, true);
}
void ExposeHeart()
{
Talk(SAY_HEART_OPENED);
Talk(EMOTE_HEART_OPENED);
DoCastSelf(SPELL_SUBMERGE); // Will make creature untargetable
me->AttackStop();
me->SetReactState(REACT_PASSIVE);
Unit* heart = me->GetVehicleKit() ? me->GetVehicleKit()->GetPassenger(HEART_VEHICLE_SEAT_NORMAL) : nullptr;
if (heart)
{
heart->CastSpell(heart, SPELL_HEART_OVERLOAD);
heart->CastSpell(me, SPELL_HEART_LIGHTNING_TETHER);
heart->CastSpell(heart, SPELL_HEART_HEAL_TO_FULL, true);
heart->CastSpell(me, SPELL_RIDE_VEHICLE_EXPOSED, true);
heart->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
heart->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNK_29);
}
events.CancelEvent(EVENT_SEARING_LIGHT);
events.CancelEvent(EVENT_GRAVITY_BOMB);
events.CancelEvent(EVENT_TYMPANIC_TANTRUM);
// Start "end of phase 2 timer"
events.ScheduleEvent(EVENT_DISPOSE_HEART, TIMER_HEART_PHASE);
// Phase 2 has officially started
_phase = 2;
_heartExposed++;
}
void DoAction(int32 action) override
{
switch (action)
{
case ACTION_PET_DIED:
if (!_petCount) // underflow check - something has gone horribly wrong
{
EnterEvadeMode(EVADE_REASON_OTHER);
return;
}
if (!--_petCount) // last pet died, emerge
{
me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
me->RemoveAurasDueToSpell(SPELL_IMPALE_AURA);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
DoCastSelf(SPELL_EMERGE);
events.SetPhase(PHASE_EMERGE);
events.ScheduleEvent(EVENT_POUND, randtime(Seconds(13), Seconds(18)), 0, PHASE_EMERGE);
events.ScheduleEvent(EVENT_LEECHING_SWARM, randtime(Seconds(3), Seconds(7)), 0, PHASE_EMERGE);
events.ScheduleEvent(EVENT_CARRION_BEETLES, randtime(Seconds(10), Seconds(15)), 0, PHASE_EMERGE);
}
break;
case ACTION_PET_EVADE:
EnterEvadeMode(EVADE_REASON_OTHER);
break;
}
}
void ScheduleEvents() override
{
events.ScheduleEvent(EVENT_FLAMESTRIKE, Seconds(8));
events.ScheduleEvent(EVENT_BLIZZARD, Seconds(25));
events.ScheduleEvent(EVENT_ARCANE_EXPLOSION, Seconds(5));
DoCastSelf(SPELL_DAMPEN_MAGIC);
}
void Reset() override
{
_Reset();
_inCombat = false;
me->SummonCreatureGroup(SUMMON_COUNCIL_GROUP);
DoCastSelf(SPELL_EMPYREAL_BALANCE, true);
}
void Reset() override
{
_scheduler.Schedule(Seconds(3), [this](TaskContext /*context*/)
{
DoCastSelf(SPELL_VOLCANIC_ERUPTION);
});
}
void Reset() override
{
_scheduler.Schedule(Seconds(1), [this](TaskContext consumption)
{
DoCastSelf(SPELL_CONSUMPTION);
consumption.Repeat();
});
}
void SummonedCreatureDies(Creature* summon, Unit* /*killer*/) override
{
if (summon->GetEntry() == NPC_APOTHECARY_FRYE || summon->GetEntry() == NPC_APOTHECARY_BAXTER)
_deadCount++;
if (me->HasAura(SPELL_PERMANENT_FEIGN_DEATH) && _deadCount == 2)
DoCastSelf(SPELL_QUIET_SUICIDE, true);
}
void DamageTaken(Unit* /*source*/, uint32& damage) override
{
if (_hadFrenzy || !me->HealthBelowPctDamaged(25, damage))
return;
_hadFrenzy = true;
Talk(CRUSHER_EMOTE_FRENZY);
DoCastSelf(SPELL_FRENZY);
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_DEADLY_STRIKE:
DoCastSelf(SPELL_DEADLY_STRIKE);
events.Repeat(Seconds(60));
break;
case EVENT_VANISH:
DoCastSelf(SPELL_VANISH);
Talk(SAY_COUNCIL_SPECIAL);
events.Repeat(Seconds(60));
break;
default:
break;
}
}
void JustEngagedWith(Unit* /*who*/) override
{
DoZoneInCombat();
DoCastSelf(SPELL_FROZEN_MALLET_2);
_events.ScheduleEvent(EVENT_FROST_BLAST, 5000);
}
void IsSummonedBy(Unit* /*summoner*/) override
{
DoCastSelf(SPELL_FROZEN_ORB_AURA, true);
DoCastSelf(SPELL_FROZEN_ORB_DMG, true);
DoCastSelf(SPELL_RANDOM_AGGRO, true);
if (Creature* toravon = me->GetInstanceScript()->GetCreature(DATA_TORAVON))
{
if (toravon->IsInCombat())
{
toravon->AI()->JustSummoned(me);
DoZoneInCombat();
}
else
me->DespawnOrUnsummon();
}
}
void ExecuteEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_ENGAGE:
instance->DoCloseDoorOrButton(instance->GetGuidData(DATA_MAIN_GATE));
me->SetImmuneToPC(false);
events.SetPhase(PHASE_COMBAT);
me->SetReactState(REACT_AGGRESSIVE);
DoZoneInCombat();
break;
case EVENT_MASSIVE_CRASH:
me->SetReactState(REACT_PASSIVE);
me->AttackStop();
events.SetPhase(PHASE_CHARGE);
me->GetMotionMaster()->MoveJump(ToCCommonLoc[1], 20.0f, 20.0f, POINT_MIDDLE);
break;
case EVENT_SELECT_CHARGE_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true))
{
DoCast(target, SPELL_FURIOUS_CHARGE_SUMMON, true);
me->SetTarget(target->GetGUID());
Talk(EMOTE_TRAMPLE_ROAR, target);
events.ScheduleEvent(EVENT_ICEHOWL_ROAR, 1s);
}
break;
case EVENT_ICEHOWL_ROAR:
if (Creature* stalker = instance->GetCreature(DATA_FURIOUS_CHARGE))
DoCast(stalker, SPELL_ROAR);
events.ScheduleEvent(EVENT_JUMP_BACK, 3s, 0, PHASE_CHARGE);
break;
case EVENT_JUMP_BACK:
if (Creature* stalker = instance->GetCreature(DATA_FURIOUS_CHARGE))
DoCast(stalker, SPELL_JUMP_BACK);
events.ScheduleEvent(EVENT_TRAMPLE, 2s, 0, PHASE_CHARGE);
break;
case EVENT_TRAMPLE:
if (Creature* stalker = instance->GetCreature(DATA_FURIOUS_CHARGE))
me->GetMotionMaster()->MoveCharge(stalker->GetPositionX(), stalker->GetPositionY(), stalker->GetPositionZ(), 42.0f, POINT_ICEHOWL_CHARGE);
me->SetTarget(ObjectGuid::Empty);
break;
case EVENT_FEROCIOUS_BUTT:
DoCastVictim(SPELL_FEROCIOUS_BUTT);
events.Repeat(20s);
break;
case EVENT_ARCTIC_BREATH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true))
DoCast(target, SPELL_ARCTIC_BREATH);
events.Repeat(24s);
break;
case EVENT_WHIRL:
DoCastSelf(SPELL_WHIRL);
events.Repeat(16s);
break;
default:
break;
}
}
void EnterCombat(Unit* /*who*/) override
{
DoCastSelf(SPELL_STATIC_CHARGED);
_scheduler.Schedule(Seconds(12), [this](TaskContext spellShock)
{
DoCastVictim(SPELL_SHOCK);
spellShock.Repeat();
});
}
void DamageTaken(Unit* /*attacker*/, uint32& damage) override
{
if (me->HealthBelowPctDamaged(30, damage) && !_hasEnraged)
{
_hasEnraged = true;
Talk(SAY_ENRAGE);
DoCastSelf(SPELL_ENRAGE);
}
}
