boss_skadi.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "ScriptMgr.h"
#include "GridNotifiers.h"
#include "InstanceScript.h"
#include "MotionMaster.h"
#include "MoveSplineInit.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "SpellAuras.h"
#include "SpellInfo.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
#include "utgarde_pinnacle.h"
#include "Vehicle.h"
 
enum Spells
{
 // Skadi Spells
 SPELL_CRUSH = 50234,
 SPELL_POISONED_SPEAR = 50255,
 SPELL_POISONED_SPEAR_PERIODIC = 50258,
 SPELL_WHIRLWIND = 50228,
 SPELL_SKADI_TELEPORT = 61790,
 SPELL_LAUNCH_HARPOON = 48642,
 SPELL_SUMMON_GAUNLET_MOBS_PERIODIC = 59275,
 SPELL_RIDE_GRAUF = 61791,
 SPELL_FREEZING_CLOUD = 47579,
 SPELL_FREEZING_CLOUD_RIGHT_PERIODIC = 47592,
 SPELL_FREEZING_CLOUD_LEFT_PERIODIC = 47590,
 SPELL_FREEZING_CLOUD_RIGHT_AREA = 47594,
 SPELL_FREEZING_CLOUD_LEFT_AREA = 47574,
 SPELL_SUMMON_YMIRJAR_WARRIOR_W = 48631,
 SPELL_SUMMON_YMIRJAR_WARRIOR_E = 48632,
 SPELL_SUMMON_YMIRJAR_HARPOONER_W = 48633,
 SPELL_SUMMON_YMIRJAR_HARPOONER_E = 48634,
 SPELL_SUMMON_YMIRJAR_WITCH_DOCTOR_W = 48635,
 SPELL_SUMMON_YMIRJAR_WITCH_DOCTOR_E = 48636,
 SPELL_UTGARDE_PINNACLE_GAUNTLET_EFFECT = 47547,
 SPELL_UTGARDE_PINNACLE_GUANTLET_RESET_CHECK = 49308,
 // Trash
 SPELL_HAMSTRING = 48639,
 SPELL_STRIKE = 48640,
 SPELL_SHADOW_BOLT = 49084,
 SPELL_SHRINK = 49089,
 SPELL_NET = 49092,
 SPELL_THROW = 49091,
 SPELL_SUMMON_HARPOON = 56789,
};
 
enum Texts
{
 SAY_AGGRO = 0,
 SAY_KILL = 1,
 SAY_DEATH = 3,
 SAY_DRAKE_DEATH = 5,
 SAY_DRAKE_BREATH = 6,
 EMOTE_BREATH = 0,
 EMOTE_ON_RANGE = 1
};
 
enum Points
{
 POINT_0 = 0,
 POINT_1 = 1,
 POINT_2 = 2,
 POINT_BREACH = 0,
 POINT_LEFT = 1,
 POINT_RIGHT = 2
};
 
enum SplineChainIds
{
 SPLINE_CHAIN_INITIAL = 1,
 SPLINE_CHAIN_BREACH_RIGHT = 2,
 SPLINE_CHAIN_BREACH_LEFT = 3,
 SPLINE_CHAIN_RIGHT = 4,
 SPLINE_CHAIN_LEFT = 5
};
 
enum Actions
{
 ACTION_START_ENCOUNTER = 0,
 ACTION_DRAKE_BREATH,
 ACTION_GAUNTLET_END,
 ACTION_HARPOON_HIT,
};
 
enum CombatPhase
{
 PHASE_FLYING = 0,
 PHASE_GROUND
};
 
enum MiscData
{
 
 DATA_LOVE_TO_SKADI = 0,
 FIRST_WAVE_MAX_WARRIORS = 10,
 FIRST_WAVE_SIZE = 13,
 ACHIEV_LODI_DODI_WE_LOVES_THE_SKADI = 17726,
};
 
float const BreachPoint = 2.670354f;
float const BreathPointRight = 3.124139f;
float const BreathPointLeft = 3.228859f;
Position const SecondaryWavesInitialPoint = { 478.7434f, -505.5758f, 104.7237f };
Position const SecondaryWavesFinalPoint = { 318.177f, -503.8898f, 104.5326f };
Position const SpawnLoc = { 477.5808f, -484.5591f, 104.8221f, 4.677482f };
Position const GraufLoc = { 341.7411f, -516.9545f, 104.6695f, 3.124139f };
Position const FirstWaveLocations[FIRST_WAVE_SIZE] =
{
 { 458.5323f, -516.2537f, 104.617f },
 { 429.4242f, -517.5624f, 104.8936f },
 { 394.4955f, -514.6144f, 104.7235f },
 { 362.2862f, -515.8771f, 104.7539f },
 { 333.5374f, -514.7942f, 104.4779f },
 { 457.6105f, -508.8362f, 104.4013f },
 { 427.4026f, -510.7716f, 104.8802f },
 { 392.5114f, -507.9429f, 104.7433f },
 { 362.9511f, -508.4115f, 104.7218f },
 { 333.536f, -506.0805f, 104.4258f },
 { 478.31f, -511.049f, 104.7242f, 3.263766f },
 { 482.25f, -514.1273f, 104.7234f, 3.263766f },
 { 481.3883f, -507.1089f, 104.7241f, 3.263766f },
};
 
struct boss_skadi : public BossAI
{
 boss_skadi(Creature* creature) : BossAI(creature, DATA_SKADI_THE_RUTHLESS)
 {
 Initialize();
 }
 
 void Initialize()
 {
 firstWaveSummoned = false;
 _harpoonHit = 0;
 _loveSkadi = 0;
 _phase = PHASE_GROUND;
 scheduler.SetValidator([this]
 {
 return !me->HasUnitState(UNIT_STATE_CASTING);
 });
 }
 
 void Reset() override
 {
 _Reset();
 Initialize();
 me->SetReactState(REACT_PASSIVE);
 if (!instance->GetCreature(DATA_GRAUF))
 me->SummonCreature(NPC_GRAUF, GraufLoc);
 }
 
 void EnterEvadeMode(EvadeReason /*why*/) override
 {
 summons.DespawnAll();
 _DespawnAtEvade();
 }
 
 void JustSummoned(Creature* summon) override
 {
 switch (summon->GetEntry())
 {
 case NPC_YMIRJAR_WARRIOR:
 case NPC_YMIRJAR_WITCH_DOCTOR:
 case NPC_YMIRJAR_HARPOONER:
 if (firstWaveSummoned)
 summon->GetMotionMaster()->MovePoint(POINT_1, SecondaryWavesInitialPoint);
 break;
 default:
 break;
 }
 summons.Summon(summon);
 }
 
 void SpawnFirstWave()
 {
 for (uint8 i = 0; i < FIRST_WAVE_MAX_WARRIORS; i++)
 if (Creature* summon = me->SummonCreature(NPC_YMIRJAR_WARRIOR, SpawnLoc, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5s))
 summon->GetMotionMaster()->MovePoint(POINT_0, FirstWaveLocations[i]);
 
 if (Creature* crea = me->SummonCreature(NPC_YMIRJAR_WITCH_DOCTOR, SpawnLoc, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5s))
 crea->GetMotionMaster()->MovePoint(POINT_0, FirstWaveLocations[10]);
 if (Creature* crea = me->SummonCreature(NPC_YMIRJAR_HARPOONER, SpawnLoc, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5s))
 crea->GetMotionMaster()->MovePoint(POINT_0, FirstWaveLocations[11]);
 if (Creature* crea = me->SummonCreature(NPC_YMIRJAR_HARPOONER, SpawnLoc, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5s))
 crea->GetMotionMaster()->MovePoint(POINT_0, FirstWaveLocations[12]);
 
 firstWaveSummoned = true;
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 _JustDied();
 Talk(SAY_DEATH);
 }
 
 void KilledUnit(Unit* who) override
 {
 if (who->GetTypeId() == TYPEID_PLAYER)
 Talk(SAY_KILL);
 }
 
 void DoAction(int32 action) override
 {
 switch (action)
 {
 case ACTION_START_ENCOUNTER:
 instance->SetBossState(DATA_SKADI_THE_RUTHLESS, IN_PROGRESS);
 me->SetUninteractible(true);
 me->setActive(true);
 SpawnFirstWave();
 Talk(SAY_AGGRO);
 _phase = PHASE_FLYING;
 instance->TriggerGameEvent(ACHIEV_LODI_DODI_WE_LOVES_THE_SKADI);
 
 scheduler
 .Schedule(Seconds(6), [this](TaskContext resetCheck)
 {
 if (Creature* resetTrigger = me->FindNearestCreature(NPC_TRIGGER_RESET, 200.0f))
 resetTrigger->CastSpell(resetTrigger, SPELL_UTGARDE_PINNACLE_GUANTLET_RESET_CHECK, true);
 resetCheck.Repeat();
 })
 .Schedule(Seconds(2), [this](TaskContext /*context*/)
 {
 if (Creature* grauf = instance->GetCreature(DATA_GRAUF))
 DoCast(grauf, SPELL_RIDE_GRAUF);
 });
 
 if (Creature* summonTrigger = me->SummonCreature(NPC_WORLD_TRIGGER, SpawnLoc))
 summonTrigger->CastSpell(summonTrigger, SPELL_SUMMON_GAUNLET_MOBS_PERIODIC, true);
 
 if (Creature* combatTrigger = me->SummonCreature(NPC_COMBAT_TRIGGER, SpawnLoc))
 combatTrigger->AI()->DoZoneInCombat();
 break;
 case ACTION_DRAKE_BREATH:
 if (_loveSkadi == 1)
 _loveSkadi++;
 Talk(SAY_DRAKE_BREATH);
 break;
 case ACTION_GAUNTLET_END:
 Talk(SAY_DRAKE_DEATH);
 DoCastSelf(SPELL_SKADI_TELEPORT);
 summons.DespawnEntry(NPC_WORLD_TRIGGER);
 me->SetUninteractible(false);
 me->SetImmuneToPC(false);
 me->SetReactState(REACT_AGGRESSIVE);
 _phase = PHASE_GROUND;
 
 scheduler
 .Schedule(Seconds(8), [this](TaskContext crush)
 {
 DoCastVictim(SPELL_CRUSH);
 crush.Repeat();
 })
 .Schedule(Seconds(11), [this](TaskContext poisonedSpear)
 {
 if (Unit* target = SelectTarget(SelectTargetMethod::Random))
 DoCast(target, SPELL_POISONED_SPEAR);
 poisonedSpear.Repeat();
 })
 .Schedule(Seconds(23), [this](TaskContext whirlwind)
 {
 DoCast(SPELL_WHIRLWIND);
 whirlwind.Repeat();
 });
 break;
 case ACTION_HARPOON_HIT:
 _harpoonHit++;
 if (_harpoonHit == 1)
 _loveSkadi = 1;
 break;
 }
 }
 
 uint32 GetData(uint32 id) const override
 {
 if (id == DATA_LOVE_TO_SKADI)
 return _loveSkadi;
 
 return 0;
 }
 
 void UpdateAI(uint32 diff) override
 {
 scheduler.Update(diff);
 
 if (_phase == PHASE_GROUND)
 {
 if (!UpdateVictim())
 return;
 }
 }
 
private:
 CombatPhase _phase;
 uint8 _harpoonHit;
 uint8 _loveSkadi;
 bool firstWaveSummoned;
};
 
struct npc_grauf : public ScriptedAI
{
 npc_grauf(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
 void Reset() override
 {
 me->SetReactState(REACT_PASSIVE);
 me->SetRegenerateHealth(false);
 me->SetSpeedRate(MOVE_RUN, 2.5f);
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 if (Creature* skadi = _instance->GetCreature(DATA_SKADI_THE_RUTHLESS))
 skadi->ExitVehicle();
 
 me->DespawnOrUnsummon(Seconds(6));
 }
 
 void PassengerBoarded(Unit* who, int8 /*seatId*/, bool apply) override
 {
 if (!apply)
 {
 if (Creature * skadi = _instance->GetCreature(DATA_SKADI_THE_RUTHLESS))
 skadi->AI()->DoAction(ACTION_GAUNTLET_END);
 return;
 }
 
 std::function<void(Movement::MoveSplineInit&)> initializer = [](Movement::MoveSplineInit& init)
 {
 init.DisableTransportPathTransformations();
 init.MoveTo(0.3320355f, 0.05355075f, 5.196949f, false);
 };
 who->GetMotionMaster()->LaunchMoveSpline(std::move(initializer), EVENT_VEHICLE_BOARD, MOTION_PRIORITY_HIGHEST);
 
 me->setActive(true);
 me->SetFarVisible(true);
 me->SetCanFly(true);
 me->SetDisableGravity(true);
 
 _scheduler.Schedule(Seconds(2), [this](TaskContext /*context*/)
 {
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_BREACH, SPLINE_CHAIN_INITIAL, false);
 });
 }
 
 void MovementInform(uint32 type, uint32 pointId) override
 {
 if (type != SPLINE_CHAIN_MOTION_TYPE)
 return;
 
 switch (pointId)
 {
 case POINT_BREACH:
 _scheduler
 .Schedule(Milliseconds(1), [this](TaskContext /*context*/)
 {
 me->SetFacingTo(BreachPoint);
 Talk(EMOTE_ON_RANGE);
 })
 .Schedule(Seconds(10), [this](TaskContext /*context*/)
 {
 if (RAND(POINT_LEFT, POINT_RIGHT) == POINT_LEFT)
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_LEFT, SPLINE_CHAIN_BREACH_LEFT, false);
 else
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_RIGHT, SPLINE_CHAIN_BREACH_RIGHT, false);
 });
 break;
 case POINT_LEFT:
 _scheduler
 .Schedule(Milliseconds(1), [this](TaskContext /*context*/)
 {
 me->SetFacingTo(BreathPointLeft);
 Talk(EMOTE_BREATH);
 })
 .Schedule(Seconds(2), [this](TaskContext /*context*/)
 {
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_BREACH, SPLINE_CHAIN_LEFT, false);
 DoCast(SPELL_FREEZING_CLOUD_LEFT_PERIODIC);
 if (Creature* skadi = _instance->GetCreature(DATA_SKADI_THE_RUTHLESS))
 skadi->AI()->DoAction(ACTION_DRAKE_BREATH);
 })
 .Schedule(Seconds(10), [this](TaskContext /*context*/)
 {
 me->RemoveAurasDueToSpell(SPELL_FREEZING_CLOUD_LEFT_PERIODIC);
 });
 break;
 case POINT_RIGHT:
 _scheduler
 .Schedule(Milliseconds(1), [this](TaskContext /*context*/)
 {
 me->SetFacingTo(BreathPointRight);
 Talk(EMOTE_BREATH);
 })
 .Schedule(Seconds(2), [this](TaskContext /*context*/)
 {
 me->GetMotionMaster()->MoveAlongSplineChain(POINT_BREACH, SPLINE_CHAIN_RIGHT, false);
 DoCast(SPELL_FREEZING_CLOUD_RIGHT_PERIODIC);
 if (Creature* skadi = _instance->GetCreature(DATA_SKADI_THE_RUTHLESS))
 skadi->AI()->DoAction(ACTION_DRAKE_BREATH);
 })
 .Schedule(Seconds(10), [this](TaskContext /*context*/)
 {
 me->RemoveAurasDueToSpell(SPELL_FREEZING_CLOUD_RIGHT_PERIODIC);
 });
 break;
 default:
 break;
 }
 }
 
 void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
 {
 if (spellInfo->Id == SPELL_LAUNCH_HARPOON)
 if (Creature* skadi = _instance->GetCreature(DATA_SKADI_THE_RUTHLESS))
 skadi->AI()->DoAction(ACTION_HARPOON_HIT);
 }
 
 void UpdateAI(uint32 diff) override
 {
 _scheduler.Update(diff);
 }
 
private:
 TaskScheduler _scheduler;
 InstanceScript* _instance;
};
 
struct npc_skadi_trashAI : public ScriptedAI
{
 npc_skadi_trashAI(Creature* creature) : ScriptedAI(creature)
 {
 _instance = me->GetInstanceScript();
 
 _scheduler.SetValidator([this]
 {
 return !me->HasUnitState(UNIT_STATE_CASTING);
 });
 }
 
 void JustEngagedWith(Unit* who) override
 {
 CreatureAI::JustEngagedWith(who);
 ScheduleTasks();
 }
 
 void IsSummonedBy(WorldObject* /*summoner*/) override
 {
 if (Creature* skadi = _instance->GetCreature(DATA_SKADI_THE_RUTHLESS))
 skadi->AI()->JustSummoned(me);
 }
 
 void MovementInform(uint32 type, uint32 pointId) override
 {
 if (type != POINT_MOTION_TYPE)
 return;
 
 switch (pointId)
 {
 case POINT_0:
 me->SetEmoteState(me->GetEntry() == NPC_YMIRJAR_WARRIOR ? EMOTE_STATE_READY1H : EMOTE_STATE_READY2HL);
 break;
 case POINT_1:
 _scheduler.Schedule(Seconds(1), [this](TaskContext /*context*/)
 {
 me->GetMotionMaster()->MovePoint(POINT_2, SecondaryWavesFinalPoint);
 });
 break;
 case POINT_2:
 DoZoneInCombat();
 break;
 default:
 break;
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 UpdateVictim();
 
 _scheduler.Update(diff);
 }
 
 virtual void ScheduleTasks() = 0;
 
protected:
 InstanceScript* _instance;
 TaskScheduler _scheduler;
};
 
struct npc_ymirjar_warrior : public npc_skadi_trashAI
{
 npc_ymirjar_warrior(Creature* creature) : npc_skadi_trashAI(creature) { }
 
 void ScheduleTasks() override
 {
 _scheduler
 .Schedule(Seconds(2), [this](TaskContext context)
 {
 DoCastVictim(SPELL_HAMSTRING);
 context.Repeat(Seconds(11), Seconds(18));
 })
 .Schedule(Seconds(9), [this](TaskContext context)
 {
 DoCastVictim(SPELL_STRIKE);
 context.Repeat(Seconds(10), Seconds(13));
 });
 }
};
 
struct npc_ymirjar_witch_doctor : public npc_skadi_trashAI
{
 npc_ymirjar_witch_doctor(Creature* creature) : npc_skadi_trashAI(creature) { }
 
 void ScheduleTasks() override
 {
 _scheduler
 .Schedule(Seconds(2), [this](TaskContext shadowBolt)
 {
 DoCastVictim(SPELL_SHADOW_BOLT);
 shadowBolt.Repeat();
 })
 .Schedule(Seconds(20), Seconds(34), [this](TaskContext shrink)
 {
 DoCastVictim(SPELL_SHRINK);
 shrink.Repeat();
 });
 }
};
 
struct npc_ymirjar_harpooner : public npc_skadi_trashAI
{
 npc_ymirjar_harpooner(Creature* creature) : npc_skadi_trashAI(creature) { }
 
 void ScheduleTasks() override
 {
 _scheduler
 .Schedule(Seconds(13), [this](TaskContext net)
 {
 if (Unit* target = SelectTarget(SelectTargetMethod::MaxDistance, 0, 30, true))
 DoCast(target, SPELL_NET);
 net.Repeat();
 })
 .Schedule(Seconds(2), [this](TaskContext castThrow)
 {
 DoCastVictim(SPELL_THROW);
 castThrow.Repeat();
 });
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 DoCast(SPELL_SUMMON_HARPOON);
 }
};
 
// 47594 - Freezing Cloud
class spell_freezing_cloud_area_right : public SpellScript
{
 bool Validate(SpellInfo const* /*spell*/) override
 {
 return ValidateSpellInfo({ SPELL_FREEZING_CLOUD });
 }
 
 void FilterTargets(std::list<WorldObject*>& targets)
 {
 targets.remove_if([](WorldObject* obj) { return obj->GetPositionY() > -511.0f; });
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 GetHitUnit()->CastSpell(GetHitUnit(), SPELL_FREEZING_CLOUD, true);
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_freezing_cloud_area_right::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
 OnEffectHitTarget += SpellEffectFn(spell_freezing_cloud_area_right::HandleScript, EFFECT_0, SPELL_EFFECT_APPLY_AURA);
 }
};
 
// 47574 - Freezing Cloud
class spell_freezing_cloud_area_left : public SpellScript
{
 bool Validate(SpellInfo const* /*spell*/) override
 {
 return ValidateSpellInfo({ SPELL_FREEZING_CLOUD });
 }
 
 void FilterTargets(std::list<WorldObject*>& targets)
 {
 targets.remove_if([](WorldObject* obj) { return obj->GetPositionY() < -511.0f; });
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 GetHitUnit()->CastSpell(GetHitUnit(), SPELL_FREEZING_CLOUD, true);
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_freezing_cloud_area_left::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
 OnEffectHitTarget += SpellEffectFn(spell_freezing_cloud_area_left::HandleScript, EFFECT_0, SPELL_EFFECT_APPLY_AURA);
 }
};
 
// 47579, 60020 - Freezing Cloud
class spell_freezing_cloud_damage : public AuraScript
{
 bool CanBeAppliedOn(Unit* target)
 {
 if (Aura* aur = target->GetAura(GetId()))
 if (aur->GetOwner() != GetOwner())
 return false;
 
 return true;
 }
 
 void Register() override
 {
 DoCheckAreaTarget += AuraCheckAreaTargetFn(spell_freezing_cloud_damage::CanBeAppliedOn);
 }
};
 
// 49308 - Utgarde Pinnacle Guantlet Reset Check
class spell_skadi_reset_check : public SpellScript
{
 void CountTargets(std::list<WorldObject*>& targets)
 {
 targets.remove_if(Trinity::UnitAuraCheck(false, SPELL_UTGARDE_PINNACLE_GAUNTLET_EFFECT));
 _targetCount = targets.size();
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 if (_targetCount)
 return;
 
 Creature* target = GetHitCreature();
 if (!target)
 return;
 
 if (InstanceScript* instance = target->GetInstanceScript())
 if (instance->GetBossState(DATA_SKADI_THE_RUTHLESS) == IN_PROGRESS)
 target->AI()->EnterEvadeMode(EvadeReason::NoHostiles);
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_skadi_reset_check::CountTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
 OnEffectHitTarget += SpellEffectFn(spell_skadi_reset_check::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY);
 }
 
private:
 uint32 _targetCount = 0;
};
 
// 48642 - Launch Harpoon
class spell_skadi_launch_harpoon : public SpellScript
{
 void FilterTargets(std::list<WorldObject*>& targets)
 {
 if (targets.size() >= 2)
 targets.remove_if([](WorldObject* obj) { return obj->GetEntry() != NPC_GRAUF; });
 }
 
 void HandleDamageCalc()
 {
 if (Unit* target = GetHitUnit())
 SetHitDamage(target->CountPctFromMaxHealth(35));
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_skadi_launch_harpoon::FilterTargets, EFFECT_0, TARGET_UNIT_CONE_ENTRY);
 OnHit += SpellHitFn(spell_skadi_launch_harpoon::HandleDamageCalc);
 }
};
 
// 50255, 59331 - Poisoned Spear
class spell_skadi_poisoned_spear : public SpellScript
{
 bool Validate(SpellInfo const* /*spell*/) override
 {
 return ValidateSpellInfo({ SPELL_POISONED_SPEAR_PERIODIC });
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 GetHitUnit()->CastSpell(GetHitUnit(), SPELL_POISONED_SPEAR_PERIODIC, true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_skadi_poisoned_spear::HandleScript, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
 }
};
 
// 61791 - Ride Vehicle
class spell_skadi_ride_vehicle : public AuraScript
{
 void OnRemoveVehicle(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 PreventDefaultAction();
 Unit* caster = GetCaster();
 if (!caster)
 return;
 
 GetTarget()->GetVehicleKit()->RemovePassenger(caster);
 caster->SetControlled(false, UNIT_STATE_ROOT);
 }
 
 void Register() override
 {
 OnEffectRemove += AuraEffectRemoveFn(spell_skadi_ride_vehicle::OnRemoveVehicle, EFFECT_0, SPELL_AURA_CONTROL_VEHICLE, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 59275 - Summon Gauntlet Mobs Periodic
class spell_summon_gauntlet_mobs_periodic : public AuraScript
{
 void CastTheNextTwoSpells()
 {
 for (uint8 i = 0; i < 2; ++i)
 {
 uint32 spellId = SummonSpellsList.front();
 GetTarget()->CastSpell(nullptr, spellId, true);
 SummonSpellsList.push_back(spellId);
 SummonSpellsList.pop_front();
 }
 }
 void PushBackTheNextTwoSpells()
 {
 for (uint8 j = 0; j < 2; ++j)
 {
 SummonSpellsList.push_back(SummonSpellsList.front());
 SummonSpellsList.pop_front();
 }
 }
 
 void OnPeriodic(AuraEffect const* /*aurEff*/)
 {
 if (RAND(0, 1))
 {
 CastTheNextTwoSpells();
 PushBackTheNextTwoSpells();
 }
 else
 {
 PushBackTheNextTwoSpells();
 CastTheNextTwoSpells();
 }
 }
private:
 std::deque<uint32> SummonSpellsList =
 {
 SPELL_SUMMON_YMIRJAR_WARRIOR_E,
 SPELL_SUMMON_YMIRJAR_HARPOONER_W,
 SPELL_SUMMON_YMIRJAR_WARRIOR_W,
 SPELL_SUMMON_YMIRJAR_HARPOONER_E,
 SPELL_SUMMON_YMIRJAR_WARRIOR_W,
 SPELL_SUMMON_YMIRJAR_WITCH_DOCTOR_E,
 SPELL_SUMMON_YMIRJAR_WARRIOR_E,
 SPELL_SUMMON_YMIRJAR_WITCH_DOCTOR_W
 };
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_summon_gauntlet_mobs_periodic::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 }
};
 
class achievement_girl_love_to_skadi : public AchievementCriteriaScript
{
 public:
 achievement_girl_love_to_skadi() : AchievementCriteriaScript("achievement_girl_love_to_skadi") { }
 
 bool OnCheck(Player* /*player*/, Unit* target) override
 {
 if (!target)
 return false;
 
 if (Creature* skadi = target->ToCreature())
 if (skadi->AI()->GetData(DATA_LOVE_TO_SKADI) == 1)
 return true;
 
 return false;
 }
};
 
class at_skadi_gaunlet : public AreaTriggerScript
{
 public:
 at_skadi_gaunlet() : AreaTriggerScript("at_skadi_gaunlet") { }
 
 bool OnTrigger(Player* player, AreaTriggerEntry const* /*areaTrigger*/) override
 {
 InstanceScript* instance = player->GetInstanceScript();
 if (!instance || player->IsGameMaster())
 return true;
 
 if (instance->GetBossState(DATA_SKADI_THE_RUTHLESS) == NOT_STARTED)
 if (Creature* skadi = instance->GetCreature(DATA_SKADI_THE_RUTHLESS))
 {
 skadi->AI()->DoAction(ACTION_START_ENCOUNTER);
 return true;
 }
 
 return true;
 }
};
 
void AddSC_boss_skadi()
{
 RegisterUtgardePinnacleCreatureAI(boss_skadi);
 RegisterUtgardePinnacleCreatureAI(npc_grauf);
 RegisterUtgardePinnacleCreatureAI(npc_ymirjar_warrior);
 RegisterUtgardePinnacleCreatureAI(npc_ymirjar_witch_doctor);
 RegisterUtgardePinnacleCreatureAI(npc_ymirjar_harpooner);
 RegisterSpellScript(spell_freezing_cloud_area_left);
 RegisterSpellScript(spell_freezing_cloud_area_right);
 RegisterSpellScript(spell_freezing_cloud_damage);
 RegisterSpellScript(spell_skadi_reset_check);
 RegisterSpellScript(spell_skadi_launch_harpoon);
 RegisterSpellScript(spell_skadi_poisoned_spear);
 RegisterSpellScript(spell_skadi_ride_vehicle);
 RegisterSpellScript(spell_summon_gauntlet_mobs_periodic);
 new achievement_girl_love_to_skadi();
 new at_skadi_gaunlet();
}