boss_anduin_wrynn.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 "AreaTrigger.h"
#include "AreaTriggerAI.h"
#include "Containers.h"
#include "Conversation.h"
#include "CreatureAI.h"
#include "CreatureAIImpl.h"
#include "DB2Structure.h"
#include "G3DPosition.hpp"
#include "GameObject.h"
#include "GameObjectAI.h"
#include "GridNotifiers.h"
#include "InstanceScript.h"
#include "Map.h"
#include "MapUtils.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "PathGenerator.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "SpellAuras.h"
#include "SpellMgr.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
#include "sepulcher_of_the_first_ones.h"
 
enum AnduinWrynnSpells
{
    // Pre-Introduction
    SPELL_BROKER_SPAWN                              = 367524,
 
    // Generic Spells
    SPELL_ANDUIN_PLUNGE_KINGSMOURNE                 = 369125,
    SPELL_POWER_DISPLAY_WILLPOWER                   = 365177,
    SPELL_POWER_ENERGIZE_WILLPOWER_SMALL            = 365217,
    SPELL_POWER_ENERGIZE_WILLPOWER_LARGE            = 365228,
    SPELL_SOUL_DESPAWN                              = 362766,
    SPELL_SHADESTEP                                 = 363976,
    SPELL_ANDUIN_PROGRESSION_AURA                   = 369317,
    SPELL_ANDUIN_WILLPOWER_PERIODIC                 = 366848,
    SPELL_ANDUIN_SOUL_GHOST                         = 369016,
 
    // Dark Zeal
    SPELL_DARK_ZEAL_AURA                            = 364247,
    SPELL_DARK_ZEAL_BUFF                            = 364248,
 
    // Hopebreaker
    SPELL_HOPEBREAKER                               = 361815,
    SPELL_HOPEBREAKER_DAMAGE                        = 361816,
    SPELL_HOPEBREAKER_DEBUFF                        = 361817,
    SPELL_HOPEBREAKER_DEBUFF_DAMAGE                 = 361818,
    SPELL_HOPEBREAKER_CLEAR                         = 364237,
 
    // Domination Word: Pain
    SPELL_DOMINATION_WORD_PAIN                      = 366849,
 
    // Befouled Barrier
    SPELL_BEFOULED_BARRIER                          = 365295,
    SPELL_BEFOULED_BARRIER_BLACK_RING               = 365633,
    SPELL_BEFOULED_ERUPTION                         = 365853,
    SPELL_BEFOULED_BARRIER_SPHERE_AREATRIGGER       = 365173,
    SPELL_BEFOULED_BARRIER_DEBUFF                   = 365293,
    SPELL_BEFOULED_BARRIER_CLEAR                    = 369871,
    SPELL_BEFOULED_BARRIER_EXPLODE                  = 365300,
 
    // Blasphemy
    SPELL_BLASPHEMY                                 = 361989,
    SPELL_BLASPHEMY_PRE_HIT                         = 364239,
    SPELL_BLASPHEMY_OVERCONFIDENCE                  = 361990,
    SPELL_BLASPHEMY_OVERCONFIDENCE_AREATRIGGER      = 361992,
    SPELL_BLASPHEMY_HOPELESSNESS                    = 361991,
    SPELL_BLASPHEMY_HOPELESSNESS_AREATRIGGER        = 361993,
    SPELL_BLASPHEMY_SUCCESS                         = 362014,
    SPELL_BLASPHEMY_EXPLODE                         = 361999,
    SPELL_BLASPHEMY_EXPLODE_LFR_NORMAL              = 366933,
    SPELL_CANCEL_BLASPHEMY                          = 370161,
    SPELL_BLASPHEMY_IMMUNE                          = 370407,
 
    // Kingsmourne Hungers
    SPELL_KINGSMOURNE_HUNGERS                       = 362405,
    SPELL_KINGSMOURNE_HUNGERS_DAMAGE_IDK            = 362406,
    SPELL_KINGSMOURNE_HUNGERS_DAMAGE                = 362407,
    SPELL_LOST_SOUL_DIMENSION                       = 362055,
    SPELL_LOST_SOUL                                 = 362472,
    SPELL_LOST_SOUL_GRACE                           = 370068,
    SPELL_LOST_SOUL_CLEAR                           = 365641,
    SPELL_CANCEL_LOST_SOUL                          = 367774,
    SPELL_SEVERED_SOUL                              = 367769,
    SPELL_LOST_SOUL_MYTHIC                          = 367770,
    SPELL_LOST_SOUL_MIRROR_IMAGE                    = 362402,
    SPELL_SCARRED_SOUL                              = 365445,
    SPELL_MIRROR_IMAGE                              = 362474,
    SPELL_FEIGN_DEATH                               = 114371,
    SPELL_BANISH_SOUL                               = 367771,
    SPELL_MIRROR_IMAGE_IGNORE_PHASE_SHIFT           = 362473,
    SPELL_ANDUIN_LOST_SOUL_TRACKER                  = 369843,
 
    // Rain of Despair (Big add)
    SPELL_RAIN_OF_DESPAIR                           = 362391,
    SPELL_ANDUIN_SOUL_DESPAIR                       = 365220,
    SPELL_RAIN_OF_DESPAIR_MELEE                     = 362393,
    SPELL_RAIN_OF_DESPAIR_RANGED                    = 362396,
    SPELL_RAIN_OF_DESPAIR_EXPLOSION                 = 362392,
 
    // Wicked Star
    SPELL_WICKED_STAR                               = 365030,
    SPELL_WICKED_STAR_POINTER                       = 365021,
    SPELL_WICKED_STAR_AREATRIGGER                   = 365017,
    SPELL_WICKED_STAR_DAMAGE_SILENCE                = 365024,
    SPELL_WICKED_STAR_EMPOWERMENT                   = 365112,
    SPELL_WICKED_STAR_IDK                           = 365992,
    SPELL_WICKED_STAR_TARGETED                      = 366674,
    SPELL_WICKED_STAR_IDK_3                         = 369280,
 
    // Empowered Wicked Star
    SPELL_EMPOWERED_WICKED_STAR                     = 367631,
    SPELL_EMPOWERED_WICKED_STAR_POINTER             = 367632,
    SPELL_EMPOWERED_WICKED_STAR_AREATRIGGER         = 367621,
    SPELL_EMPOWERED_WICKED_STAR_DAMAGE_SILENCE      = 367634,
 
    // Force of Will
    SPELL_FORCE_OF_WILL                             = 368913,
    SPELL_CANCEL_FORCE_OF_WILL                      = 368978,
 
    // Fiendish Soul
    SPELL_NECROTIC_CLAWS_LEAP                       = 363019,
    SPELL_NECROTIC_CLAWS_DEBUFF                     = 363020,
    SPELL_SOUL_EXPLOSION_TARGET                     = 363029,
    SPELL_SOUL_EXPLOSION_TRIGGER_MISSILE            = 363030,
    SPELL_SOUL_EXPLOSION_DAMAGE                     = 363031,
 
    // Monstrous Soul
    SPELL_UNRAVELING_FRENZY_PERIODIC                = 363027,
    SPELL_UNRAVELING_FRENZY                         = 363028,
    SPELL_NECROTIC_DETONATION                       = 363024,
 
    // Grim Reflections
    SPELL_GRIM_REFLECTIONS                          = 365120,
    SPELL_GRIM_REFLECTIONS_SUMMON                   = 365121,
    SPELL_GRIM_REFLECTIONS_DEST_SUMMON              = 365039,
    SPELL_CALAMITY_STATE_VISUAL                     = 361685,
    SPELL_WICKED_STAR_PROTECTION                    = 370400,
    SPELL_PSYCHIC_TERROR                            = 365008,
    SPELL_GRIM_FATE                                 = 367932,
 
    // Beacon of Hope
    SPELL_BEACON_OF_HOPE                            = 365872,
    SPELL_BEACON_OF_HOPE_AREATRIGGER                = 362702,
 
    // Fragment of Hope
    SPELL_FRAGMENT_OF_HOPE_AREATRIGGER              = 365816,
    SPELL_FRAGMENT_OF_HOPE_CLEAR_DEBUFF             = 365828,
    SPELL_FRAGMENT_OF_HOPE_DAMAGE                   = 365990,
 
    // Purging Light
    SPELL_PURGING_LIGHT                             = 368428,
 
    // Hopelessness
    SPELL_HOPELESSNESS                              = 365958,
    SPELL_HOPELESSNESS_MISSILE                      = 365962,
    SPELL_HOPELESSNESS_HOPELESSNESS_AREATRIGGER     = 365966,
    SPELL_HOPELESSNESS_EXPLODE                      = 365971,
 
    // Empowered Hopebreaker
    SPELL_EMPOWERED_HOPEBREAKER                     = 365805,
    SPELL_EMPOWERED_HOPEBREAKER_EXPLOSION           = 365806,
 
    // Anduin's Soul
    SPELL_LOST_SOUL_PERIODIC                        = 365650,
    SPELL_LOST_SOUL_CONSUME                         = 365652,
 
    // Anduin's Hope
    SPELL_ANDUIN_SLOW                               = 365218,
    SPELL_GLOOM                                     = 364031,
 
    // Anduin's Doubt
    SPELL_GHOST_VISUAL_COSMETIC                     = 370833,
 
    // Remnant of a Fallen King
    SPELL_DOMINATION_GRASP                          = 365216,
    SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER         = 362505,
    SPELL_SHADE_VISUAL                              = 362490,
    SPELL_REMNANT_SPAWN                             = 362500,
    SPELL_DARK_PRESENCE                             = 368986,
    SPELL_WEATHER_COSMETIC                          = 362493,
    SPELL_SPAWN_REMNANT                             = 362497,
    SPELL_REMNANT_TIMER                             = 365291,
    SPELL_RETURN_TO_KINGSMOURNE                     = 363022,
    SPELL_RETURN_TO_KINGSMOURNE_VISUALS             = 363021,
    SPELL_SHADE_DESPAWN_CEREMONY                    = 363023,
 
    // Remorseless Winter
    SPELL_REMORSELESS_WINTER                        = 362542,
    SPELL_REMORSELESS_WINTER_PERIODIC               = 362543,
    SPELL_REMORSELESS_WINTER_DEBUFF_DAMAGE          = 362545,
    SPELL_REMORSELESS_WINTER_CLEAR                  = 370619,
 
    // Army of the Dead
    SPELL_ARMY_OF_THE_DEAD                          = 362862,
    SPELL_ECHOES_OF_ANDORHAL                        = 362863,
    SPELL_ECHOES_OF_ANDORHAL_FIENDISH_GHOULS        = 362864,
    SPELL_ECHOES_OF_ANDORHAL_MONSTROUS_SOUL         = 363025,
 
    // March of the Damned
    SPELL_MARCH_OF_THE_DAMNED                       = 363116,
    SPELL_MARCH_OF_THE_DAMNED_PERIODIC              = 363233,
    SPELL_MARCH_OF_THE_DAMNED_AREATRIGGER           = 363133,
    SPELL_MARCH_OF_THE_DAMNED_DAMAGE                = 364020,
    SPELL_DESPAWN_WALLS                             = 371694,
 
    // Soul Reaper
    SPELL_SOUL_REAPER                               = 362771,
    SPELL_SOUL_REAPER_PHYSICAL_DAMAGE               = 362772,
    SPELL_SOUL_REAPER_SHADOWFROST_DAMAGE            = 362773,
    SPELL_SOUL_REAPER_DEBUFF                        = 362774,
    SPELL_SOUL_REAPER_ATTACK_SPEED                  = 362775,
 
    // Finish Encounter
    SPELL_ANDUIN_KNEEL_POSE                         = 369367,
    SPELL_FINAL_MOVIE                               = 367306,
    SPELL_AWARD_ANDUIN_KILL                         = 359476,
 
    // Berserk
    SPELL_BERSERK                                   = 26662,
 
    // Jaina Spells
    SPELL_BLINK                                     = 362844,
    SPELL_FROSTBOLT                                 = 362843,
    SPELL_GENERIC_BLINK                             = 363984,
 
    // Sylvanas Spells
    SPELL_SHOOT_BOW                                 = 364068,
    SPELL_TUMBLE                                    = 364069,
 
    // Uther Spells
    SPELL_BLADE_OF_JUSTICE                          = 363971,
    SPELL_UTHER_CHARGE                              = 363972,
 
    // Translocators Teleport
    SPELL_TELEPORT_COSMIC_HUB                       = 364475,
    SPELL_TELEPORT_DOMINATIONS_GRASP                = 368563,
};
 
enum AnduinWrynnPhases
{
    PHASE_ONE = 1,
    PHASE_TWO,
    PHASE_THREE,
};
 
enum AnduinWrynnEvents
{
    // Anduin Wrynn
    EVENT_HOPEBREAKER = 1,
    EVENT_DOMINATION_WORD_PAIN,
    EVENT_BEFOULED_BARRIER,
    EVENT_UPDATE_BEFOULED_BARRIER,
    EVENT_BLASPHEMY,
    EVENT_HOPELESSNESS,
    EVENT_WICKED_STAR,
    EVENT_EMPOWERED_WICKED_STAR,
    EVENT_KINGSMOURNE_HUNGERS,
    EVENT_INTERMISSION_ONE,
    EVENT_INTERMISSION_TWO,
    EVENT_GRIM_REFLECTIONS,
    EVENT_BEACON_OF_HOPE,
    EVENT_EMPOWERED_HOPEBREAKER,
    EVENT_BANISH_SOUL,
    EVENT_BERSERK,
 
    // Kingsmourne Room
    EVENT_ANDUIN_SOUL,
 
    // Remnant of a Fallen King
    EVENT_ARMY_OF_THE_DEAD,
    EVENT_SOUL_REAPER,
    EVENT_RETURN_TO_KINGSMOURNE,
 
    // Fiendish Soul
    EVENT_GHOUL_LEAP,
    EVENT_NECROTIC_CLAWS,
 
    // Monstrous Soul
    EVENT_UNRAVELING_FRENZY,
    EVENT_NECROTIC_DETONATION,
 
    // Grim Reflections
    EVENT_PSYCHIC_TERROR,
    EVENT_GRIM_REFLECTION_IMMUNITY,
 
    // Sylvanas Windrunner
    EVENT_CANCEL_SYLVANAS_EVENTS,
    EVENT_TUMBLE,
 
    // Uther the Lightbringer
    EVENT_CANCEL_UTHER_EVENTS,
    EVENT_BLADE_OF_JUSTICE,
 
    // Jaina Proudmoore
    EVENT_CANCEL_JAINA_EVENTS,
    EVENT_BLINK,
};
 
enum AnduinWrynnActions
{
    ACTION_START_PRE_INTRODUCTION = 1,
    ACTION_START_MOVEMENT,
    ACTION_START_INTRODUCTION,
    ACTION_ARTHAS_INTERMISSION_UTHER,
    ACTION_ARTHAS_INTERMISSION_SYLVANAS,
    ACTION_EXIT_INTERMISSION,
    ACTION_ACTIVATE_REMNANT,
    ACTION_DESPAWN_REMNANT,
    ACTION_SUMMON_KINGSMOURNE_SOULS,
    ACTION_END_ENCOUNTER,
    ACTION_START_OUTRODUCTION,
    ACTION_DESPAIR_GONE,
    ACTION_DOUBT_GONE,
    ACTION_HOPE_RESTORED,
 
    // Monstrous Soul
    ACTION_NECROTIC_DETONATION,
 
    // Outroduction
    ACTION_MOVE_NPCS_ON_PLATFORM,
};
 
enum AnduinWrynnTexts
{
    SAY_AGGRO                           = 0,
    SAY_HOPEBREAKER                     = 1,
    SAY_BEFOULED_BARRIER                = 2,
    SAY_BLASPHEMY                       = 3,
    SAY_ANNOUNCE_BLASPHEMY              = 4,
    SAY_ANNOUNCE_KINGSMOURNE_HUNGERS    = 5,
    SAY_KINGSMOURNE_HUNGERS             = 6,
    SAY_WICKED_STAR                     = 7,
    SAY_ANNOUNCE_WICKED_STAR            = 8,
    SAY_GRIM_REFLECTIONS                = 9,
    SAY_SLAY                            = 10,
    SAY_EMPOWERED_HOPEBREAKER           = 11,
    SAY_DISENGAGE                       = 12,
    SAY_NECROTIC_DETONATION             = 13,
    SAY_ANNOUNCE_EMPOWERED_WICKED_STAR  = 14,
};
 
enum AnduinWrynnConversations
{
    CONVERSATION_INTRO                  = 17835,
    CONVERSATION_ARTHAS_UTHER           = 17921,
    CONVERSATION_ARTHAS_SYLVANAS        = 17923,
    CONVERSATION_ANDUIN_PHASE_THREE     = 17924,
    CONVERSATION_ANDUIN_OUTRODUCTION    = 17836,
};
 
enum AnduinWrynnSpawnGroups
{
    SPAWN_GROUP_INITIAL         = 0
};
 
enum AnduinWrynnPoints
{
    POINT_START_INTRODUCTION    = 1,
    POINT_ANDUIN_SOUL           = 2,
    POINT_ESCAPE_PLATFORM       = 3,
    POINT_MARCH_OF_THE_DAMNED   = 4,
};
 
enum AnduinWrynnPaths
{
    PATH_INTRODUCTION_JAINA     = 183664 * 100,
    PATH_INTRODUCTION_UTHER     = 183665 * 100,
    PATH_INTRODUCTION_SYLVANAS  = 183666 * 100,
    PATH_OUTRODUCTION_FIRIM     = 184589 * 100,
    PATH_OUTRODUCTION_THRALL    = 184599 * 100,
    PATH_OUTRODUCTION_BOLVAR    = 184601 * 100,
};
 
enum AnduinWrynnSpellVisuals
{
    SPELL_VISUAL_CHEST_LOOT     = 114023,
};
 
constexpr Position PreIntroductionAssistersPositions[3] =
{
    { -3826.9548f, -2626.2761f, 78.9296f, 4.644121f }, // Jaina
    { -3831.6807f, -2626.2761f, 78.9296f, 5.460620f }, // Uther
    { -3818.7300f, -2626.2800f, 78.9296f, 4.558697f }, // Sylvanas
};
 
//constexpr Position FirimOutroductionPos = { -3830.0156f, -2676.7969f, 91.56402f };
constexpr Position QuartermasterRahmPos = { -3824.9565f, -2673.0190f, 91.44697f, 4.7163963f };
constexpr Position LeftKnightPosition = { -3815.4097f, -2677.1824f, 91.44697f, 4.742376f };
constexpr Position RightKnightPosition = { -3834.6807f, -2677.42360f, 91.44697f, 4.6956997f };
 
constexpr Position DominationGraspCenter = { -3825.0601f, -2715.4600f, 91.3567f, 1.6260f };
 
constexpr Position IntermissionAssistersTeleportPosition[3] =
{
    { -3828.472f, -2688.191f, 91.2652f, 1.9153f }, // Sylvanas
    { -3819.519f, -2687.170f, 91.2652f, 2.1812f }, // Uther
    { -3824.960f, -2692.550f, 91.2652f, 1.5733f }, // Jaina
};
 
constexpr Position AnduinsDespairSpawnPosition = { -3828.355957f, -2704.1875f, 91.350716f, 4.982021f };
 
constexpr Position AnduinsSoulSpawnPosition = { -3825.060059f, -2715.459961f, 91.356697f, 1.626040f };
 
constexpr Position AnduinsDoubtSpawnPositions[4] =
{
    {  -3852.638916f, -2687.373291f, 91.348526f, 5.560700f }, // Right of Uther
    {  -3852.845459f, -2742.732666f, 91.348534f, 0.961583f }, // Next Right
    {  -3797.704834f, -2686.685791f, 91.348526f, 3.804689f }, // Left of Sylvanas
    {  -3799.805664f, -2740.925293f, 91.348541f, 2.247305f }, // Next Left
};
 
constexpr Position AnduinsHopeSpawnPosition[4] =
{
    {  -3825.149414f, -2711.508789f, 91.354919f, 1.463445f }, // In front of Anduin
    {  -3828.751709f, -2715.171875f, 91.354919f, 3.221487f }, // Left of Anduin
    {  -3821.041748f, -2715.296875f, 91.354889f, 0.046978f }, // Right of Anduin
    {  -3825.180664f, -2719.208252f, 91.354820f, 4.741285f }, // Behind Anduin
};
 
constexpr Position RemnantOfAFallenKingSpawnPosition = { -3825.2466f, -2700.0486f, 91.3650f, 1.3762f };
 
constexpr Position GrimReflectionsSpawnPositions[4] =
{
    { -3825.389f, -2739.4202f, 91.431305f, 4.8445f}, // back side of Anduin
    { -3849.8438f, -2715.0574f, 91.40953f, 2.9961f}, // left side of Anduin
    { -3825.4966f, -2692.6199f, 91.487495f, 1.4654f}, // in front of Anduin
    { -3800.6980f, -2715.4340f, 91.390780f, 6.2769f}, // right side of Anduin
};
 
Position const MarchOfTheDamnedSpawnPositions[8] =
{
    { -3839.8489f, -2679.7708f, 91.53031f, 5.1081f }, // First right
    { -3860.8940f, -2701.0051f, 91.53032f, 5.9010f }, // Second Right
    { -3860.5696f, -2729.7344f, 91.53032f, 0.3886f }, // Third Right
    { -3839.6390f, -2750.8890f, 91.53032f, 1.1935f }, // Fourth Right
    { -3811.0625f, -2679.6528f, 91.53031f, 4.3362f }, // First left
    { -3789.8125f, -2700.5088f, 91.53032f, 3.5383f }, // Second Left
    { -3789.2812f, -2729.3160f, 91.53032f, 2.7669f }, // Third Left
    { -3810.4290f, -2751.0903f, 91.53032f, 1.9584f } // Fourth Left
};
 
constexpr Position BeaconOfHopeSpawnPosition = { -3825.0417f, -2715.3923f, 91.3568f, 0.0f };
 
constexpr Position ChestLootSpawnPosition = { -3840.9915f, -2741.7847f, 91.26521f, 1.334929f };
 
class ActivateGhouls : public BasicEvent
{
public:
    ActivateGhouls(Creature* summoner, Creature* owner)
        : _summonerGuid(summoner->GetGUID()), _owner(owner) { }
 
    bool Execute(uint64 /*time*/, uint32 /*diff*/) override
    {
        if (Creature* _summoner = ObjectAccessor::GetCreature(*_owner, _summonerGuid))
        {
            if (Unit* target = _summoner->AI()->SelectTarget(SelectTargetMethod::Random, 0))
            {
                _owner->SetReactState(REACT_AGGRESSIVE);
                _owner->AI()->AttackStart(target);
            }
        }
        return true;
    }
 
private:
    ObjectGuid _summonerGuid;
    Creature* _owner;
};
 
// 181954 - Anduin Wrynn
struct boss_anduin_wrynn : public BossAI
{
    boss_anduin_wrynn(Creature* creature) : BossAI(creature, DATA_ANDUIN_WRYNN),
        _slayTextOnCooldown(false), _intermissionsDone(0), _encounterEnded(false) { }
 
    void HandleIntroduction()
    {
        if (instance->GetData(DATA_ANDUIN_WRYNN_INTRODUCTION) == DONE)
        {
            me->RemoveUnitFlag(UNIT_FLAG_NOT_ATTACKABLE_1);
            me->SetImmuneToAll(false);
            me->SetSpeed(MOVE_RUN, 11.0f);
            me->RemoveAurasDueToSpell(SPELL_ANDUIN_PLUNGE_KINGSMOURNE);
        }
        else
        {
            DoCastSelf(SPELL_ANDUIN_PLUNGE_KINGSMOURNE);
            me->SetUnitFlag(UNIT_FLAG_NOT_ATTACKABLE_1);
            me->SetImmuneToAll(true);
        }
    }
 
    void PrepareAssistersForIntermission() const
    {
        if (Creature* sylvanas = instance->GetCreature(DATA_SYLVANAS_WINDRUNNER_ANDUIN))
        {
            sylvanas->CastSpell(IntermissionAssistersTeleportPosition[0], SPELL_GENERIC_BLINK);
            sylvanas->AttackStop();
            sylvanas->SetSheath(SHEATH_STATE_RANGED);
            sylvanas->SetEmoteState(EMOTE_STATE_READY_BOW);
        }
 
        if (Creature* uther = instance->GetCreature(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN))
        {
            uther->CastSpell(IntermissionAssistersTeleportPosition[1], SPELL_GENERIC_BLINK);
            uther->AttackStop();
            uther->SetSheath(SHEATH_STATE_MELEE);
            uther->SetEmoteState(EMOTE_STATE_READY2H);
        }
 
        if (Creature* jaina = instance->GetCreature(DATA_JAINA_PROUDMOORE_ANDUIN))
        {
            jaina->CastSpell(IntermissionAssistersTeleportPosition[2], SPELL_GENERIC_BLINK);
            jaina->AttackStop();
            jaina->SetSheath(SHEATH_STATE_RANGED);
            jaina->SetEmoteState(EMOTE_STATE_READY2H);
        }
    }
 
    void ForceAssistersToAttackRemnant() const
    {
        Unit* remnant = instance->GetCreature(DATA_REMNANT_OF_A_FALLEN_KING);
        if (!remnant)
            return;
 
        auto forceAttack = [this, remnant](uint32 data)
        {
            Creature* creature = instance->GetCreature(data);
            if (!creature)
                return;
 
            creature->AI()->AttackStart(remnant);
            creature->SetReactState(REACT_AGGRESSIVE);
        };
 
        forceAttack(DATA_SYLVANAS_WINDRUNNER_ANDUIN);
        forceAttack(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN);
        forceAttack(DATA_JAINA_PROUDMOORE_ANDUIN);
    }
 
    void MoveKnightsOnPlatform() const
    {
        if (Creature* rahm = instance->GetCreature(DATA_QUARTERMASTER_RAHM_ANDUIN))
            rahm->NearTeleportTo(QuartermasterRahmPos);
 
        std::list<Creature*> knights;
        me->GetCreatureListWithOptionsInGrid(knights, 150.0f, { .CreatureId = NPC_KNIGHT_OF_EBON_BLADE_ANDUIN });
 
        for (Creature* knight : knights)
        {
            if (knight->HasStringId("left_knight"))
                knight->NearTeleportTo(LeftKnightPosition);
            else
                knight->NearTeleportTo(RightKnightPosition);
        }
    }
 
    void ClearDebuffs() const
    {
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_HOPEBREAKER_DEBUFF);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_BLASPHEMY_OVERCONFIDENCE);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_BLASPHEMY_HOPELESSNESS);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_DOMINATION_WORD_PAIN);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_BEFOULED_BARRIER_DEBUFF);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_BEFOULED_BARRIER_EXPLODE);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_LOST_SOUL_DIMENSION);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_FORCE_OF_WILL);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_SCARRED_SOUL);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_WEATHER_COSMETIC);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_REMORSELESS_WINTER_PERIODIC);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_HOPELESSNESS_HOPELESSNESS_AREATRIGGER);
    }
 
    void JustAppeared() override
    {
        scheduler.ClearValidator();
        HandleIntroduction();
        me->SetEmoteState(EMOTE_STATE_READY2H);
        me->ModifyPower(me->GetPowerType(), 0);
        DoCastSelf(SPELL_ANDUIN_PROGRESSION_AURA);
        DoCastSelf(SPELL_POWER_DISPLAY_WILLPOWER, true);
        DoCastSelf(SPELL_DARK_ZEAL_AURA, true);
        instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_ENCOUNTER_STARTED, 0);
        instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_INTERMISSION, 0);
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        ClearDebuffs();
        Talk(SAY_DISENGAGE);
        if (_encounterEnded == true)
            return;
 
        _DespawnAtEvade();
        summons.DespawnAll();
        instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_ENCOUNTER_STARTED, 0);
        instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
    }
 
    void Reset() override
    {
        _Reset();
        me->SummonCreatureGroup(SPAWN_GROUP_INITIAL);
        me->SetPower(POWER_ENERGY, 0);
 
        _slayTextOnCooldown = false;
        _intermissionsDone = 0;
        _encounterEnded = false;
    }
 
    void KilledUnit(Unit* victim) override
    {
        if (_slayTextOnCooldown == false && !victim->IsPlayer())
        {
            Talk(SAY_SLAY);
            _slayTextOnCooldown = true;
            scheduler.Schedule(3s, [this](TaskContext const& /*task*/)
            {
                _slayTextOnCooldown = false;
            });
        }
    }
 
    void JustSummoned(Creature* summon) override
    {
        summons.Summon(summon);
 
        switch (summon->GetEntry())
        {
            case NPC_BEFOULED_BARRIER:
            {
                summon->SetReactState(REACT_PASSIVE);
                summon->CastSpell(summon, SPELL_BEFOULED_ERUPTION, true);
                summon->CastSpell(summon, SPELL_BEFOULED_BARRIER_SPHERE_AREATRIGGER, true);
                summon->CastSpell(summon, SPELL_BEFOULED_BARRIER_BLACK_RING, true);
                break;
            }
 
            case BOSS_REMNANT_OF_A_FALLEN_KING:
            {
                summon->SetReactState(REACT_PASSIVE);
                summon->SetUninteractible(true);
                summon->CastSpell(summon, SPELL_REMNANT_SPAWN);
                break;
            }
 
            case NPC_MARCH_OF_THE_DAMNED:
            {
                float marchSpeed = 0.0f;
                switch (me->GetMap()->GetDifficultyID())
                {
                    case DIFFICULTY_LFR_NEW:
                    case DIFFICULTY_NORMAL_RAID:
                    case DIFFICULTY_HEROIC_RAID:
                        marchSpeed = 0.40f;
                        break;
                    case DIFFICULTY_MYTHIC_RAID:
                        marchSpeed = 0.60f;
                        break;
                    default:
                        marchSpeed = 0.40f;
                        break;
                }
 
                summon->SetSpeedRate(MOVE_RUN, marchSpeed);
                summon->SetReactState(REACT_PASSIVE);
                summon->CastSpell(summon, SPELL_MARCH_OF_THE_DAMNED_AREATRIGGER, true);
                scheduler.Schedule(1s, [summon](TaskContext const& /*task*/)
                {
                    Position exitPlatform = summon->GetFirstCollisionPosition(100.0f, summon->GetAbsoluteAngle(summon));
                    summon->GetMotionMaster()->MovePoint(POINT_MARCH_OF_THE_DAMNED, exitPlatform, false, summon->GetOrientation());
                });
                break;
            }
 
            case NPC_BEACON_OF_HOPE:
            {
                summon->SetReactState(REACT_PASSIVE);
                summon->CastSpell(summon, SPELL_BEACON_OF_HOPE_AREATRIGGER);
                break;
            }
 
            default:
                break;
        }
    }
 
    void SummonedCreatureDies(Creature* summon, Unit* /*killer*/) override
    {
        if (summon->GetEntry() == NPC_GRIM_REFLECTION)
            summon->DespawnOrUnsummon(3s);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        BossAI::JustEngagedWith(who);
        instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me, 1);
        PhaseEvents(PHASE_ONE);
        instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_ENCOUNTER_STARTED, PHASE_ONE);
        Talk(SAY_AGGRO);
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_START_PRE_INTRODUCTION:
            {
                auto teleportNamed = [this](uint32 data, Position const& position)
                {
                    Creature* creature = instance->GetCreature(data);
                    if (!creature)
                        return;
 
                    creature->NearTeleportTo(position);
                    creature->CastSpell(creature, SPELL_BROKER_SPAWN, true);
                };
 
                teleportNamed(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN, PreIntroductionAssistersPositions[0]);
                teleportNamed(DATA_SYLVANAS_WINDRUNNER_ANDUIN, PreIntroductionAssistersPositions[1]);
                teleportNamed(DATA_JAINA_PROUDMOORE_ANDUIN, PreIntroductionAssistersPositions[2]);
                break;
            }
            case ACTION_START_MOVEMENT:
            {
                auto castBrokerSpawn = [this](uint32 data)
                {
                    Creature* creature = instance->GetCreature(data);
                    if (!creature)
                        return;
 
                    creature->CastSpell(creature, SPELL_BROKER_SPAWN, true);
                };
 
                castBrokerSpawn(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN);
                castBrokerSpawn(DATA_SYLVANAS_WINDRUNNER_ANDUIN);
                castBrokerSpawn(DATA_JAINA_PROUDMOORE_ANDUIN);
                break;
            }
            case ACTION_START_INTRODUCTION:
            {
                instance->SetData(DATA_ANDUIN_WRYNN_INTRODUCTION, IN_PROGRESS);
                scheduler.Schedule(1ms, [this](TaskContext const& /*task*/)
                {
                    Creature* uther = instance->GetCreature(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN);
                    if (!uther)
                        return;
 
                    Creature* sylvanas = instance->GetCreature(DATA_SYLVANAS_WINDRUNNER_ANDUIN);
                    if (!sylvanas)
                        return;
 
                    Creature* jaina = instance->GetCreature(DATA_JAINA_PROUDMOORE_ANDUIN);
                    if (!jaina)
                        return;
 
                    Conversation* conversation = Conversation::CreateConversation(CONVERSATION_INTRO, me, me->GetPosition(), ObjectGuid::Empty, nullptr, false);
                    if (!conversation)
                        return;
 
                    conversation->AddActor(NPC_UTHER_THE_LIGHTBRINGER_ANDUIN, 1, uther->GetGUID());
                    conversation->AddActor(NPC_SYLVANAS_WINDRUNNER_ANDUIN, 2, sylvanas->GetGUID());
                    conversation->AddActor(NPC_LADY_JAINA_PROUDMOORE_ANDUIN, 3, jaina->GetGUID());
                    conversation->Start();
                });
 
                scheduler.Schedule(35s, [this](TaskContext const& /*task*/)
                {
                    instance->SetData(DATA_ANDUIN_WRYNN_INTRODUCTION, DONE);
                    HandleIntroduction();
                });
                break;
            }
            case ACTION_MOVE_NPCS_ON_PLATFORM:
            {
                if (Creature* bolvar = me->GetInstanceScript()->GetCreature(DATA_BOLVAR_FORDRAGON_ANDUIN))
                    bolvar->GetMotionMaster()->MovePath(PATH_OUTRODUCTION_BOLVAR, false);
 
                if (Creature* thrall = me->GetInstanceScript()->GetCreature(DATA_THRALL_ANDUIN))
                    thrall->GetMotionMaster()->MovePath(PATH_OUTRODUCTION_THRALL, false);
 
                scheduler.Schedule(10s, [this](TaskContext const& /*task*/)
                {
                    MoveKnightsOnPlatform();
                });
                break;
            }
            case ACTION_START_OUTRODUCTION:
            {
                Creature* uther = instance->GetCreature(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN);
                if (!uther)
                    break;
 
                Creature* sylvanas = instance->GetCreature(DATA_SYLVANAS_WINDRUNNER_ANDUIN);
                if (!sylvanas)
                    break;
 
                Creature* jaina = instance->GetCreature(DATA_JAINA_PROUDMOORE_ANDUIN);
                if (!jaina)
                    break;
 
                Creature* firim = instance->GetCreature(DATA_FIRIM_ANDUIN);
                if (!firim)
                    break;
 
                firim->GetMotionMaster()->MovePath(PATH_OUTRODUCTION_FIRIM, false);
 
                Conversation* conversation = Conversation::CreateConversation(CONVERSATION_ANDUIN_OUTRODUCTION, me, me->GetPosition(), ObjectGuid::Empty, nullptr, false);
                if (!conversation)
                    break;
 
                conversation->AddActor(NPC_LADY_JAINA_PROUDMOORE_ANDUIN, 1, jaina->GetGUID());
                conversation->AddActor(NPC_SYLVANAS_WINDRUNNER_ANDUIN, 2, sylvanas->GetGUID());
                conversation->AddActor(NPC_UTHER_THE_LIGHTBRINGER_ANDUIN, 3, uther->GetGUID());
                conversation->AddActor(NPC_FIRIM_ANDUIN, 4, firim->GetGUID());
                conversation->Start();
                break;
            }
            case ACTION_ARTHAS_INTERMISSION_UTHER:
            {
                instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_INTERMISSION, 1);
                if (Creature* uther = instance->GetCreature(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN))
                {
                    if (Conversation* conversation = Conversation::CreateConversation(CONVERSATION_ARTHAS_UTHER, me, me->GetPosition(), ObjectGuid::Empty, nullptr, false))
                    {
                        conversation->AddActor(NPC_UTHER_THE_LIGHTBRINGER_ANDUIN, 1, uther->GetGUID());
                        conversation->Start();
                    }
                }
                break;
            }
            case ACTION_ARTHAS_INTERMISSION_SYLVANAS:
            {
                instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_INTERMISSION, 2);
                if (Creature* sylvanas = instance->GetCreature(DATA_SYLVANAS_WINDRUNNER_ANDUIN))
                {
                    if (Conversation* conversation = Conversation::CreateConversation(CONVERSATION_ARTHAS_SYLVANAS, me, me->GetPosition(), ObjectGuid::Empty, nullptr, false))
                    {
                        conversation->AddActor(NPC_SYLVANAS_WINDRUNNER_ANDUIN, 1, sylvanas->GetGUID());
                        conversation->Start();
                    }
                }
                break;
            }
            case ACTION_EXIT_INTERMISSION:
            {
                if (_intermissionsDone == 0)
                {
                    PhaseEvents(PHASE_TWO);
                    scheduler.Schedule(3s, [this](TaskContext const& /*task*/)
                    {
                        me->SetReactState(REACT_AGGRESSIVE);
                    });
                }
                else if (_intermissionsDone == 1)
                {
                    PhaseEvents(PHASE_THREE);
                    scheduler.Schedule(6s, [this](TaskContext const& /*task*/)
                    {
                        me->SetReactState(REACT_AGGRESSIVE);
                    });
                }
                break;
            }
            case ACTION_END_ENCOUNTER:
            {
                EndEncounter();
                break;
            }
            default:
                break;
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        scheduler.Update(diff);
 
        if (!UpdateVictim())
            return;
 
        Unit* victim = me->GetVictim();
        if (victim && !victim->IsPlayer())
        {
            EnterEvadeMode(EvadeReason::NoHostiles);
            return;
        }
 
        events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_HOPEBREAKER:
                {
                    DoCastSelf(SPELL_HOPEBREAKER);
                    Talk(SAY_HOPEBREAKER);
                    break;
                }
                case EVENT_EMPOWERED_HOPEBREAKER:
                {
                    DoCastSelf(SPELL_EMPOWERED_HOPEBREAKER);
                    Talk(SAY_EMPOWERED_HOPEBREAKER);
                    if (IsMythic())
                        events.Repeat(65500ms);
                    else
                        events.Repeat(58400ms);
                    break;
                }
                case EVENT_DOMINATION_WORD_PAIN:
                {
                    DoCastSelf(SPELL_DOMINATION_WORD_PAIN);
                    break;
                }
                case EVENT_BEFOULED_BARRIER:
                {
                    DoCastSelf(SPELL_BEFOULED_BARRIER);
                    Talk(SAY_BEFOULED_BARRIER);
                    break;
                }
                case EVENT_BLASPHEMY:
                {
                    DoCastSelf(SPELL_BLASPHEMY);
                    Talk(SAY_ANNOUNCE_BLASPHEMY);
                    Talk(SAY_BLASPHEMY);
                    break;
                }
                case EVENT_HOPELESSNESS:
                {
                    DoCastAOE(SPELL_HOPELESSNESS);
                    Talk(SAY_BLASPHEMY);
                    if (IsMythic())
                        events.Repeat(65500ms);
                    else
                        events.Repeat(58500ms);
                    break;
                }
                case EVENT_WICKED_STAR:
                {
                    DoCastSelf(SPELL_WICKED_STAR);
                    Talk(SAY_WICKED_STAR);
                    if (events.IsInPhase(PHASE_THREE))
                        events.Repeat(58500ms);
                    break;
                }
                case EVENT_EMPOWERED_WICKED_STAR:
                {
                    DoCastSelf(SPELL_EMPOWERED_WICKED_STAR, true);
                    Talk(SAY_WICKED_STAR);
                    if (IsMythic())
                        events.Repeat(65500ms);
                    else
                        events.Repeat(58500ms);
                    break;
                }
                case EVENT_KINGSMOURNE_HUNGERS:
                {
                    DoCastSelf(SPELL_KINGSMOURNE_HUNGERS);
                    Talk(SAY_ANNOUNCE_KINGSMOURNE_HUNGERS);
                    Talk(SAY_KINGSMOURNE_HUNGERS);
                    break;
                }
                case EVENT_GRIM_REFLECTIONS:
                {
                    Talk(SAY_GRIM_REFLECTIONS);
                    DoCastSelf(SPELL_GRIM_REFLECTIONS);
                    break;
                }
                case EVENT_BEACON_OF_HOPE:
                {
                    DoCastSelf(SPELL_BEACON_OF_HOPE);
                    break;
                }
                case EVENT_INTERMISSION_ONE:
                {
                    StartIntermission(0);
                    break;
                }
                case EVENT_INTERMISSION_TWO:
                {
                    StartIntermission(1);
                    break;
                }
                case EVENT_BERSERK:
                {
                    DoCastSelf(SPELL_BERSERK);
                    break;
                }
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
    void StartIntermission(uint8 intermissionNum)
    {
        auto SpawnRemnant = [this](TaskContext const& /*task*/)
        {
            if (Creature* arthas = instance->GetCreature(DATA_REMNANT_OF_A_FALLEN_KING))
                me->CastSpell(arthas, SPELL_SPAWN_REMNANT);
        };
 
        Seconds timeOffset = intermissionNum * 1s;
 
        scheduler.Schedule(1ms, [this](TaskContext const& /*task*/)
        {
            me->SetReactState(REACT_PASSIVE);
            me->CastSpell(DominationGraspCenter, SPELL_SHADESTEP);
            PrepareAssistersForIntermission();
        });
 
        scheduler.Schedule(1204ms + timeOffset, [this, intermissionNum](TaskContext const& /*task*/)
        {
            DoAction(intermissionNum == 0 ? ACTION_ARTHAS_INTERMISSION_UTHER : ACTION_ARTHAS_INTERMISSION_SYLVANAS);
        });
 
        scheduler.Schedule(2204ms + timeOffset, [this](TaskContext const& /*task*/)
        {
            me->SetFacingTo(1.626040f);
        });
 
        scheduler.Schedule(4s + timeOffset, [this](TaskContext const& /*task*/)
        {
            DoCastSelf(SPELL_FORCE_OF_WILL);
            DoCastSelf(SPELL_HOPEBREAKER_CLEAR);
            DoCastSelf(SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER);
 
            if (Creature* arthas = me->SummonCreature(BOSS_REMNANT_OF_A_FALLEN_KING, RemnantOfAFallenKingSpawnPosition, TEMPSUMMON_MANUAL_DESPAWN))
            {
                me->CastSpell(arthas, SPELL_DOMINATION_GRASP);
                me->CastSpell(arthas, SPELL_SPAWN_REMNANT);
            }
        });
 
        scheduler.Schedule(5s + timeOffset, SpawnRemnant);
 
        scheduler.Schedule(6s + timeOffset, SpawnRemnant);
 
        scheduler.Schedule(7s + timeOffset, SpawnRemnant);
 
        scheduler.Schedule(8s + timeOffset, [this, intermissionNum](TaskContext const& /*task*/)
        {
            if (intermissionNum == 1 || IsMythic())
                DoCastSelf(SPELL_MARCH_OF_THE_DAMNED_PERIODIC);
 
            if (Creature* arthas = instance->GetCreature(DATA_REMNANT_OF_A_FALLEN_KING))
            {
                me->CastSpell(arthas, SPELL_SPAWN_REMNANT);
                arthas->SetImmuneToAll(false);
                ForceAssistersToAttackRemnant();
            }
        });
    }
 
    void PhaseEvents(uint8 phase)
    {
        events.Reset();
 
        switch (phase)
        {
            case PHASE_ONE:
            {
                events.SetPhase(PHASE_ONE);
                events.ScheduleEventSeries(EVENT_HOPEBREAKER, { 5s, 31900ms, 28s, 29900ms, 29900ms });
                events.ScheduleEventSeries(EVENT_BEFOULED_BARRIER, { 17s, 51900ms, 48s });
                events.ScheduleEventSeries(EVENT_BLASPHEMY, { 30s, 49900ms, 54900ms });
                events.ScheduleEventSeries(EVENT_WICKED_STAR, { 55s, 35s, 30s });
                events.ScheduleEventSeries(EVENT_DOMINATION_WORD_PAIN, { 7s, 13s, 13s, 10s, 15s, 13100ms, 12900ms, 13s, 13900ms, 12200ms, 14800ms });
                events.ScheduleEvent(EVENT_INTERMISSION_ONE, 150s);
                events.ScheduleEvent(EVENT_BERSERK, 15min);
 
                if (IsLFR())
                    DoCastSelf(SPELL_ANDUIN_WILLPOWER_PERIODIC, true);
                else
                    events.ScheduleEventSeries(EVENT_KINGSMOURNE_HUNGERS, { 45s, 1min });
                break;
            }
 
            case PHASE_TWO:
            {
                _intermissionsDone = 1;
                me->ModifyPower(me->GetPowerType(), 0);
                events.SetPhase(PHASE_TWO);
                events.ScheduleEventSeries(EVENT_GRIM_REFLECTIONS, { 8700ms, 87s });
                events.ScheduleEventSeries(EVENT_BEFOULED_BARRIER, { 80600ms, 47s });
                events.ScheduleEvent(EVENT_INTERMISSION_TWO, 169s);
 
                if (!IsMythic())
                {
                    events.ScheduleEventSeries(EVENT_DOMINATION_WORD_PAIN, { 11500ms, 13s, 13s, 17700ms, 8100ms, 13s, 13s, 14400ms, 11200ms, 12200ms });
                    events.ScheduleEventSeries(EVENT_HOPEBREAKER, { 13600ms, 22s, 33300ms, 29s, 29s });
                    events.ScheduleEventSeries(EVENT_WICKED_STAR, { 18500ms, 39s, 26s, 30500ms, 19s });
                }
                else
                {
                    events.ScheduleEventSeries(EVENT_DOMINATION_WORD_PAIN, { 10700ms, 13s, 13s, 17700ms, 8100ms, 13s, 13s, 14400ms, 11200ms, 12200ms });
                    events.ScheduleEventSeries(EVENT_HOPEBREAKER, { 13600ms, 25s, 33s, 29s, 29100ms });
                    events.ScheduleEventSeries(EVENT_WICKED_STAR, { 18500ms, 39s, 26s, 30900ms, 19100ms });
                }
 
                if (IsLFR())
                    DoCastSelf(SPELL_ANDUIN_WILLPOWER_PERIODIC, true);
                else
                    events.ScheduleEventSeries(EVENT_KINGSMOURNE_HUNGERS, { 48600ms, 1min });
                break;
            }
 
            case PHASE_THREE:
            {
                _intermissionsDone = 2;
                me->ModifyPower(me->GetPowerType(), 0);
                Conversation::CreateConversation(CONVERSATION_ANDUIN_PHASE_THREE, me, me->GetPosition(), ObjectGuid::Empty, nullptr, true);
                events.SetPhase(PHASE_THREE);
                events.ScheduleEvent(EVENT_BEACON_OF_HOPE, 1ms);
                events.ScheduleEvent(EVENT_EMPOWERED_HOPEBREAKER, 11500ms);
                events.ScheduleEvent(EVENT_HOPELESSNESS, 21700ms);
 
                if (!IsMythic())
                    events.ScheduleEvent(EVENT_WICKED_STAR, 41s);
                else
                    events.ScheduleEvent(EVENT_EMPOWERED_WICKED_STAR, 41s);
                break;
            }
            default:
                break;
        }
    }
 
    void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (_intermissionsDone < 2 && me->HealthBelowPctDamaged(10, damage))
        {
            me->RemoveAurasDueToSpell(SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER);
            me->RemoveAurasDueToSpell(SPELL_MARCH_OF_THE_DAMNED_PERIODIC);
            scheduler.Schedule(6s, [this](TaskContext const& /*task*/)
            {
                me->SetReactState(REACT_AGGRESSIVE);
            });
 
            scheduler.CancelAll();
            me->SetReactState(REACT_AGGRESSIVE);
            PhaseEvents(PHASE_THREE);
 
            std::list<Creature*> fiendishSouls;
            GetCreatureListWithEntryInGrid(fiendishSouls, me, NPC_FIENDISH_SOUL, 50.0f);
 
            for (Creature* fiends : fiendishSouls)
            {
                fiends->CastSpell(fiends, SPELL_SOUL_DESPAWN);
                fiends->DespawnOrUnsummon(500ms);
            }
 
            std::list<Creature*> marches;
            GetCreatureListWithEntryInGrid(marches, me, NPC_MARCH_OF_THE_DAMNED, 50.0f);
 
            for (Creature* march : marches)
                march->DespawnOrUnsummon();
 
            if (Creature* remnant = instance->GetCreature(DATA_REMNANT_OF_A_FALLEN_KING))
                remnant->GetAI()->DoAction(ACTION_DESPAWN_REMNANT);
        }
    }
 
    void EndEncounter()
    {
        ClearDebuffs();
        events.Reset();
        scheduler.CancelAll();
        _encounterEnded = true;
        instance->SetBossState(DATA_ANDUIN_WRYNN, DONE);
        _EnterEvadeMode();
        DoCastSelf(SPELL_ANDUIN_KNEEL_POSE);
 
        if (Creature* beacon = instance->GetCreature(DATA_BEACON_OF_HOPE))
            beacon->DespawnOrUnsummon();
 
        me->SetReactState(REACT_PASSIVE);
        me->SetFaction(FACTION_FRIENDLY);
        instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_ENCOUNTER_COMPLETED, 1);
        instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
        DoAction(ACTION_MOVE_NPCS_ON_PLATFORM);
 
        if (GameObject* chest = me->SummonGameObject(GAMEOBJECT_ANDUIN_CHEST_LOOT, ChestLootSpawnPosition, QuaternionData::fromEulerAnglesZYX(-225.0f, 0.0f, 0.0f), 7_days))
        {
            chest->SetGoState(GO_STATE_ACTIVE);
            chest->SetSpellVisualId(SPELL_VISUAL_CHEST_LOOT, ObjectGuid::Empty);
        }
 
        scheduler.Schedule(5s, [this](TaskContext const& /*task*/)
        {
            instance->DoCastSpellOnPlayers(SPELL_FINAL_MOVIE);
        });
    }
 
private:
    bool _slayTextOnCooldown;
    uint8 _intermissionsDone;
    bool _encounterEnded;
};
 
// 184830 - Beacon of Hope
struct npc_anduin_wrynn_beacon_of_hope : public ScriptedAI
{
    npc_anduin_wrynn_beacon_of_hope(Creature* creature) : ScriptedAI(creature) { }
 
    void JustUnregisteredAreaTrigger(AreaTrigger* areaTrigger) override
    {
        switch (areaTrigger->GetSpellId())
        {
            case SPELL_FRAGMENT_OF_HOPE_AREATRIGGER:
            {
                if (!areaTrigger->GetInsideUnits().empty())
                    break;
 
                InstanceScript* instance = me->GetInstanceScript();
                if (!instance)
                    break;
 
                if (Creature* beacon = instance->GetCreature(DATA_BEACON_OF_HOPE))
                    beacon->CastSpell(beacon, SPELL_FRAGMENT_OF_HOPE_DAMAGE, true);
                break;
            }
            default:
                break;
        }
    }
};
 
// 183452 - Empty Vessel
struct npc_anduin_wrynn_empty_vessel : public ScriptedAI
{
    npc_anduin_wrynn_empty_vessel(Creature* creature) : ScriptedAI(creature) { }
 
    void JustAppeared() override
    {
        me->SetReactState(REACT_PASSIVE);
    }
 
    void IsSummonedBy(WorldObject* summoner) override
    {
        if (!summoner->IsPlayer())
            return;
 
        summoner->CastSpell(me, SPELL_MIRROR_IMAGE);
        DoCast(me, SPELL_FEIGN_DEATH);
    }
};
 
// 185607 - Lost Soul
struct npc_anduin_wrynn_lost_soul : public ScriptedAI
{
    npc_anduin_wrynn_lost_soul(Creature* creature) : ScriptedAI(creature) { }
 
    void JustAppeared() override
    {
        me->SetReactState(REACT_PASSIVE);
        _events.ScheduleEvent(EVENT_BANISH_SOUL, 1ms);
    }
 
    void IsSummonedBy(WorldObject* summoner) override
    {
        if (!summoner->IsPlayer())
            return;
 
        summoner->CastSpell(me, SPELL_LOST_SOUL_MIRROR_IMAGE);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        TempSummon* summon = me->ToTempSummon();
        if (!summon)
            return;
 
        if (Unit* summoner = summon->GetSummonerUnit())
        {
            summoner->RemoveAurasDueToSpell(SPELL_SEVERED_SOUL);
            summoner->NearTeleportTo(me->GetPosition());
        }
        me->DespawnOrUnsummon(2s);
    }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    void UpdateAI(uint32 diff) override
    {
        UpdateVictim();
 
        _events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_BANISH_SOUL:
                {
                    DoCastSelf(SPELL_BANISH_SOUL);
                    _events.Repeat(1ms);
                    break;
                }
                default:
                    break;
            }
        }
    }
 
private:
    EventMap _events;
};
 
// 184519 - Anduin's Soul
struct npc_anduin_wrynn_anduin_soul : public ScriptedAI
{
    npc_anduin_wrynn_anduin_soul(Creature* creature) : ScriptedAI(creature),
        _hopeRestored(0), _doubtGone(0), _despairGone(0), _summons(me) { }
 
    void CheckForReleaseFromKingsmourne()
    {
        if (_hopeRestored == 4 && _doubtGone == 4 && _despairGone == 1)
        {
            DoCastAOE(SPELL_LOST_SOUL_CLEAR, true);
            _hopeRestored = 0;
            _doubtGone = 0;
            _despairGone = 0;
        }
    }
 
    void JustAppeared() override
    {
        me->SetDisableGravity(true, true);
        me->SetHoverHeight(1.0);
        DoCastSelf(SPELL_LOST_SOUL_PERIODIC);
    }
 
    void Reset() override
    {
        _summons.DespawnAll();
        DoCastSelf(SPELL_ANDUIN_SOUL_GHOST, true);
    }
 
    void JustSummoned(Creature* who) override
    {
        _summons.Summon(who);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        _summons.DespawnAll();
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        _summons.DespawnAll();
        DoCastSelf(SPELL_ANDUIN_SOUL_GHOST, true);
    }
 
    void DoAction(int32 action) override
    {
        InstanceScript* instance = me->GetInstanceScript();
        if (!instance)
            return;
 
        Creature* anduin = instance->GetCreature(DATA_ANDUIN_SOUL);
        if (!anduin)
            return;
 
        switch (action)
        {
            case ACTION_SUMMON_KINGSMOURNE_SOULS:
            {
                me->SummonCreature(NPC_ANDUIN_DESPAIR, AnduinsDespairSpawnPosition, TEMPSUMMON_TIMED_DESPAWN, 40s);
                for (uint8 i = 0; i < 4; i++)
                {
                    me->SummonCreature(NPC_ANDUIN_DOUBT, AnduinsDoubtSpawnPositions[i], TEMPSUMMON_TIMED_DESPAWN, 40s);
                    me->SummonCreature(NPC_ANDUIN_HOPE, AnduinsHopeSpawnPosition[i], TEMPSUMMON_TIMED_DESPAWN, 40s);
                }
                break;
            }
            case ACTION_DESPAIR_GONE:
                _despairGone++;
                CheckForReleaseFromKingsmourne();
                break;
 
            case ACTION_DOUBT_GONE:
                _doubtGone++;
                CheckForReleaseFromKingsmourne();
                break;
 
            case ACTION_HOPE_RESTORED:
                _hopeRestored++;
                CheckForReleaseFromKingsmourne();
                break;
 
            default:
                break;
        }
    }
 
public:
    uint8 _hopeRestored;
    uint8 _doubtGone;
    uint8 _despairGone;
    SummonList _summons;
};
 
// 184520 - Anduin's Despair
struct npc_anduin_wrynn_anduin_despair : public ScriptedAI
{
    npc_anduin_wrynn_anduin_despair(Creature* creature) : ScriptedAI(creature),
        _instance(creature->GetInstanceScript()) { }
 
    void JustAppeared() override
    {
        DoCastSelf(SPELL_RAIN_OF_DESPAIR);
        DoCastSelf(SPELL_ANDUIN_SOUL_DESPAIR);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        DoCastSelf(SPELL_POWER_ENERGIZE_WILLPOWER_LARGE);
 
        if (Creature* soul = _instance->GetCreature(DATA_ANDUIN_SOUL))
            soul->GetAI()->DoAction(ACTION_DESPAIR_GONE);
    }
 
private:
    InstanceScript* _instance;
};
 
// 184494 - Anduin's Doubt
struct npc_anduin_wrynn_anduin_doubt : public ScriptedAI
{
    npc_anduin_wrynn_anduin_doubt(Creature* creature) : ScriptedAI(creature) { }
 
    void JustAppeared() override
    {
        me->SetWalk(true);
        DoCastSelf(SPELL_GHOST_VISUAL_COSMETIC, true);
        DoZoneInCombat();
        me->GetMotionMaster()->MovePoint(POINT_ANDUIN_SOUL, AnduinsSoulSpawnPosition);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        DoCastSelf(SPELL_POWER_ENERGIZE_WILLPOWER_SMALL);
        DoCastSelf(SPELL_SOUL_DESPAWN);
 
        if (Creature* soul = me->GetInstanceScript()->GetCreature(DATA_ANDUIN_SOUL))
            soul->GetAI()->DoAction(ACTION_DOUBT_GONE);
    }
 
    void UpdateAI(uint32 /*diff*/) override
    {
        UpdateVictim();
    }
};
 
// 184493 - Anduin's Hope
struct npc_anduin_wrynn_anduin_hope : public ScriptedAI
{
    npc_anduin_wrynn_anduin_hope(Creature* creature) : ScriptedAI(creature),
        _instance(creature->GetInstanceScript()) { }
 
    void Reset() override
    {
        me->SetRegenerateHealth(false);
        me->SetHealth(1);
        me->SetReactState(REACT_PASSIVE);
    }
 
    void JustAppeared() override
    {
        _instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me, 255);
        me->SetWalk(true);
        DoCastSelf(SPELL_ANDUIN_SLOW);
        if (IsHeroic() || IsMythic())
            DoCastSelf(SPELL_GLOOM);
 
        _scheduler.Schedule(2s, [this](TaskContext const& /*task*/)
        {
            Position exitPlatform = me->GetFirstCollisionPosition(100.0f, 0);
            me->GetMotionMaster()->MovePoint(POINT_ESCAPE_PLATFORM, exitPlatform, false, me->GetOrientation());
        });
        me->SetHealth(1);
 
        _scheduler.Schedule(40s, [this](TaskContext const& /*task*/)
        {
            me->DespawnOrUnsummon();
        });
    }
 
    void UpdateAI(uint32 diff) override
    {
        UpdateVictim();
 
        _scheduler.Update(diff);
    }
 
    void HealReceived(Unit* /*healer*/, uint32& heal) override
    {
        if (me->HealthAbovePctHealed(100, heal))
        {
            _instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
            DoCastSelf(SPELL_POWER_ENERGIZE_WILLPOWER_SMALL);
            DoCastSelf(SPELL_SOUL_DESPAWN);
 
            if (Creature* soul = _instance->GetCreature(DATA_ANDUIN_SOUL))
                soul->GetAI()->DoAction(ACTION_HOPE_RESTORED);
        }
    }
 
    void MovementInform(uint32 type, uint32 pointId) override
    {
        if (type != POINT_MOTION_TYPE)
            return;
 
        switch (pointId)
        {
            case POINT_ESCAPE_PLATFORM:
            {
                DoCastSelf(SPELL_SOUL_DESPAWN);
                break;
            }
            default:
                break;
        }
    }
 
private:
    InstanceScript* _instance;
    TaskScheduler _scheduler;
};
 
// 183669 - Fiendish Soul
struct npc_anduin_wrynn_fiendish_soul : public ScriptedAI
{
    npc_anduin_wrynn_fiendish_soul(Creature* creature) : ScriptedAI(creature) { }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        _events.ScheduleEvent(EVENT_GHOUL_LEAP, 1s);
        _events.ScheduleEvent(EVENT_NECROTIC_CLAWS, 10s);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        if (IsHeroic() || IsMythic())
            DoCastSelf(SPELL_SOUL_EXPLOSION_TARGET);
 
        DoCastSelf(SPELL_SOUL_DESPAWN);
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        me->DespawnOrUnsummon();
    }
 
    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_GHOUL_LEAP:
                {
                    std::list<Player*> targetList;
                    GetPlayerListInGrid(targetList, me, 50.0f);
                    if (!targetList.empty())
                        me->CastSpell(Trinity::Containers::SelectRandomContainerElement(targetList), SPELL_NECROTIC_CLAWS_LEAP);
                    _events.Repeat(10s);
                    break;
                }
                case EVENT_NECROTIC_CLAWS:
                {
                    DoCastVictim(SPELL_NECROTIC_CLAWS_DEBUFF);
                    _events.Repeat(5s, 10s);
                    break;
                }
                default:
                    break;
            }
        }
    }
 
private:
    EventMap _events;
};
 
// 183671 - Monstrous Soul
struct npc_anduin_wrynn_monstrous_soul : public ScriptedAI
{
    npc_anduin_wrynn_monstrous_soul(Creature* creature) : ScriptedAI(creature) { }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        me->GetInstanceScript()->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me, 255);
        DoCastSelf(SPELL_UNRAVELING_FRENZY_PERIODIC, true);
    }
 
    void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (me->HealthBelowPctDamaged(35, damage))
            _events.ScheduleEvent(EVENT_NECROTIC_DETONATION, 1ms);
    }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_NECROTIC_DETONATION:
            {
                Talk(SAY_NECROTIC_DETONATION);
                DoCastSelf(SPELL_NECROTIC_DETONATION);
                break;
            }
            default:
                break;
        }
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        me->GetInstanceScript()->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        me->GetInstanceScript()->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
        me->DespawnOrUnsummon();
    }
 
    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_NECROTIC_DETONATION:
                {
                    Talk(SAY_NECROTIC_DETONATION);
                    DoCastSelf(SPELL_NECROTIC_DETONATION);
                    break;
                }
                default:
                    break;
            }
        }
    }
 
private:
    EventMap _events;
};
 
// 183463 - Remnant of a Fallen King
struct boss_remnant_of_a_fallen_king : public ScriptedAI
{
    boss_remnant_of_a_fallen_king(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()), _summons(creature) { }
 
    void JustAppeared() override
    {
        _scheduler.ClearValidator();
        DoCastSelf(SPELL_SHADE_VISUAL);
        me->ModifyPower(me->GetPowerType(), 0);
        me->SetPower(me->GetPowerType(), 0);
        for (MapReference const& players : me->GetMap()->GetPlayers())
        {
            if (Player* player = players.GetSource())
                me->CastSpell(player, SPELL_WEATHER_COSMETIC, true);
        }
        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_HOPEBREAKER);
        me->SetReactState(REACT_PASSIVE);
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        _summons.DespawnAll();
        me->DespawnOrUnsummon();
 
        if (Creature* anduin = _instance->GetCreature(DATA_ANDUIN_WRYNN))
            anduin->AI()->EnterEvadeMode(EvadeReason::NoHostiles);
 
        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_WEATHER_COSMETIC);
        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_REMORSELESS_WINTER_PERIODIC);
        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_NECROTIC_CLAWS_DEBUFF);
        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_FORCE_OF_WILL);
    }
 
    void ContinueAttacking() const
    {
        if (Creature* sylvanas = _instance->GetCreature(DATA_SYLVANAS_WINDRUNNER_ANDUIN))
            sylvanas->GetAI()->AttackStartCaster(me, 25.0f);
 
        if (Creature* uther = _instance->GetCreature(DATA_UTHER_THE_LIGHTBRINGER_ANDUIN))
            uther->GetAI()->AttackStart(me);
 
        if (Creature* jaina = _instance->GetCreature(DATA_JAINA_PROUDMOORE_ANDUIN))
            jaina->GetAI()->AttackStartCaster(me, 25.0f);
    }
 
    void JustSummoned(Creature* summon) override
    {
        _summons.Summon(summon);
 
        switch (summon->GetEntry())
        {
            case NPC_FIENDISH_SOUL:
            case NPC_MONSTROUS_SOUL:
                summon->SetReactState(REACT_PASSIVE);
                summon->m_Events.AddEvent(new ActivateGhouls(me, summon), summon->m_Events.CalculateTime(5s));
                break;
            default:
                break;
        }
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_ACTIVATE_REMNANT:
            {
                DoCastAOE(SPELL_DARK_PRESENCE);
                DoZoneInCombat();
 
                _scheduler.Schedule(1500ms, [this](TaskContext const& /*task*/)
                {
                    _instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, me, 2);
                    me->SetUninteractible(false);
                });
 
                _scheduler.Schedule(2s, [this](TaskContext const& /*task*/)
                {
                    DoCastSelf(SPELL_REMNANT_TIMER);
                    _events.ScheduleEvent(EVENT_ARMY_OF_THE_DEAD, 1ms);
                    _events.ScheduleEvent(EVENT_SOUL_REAPER, 8000ms);
                    _events.ScheduleEvent(EVENT_RETURN_TO_KINGSMOURNE, 67500ms);
                    me->SetReactState(REACT_AGGRESSIVE);
                    ContinueAttacking();
                });
                break;
            }
            case ACTION_DESPAWN_REMNANT:
            {
                DoCastSelf(SPELL_SOUL_DESPAWN);
                _scheduler.Schedule(500ms, [this](TaskContext const& /*task*/)
                {
                    EnterEvadeMode(EvadeReason::Other);
                });
                break;
            }
            default:
                break;
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        _scheduler.Update(diff);
 
        if (!UpdateVictim())
            return;
 
        _events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_RETURN_TO_KINGSMOURNE:
                {
                    me->SetReactState(REACT_PASSIVE);
                    me->AttackStop();
                    me->InterruptNonMeleeSpells(true);
                    DoCastSelf(SPELL_RETURN_TO_KINGSMOURNE);
                    break;
                }
                case EVENT_ARMY_OF_THE_DEAD:
                {
                    DoCastSelf(SPELL_ARMY_OF_THE_DEAD);
                    me->SetReactState(REACT_AGGRESSIVE);
                    if (!IsLFR())
                        _events.Repeat(36900ms);
                    break;
                }
                case EVENT_SOUL_REAPER:
                {
                    DoCastVictim(SPELL_SOUL_REAPER);
                    _events.Repeat(12s);
                    break;
                }
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
private:
    EventMap _events;
    TaskScheduler _scheduler;
    InstanceScript* _instance;
    SummonList _summons;
};
 
// 183033 - Grim Reflection
struct npc_anduin_wrynn_grim_reflection : public ScriptedAI
{
    npc_anduin_wrynn_grim_reflection(Creature* creature) : ScriptedAI(creature) { }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    void JustAppeared() override
    {
        SetCombatMovement(false);
        DoCastSelf(SPELL_CALAMITY_STATE_VISUAL);
        DoZoneInCombat();
        me->SetReactState(REACT_AGGRESSIVE);
        _events.ScheduleEvent(EVENT_PSYCHIC_TERROR, 1ms);
 
        if (IsLFR() || IsNormal())
            _events.ScheduleEvent(EVENT_GRIM_REFLECTION_IMMUNITY, 1ms);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        if (IsMythic())
            DoCastAOE(SPELL_GRIM_FATE);
    }
 
    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_PSYCHIC_TERROR:
                {
                    DoCastSelf(SPELL_PSYCHIC_TERROR);
                    _events.Repeat(2s);
                    break;
                }
                case EVENT_GRIM_REFLECTION_IMMUNITY:
                {
                    DoCastSelf(SPELL_WICKED_STAR_PROTECTION);
                    _events.Repeat(1s);
                    break;
                }
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
private:
    EventMap _events;
};
 
// 183666 - Sylvanas Windrunner
struct npc_anduin_wrynn_sylvanas : public ScriptedAI
{
    npc_anduin_wrynn_sylvanas(Creature* creature) : ScriptedAI(creature) { }
 
    void JustAppeared() override
    {
        me->SetReactState(REACT_AGGRESSIVE);
        me->SetCanMelee(false); // DoSpellAttackIfReady
    }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        _events.ScheduleEvent(EVENT_TUMBLE, 10s);
    }
 
    bool CanAIAttack(Unit const* target) const override
    {
        return !target->HasAura(SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER);
    }
 
    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_TUMBLE:
                {
                    DoCastSelf(SPELL_TUMBLE);
                    _events.Repeat(10s);
                    break;
                }
                default:
                    break;
            }
        }
 
        DoSpellAttackIfReady(SPELL_SHOOT_BOW);
    }
 
private:
    EventMap _events;
};
 
// 183664 - Jaina Proudmoore
struct npc_anduin_wrynn_jaina : public ScriptedAI
{
    npc_anduin_wrynn_jaina(Creature* creature) : ScriptedAI(creature) { }
 
    void JustAppeared() override
    {
        me->SetReactState(REACT_AGGRESSIVE);
        me->SetCanMelee(false); // DoSpellAttackIfReady
    }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        _events.ScheduleEvent(EVENT_BLINK, 10s);
    }
 
    bool CanAIAttack(Unit const* target) const override
    {
        return !target->HasAura(SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER);
    }
 
    void WaypointPathEnded(uint32 /*nodeId*/, uint32 pathId) override
    {
        if (pathId != PATH_INTRODUCTION_JAINA)
            return;
 
        if (Creature* anduin = me->GetInstanceScript()->GetCreature(DATA_ANDUIN_WRYNN))
            anduin->GetAI()->DoAction(ACTION_START_INTRODUCTION);
    }
 
    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_CANCEL_JAINA_EVENTS:
                {
                    _events.CancelEvent(EVENT_BLINK);
                    break;
                }
                case EVENT_BLINK:
                {
                    DoCastSelf(SPELL_BLINK);
                    _events.Repeat(60s);
                    break;
                }
                default:
                    break;
            }
        }
 
        DoSpellAttackIfReady(SPELL_FROSTBOLT);
    }
 
private:
    EventMap _events;
};
 
// 183665 - Uther the Lightbringer
struct npc_anduin_wrynn_uther : public ScriptedAI
{
    npc_anduin_wrynn_uther(Creature* creature) : ScriptedAI(creature) { }
 
    void JustAppeared() override
    {
        me->SetReactState(REACT_AGGRESSIVE);
    }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    void JustEngagedWith(Unit* who) override
    {
        DoCast(who, SPELL_UTHER_CHARGE);
        _events.ScheduleEvent(EVENT_BLADE_OF_JUSTICE, 3s);
    }
 
    bool CanAIAttack(Unit const* target) const override
    {
        return !target->HasAura(SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER);
    }
 
    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_CANCEL_UTHER_EVENTS:
                {
                    _events.CancelEvent(EVENT_BLADE_OF_JUSTICE);
                    break;
                }
                case EVENT_BLADE_OF_JUSTICE:
                {
                    DoCastVictim(SPELL_BLADE_OF_JUSTICE);
                    _events.Repeat(10s);
                    break;
                }
                default:
                    break;
            }
        }
    }
 
private:
    EventMap _events;
};
 
// 367524 - Spawn Pre-Introduction
class spell_anduin_wrynn_pre_introduction : public AuraScript
{
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        switch (caster->GetEntry())
        {
            case NPC_LADY_JAINA_PROUDMOORE_ANDUIN:
                caster->NearTeleportTo(PreIntroductionAssistersPositions[0]);
                break;
            case NPC_UTHER_THE_LIGHTBRINGER_ANDUIN:
                caster->NearTeleportTo(PreIntroductionAssistersPositions[1]);
                break;
            case NPC_SYLVANAS_WINDRUNNER_ANDUIN:
                caster->NearTeleportTo(PreIntroductionAssistersPositions[2]);
                break;
            default:
                break;
        }
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        uint32 pathId = 0;
        switch (caster->GetEntry())
        {
            case NPC_LADY_JAINA_PROUDMOORE_ANDUIN:
                pathId = PATH_INTRODUCTION_JAINA;
                break;
            case NPC_UTHER_THE_LIGHTBRINGER_ANDUIN:
                pathId = PATH_INTRODUCTION_UTHER;
                break;
            case NPC_SYLVANAS_WINDRUNNER_ANDUIN:
                pathId = PATH_INTRODUCTION_SYLVANAS;
                break;
            default:
                break;
        }
        caster->GetMotionMaster()->MovePath(pathId, false);
    }
 
    void Register() override
    {
        OnEffectApply += AuraEffectApplyFn(spell_anduin_wrynn_pre_introduction::OnApply, EFFECT_1, SPELL_AURA_MOD_STUN, AURA_EFFECT_HANDLE_REAL);
        AfterEffectRemove += AuraEffectRemoveFn(spell_anduin_wrynn_pre_introduction::OnRemove, EFFECT_2, SPELL_AURA_MOD_ROOT, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 369317 - Anduin Progression Aura (Can't be reduced < 1 hp)
class spell_anduin_wrynn_progression_aura : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_ANDUIN_PROGRESSION_AURA, SPELL_ANDUIN_KNEEL_POSE });
    }
 
    void CalculateAmount(AuraEffect const* /*aurEff*/, SpellEffectValue& amount, bool& canBeRecalculated)
    {
        amount = -1;
        canBeRecalculated = true;
    }
 
    void Trigger(AuraEffect* /*aurEff*/, DamageInfo const& dmgInfo, uint32& absorbAmount)
    {
        if (!GetTarget()->GetAura(SPELL_ANDUIN_PROGRESSION_AURA))
            return;
 
        if (dmgInfo.GetDamage() <= GetTarget()->GetHealth())
            return;
 
        if (dmgInfo.GetDamage() >= GetTarget()->GetHealth())
        {
            absorbAmount = dmgInfo.GetDamage();
            if (_triggered)
                return;
 
            GetTarget()->SetHealth(1);
            GetTarget()->CastSpell(GetTarget(), SPELL_ANDUIN_KNEEL_POSE);
            GetTarget()->GetAI()->DoAction(ACTION_END_ENCOUNTER);
            _triggered = true;
        }
    }
 
    void Register() override
    {
        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_anduin_wrynn_progression_aura::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
        OnEffectAbsorb += AuraEffectAbsorbFn(spell_anduin_wrynn_progression_aura::Trigger, EFFECT_0);
    }
 
private:
    bool _triggered = false;
};
 
// 366848 - Anduin Willpower Periodic (Only LFR)
class spell_anduin_wrynn_energize_willpower_lfr : public AuraScript
{
    static constexpr std::array<int32, 22> AnduinRegenCycle =
    { 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1 }; // 0.681 willpower per second on Retail
 
    void HandlePeriodic(AuraEffect const* /*aurEff*/)
    {
        Unit* target = GetTarget();
        _powerGained = AnduinRegenCycle[_powerRegenCycle++];
 
        if (_powerRegenCycle >= 22)
           _powerRegenCycle = 0;
 
        target->ModifyPower(target->GetPowerType(), _powerGained);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_anduin_wrynn_energize_willpower_lfr::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
 
    uint8 _powerRegenCycle = 0;
    uint32 _powerGained = 0;
};
 
// 364247 - Dark Zeal
class spell_anduin_wrynn_dark_zeal : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_DARK_ZEAL_BUFF });
    }
 
    void OnProc(AuraEffect* /*aurEff*/, ProcEventInfo const& eventInfo)
    {
        Unit* actionTarget = eventInfo.GetActionTarget();
        if (!actionTarget)
            return;
 
        Unit* target = GetTarget();
        target->CastSpell(target, SPELL_DARK_ZEAL_BUFF, true);
 
        if (actionTarget->GetGUID() == _currentTank)
            return;
 
        target->RemoveAura(SPELL_DARK_ZEAL_BUFF);
        _currentTank = actionTarget->GetGUID();
    }
 
    void Register() override
    {
        OnEffectProc += AuraEffectProcFn(spell_anduin_wrynn_dark_zeal::OnProc, EFFECT_0, SPELL_AURA_DUMMY);
    }
 
private:
    ObjectGuid _currentTank;
};
 
// 361815 - Hopebreaker
// 365806 - Empowered Hopebreaker
class spell_anduin_wrynn_hopebreaker : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_HOPEBREAKER_DAMAGE, SPELL_HOPEBREAKER_DEBUFF });
    }
 
    void HandleHit(SpellEffIndex /*effIndex*/) const
    {
        GetCaster()->CastSpell(GetHitUnit(), SPELL_HOPEBREAKER_DAMAGE, true);
        GetCaster()->CastSpell(GetHitUnit(), SPELL_HOPEBREAKER_DEBUFF, true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_anduin_wrynn_hopebreaker::HandleHit, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 361817 - Hopebreaker Periodic
class spell_anduin_wrynn_hopebreaker_periodic : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_HOPEBREAKER_DEBUFF_DAMAGE });
    }
 
    void OnPeriodic(AuraEffect const* /*aurEff*/) const
    {
        if (!GetCaster())
            return;
 
        GetCaster()->CastSpell(GetTarget(), SPELL_HOPEBREAKER_DEBUFF_DAMAGE, true);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_anduin_wrynn_hopebreaker_periodic::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 361818 - Hopebreaker Damage
class spell_anduin_wrynn_hopebreaker_damage : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_HOPEBREAKER_DEBUFF });
    }
 
    void HandleDamage(SpellEffIndex /*effIndex*/)
    {
        Unit* target = GetHitUnit();
 
        Aura* hopebreaker = target->GetAura(SPELL_HOPEBREAKER_DEBUFF);
        if (!hopebreaker)
            return;
 
        uint8 hopebreakerStacks = hopebreaker->GetStackAmount();
        SetHitDamage(GetHitDamage() * hopebreakerStacks);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_anduin_wrynn_hopebreaker_damage::HandleDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
    }
};
 
// 363133 - March of the Damned, CreatePropertiesId - 24093
struct at_anduin_wrynn_march_of_the_damned : AreaTriggerAI
{
    at_anduin_wrynn_march_of_the_damned(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger) { }
 
    void OnUnitEnter(Unit* unit) override
    {
        if (!unit->IsPlayer())
            return;
 
        Unit* caster = at->GetCaster();
        if (!caster)
            return;
 
        caster->CastSpell(unit, SPELL_MARCH_OF_THE_DAMNED_DAMAGE, true);
    }
};
 
float constexpr BEFOULED_BARRIER_MAX_RADIUS = 12.0f;
float constexpr BEFOULED_BARRIER_MIN_RADIUS = 4.0f;
 
// 365173 - Befouled Barrier - CreatePropertiesId: 24332
struct at_anduin_wrynn_befouled_barrier : AreaTriggerAI
{
    at_anduin_wrynn_befouled_barrier(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger) { }
 
    void OnInitialize() override
    {
        if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_BEFOULED_BARRIER_DEBUFF, at->GetMap()->GetDifficultyID()))
            _absorbRequired = spellInfo->GetEffect(EFFECT_0).CalcValueAsInt(at->GetCaster());
 
        at->SetTimeToTargetScale(30000);
 
        // The aura is handling it automatically
        at->SetDuration(-1);
    }
 
    void OnCreate(Spell const* /*creatingSpell*/) override
    {
        _scheduler.Schedule(500ms, [this](TaskContext& task)
        {
            float startRadius = 1.0f;
 
            UpdateSize(startRadius, BEFOULED_BARRIER_MAX_RADIUS);
            at->SetTimeToTargetScale(500);
 
            task.Schedule(Milliseconds(at->GetTimeToTargetScale()), [this](TaskContext& task)
            {
                UpdateSizeBasedOnAbsorb();
                task.Repeat();
            });
        });
    }
 
    void UpdateSize(float radius, float targetRadius) const
    {
        std::array<DBCPosition2D, 2> points =
        { {
            { 0.0f, radius },
            { 1.0f, targetRadius }
        } };
 
        at->SetOverrideScaleCurve(points);
    }
 
    void UpdateSizeBasedOnAbsorb() const
    {
        Unit* target = at->GetTarget();
        if (!target)
            return;
 
        float radiusMod = 1.0f - (_absorbDone / (float)_absorbRequired);
        float targetRadius = BEFOULED_BARRIER_MAX_RADIUS * radiusMod;
        float currentRadius = at->GetMaxSearchRadius();
 
        if (G3D::fuzzyEq(currentRadius, targetRadius))
            return;
 
        // Players need to be able to actually enter the AT to heal it no sniff has a value lower than 4.0f
        if (targetRadius <= BEFOULED_BARRIER_MIN_RADIUS)
            return;
 
        UpdateSize(currentRadius, targetRadius);
    }
 
    void OnUpdate(uint32 diff) override
    {
        _scheduler.Update(diff);
    }
 
    void OnUnitEnter(Unit* unit) override
    {
        Unit* caster = at->GetCaster();
        if (!caster)
            return;
 
        caster->CastSpell(unit, SPELL_BEFOULED_BARRIER_DEBUFF, true);
    }
 
    void OnUnitExit(Unit* unit, AreaTriggerExitReason /*reason*/) override
    {
        unit->RemoveAura(SPELL_BEFOULED_BARRIER_DEBUFF);
    }
 
    void Absorb(uint32 absorbAmount)
    {
        _absorbDone += absorbAmount;
 
        if (_absorbDone < _absorbRequired)
            return;
 
        Unit* target = at->GetTarget();
        if (!target)
            return;
 
        // remove barrier, we're done healing
        if (Creature* creature = target->ToCreature())
        {
            creature->CastSpell(creature, SPELL_BEFOULED_BARRIER_CLEAR, true);
            creature->DespawnOrUnsummon(1s);
        }
    }
 
    uint32 GetRemainingAbsorb() const
    {
        return _absorbRequired - _absorbDone;
    }
 
private:
    uint32 _absorbDone = 0;
    uint32 _absorbRequired = 0;
    TaskScheduler _scheduler;
};
 
float constexpr BEACON_OF_HOPE_MAX_RADIUS = 12.0f;
float constexpr BEACON_OF_HOPE_MIN_RADIUS = 4.0f;
 
// 362702 - Beacon of Hope - CreatePropertiesId: 25025 / 24247
struct at_anduin_wrynn_beacon_of_hope : AreaTriggerAI
{
    at_anduin_wrynn_beacon_of_hope(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger),
        _instance(at->GetInstanceScript()), _entries(0), _chargesRemaining(40) { }
 
    void OnInitialize() override
    {
        _entries = 0;
        _chargesRemaining = 40;
    }
 
    void OnCreate(Spell const* /*creatingSpell*/) override
    {
        _scheduler.Schedule(500ms, [this](TaskContext& task)
        {
            float startRadius = 1.0f;
            float targetRadius = BEACON_OF_HOPE_MAX_RADIUS;
 
            UpdateSize(startRadius, targetRadius);
            at->SetTimeToTargetScale(500);
 
            task.Schedule(Milliseconds(at->GetTimeToTargetScale()), [this](TaskContext& task)
            {
                UpdateSizeBasedOnCharges();
                task.Repeat();
            });
        });
    }
 
    void UpdateSize(float radius, float targetRadius) const
    {
        std::array<DBCPosition2D, 2> points =
        { {
            { 0.0f, radius },
            { 1.0f, targetRadius }
        } };
 
        at->SetOverrideScaleCurve(points);
    }
 
    void UpdateSizeBasedOnCharges() const
    {
        float radiusMod = 0.205129f * _entries;
        float targetRadius = BEACON_OF_HOPE_MAX_RADIUS - radiusMod;
 
        if (targetRadius <= BEACON_OF_HOPE_MIN_RADIUS || _chargesRemaining <= 0)
            at->Remove();
 
        float currentRadius = at->GetMaxSearchRadius();
        if (G3D::fuzzyEq(currentRadius, targetRadius))
            return;
 
        UpdateSize(currentRadius, targetRadius);
    }
 
    void OnUpdate(uint32 diff) override
    {
        _scheduler.Update(diff);
    }
 
    void OnUnitEnter(Unit* unit) override
    {
        if (!unit->IsPlayer())
            return;
 
        if (!at->GetCaster())
            return;
 
        Creature* beacon = _instance->GetCreature(DATA_BEACON_OF_HOPE);
        if (!beacon)
            return;
 
        beacon->CastSpell(beacon, SPELL_PURGING_LIGHT, true);
        unit->RemoveAurasDueToSpell(SPELL_HOPELESSNESS_HOPELESSNESS_AREATRIGGER);
 
        if (at->GetMap()->IsMythic())
        {
            _entries++;
            _chargesRemaining--;
            beacon->CastSpell(unit, SPELL_FRAGMENT_OF_HOPE_AREATRIGGER, true);
        }
    }
 
private:
    InstanceScript* _instance;
    uint8 _entries;
    uint8 _chargesRemaining;
    TaskScheduler _scheduler;
};
 
// 365816 - Fragment of Hope
class spell_anduin_wrynn_fragment_of_hope : public SpellScript
{
    void SetDest(SpellDestination& destination) const
    {
        Unit* caster = GetCaster();
        Position dest = caster->GetPosition();
 
        if (Creature* beacon = caster->GetInstanceScript()->GetCreature(DATA_BEACON_OF_HOPE))
            beacon->MovePositionToFirstCollision(dest, 30.0f, beacon->GetAbsoluteAngle(GetExplTargetWorldObject()) - beacon->GetOrientation());
 
        destination.Relocate(dest);
    }
 
    void Register() override
    {
        OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_anduin_wrynn_fragment_of_hope::SetDest, EFFECT_0, TARGET_DEST_DEST);
    }
};
 
// 365293 - Befouled Barrier
class spell_anduin_wrynn_befouled_barrier_absorb : public AuraScript
{
    bool Validate(SpellInfo const* spellInfo) override
    {
        return ValidateSpellInfo({ SPELL_BEFOULED_BARRIER_SPHERE_AREATRIGGER })
            && ValidateSpellEffect({ { spellInfo->Id, EFFECT_2 } });
    }
 
    void OnHealAbsorb(AuraEffect* /*aurEff*/, HealInfo const& healInfo, uint32& absorbAmount) const
    {
        absorbAmount = CalculatePct(healInfo.GetHeal(), GetEffectInfo(EFFECT_2).CalcValueAsInt());
 
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        AreaTrigger* barrier = caster->GetAreaTrigger(SPELL_BEFOULED_BARRIER_SPHERE_AREATRIGGER);
        if (!barrier)
            return;
 
        at_anduin_wrynn_befouled_barrier* barrierScript = dynamic_cast<at_anduin_wrynn_befouled_barrier*>(barrier->AI());
        if (!barrierScript)
            return;
 
        barrierScript->Absorb(absorbAmount);
    }
 
    void Register() override
    {
        OnEffectAbsorbHeal += AuraEffectAbsorbHealFn(spell_anduin_wrynn_befouled_barrier_absorb::OnHealAbsorb, EFFECT_0);
    }
};
 
// 365173 - Befouled Barrier Expire
class spell_anduin_wrynn_befouled_barrier_expire : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_BEFOULED_BARRIER_SPHERE_AREATRIGGER, SPELL_BEFOULED_BARRIER_EXPLODE });
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* target = GetTarget();
        if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
        {
            AreaTrigger* barrier = GetTarget()->GetAreaTrigger(SPELL_BEFOULED_BARRIER_SPHERE_AREATRIGGER);
            if (!barrier)
                return;
 
            at_anduin_wrynn_befouled_barrier* barrierScript = dynamic_cast<at_anduin_wrynn_befouled_barrier*>(barrier->AI());
            if (!barrierScript)
                return;
 
            target->CastSpell(target, SPELL_BEFOULED_BARRIER_EXPLODE, CastSpellExtraArgs().AddSpellMod(SPELLVALUE_BASE_POINT1, barrierScript->GetRemainingAbsorb()));
        }
 
        if (Creature* creatureTarget = target->ToCreature())
            creatureTarget->DespawnOrUnsummon();
    }
 
    void Register() override
    {
        OnEffectRemove += AuraEffectRemoveFn(spell_anduin_wrynn_befouled_barrier_expire::OnRemove, EFFECT_0, SPELL_AURA_AREA_TRIGGER, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 361989 - Blasphemy
class spell_anduin_wrynn_blasphemy : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_BLASPHEMY_PRE_HIT, SPELL_BLASPHEMY_OVERCONFIDENCE, SPELL_BLASPHEMY_HOPELESSNESS });
    }
 
    void OnPrecast() override
    {
        GetCaster()->CastSpell(GetCaster(), SPELL_BLASPHEMY_PRE_HIT, true);
    }
 
    void FilterTargets(std::list<WorldObject*>& targets)
    {
        int64 hopelessnessAffected = targets.size() / 2;
        int64 maxAffected = hopelessnessAffected * 2;
        Trinity::Containers::RandomResize(targets, maxAffected);
 
        for (WorldObject* target : targets)
        {
            if (hopelessnessAffected > 0)
            {
                _spellAssignments[target->GetGUID()] = SPELL_BLASPHEMY_HOPELESSNESS;
                hopelessnessAffected--;
            }
            else
                _spellAssignments[target->GetGUID()] = SPELL_BLASPHEMY_OVERCONFIDENCE;
        }
    }
 
    void HandleDebuff(SpellEffIndex /*effIndex*/)
    {
        uint32* spellId = Trinity::Containers::MapGetValuePtr(_spellAssignments, GetHitUnit()->GetGUID());
        if (!spellId)
            return;
 
        GetCaster()->CastSpell(GetHitUnit(), *spellId, true);
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_anduin_wrynn_blasphemy::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
        OnEffectHitTarget += SpellEffectFn(spell_anduin_wrynn_blasphemy::HandleDebuff, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
 
private:
    std::unordered_map<ObjectGuid /*player*/, uint32 /*spell*/> _spellAssignments;
};
 
// 361992 - Overconfidence CreatePropertiesId: 24616
// 361993 - Hopelessness CreatePropertiesId: 24616
struct at_anduin_wrynn_blasphemy : AreaTriggerAI
{
    at_anduin_wrynn_blasphemy(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger)  { }
 
    void OnUnitEnter(Unit* unit) override
    {
        if (!unit->IsPlayer() || unit->HasAura(SPELL_BLASPHEMY_PRE_HIT))
            return;
 
        if (!unit->IsAlive())
            at->Remove();
 
        if (unit->HasAura(at->GetSpellId()))
        {
            uint32 explodeSpellId = SPELL_BLASPHEMY_EXPLODE;
            if (at->GetMap()->IsLFR() || at->GetMap()->IsNormal())
                explodeSpellId = SPELL_BLASPHEMY_EXPLODE_LFR_NORMAL;
 
            unit->CastSpell(unit, explodeSpellId, true);
            unit->RemoveAurasDueToSpell(at->GetSpellId());
            if (Unit* target = at->GetTarget())
            {
                target->CastSpell(target, explodeSpellId, true);
                target->RemoveAurasDueToSpell(at->GetSpellId());
            }
        }
        else if (at->GetSpellId() == SPELL_BLASPHEMY_HOPELESSNESS_AREATRIGGER && unit->HasAura(SPELL_BLASPHEMY_OVERCONFIDENCE_AREATRIGGER))
        {
            unit->RemoveAurasDueToSpell(SPELL_BLASPHEMY_OVERCONFIDENCE);
            unit->RemoveAurasDueToSpell(SPELL_BLASPHEMY_OVERCONFIDENCE_AREATRIGGER);
            unit->CastSpell(unit, SPELL_BLASPHEMY_SUCCESS, true);
            if (Unit* target = at->GetTarget())
            {
                target->RemoveAurasDueToSpell(SPELL_BLASPHEMY_HOPELESSNESS);
                target->RemoveAurasDueToSpell(SPELL_BLASPHEMY_HOPELESSNESS_AREATRIGGER);
                target->CastSpell(target, SPELL_BLASPHEMY_SUCCESS, true);
            }
        }
        else if (at->GetSpellId() == SPELL_BLASPHEMY_OVERCONFIDENCE_AREATRIGGER && unit->HasAura(SPELL_BLASPHEMY_HOPELESSNESS_AREATRIGGER))
        {
            unit->RemoveAurasDueToSpell(SPELL_BLASPHEMY_HOPELESSNESS);
            unit->RemoveAurasDueToSpell(SPELL_BLASPHEMY_HOPELESSNESS_AREATRIGGER);
            unit->CastSpell(unit, SPELL_BLASPHEMY_SUCCESS, true);
            if (Unit* target = at->GetTarget())
            {
                target->RemoveAurasDueToSpell(SPELL_BLASPHEMY_OVERCONFIDENCE);
                target->RemoveAurasDueToSpell(SPELL_BLASPHEMY_OVERCONFIDENCE_AREATRIGGER);
                target->CastSpell(target, SPELL_BLASPHEMY_SUCCESS, true);
            }
        }
        else
        {
            // On Mythic players walking in with no debuff also trigger explosion
            if (!at->GetMap()->IsMythic())
                return;
 
            if (!unit->HasAura(SPELL_BLASPHEMY_HOPELESSNESS_AREATRIGGER) || !unit->HasAura(SPELL_BLASPHEMY_OVERCONFIDENCE_AREATRIGGER))
            {
                if (Unit* target = at->GetTarget())
                    target->CastSpell(target, SPELL_BLASPHEMY_EXPLODE, true);
            }
        }
    }
};
 
// 361992 - Overconfidence
// 361993 - Hopelessness
class spell_anduin_wrynn_hopelessness_overconfidence : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo(
        {
            SPELL_BLASPHEMY_EXPLODE,
            SPELL_BLASPHEMY_EXPLODE_LFR_NORMAL
        });
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
        {
            Unit* target = GetTarget();
            uint32 explodeSpellId = SPELL_BLASPHEMY_EXPLODE;
            if (target->GetMap()->IsLFR() || target->GetMap()->IsNormal())
                explodeSpellId = SPELL_BLASPHEMY_EXPLODE_LFR_NORMAL;
 
            target->CastSpell(target, explodeSpellId, true);
        }
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_anduin_wrynn_hopelessness_overconfidence::OnRemove, EFFECT_0, SPELL_AURA_AREA_TRIGGER, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 365021 - Wicked Star
class spell_anduin_wrynn_wicked_star_selector : public SpellScript
{
    void FilterTargets(std::list<WorldObject*>& targets)
    {
        uint32 rangedDpsCount = 0;
        for (WorldObject* target : targets)
        {
            Player* targetPlayer = target->ToPlayer();
            if (!targetPlayer)
                continue;
 
            ChrSpecializationEntry const* spec = targetPlayer->GetPrimarySpecializationEntry();
            if (!spec)
                continue;
 
            if (!targetPlayer->IsAlive())
                continue;
 
            if ((spec->GetRole() == ChrSpecializationRole::Dps && spec->GetFlags().HasFlag(ChrSpecializationFlag::Caster)) ||
                (spec->GetRole() == ChrSpecializationRole::Dps && spec->GetFlags().HasFlag(ChrSpecializationFlag::Ranged)))
                rangedDpsCount++;
        }
 
        targets.remove_if([rangedDpsCount](WorldObject* target) -> bool
        {
            Player* player = target->ToPlayer();
            if (!player || player->HasAura(SPELL_WICKED_STAR_TARGETED))
                return true;
 
            if (player->GetPrimarySpecializationEntry()->GetRole() == ChrSpecializationRole::Tank)
                return true;
 
            if (rangedDpsCount >= 3)
            {
                if (player->GetPrimarySpecializationEntry()->GetRole() == ChrSpecializationRole::Dps && player->GetPrimarySpecializationEntry()->GetFlags().HasFlag(ChrSpecializationFlag::Melee))
                    return true;
 
                if (player->GetPrimarySpecializationEntry()->GetRole() == ChrSpecializationRole::Healer)
                    return true;
            }
            return false;
        });
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_anduin_wrynn_wicked_star_selector::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
    }
};
 
// 365021 - Wicked Star
class spell_anduin_wrynn_wicked_star_selector_AuraScript : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_WICKED_STAR_TARGETED, GetAreaTriggerSpellID() });
    }
 
    virtual uint8 GetAnnounceGroupID() const
    {
        return SAY_ANNOUNCE_WICKED_STAR;
    }
 
    virtual uint32 GetAreaTriggerSpellID() const
    {
        return SPELL_WICKED_STAR_AREATRIGGER;
    }
 
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* caster = GetCaster();
        Unit* target = GetTarget();
        if (!caster)
            return;
 
        caster->CastSpell(target, SPELL_WICKED_STAR_TARGETED, true);
 
        if (Creature* creature = caster->ToCreature())
            if (CreatureAI* anduinAI = creature->AI())
                anduinAI->Talk(GetAnnounceGroupID(), target);
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        if (GetTargetApplication()->GetRemoveMode() != AURA_REMOVE_BY_EXPIRE)
            return;
 
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        float angle = caster->GetAbsoluteAngle(GetTarget());
        Position spellDest(caster->GetPositionX(), caster->GetPositionY(), caster->GetPositionZ(), angle);
 
        if (InstanceScript* instance = GetTarget()->GetInstanceScript())
            if (Creature* anduin = instance->GetCreature(DATA_ANDUIN_WRYNN))
                anduin->CastSpell(spellDest, GetAreaTriggerSpellID(), true);
    }
 
    void Register() override
    {
        OnEffectApply += AuraEffectApplyFn(spell_anduin_wrynn_wicked_star_selector_AuraScript::OnApply, EFFECT_0, SPELL_AURA_MOD_SCALE, AURA_EFFECT_HANDLE_REAL);
        AfterEffectRemove += AuraEffectRemoveFn(spell_anduin_wrynn_wicked_star_selector_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_MOD_SCALE, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 365017 - Wicked Star CreatePropertiesId: 24322
// 365017 - Wicked Star CreatePropertiesId: 24740
// 365017 - Wicked Star CreatePropertiesId: 24741
struct at_anduin_wrynn_wicked_star : AreaTriggerAI
{
    at_anduin_wrynn_wicked_star(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger) { }
 
    void OnInitialize() override
    {
        if (Unit* caster = at->GetCaster())
        {
            at->SetOrientation(caster->GetOrientation());
 
            Position destPos = caster->GetPosition();
            at->MovePositionToFirstCollision(destPos, 100.0f, 0.0f);
 
            std::vector<G3D::Vector3> splinePoints;
            splinePoints.push_back(PositionToVector3(at->GetPosition()));
            splinePoints.push_back(PositionToVector3(destPos));
            splinePoints.push_back(PositionToVector3(at->GetPosition()));
 
            at->InitSplines(splinePoints);
        }
    }
 
    void OnUnitEnter(Unit* unit) override
    {
        if (unit->GetEntry() == NPC_SYLVANAS_WINDRUNNER_ANDUIN || unit->GetEntry() == NPC_UTHER_THE_LIGHTBRINGER_ANDUIN ||
            unit->GetEntry() == NPC_LADY_JAINA_PROUDMOORE_ANDUIN || unit->GetEntry() == BOSS_ANDUIN_WRYNN)
            return;
 
        Unit* caster = at->GetCaster();
        if (!caster)
            return;
 
        if (caster->IsValidAttackTarget(unit))
            caster->CastSpell(unit, SPELL_WICKED_STAR_DAMAGE_SILENCE, TRIGGERED_IGNORE_GCD | TRIGGERED_IGNORE_CAST_IN_PROGRESS);
        else if (caster->IsValidAssistTarget(unit))
            caster->CastSpell(unit, SPELL_WICKED_STAR_EMPOWERMENT, TRIGGERED_IGNORE_GCD | TRIGGERED_IGNORE_CAST_IN_PROGRESS);
    }
 
    void OnDestinationReached() override
    {
        at->Remove();
    }
};
 
// 367632 - Empowered Wicked Star
class spell_anduin_wrynn_empowered_wicked_star_selector_AuraScript : public spell_anduin_wrynn_wicked_star_selector_AuraScript
{
    uint8 GetAnnounceGroupID() const override
    {
        return SAY_ANNOUNCE_EMPOWERED_WICKED_STAR;
    }
 
    uint32 GetAreaTriggerSpellID() const override
    {
        return SPELL_EMPOWERED_WICKED_STAR_AREATRIGGER;
    }
};
 
// 367621 - Empowered Wicked Star CreatePropertiesId: 24599
struct at_anduin_wrynn_empowered_wicked_star : public at_anduin_wrynn_wicked_star
{
    at_anduin_wrynn_empowered_wicked_star(AreaTrigger* areatrigger) : at_anduin_wrynn_wicked_star(areatrigger) { }
 
    void HandleMovement(float angle) const
    {
        Unit* caster = at->GetCaster();
        if (!caster)
            return;
 
        // hack: when reflection is implemented use at position instead of center; due to mmaps we are causing infinite loop if using at position after dest reach
        Position destPos = DominationGraspCenter;
        at->MovePositionToFirstCollision(destPos, 100.0f, angle);
 
        std::vector<G3D::Vector3> splinePoints;
        splinePoints.push_back(PositionToVector3(at->GetPosition()));
        splinePoints.push_back(PositionToVector3(destPos));
 
        at->InitSplines(splinePoints);
    }
 
    void OnInitialize() override
    {
        HandleMovement(0);
    }
 
    void OnDestinationReached() override
    {
        // hack: angle should use physical laws for reflection
        HandleMovement(frand(0, 2.0f * float(M_PI)));
    }
};
 
// 362405 - Kingsmourne Hungers
class spell_anduin_wrynn_kingsmourne_hungers : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo(
        {
            SPELL_KINGSMOURNE_HUNGERS_DAMAGE,
            SPELL_LOST_SOUL_DIMENSION,
            SPELL_LOST_SOUL,
            SPELL_SEVERED_SOUL
        });
    }
 
    void HandleDummyEffect(SpellEffIndex /*effIndex*/) const
    {
        Unit* caster = GetCaster();
        Unit* hitUnit = GetHitUnit();
        caster->CastSpell(hitUnit, SPELL_KINGSMOURNE_HUNGERS_DAMAGE, true);
        if (caster->GetMap()->IsMythic())
            hitUnit->CastSpell(hitUnit, SPELL_SEVERED_SOUL, true);
        caster->CastSpell(hitUnit, SPELL_LOST_SOUL_DIMENSION);
        hitUnit->CastSpell(hitUnit, SPELL_LOST_SOUL, true);
    }
 
    void OnCast() const
    {
        InstanceScript* instance = GetCaster()->GetInstanceScript();
        if (!instance)
            return;
 
        if (Creature* anduinSoul = instance->GetCreature(DATA_ANDUIN_SOUL))
            anduinSoul->GetAI()->DoAction(ACTION_SUMMON_KINGSMOURNE_SOULS);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_anduin_wrynn_kingsmourne_hungers::HandleDummyEffect, EFFECT_0, SPELL_EFFECT_DUMMY);
        AfterCast += SpellCastFn(spell_anduin_wrynn_kingsmourne_hungers::OnCast);
    }
};
 
// 362055 - Lost Soul
class spell_anduin_wrynn_lost_soul : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo(
        {
            SPELL_LOST_SOUL_GRACE,
            SPELL_SCARRED_SOUL
        });
    }
 
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        Unit* target = GetTarget();
        _lostSoulPosition = target->GetPosition();
        target->CastSpell(target, SPELL_LOST_SOUL_GRACE, true);
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* target = GetTarget();
        switch (GetTargetApplication()->GetRemoveMode())
        {
            case AURA_REMOVE_BY_DEFAULT:
            case AURA_REMOVE_BY_ENEMY_SPELL:
                target->CastSpell(target, SPELL_SCARRED_SOUL, true);
                break;
            case AURA_REMOVE_BY_EXPIRE:
            {
                if (target->GetMap()->IsMythic())
                {
                    target->KillSelf();
                    target->NearTeleportTo(_lostSoulPosition);
                }
                break;
            }
            case AURA_REMOVE_BY_DEATH:
            {
                target->CastSpell(target, SPELL_SCARRED_SOUL, true);
                if (target->GetMap()->IsMythic())
                    target->NearTeleportTo(_lostSoulPosition);
                break;
            }
            default:
                break;
        }
    }
 
    void Register() override
    {
        OnEffectApply += AuraEffectApplyFn(spell_anduin_wrynn_lost_soul::OnApply, EFFECT_0, SPELL_AURA_PHASE, AURA_EFFECT_HANDLE_REAL);
        OnEffectRemove += AuraEffectRemoveFn(spell_anduin_wrynn_lost_soul::OnRemove, EFFECT_1, SPELL_AURA_SCREEN_EFFECT, AURA_EFFECT_HANDLE_REAL);
    }
 
    Position _lostSoulPosition;
};
 
// 362392 - Rain of Despair
class spell_anduin_rain_of_despair_player_selector : public SpellScript
{
    void HandleDespair(SpellEffIndex effIndex) const
    {
        GetCaster()->CastSpell(GetHitUnit(), GetEffectInfo(effIndex).TriggerSpell, true);
    }
 
    void Register() override
    {
        OnEffectLaunchTarget += SpellEffectFn(spell_anduin_rain_of_despair_player_selector::HandleDespair, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 362766 - Soul Despawn
class spell_anduin_wrynn_soul_despawn : public SpellScript
{
    void OnCast() const
    {
        if (Creature* creature = GetCaster()->ToCreature())
            if (creature->GetEntry() == NPC_ANDUIN_HOPE || creature->GetEntry() == NPC_ANDUIN_DOUBT)
                creature->DespawnOrUnsummon(3s);
    }
 
    void Register() override
    {
        AfterCast += SpellCastFn(spell_anduin_wrynn_soul_despawn::OnCast);
    }
};
 
// 368913 - Force of Will
class spell_anduin_wrynn_force_of_will : public AuraScript
{
    void RecalculateHook(AuraEffect const* /*aurEffect*/, SpellEffectValue& amount, bool& canBeRecalculated) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        // at 100 will power = 200% Damage Done increase
        int32 powerValue = caster->GetPower(caster->GetPowerType());
        amount = 2 * powerValue;
        canBeRecalculated = false;
    }
 
    void RecalculateHookDamageTaken(AuraEffect const* /*aurEffect*/, SpellEffectValue& amount, bool& canBeRecalculated) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        // Damage Taken reduction can only be capped to 90%
        int32 powerValue = caster->GetPower(caster->GetPowerType());
        amount = -std::min(powerValue, 90);
        canBeRecalculated = false;
    }
 
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        caster->SetPower(caster->GetPowerType(), 0);
    }
 
    void Register() override
    {
        OnEffectApply += AuraEffectApplyFn(spell_anduin_wrynn_force_of_will::OnApply, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE, AURA_EFFECT_HANDLE_REAL);
        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_anduin_wrynn_force_of_will::RecalculateHook, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_anduin_wrynn_force_of_will::RecalculateHook, EFFECT_1, SPELL_AURA_MOD_SUMMON_DAMAGE);
        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_anduin_wrynn_force_of_will::RecalculateHookDamageTaken, EFFECT_2, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
    }
};
 
// 363233 - March of the Damned
class spell_anduin_wrynn_march_of_the_damned : public AuraScript
{
    void OnPeriodic(AuraEffect const* aurEff)
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        Seconds raidDifficulty = 0s;
 
        switch (GetCaster()->GetMap()->GetDifficultyID())
        {
            case DIFFICULTY_LFR_NEW:
            case DIFFICULTY_NORMAL_RAID:
            case DIFFICULTY_HEROIC_RAID:
                raidDifficulty = 28s;
                break;
            case DIFFICULTY_MYTHIC_RAID:
                raidDifficulty = 21s;
                break;
            default:
                raidDifficulty = 28s;
                break;
        }
 
        // Don't summon the wall on aura granted
        if (aurEff->GetTickNumber() == 1)
            return;
 
        if (_availableSpawnPositions.empty())
            return;
 
        Position chosenPosition = Trinity::Containers::SelectRandomContainerElement(_availableSpawnPositions);
        auto it = std::find(_availableSpawnPositions.begin(), _availableSpawnPositions.end(), chosenPosition);
        _availableSpawnPositions.erase(it);
 
        GetCaster()->SummonCreature(NPC_MARCH_OF_THE_DAMNED, chosenPosition, TEMPSUMMON_TIMED_DESPAWN, raidDifficulty);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_anduin_wrynn_march_of_the_damned::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
 
    std::vector<Position> _availableSpawnPositions = { std::begin(MarchOfTheDamnedSpawnPositions), std::end(MarchOfTheDamnedSpawnPositions) };
};
 
// 362500 - Shade Spawn Ceremony
class spell_remnant_of_a_fallen_king_spawn : public AuraScript
{
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
            GetTarget()->GetAI()->DoAction(ACTION_ACTIVATE_REMNANT);
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_remnant_of_a_fallen_king_spawn::OnRemove, EFFECT_2, SPELL_AURA_TRIGGER_SPELL_ON_EXPIRE, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 365652 - Lost Soul
class spell_anduin_soul_lost_soul : public SpellScript
{
    void FilterTargets(std::list<WorldObject*>& unitList) const
    {
        unitList.remove_if([this](WorldObject const* target)
        {
            if (target->GetEntry() == NPC_ANDUIN_DOUBT && target->IsWithinDistInMap(GetCaster(), 0.2f))
                return false;
            return true;
        });
    }
 
    void HandleDummy(SpellEffIndex /*effIndex*/) const
    {
        if (Creature* creature = GetHitUnit()->ToCreature())
            creature->DespawnOrUnsummon();
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_anduin_soul_lost_soul::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
        OnEffectHitTarget += SpellEffectFn(spell_anduin_soul_lost_soul::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 367769 - Severed Soul
class spell_anduin_wrynn_severed_soul : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_CANCEL_LOST_SOUL });
    }
 
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (Unit* caster = GetCaster())
            _soulPosition = caster->GetPosition();
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        caster->CastSpell(caster, SPELL_CANCEL_LOST_SOUL, true);
 
        if (TempSummon* summon = GetTarget()->ToTempSummon())
            if (summon->GetSummonerUnit() == caster)
                caster->NearTeleportTo(_soulPosition);
    }
 
    void Register() override
    {
        OnEffectApply += AuraEffectApplyFn(spell_anduin_wrynn_severed_soul::OnApply, EFFECT_0, SPELL_AURA_LINKED_SUMMON, AURA_EFFECT_HANDLE_REAL);
        AfterEffectRemove += AuraEffectRemoveFn(spell_anduin_wrynn_severed_soul::OnRemove, EFFECT_1, SPELL_AURA_TRIGGER_SPELL_ON_EXPIRE, AURA_EFFECT_HANDLE_REAL);
    }
 
    Position _soulPosition;
};
 
// 362402 - Lost Soul Mirror Image
class spell_anduin_wrynn_lost_soul_mirror_image : public SpellScript
{
    void FilterTargets(std::list<WorldObject*>& targets) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        ObjectGuid casterGuid = caster->GetGUID();
 
        targets.remove_if([casterGuid](WorldObject const* target) -> bool
        {
            Unit const* unit = target->ToUnit();
            if (!unit)
                return true;
 
            TempSummon const* summon = unit->ToTempSummon();
            if (!summon)
                return true;
 
            if (summon->GetSummonerGUID() != casterGuid)
                return true;
 
            return false;
        });
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_anduin_wrynn_lost_soul_mirror_image::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_anduin_wrynn_lost_soul_mirror_image::FilterTargets, EFFECT_1, TARGET_UNIT_SRC_AREA_ENTRY);
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_anduin_wrynn_lost_soul_mirror_image::FilterTargets, EFFECT_2, TARGET_UNIT_SRC_AREA_ENTRY);
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_anduin_wrynn_lost_soul_mirror_image::FilterTargets, EFFECT_3, TARGET_UNIT_SRC_AREA_ENTRY);
    }
};
 
// 363029 - Soul Explosion
class spell_friendish_soul_explosion : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_SOUL_EXPLOSION_TRIGGER_MISSILE });
    }
 
    void FilterTargets(std::list<WorldObject*>& targets) const
    {
        if (targets.empty())
            return;
 
        targets.remove_if(Trinity::ObjectTypeIdCheck(TYPEID_PLAYER, false));
 
        std::vector<WorldObject*> rangedTargets;
        for (WorldObject* target : targets)
        {
            if (target->GetDistance(GetCaster()) >= 5.0f)
            {
                rangedTargets.push_back(target);
                break;
            }
        }
 
        if (!rangedTargets.empty())
        {
            targets.clear();
            targets.push_back(Trinity::Containers::SelectRandomContainerElement(rangedTargets));
        }
    }
 
    void HandleMissile(SpellEffIndex /*effIndex*/) const
    {
        GetCaster()->CastSpell(GetHitUnit(), SPELL_SOUL_EXPLOSION_TRIGGER_MISSILE, true);
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_friendish_soul_explosion::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
        OnEffectHitTarget += SpellEffectFn(spell_friendish_soul_explosion::HandleMissile, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 363022 - Return to Kingsmourne
class spell_remnant_of_a_fallen_king_return_to_kingsmourne_applied : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_RETURN_TO_KINGSMOURNE_VISUALS });
    }
 
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        caster->CastSpell(caster, SPELL_RETURN_TO_KINGSMOURNE_VISUALS);
    }
 
    void Register() override
    {
        OnEffectApply += AuraEffectApplyFn(spell_remnant_of_a_fallen_king_return_to_kingsmourne_applied::OnApply, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 363021 - Return to Kingsmourne
class spell_remnant_of_a_fallen_king_return_to_kingsmourne : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo(
        {
            SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER,
            SPELL_CANCEL_FORCE_OF_WILL
        });
    }
 
    void AfterRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        InstanceScript* instance = caster->GetInstanceScript();
        if (!instance)
            return;
 
        if (Creature* arthas = instance->GetCreature(DATA_REMNANT_OF_A_FALLEN_KING))
            arthas->AI()->EnterEvadeMode(EvadeReason::Other);
 
        if (Creature* anduin = instance->GetCreature(DATA_ANDUIN_WRYNN))
        {
            anduin->RemoveAurasDueToSpell(SPELL_DOMINATION_GRASP_ROOT_AREATRIGGER);
            instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_INTERMISSION, 0);
            instance->DoUpdateWorldState(WORLD_STATE_ANDUIN_ENCOUNTER_STARTED, 1);
            if (anduin->IsAIEnabled())
            {
                anduin->AI()->DoAction(ACTION_EXIT_INTERMISSION);
                anduin->AI()->DoCastSelf(SPELL_CANCEL_FORCE_OF_WILL);
            }
        }
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_remnant_of_a_fallen_king_return_to_kingsmourne::AfterRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 365120 - Grim Reflections
class spell_anduin_wrynn_grim_reflections : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_GRIM_REFLECTIONS_SUMMON });
    }
 
    void HandleCast() const
    {
        uint8 reflectionsNumber = GetCaster()->GetMap()->IsMythic() ? 4 : 3;
        std::vector<Position> grimReflectionPositions(std::begin(GrimReflectionsSpawnPositions), std::end(GrimReflectionsSpawnPositions));
        Trinity::Containers::RandomResize(grimReflectionPositions, reflectionsNumber);
 
        for (uint8 i = 0; i < reflectionsNumber; i++)
            GetCaster()->CastSpell(grimReflectionPositions[i], SPELL_GRIM_REFLECTIONS_SUMMON, true);
    }
 
    void Register() override
    {
        OnCast += SpellCastFn(spell_anduin_wrynn_grim_reflections::HandleCast);
    }
};
 
// 365872 - Beacon of Hope
class spell_anduin_wrynn_beacon_of_hope : public SpellScript
{
    void OnCast() const
    {
        GetCaster()->SummonCreature(NPC_BEACON_OF_HOPE, BeaconOfHopeSpawnPosition, TEMPSUMMON_MANUAL_DESPAWN);
    }
 
    void Register() override
    {
        AfterCast += SpellCastFn(spell_anduin_wrynn_beacon_of_hope::OnCast);
    }
};
 
// 365958 - Hopelessness
class spell_anduin_wrynn_hopelessness : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo(
        {
            SPELL_BLASPHEMY_PRE_HIT,
            SPELL_HOPELESSNESS_MISSILE
        });
    }
 
    void OnPrecast() override
    {
        GetCaster()->CastSpell(GetCaster(), SPELL_BLASPHEMY_PRE_HIT, true);
    }
 
    void HandleDebuff(SpellEffIndex /*effIndex*/) const
    {
        GetCaster()->CastSpell(GetHitUnit(), SPELL_HOPELESSNESS_MISSILE, true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_anduin_wrynn_hopelessness::HandleDebuff, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 365966 - Hopelessness CreatePropertiesId 24443
struct at_anduin_wrynn_hopelessness : AreaTriggerAI
{
    at_anduin_wrynn_hopelessness(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger)  { }
 
    void OnUnitEnter(Unit* unit) override
    {
        if (!unit->IsPlayer() || unit->HasAura(SPELL_BLASPHEMY_PRE_HIT))
            return;
 
        if (!unit->IsAlive())
        {
            at->Remove();
            return;
        }
 
        if (unit->HasAura(at->GetSpellId()))
        {
            unit->CastSpell(unit, SPELL_BLASPHEMY_EXPLODE, true);
            if (Unit* target = at->GetTarget())
                target->CastSpell(target, SPELL_BLASPHEMY_EXPLODE, true);
        }
    }
 
    void OnUnitExit(Unit* unit, AreaTriggerExitReason /*reason*/) override
    {
        if (!unit->IsAlive() && unit->HasAura(at->GetSpellId()))
            unit->RemoveAurasDueToSpell(at->GetSpellId());
    }
};
 
// 365966 - Hopelessness
class spell_anduin_wrynn_hopelessness_expire : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_HOPELESSNESS_EXPLODE });
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) const
    {
        switch (GetTargetApplication()->GetRemoveMode())
        {
            case AURA_REMOVE_BY_ENEMY_SPELL:
            case AURA_REMOVE_BY_EXPIRE:
            case AURA_REMOVE_BY_DEATH:
                GetTarget()->CastSpell(GetTarget(), SPELL_HOPELESSNESS_EXPLODE, true);
                break;
            default:
                break;
        }
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_anduin_wrynn_hopelessness_expire::OnRemove, EFFECT_0, SPELL_AURA_AREA_TRIGGER, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 365291 - Remnant Timer
class spell_remnant_of_a_fallen_king_energize_runic_power : public AuraScript
{
    static constexpr std::array<int32, 3> RemnantRegenCycle = { 1, 1, 2 };
 
    void HandlePeriodic(AuraEffect const* /*aurEff*/)
    {
        Unit* target = GetTarget();
        int32 powerGained = RemnantRegenCycle[_powerRegenCycle++];
 
        if (_powerRegenCycle > 2)
            _powerRegenCycle = 1;
 
        target->ModifyPower(target->GetPowerType(), powerGained);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_remnant_of_a_fallen_king_energize_runic_power::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
 
    uint8 _powerRegenCycle = 0;
};
 
// 362862 - Army of the Dead
class spell_remnant_of_a_fallen_king_army_of_the_dead : public SpellScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_ECHOES_OF_ANDORHAL_MONSTROUS_SOUL });
    }
 
    void HandleAfterCast() const
    {
        if (GetCaster()->GetMap()->IsLFR())
            return;
 
        Position monstrousSoulSpawnPosition = GetCaster()->GetNearPosition(frand(30.0f, 50.0f), frand(0.0f, 3.5f));
        GetCaster()->CastSpell(monstrousSoulSpawnPosition, SPELL_ECHOES_OF_ANDORHAL_MONSTROUS_SOUL, true);
    }
 
    void Register() override
    {
        AfterCast += SpellCastFn(spell_remnant_of_a_fallen_king_army_of_the_dead::HandleAfterCast);
    }
};
 
// 362543 - Remorseless Winter
class spell_remnant_of_a_fallen_king_remorseless_winter_periodic : public AuraScript
{
    void OnPeriodic(AuraEffect const* /*aurEff*/) const
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        caster->CastSpell(GetTarget(), SPELL_REMORSELESS_WINTER_DEBUFF_DAMAGE, true);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_remnant_of_a_fallen_king_remorseless_winter_periodic::OnPeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 362545 - Remorseless Winter
class spell_remnant_of_a_fallen_king_remorseless_winter_damage : public SpellScript
{
    void HandleDamage(SpellEffIndex /*effIndex*/)
    {
        Unit* caster = GetCaster();
        if (!caster)
            return;
 
        Aura* remorselessWinter = GetHitUnit()->GetAura(SPELL_REMORSELESS_WINTER_PERIODIC);
        if (!remorselessWinter)
            return;
 
        SetHitDamage(int32(GetHitDamage() * remorselessWinter->GetStackAmount()));
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_remnant_of_a_fallen_king_remorseless_winter_damage::HandleDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
    }
};
 
// 362771 - Soul Reaper
class spell_remnant_of_a_fallen_king_soul_reaper : public SpellScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo
        ({
            SPELL_SOUL_REAPER_PHYSICAL_DAMAGE,
            SPELL_SOUL_REAPER_SHADOWFROST_DAMAGE,
            SPELL_SOUL_REAPER_DEBUFF,
            SPELL_SOUL_REAPER_ATTACK_SPEED,
        });
    }
 
    void HandleDummyEffect(SpellEffIndex /*effIndex*/) const
    {
        Unit* caster = GetCaster();
        Unit* hitUnit = GetHitUnit();
        caster->CastSpell(hitUnit, SPELL_SOUL_REAPER_PHYSICAL_DAMAGE, true);
        caster->CastSpell(hitUnit, SPELL_SOUL_REAPER_SHADOWFROST_DAMAGE, true);
        caster->CastSpell(hitUnit, SPELL_SOUL_REAPER_DEBUFF, true);
        caster->CastSpell(caster, SPELL_SOUL_REAPER_ATTACK_SPEED, true);
        caster->resetAttackTimer(BASE_ATTACK);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_remnant_of_a_fallen_king_soul_reaper::HandleDummyEffect, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// Anduin Wrynn Introduction Custom AT
struct at_anduin_wrynn_pre_introduction : AreaTriggerAI
{
    at_anduin_wrynn_pre_introduction(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger) { }
 
    void OnUnitEnter(Unit* unit) override
    {
        Player* player = unit->ToPlayer();
        if (!player || player->IsGameMaster())
            return;
 
        InstanceScript* instance = at->GetInstanceScript();
        if (!instance)
            return;
 
        if (Creature* anduin = instance->GetCreature(DATA_ANDUIN_WRYNN))
            anduin->GetAI()->DoAction(ACTION_START_PRE_INTRODUCTION);
 
        at->Remove();
    }
};
 
// 956 - Anduin End Movie
class movie_anduin_final : public PlayerScript
{
public:
    movie_anduin_final() : PlayerScript("movie_anduin_final") { }
 
    void MarkPlayerAsSkipped(uint32 playerId)
    {
        _skippedPlayers.insert(playerId);
    }
 
    void OnMovieComplete(Player* player, uint32 /*movieId*/) override
    {
        InstanceScript* instance = player->GetInstanceScript();
        if (!instance)
            return;
 
        Creature* anduin = instance->GetCreature(DATA_ANDUIN_WRYNN);
        if (!anduin)
            return;
 
        MarkPlayerAsSkipped(static_cast<uint32>(player->GetGUID().GetCounter()));
        player->RemoveAurasDueToSpell(SPELL_FINAL_MOVIE);
 
        // Outroduction must start once every player skips or completes the movie
        if (_skippedPlayers.size() == player->GetMap()->GetPlayersCountExceptGMs())
            anduin->GetAI()->DoAction(ACTION_START_OUTRODUCTION);
    }
 
private:
    std::unordered_set<uint32> _skippedPlayers;
};
 
void AddSC_boss_anduin_wrynn()
{
    RegisterSepulcherOfTheFirstOnesCreatureAI(boss_anduin_wrynn);
    RegisterSepulcherOfTheFirstOnesCreatureAI(boss_remnant_of_a_fallen_king);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_sylvanas);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_jaina);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_uther);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_empty_vessel);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_lost_soul);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_anduin_soul);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_anduin_despair);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_anduin_doubt);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_anduin_hope);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_monstrous_soul);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_fiendish_soul);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_grim_reflection);
    RegisterSepulcherOfTheFirstOnesCreatureAI(npc_anduin_wrynn_beacon_of_hope);
 
    RegisterAreaTriggerAI(at_anduin_wrynn_pre_introduction);
    RegisterSpellScript(spell_anduin_wrynn_pre_introduction);
    RegisterSpellScript(spell_anduin_wrynn_progression_aura);
    RegisterSpellScript(spell_anduin_wrynn_energize_willpower_lfr);
    RegisterSpellScript(spell_anduin_wrynn_dark_zeal);
    RegisterSpellScript(spell_anduin_wrynn_hopebreaker);
    RegisterSpellScript(spell_anduin_wrynn_hopebreaker_periodic);
    RegisterSpellScript(spell_anduin_wrynn_hopebreaker_damage);
    RegisterAreaTriggerAI(at_anduin_wrynn_befouled_barrier);
    RegisterSpellScript(spell_anduin_wrynn_befouled_barrier_absorb);
    RegisterSpellScript(spell_anduin_wrynn_befouled_barrier_expire);
    RegisterAreaTriggerAI(at_anduin_wrynn_blasphemy);
    RegisterSpellScript(spell_anduin_wrynn_blasphemy);
    RegisterSpellScript(spell_anduin_wrynn_hopelessness_overconfidence);
    RegisterAreaTriggerAI(at_anduin_wrynn_wicked_star);
    RegisterAreaTriggerAI(at_anduin_wrynn_empowered_wicked_star);
    RegisterSpellAndAuraScriptPair(spell_anduin_wrynn_wicked_star_selector, spell_anduin_wrynn_wicked_star_selector_AuraScript);
    RegisterSpellAndAuraScriptPairWithArgs(spell_anduin_wrynn_wicked_star_selector, spell_anduin_wrynn_empowered_wicked_star_selector_AuraScript, "spell_anduin_wrynn_empowered_wicked_star_selector");
    RegisterSpellScript(spell_anduin_wrynn_kingsmourne_hungers);
    RegisterSpellScript(spell_anduin_soul_lost_soul);
    RegisterSpellScript(spell_anduin_wrynn_lost_soul);
    RegisterSpellScript(spell_anduin_wrynn_lost_soul_mirror_image);
    RegisterSpellScript(spell_anduin_wrynn_severed_soul);
    RegisterSpellScript(spell_anduin_wrynn_soul_despawn);
    RegisterSpellScript(spell_anduin_rain_of_despair_player_selector);
    RegisterSpellScript(spell_anduin_wrynn_force_of_will);
    RegisterAreaTriggerAI(at_anduin_wrynn_march_of_the_damned);
    RegisterSpellScript(spell_anduin_wrynn_march_of_the_damned);
    RegisterSpellScript(spell_friendish_soul_explosion);
    RegisterSpellScript(spell_anduin_wrynn_grim_reflections);
    RegisterAreaTriggerAI(at_anduin_wrynn_beacon_of_hope);
    RegisterSpellScript(spell_anduin_wrynn_beacon_of_hope);
    RegisterAreaTriggerAI(at_anduin_wrynn_hopelessness);
    RegisterSpellScript(spell_anduin_wrynn_hopelessness);
    RegisterSpellScript(spell_anduin_wrynn_hopelessness_expire);
    RegisterSpellScript(spell_anduin_wrynn_fragment_of_hope);
 
    RegisterSpellScript(spell_remnant_of_a_fallen_king_spawn);
    RegisterSpellScript(spell_remnant_of_a_fallen_king_energize_runic_power);
    RegisterSpellScript(spell_remnant_of_a_fallen_king_army_of_the_dead);
    RegisterSpellScript(spell_remnant_of_a_fallen_king_soul_reaper);
    RegisterSpellScript(spell_remnant_of_a_fallen_king_remorseless_winter_periodic);
    RegisterSpellScript(spell_remnant_of_a_fallen_king_remorseless_winter_damage);
    RegisterSpellScript(spell_remnant_of_a_fallen_king_return_to_kingsmourne);
    RegisterSpellScript(spell_remnant_of_a_fallen_king_return_to_kingsmourne_applied);
 
    new movie_anduin_final();
}