boss_thorim.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "ScriptMgr.h"
#include "AreaBoundary.h"
#include "CellImpl.h"
#include "Containers.h"
#include "GridNotifiersImpl.h"
#include "InstanceScript.h"
#include "MotionMaster.h"
#include "MoveSplineInit.h"
#include "ObjectAccessor.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "SpellMgr.h"
#include "SpellScript.h"
#include "ulduar.h"
#include <G3D/Vector3.h>
 
enum Spells
{
    // Thorim
    SPELL_SHEATH_OF_LIGHTNING                   = 62276,
    SPELL_STORMHAMMER                           = 62042,
    SPELL_STORMHAMMER_SIF                       = 64767,
    SPELL_STORMHAMMER_BOOMERANG                 = 64909,
    SPELL_DEAFENING_THUNDER                     = 62470,
    SPELL_CHARGE_ORB                            = 62016,
    SPELL_SUMMON_LIGHTNING_ORB                  = 62391,
    SPELL_LIGHTNING_DESTRUCTION                 = 62393,
    SPELL_TOUCH_OF_DOMINION                     = 62507,
    SPELL_TOUCH_OF_DOMINION_TRIGGERED           = 62565,
    SPELL_CHAIN_LIGHTNING                       = 62131,
    SPELL_LIGHTNING_ORB_CHARGED                 = 62186, // wrong duration, triggered spell should handle lightning release
    SPELL_LIGHTNING_CHARGE                      = 62279,
    SPELL_LIGHTNING_RELEASE                     = 62466,
    SPELL_LIGHTNING_PILLAR_2                    = 62976, // caster high position, target low position
    SPELL_LIGHTNING_PILLAR_1                    = 63238, // caster high position, target low position
    SPELL_UNBALANCING_STRIKE                    = 62130,
    SPELL_BERSERK_PHASE_1                       = 62560,
    SPELL_BERSERK_PHASE_2                       = 62555,
    SPELL_ACTIVATE_LIGHTNING_ORB_PERIODIC       = 62184,
 
    // Credits
    SPELL_CREDIT_SIFFED                         = 64980,
    SPELL_CREDIT_KILL                           = 64985,
 
    // Lightning Field
    SPELL_LIGHTNING_FIELD                       = 64972,
    SPELL_LIGHTNING_BEAM_CHANNEL                = 45537,
 
    // Sif
    SPELL_BLIZZARD                              = 62577,
    SPELL_BLINK                                 = 62578,
    SPELL_FROSTBOLT_VOLLEY                      = 62580,
    SPELL_FROSTBOLT                             = 62583,
    SPELL_FROSTNOVA                             = 62597,
    SPELL_SIF_TRANSFORM                         = 64778,
 
    // Runic Colossus
    SPELL_SMASH                                 = 62339,
    SPELL_RUNIC_BARRIER                         = 62338,
    SPELL_RUNIC_CHARGE                          = 62613,
    SPELL_RUNIC_SMASH                           = 62465,
    SPELL_RUNIC_SMASH_RIGHT                     = 62057,
    SPELL_RUNIC_SMASH_LEFT                      = 62058,
 
    // Ancient Rune Giant
    SPELL_RUNIC_FORTIFICATION                   = 62942,
    SPELL_RUNE_DETONATION                       = 62526,
};
 
#define SPELL_STOMP RAID_MODE<uint32>(62411,62413)
 
enum Phases
{
    PHASE_NULL,
    PHASE_1,
    PHASE_2
};
 
enum Events
{
    // Thorim
    EVENT_SAY_AGGRO_2 = 1,
    EVENT_SAY_SIF_START,
    EVENT_START_SIF_CHANNEL,
    EVENT_STORMHAMMER,
    EVENT_CHARGE_ORB,
    EVENT_SUMMON_ADDS,
    EVENT_BERSERK,
    EVENT_JUMPDOWN,
    EVENT_UNBALANCING_STRIKE,
    EVENT_CHAIN_LIGHTNING,
    EVENT_START_PERIODIC_CHARGE,
    EVENT_LIGHTNING_CHARGE,
    EVENT_ACTIVATE_LIGHTNING_FIELD,
    EVENT_OUTRO_1,
    EVENT_OUTRO_2,
    EVENT_OUTRO_3,
 
    // Runic Colossus
    EVENT_RUNIC_BARRIER,
    EVENT_SMASH,
    EVENT_RUNIC_CHARGE,
    EVENT_RUNIC_SMASH,
 
    // Ancient Rune Giant
    EVENT_RUNIC_FORTIFICATION,
    EVENT_STOMP,
    EVENT_RUNE_DETONATION,
 
    // Arena NPC
    EVENT_PRIMARY_ABILITY,
    EVENT_SECONDARY_ABILITY,
    EVENT_THIRD_ABILITY,
    EVENT_ABILITY_CHARGE,
 
    // Sif
    EVENT_BLINK,
    EVENT_FROST_NOVA,
    EVENT_FROSTBOLT,
    EVENT_FROSTBOLT_VOLLEY,
    EVENT_BLIZZARD
};
 
enum Yells
{
    // Thorim
    SAY_AGGRO_1                                 = 0,
    SAY_AGGRO_2                                 = 1,
    SAY_SPECIAL                                 = 2,
    SAY_JUMPDOWN                                = 3,
    SAY_SLAY                                    = 4,
    SAY_BERSERK                                 = 5,
    SAY_WIPE                                    = 6,
    SAY_DEATH                                   = 7,
    SAY_END_NORMAL_1                            = 8,
    SAY_END_NORMAL_2                            = 9,
    SAY_END_NORMAL_3                            = 10,
    SAY_END_HARD_1                              = 11,
    SAY_END_HARD_2                              = 12,
    SAY_END_HARD_3                              = 13,
 
    // Runic Colossus
    EMOTE_RUNIC_BARRIER                         = 0,
 
    // Ancient Rune Giant
    EMOTE_RUNIC_MIGHT                           = 0,
 
    // Sif
    SAY_SIF_START                               = 0,
    SAY_SIF_DESPAWN                             = 1,
    SAY_SIF_EVENT                               = 2
};
 
enum PreAddSpells
{
    SPELL_ACID_BREATH               = 62315,
    SPELL_SWEEP                     = 62316,
 
    SPELL_DEVASTATE                 = 62317,
    SPELL_HEROIC_SWIPE              = 62444,
    SPELL_SUNDER_ARMOR              = 57807,
 
    SPELL_BARBED_SHOT               = 62318,
    SPELL_SHOOT                     = 16496,
 
    SPELL_RENEW                     = 62333,
    SPELL_GREATER_HEAL              = 62334, 
    SPELL_CIRCLE_OF_HEALING         = 61964,
 
    SPELL_HOLY_SMITE                = 62335,
 
    SPELL_LEAP                      = 61934,
 
    SPELL_CHARGE                    = 32323,
    SPELL_MORTAL_STRIKE             = 35054,
    SPELL_WHIRLWIND                 = 33500,
 
    SPELL_LOW_BLOW                  = 62326,
    SPELL_PUMMEL                    = 38313,
 
    SPELL_RUNIC_LIGHTNING           = 62327,
    SPELL_RUNIC_MENDING             = 62328,
    SPELL_RUNIC_SHIELD              = 62321,
 
    SPELL_RUNIC_STRIKE              = 62322,
    SPELL_AURA_OF_CELERITY          = 62320,
    SPELL_AURA_OF_CELERITY_VISUAL   = 62398,
 
    SPELL_IMPALE                    = 62331,
    SPELL_WHIRLING_TRIP             = 64151,
 
    SPELL_CLEAVE                    = 42724,
    SPELL_HAMSTRING                 = 48639,
    SPELL_SHIELD_SMASH              = 62332,
};
 
enum TrashTypes
{
    // Pre Phase Trash
    BEHEMOTH,
    MERCENARY_CAPTAIN,
    MERCENARY_SOLDIER,
 
    // Arena Phase Trash
    DARK_RUNE_CHAMPION,
    DARK_RUNE_WARBRINGER,
    DARK_RUNE_COMMONER,
    DARK_RUNE_EVOKER,
 
    // Hall Way Trash
    IRON_RING_GUARD,
    IRON_HONOR_GUARD,
 
    // Shared
    DARK_RUNE_ACOLYTE
};
 
struct ThorimTrashInfo
{
    uint32 Type;
    uint32 Entry;
    uint32 PrimaryAbility;
    uint32 SecondaryAbility;
    uint32 ThirdAbility;
};
 
uint8 const ThorimTrashCount = 13;
ThorimTrashInfo const StaticThorimTrashInfo[ThorimTrashCount] =
{
    // Pre Phase
    { BEHEMOTH,             NPC_JORMUNGAR_BEHEMOTH,    SPELL_ACID_BREATH,     SPELL_SWEEP,        0                       },
    { MERCENARY_CAPTAIN,    NPC_MERCENARY_CAPTAIN_A,   SPELL_DEVASTATE,       SPELL_HEROIC_SWIPE, SPELL_SUNDER_ARMOR      },
    { MERCENARY_SOLDIER,    NPC_MERCENARY_SOLDIER_A,   SPELL_BARBED_SHOT,     SPELL_SHOOT,        0                       },
    { DARK_RUNE_ACOLYTE,    NPC_DARK_RUNE_ACOLYTE_PRE, SPELL_RENEW,           SPELL_GREATER_HEAL, SPELL_CIRCLE_OF_HEALING },
    { MERCENARY_CAPTAIN,    NPC_MERCENARY_CAPTAIN_H,   SPELL_DEVASTATE,       SPELL_HEROIC_SWIPE, SPELL_SUNDER_ARMOR      },
    { MERCENARY_SOLDIER,    NPC_MERCENARY_SOLDIER_H,   SPELL_BARBED_SHOT,     SPELL_SHOOT,        0                       },
 
    // Arena Phase
    { DARK_RUNE_CHAMPION,   NPC_DARK_RUNE_CHAMPION,    SPELL_MORTAL_STRIKE,   SPELL_WHIRLWIND,    0                       },
    { DARK_RUNE_WARBRINGER, NPC_DARK_RUNE_WARBRINGER,  SPELL_RUNIC_STRIKE,    0,                  0                       },
    { DARK_RUNE_EVOKER,     NPC_DARK_RUNE_EVOKER,      SPELL_RUNIC_LIGHTNING, SPELL_RUNIC_SHIELD, SPELL_RUNIC_MENDING     },
    { DARK_RUNE_COMMONER,   NPC_DARK_RUNE_COMMONER,    SPELL_LOW_BLOW,        SPELL_PUMMEL,       0                       },
 
    // Hall Way
    { IRON_RING_GUARD,      NPC_IRON_RING_GUARD,       SPELL_WHIRLING_TRIP,   SPELL_IMPALE,       0                       },
    { IRON_HONOR_GUARD,     NPC_IRON_HONOR_GUARD,      SPELL_CLEAVE,          SPELL_SHIELD_SMASH, 0                       },
    { DARK_RUNE_ACOLYTE,    NPC_DARK_RUNE_ACOLYTE,     SPELL_RENEW,           SPELL_GREATER_HEAL, 0                       }
};
 
enum Actions
{
    ACTION_INCREASE_PREADDS_COUNT,
    ACTION_ACTIVATE_RUNIC_SMASH,
    ACTION_ACTIVATE_ADDS,
    ACTION_PILLAR_CHARGED,
    ACTION_START_HARD_MODE,
    ACTION_BERSERK
};
 
struct SummonLocation
{
    Position pos;
    uint32 entry;
};
 
SummonLocation const PreAddLocations[] =
{
    { { 2149.68f, -263.477f, 419.679f, 3.120f }, NPC_JORMUNGAR_BEHEMOTH    },
    { { 2131.31f, -271.640f, 419.840f, 2.188f }, NPC_MERCENARY_CAPTAIN_A   },
    { { 2127.24f, -259.182f, 419.974f, 5.917f }, NPC_MERCENARY_SOLDIER_A   },
    { { 2123.32f, -254.770f, 419.840f, 6.170f }, NPC_MERCENARY_SOLDIER_A   },
    { { 2120.10f, -258.990f, 419.840f, 6.250f }, NPC_MERCENARY_SOLDIER_A   },
    { { 2129.09f, -277.142f, 419.756f, 1.222f }, NPC_DARK_RUNE_ACOLYTE_PRE }
};
 
SummonLocation const ColossusAddLocations[] =
{
    { { 2218.38f, -297.50f, 412.18f, 1.030f }, NPC_IRON_RING_GUARD   },
    { { 2235.07f, -297.98f, 412.18f, 1.613f }, NPC_IRON_RING_GUARD   },
    { { 2235.26f, -338.34f, 412.18f, 1.589f }, NPC_IRON_RING_GUARD   },
    { { 2217.69f, -337.39f, 412.18f, 1.241f }, NPC_IRON_RING_GUARD   },
    { { 2227.58f, -308.30f, 412.18f, 1.591f }, NPC_DARK_RUNE_ACOLYTE },
    { { 2227.47f, -345.37f, 412.18f, 1.566f }, NPC_DARK_RUNE_ACOLYTE }
};
 
SummonLocation const GiantAddLocations[] =
{
    { { 2198.05f, -428.77f, 419.95f, 6.056f }, NPC_IRON_HONOR_GUARD  },
    { { 2220.31f, -436.22f, 412.26f, 1.064f }, NPC_IRON_HONOR_GUARD  },
    { { 2158.88f, -441.73f, 438.25f, 0.127f }, NPC_IRON_HONOR_GUARD  },
    { { 2198.29f, -436.92f, 419.95f, 0.261f }, NPC_DARK_RUNE_ACOLYTE },
    { { 2230.93f, -434.27f, 412.26f, 1.931f }, NPC_DARK_RUNE_ACOLYTE }
};
 
Position const SifSpawnPosition = { 2148.301f, -297.8453f, 438.3308f, 2.687807f };
 
enum Data
{
    DATA_CHARGED_PILLAR                     = 1
};
 
enum DisplayIds
{
    THORIM_WEAPON_DISPLAY_ID                = 45900
};
 
G3D::Vector3 const LightningOrbPath[] =
{
    { 2134.889893f, -298.632996f, 438.247467f },
    { 2134.570068f, -440.317993f, 438.247467f },
    { 2167.820312f, -440.330261f, 438.247589f },
    { 2213.394287f, -433.318298f, 412.665863f },
    { 2227.766113f, -433.275818f, 412.177032f },
    { 2227.551270f, -263.081085f, 412.176880f },
    { 2202.208008f, -262.939270f, 412.168976f },
    { 2182.310059f, -263.233093f, 414.739410f }
};
 
// used for trash jump calculation
Position const ArenaCenter = { 2134.77f, -262.307f };
 
// used for lightning field calculation
Position const LightningFieldCenter = { 2135.178f, -321.122f };
 
CircleBoundary const ArenaFloorCircle(ArenaCenter, 45.4f);
CircleBoundary const InvertedBalconyCircle(LightningFieldCenter, 32.0f, true);
 
CreatureBoundary const ArenaBoundaries =
{
    &ArenaFloorCircle,
    &InvertedBalconyCircle
};
 
class HeightPositionCheck
{
    public:
        HeightPositionCheck(bool ret) : _ret(ret) { }
 
        bool operator()(Position const* pos) const
        {
            return (pos->GetPositionZ() > THORIM_BALCONY_Z_CHECK) == _ret;
        }
 
    private:
        bool _ret;
 
        static float const THORIM_BALCONY_Z_CHECK;
};
float const HeightPositionCheck::THORIM_BALCONY_Z_CHECK = 428.0f;
 
class RunicSmashExplosionEvent : public BasicEvent
{
    public:
        RunicSmashExplosionEvent(Creature* owner) : _owner(owner) { }
 
        bool Execute(uint64 /*eventTime*/, uint32 /*updateTime*/) override
        {
            _owner->CastSpell(nullptr, SPELL_RUNIC_SMASH);
            return true;
        }
 
    private:
        Creature* _owner;
};
 
class TrashJumpEvent : public BasicEvent
{
    public:
        TrashJumpEvent(Creature* owner) : _owner(owner), _stage(0) { }
 
        bool Execute(uint64 eventTime, uint32 /*updateTime*/) override
        {
            switch (_stage)
            {
                case 0:
                    _owner->CastSpell(nullptr, SPELL_LEAP);
                    ++_stage;
                    _owner->m_Events.AddEvent(this, Milliseconds(eventTime) + 2s);
                    return false;
                case 1:
                    _owner->SetReactState(REACT_AGGRESSIVE);
                    _owner->AI()->DoZoneInCombat(_owner);
                    _owner->AI()->SetBoundary(&ArenaBoundaries);
                    return true;
                default:
                    break;
            }
 
            return true;
        }
 
    private:
        Creature* _owner;
        uint8 _stage;
};
 
class LightningFieldEvent : public BasicEvent
{
    public:
        LightningFieldEvent(Creature* owner) : _owner(owner) { }
 
        bool Execute(uint64 eventTime, uint32 /*updateTime*/) override
        {
            if (InstanceScript* instance = _owner->GetInstanceScript())
            {
                if (instance->GetBossState(DATA_THORIM) == IN_PROGRESS)
                {
                    _owner->CastSpell(nullptr, SPELL_LIGHTNING_FIELD);
                    _owner->m_Events.AddEvent(this, Milliseconds(eventTime) + 1s);
                    return false;
                }
            }
 
            _owner->InterruptNonMeleeSpells(false);
            _owner->AI()->EnterEvadeMode();
            return true;
        }
 
    private:
        Creature* _owner;
};
 
class boss_thorim : public CreatureScript
{
    public:
        boss_thorim() : CreatureScript("boss_thorim") { }
 
        struct boss_thorimAI : public BossAI
        {
            boss_thorimAI(Creature* creature) : BossAI(creature, DATA_THORIM)
            {
                _encounterFinished = false;
                Initialize();
            }
 
            void Initialize()
            {
                _killedCount = 0;
                _waveType = 0;
                _hardMode = true;
                _orbSummoned = false;
                _dontStandInTheLightning = true;
            }
 
            void Reset() override
            {
                if (_encounterFinished)
                    return;
 
                SetBoundary(nullptr);
                _Reset();
                Initialize();
 
                me->SetReactState(REACT_PASSIVE);
                me->SetDisableGravity(true);
                me->SetControlled(true, UNIT_STATE_ROOT);
                me->SetImmuneToPC(true);
 
                events.SetPhase(PHASE_NULL);
 
                // Respawn Mini Bosses
                for (uint8 i = DATA_RUNIC_COLOSSUS; i <= DATA_RUNE_GIANT; ++i)
                    if (Creature* miniBoss = ObjectAccessor::GetCreature(*me, instance->GetGuidData(i)))
                        miniBoss->Respawn(true);
 
                // Spawn Pre Phase Adds
                for (SummonLocation const& s : PreAddLocations)
                    me->SummonCreature(s.entry, s.pos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3s);
 
                if (GameObject* lever = instance->GetGameObject(DATA_THORIM_LEVER))
                    lever->SetFlag(GO_FLAG_NOT_SELECTABLE);
 
                // Remove trigger auras
                if (Creature* pillar = ObjectAccessor::GetCreature(*me, _activePillarGUID))
                    pillar->RemoveAllAuras();
 
                if (Creature* controller = instance->GetCreature(DATA_THORIM_CONTROLLER))
                    controller->RemoveAllAuras();
 
                _activePillarGUID.Clear();
            }
 
            void EnterEvadeMode(EvadeReason /*why*/) override
            {
                summons.DespawnAll();
                _DespawnAtEvade();
            }
 
            void SetGUID(ObjectGuid const& guid, int32 id) override
            {
                if (id == DATA_CHARGED_PILLAR)
                {
                    _activePillarGUID = guid;
 
                    if (Creature* pillar = ObjectAccessor::GetCreature(*me, _activePillarGUID))
                    {
                        pillar->CastSpell(pillar, SPELL_LIGHTNING_ORB_CHARGED, true);
                        pillar->CastSpell(nullptr, SPELL_LIGHTNING_PILLAR_2);
                        events.ScheduleEvent(EVENT_LIGHTNING_CHARGE, 8s, 0, PHASE_2);
                    }
                }
            }
 
            void KilledUnit(Unit* who) override
            {
                if (who->GetTypeId() == TYPEID_PLAYER)
                    Talk(SAY_SLAY);
            }
 
            void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
            {
                if (spellInfo->Id == SPELL_TOUCH_OF_DOMINION_TRIGGERED)
                {
                    if (Creature* sif = instance->GetCreature(DATA_SIF))
                    {
                        sif->AI()->Talk(SAY_SIF_DESPAWN);
                        sif->DespawnOrUnsummon(6s);
                        _hardMode = false;
                    }
                }
            }
 
            void SpellHitTarget(WorldObject* target, SpellInfo const* spellInfo) override
            {
                if (target->GetTypeId() == TYPEID_PLAYER && spellInfo->Id == SPELL_LIGHTNING_RELEASE)
                    _dontStandInTheLightning = false;
            }
 
            void FinishEncounter()
            {
                if (_encounterFinished)
                    return;
 
                _encounterFinished = true;
 
                DoCastAOE(SPELL_CREDIT_KILL, true); // before change faction
 
                me->SetReactState(REACT_PASSIVE);
                me->InterruptNonMeleeSpells(true);
                me->RemoveAllAttackers();
                me->AttackStop();
                me->SetFaction(FACTION_FRIENDLY);
                me->SetUnitFlag(UNIT_FLAG_RENAME);
 
                if (Creature* controller = instance->GetCreature(DATA_THORIM_CONTROLLER))
                    controller->RemoveAllAuras();
                if (Creature* pillar = ObjectAccessor::GetCreature(*me, _activePillarGUID))
                    pillar->RemoveAllAuras();
 
                if (_hardMode)
                {
                    if (Creature* sif = instance->GetCreature(DATA_SIF))
                    {
                        summons.Despawn(sif);
                        sif->DespawnOrUnsummon(10s);
                    }
                }
 
                _JustDied();
 
                Talk(SAY_DEATH);
                events.ScheduleEvent(EVENT_OUTRO_1, 4s);
                events.ScheduleEvent(EVENT_OUTRO_2, _hardMode ? 8s : 11s);
                events.ScheduleEvent(EVENT_OUTRO_3, _hardMode ? 19s : 21s);
 
                me->m_Events.AddEvent(new UlduarKeeperDespawnEvent(me), me->m_Events.CalculateTime(35s));
            }
 
            void MovementInform(uint32 type, uint32 id) override
            {
                if (type != EFFECT_MOTION_TYPE || id != EVENT_JUMP)
                    return;
 
                ResetThreatList();
                SetBoundary(&ArenaBoundaries);
            }
 
            void JustEngagedWith(Unit* who) override
            {
                BossAI::JustEngagedWith(who);
                Talk(SAY_AGGRO_1);
 
                events.SetPhase(PHASE_1);
 
                events.ScheduleEvent(EVENT_SAY_AGGRO_2, 9s, 0, PHASE_1);
                events.ScheduleEvent(EVENT_SAY_SIF_START, 16500ms, 0, PHASE_1);
                events.ScheduleEvent(EVENT_START_SIF_CHANNEL, 22500ms, 0, PHASE_1);
 
                events.ScheduleEvent(EVENT_STORMHAMMER, 40s, 0, PHASE_1);
                events.ScheduleEvent(EVENT_CHARGE_ORB, 30s, 0, PHASE_1);
                events.ScheduleEvent(EVENT_SUMMON_ADDS, 15s, 0, PHASE_1);
                events.ScheduleEvent(EVENT_BERSERK, 369s);
 
                DoCast(me, SPELL_SHEATH_OF_LIGHTNING);
 
                if (Creature* runicColossus = instance->GetCreature(DATA_RUNIC_COLOSSUS))
                {
                    runicColossus->SetImmuneToPC(false);
                    runicColossus->AI()->DoAction(ACTION_ACTIVATE_ADDS);
                }
 
                if (GameObject* lever = instance->GetGameObject(DATA_THORIM_LEVER))
                    lever->RemoveFlag(GO_FLAG_NOT_SELECTABLE);
 
                // Summon Sif
                me->SummonCreature(NPC_SIF, SifSpawnPosition);
            }
 
            void JustSummoned(Creature* summon) override
            {
                switch (summon->GetEntry())
                {
                    case NPC_LIGHTNING_ORB:
                    {
                        summon->SetReactState(REACT_PASSIVE);
                        summon->CastSpell(summon, SPELL_LIGHTNING_DESTRUCTION, true);
 
                        std::function<void(Movement::MoveSplineInit&)> initializer = [](Movement::MoveSplineInit& init)
                        {
                            init.MovebyPath(LightningOrbPath);
                        };
                        summon->GetMotionMaster()->LaunchMoveSpline(std::move(initializer), 0, MOTION_PRIORITY_NORMAL, POINT_MOTION_TYPE);
                        break;
                    }
                    case NPC_DARK_RUNE_CHAMPION:
                    case NPC_DARK_RUNE_WARBRINGER:
                    case NPC_DARK_RUNE_EVOKER:
                    case NPC_DARK_RUNE_COMMONER:
                        summon->SetReactState(REACT_PASSIVE);
                        summon->m_Events.AddEvent(new TrashJumpEvent(summon), summon->m_Events.CalculateTime(3s));
                        break;
                    case NPC_SIF:
                        summon->SetReactState(REACT_PASSIVE);
                        break;
                    default:
                        break;
                }
 
                BossAI::JustSummoned(summon);
            }
 
            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_SAY_AGGRO_2:
                            Talk(SAY_AGGRO_2);
                            break;
                        case EVENT_SAY_SIF_START:
                            if (Creature* sif = instance->GetCreature(DATA_SIF))
                                sif->AI()->Talk(SAY_SIF_START);
                            break;
                        case EVENT_START_SIF_CHANNEL:
                            if (Creature* sif = instance->GetCreature(DATA_SIF))
                                sif->CastSpell(me, SPELL_TOUCH_OF_DOMINION);
                            break;
                        case EVENT_STORMHAMMER:
                            DoCast(SPELL_STORMHAMMER);
                            events.Repeat(15s, 20s);
                            break;
                        case EVENT_CHARGE_ORB:
                            DoCastAOE(SPELL_CHARGE_ORB);
                            events.Repeat(15s, 20s);
                            break;
                        case EVENT_SUMMON_ADDS:
                            SummonWave();
                            events.Repeat(_orbSummoned ? 3s : 10s);
                            break;
                        case EVENT_JUMPDOWN:
                            if (_hardMode)
                                if (Creature* sif = instance->GetCreature(DATA_SIF))
                                    sif->AI()->DoAction(ACTION_START_HARD_MODE);
                            me->RemoveAurasDueToSpell(SPELL_SHEATH_OF_LIGHTNING);
                            me->SetReactState(REACT_AGGRESSIVE);
                            me->SetDisableGravity(false);
                            me->SetControlled(false, UNIT_STATE_ROOT);
                            me->GetMotionMaster()->MoveJump(EVENT_JUMP, { 2134.8f, -263.056f, 419.983f }, {}, 5.0f);
                            events.ScheduleEvent(EVENT_START_PERIODIC_CHARGE, 2s, 0, PHASE_2);
                            events.ScheduleEvent(EVENT_UNBALANCING_STRIKE, 15s, 0, PHASE_2);
                            events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 20s, 0, PHASE_2);
                            break;
                        case EVENT_UNBALANCING_STRIKE:
                            DoCastVictim(SPELL_UNBALANCING_STRIKE);
                            events.Repeat(15s, 20s);
                            break;
                        case EVENT_CHAIN_LIGHTNING:
                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100.0f, true))
                                DoCast(target, SPELL_CHAIN_LIGHTNING);
                            events.Repeat(7s, 15s);
                            break;
                        case EVENT_START_PERIODIC_CHARGE:
                            if (Creature* controller = instance->GetCreature(DATA_THORIM_CONTROLLER))
                                controller->CastSpell(controller, SPELL_ACTIVATE_LIGHTNING_ORB_PERIODIC, true);
                            break;
                        case EVENT_LIGHTNING_CHARGE:
                            if (Creature* pillar = ObjectAccessor::GetCreature(*me, _activePillarGUID))
                                DoCast(pillar, SPELL_LIGHTNING_RELEASE);
                            break;
                        case EVENT_BERSERK:
                            if (events.IsInPhase(PHASE_1))
                            {
                                Talk(SAY_WIPE);
                                DoCastAOE(SPELL_BERSERK_PHASE_1, true);
                                DoCast(me, SPELL_SUMMON_LIGHTNING_ORB, true);
                            }
                            else
                            {
                                Talk(SAY_BERSERK);
                                DoCast(me, SPELL_BERSERK_PHASE_2, true);
                            }
                            break;
                        case EVENT_ACTIVATE_LIGHTNING_FIELD:
                        {
                            std::list<Creature*> triggers;
                            me->GetCreatureListWithEntryInGrid(triggers, NPC_THORIM_EVENT_BUNNY, 100.0f);
                            triggers.remove_if([](Creature* bunny)
                            {
                                if (HeightPositionCheck(false)(bunny))
                                    return true;
                                return LightningFieldCenter.GetExactDist2dSq(bunny) > 1296.0f;
                            });
 
                            Milliseconds timer = 1s;
                            for (Creature* bunny : triggers)
                                bunny->m_Events.AddEvent(new LightningFieldEvent(bunny), bunny->m_Events.CalculateTime(timer += 100ms));
 
                            triggers.remove_if([](Creature* bunny)
                            {
                                return LightningFieldCenter.GetExactDist2dSq(bunny) < 576.0f;
                            });
 
                            triggers.sort([](Creature* a, Creature* b)
                            {
                                return a->GetPositionX() < b->GetPositionX();
                            });
 
                            for (auto itr = triggers.cbegin(); itr != triggers.cend();)
                            {
                                auto prev = itr++;
                                if (itr != triggers.cend())
                                    (*prev)->CastSpell(*itr, SPELL_LIGHTNING_BEAM_CHANNEL);
                            }
                            break;
                        }
                        case EVENT_OUTRO_1:
                            Talk(_hardMode ? SAY_END_HARD_1 : SAY_END_NORMAL_1);
                            if (_hardMode)
                                DoCast(me, SPELL_STORMHAMMER_SIF);
                            break;
                        case EVENT_OUTRO_2:
                            Talk(_hardMode ? SAY_END_HARD_2 : SAY_END_NORMAL_2);
                            if (_hardMode)
                                if (Creature* sif = instance->GetCreature(DATA_SIF))
                                    sif->SetStandState(UNIT_STAND_STATE_DEAD);
                            break;
                        case EVENT_OUTRO_3:
                            Talk(_hardMode ? SAY_END_HARD_3 : SAY_END_NORMAL_3);
                            break;
                        default:
                            break;
                    }
 
                    if (me->HasUnitState(UNIT_STATE_CASTING))
                        return;
                }
            }
 
            void DoAction(int32 action) override
            {
                switch (action)
                {
                    case ACTION_BERSERK:
                        if (events.IsInPhase(PHASE_2))
                            return;
 
                        if (!_orbSummoned)
                        {
                            _orbSummoned = true;
                            events.RescheduleEvent(EVENT_BERSERK, 1s);
                        }
                        return;
                    case ACTION_INCREASE_PREADDS_COUNT:
                        if (++_killedCount >= 6)
                        {
                            // Event starts
                            me->SetImmuneToPC(false);
                            DoZoneInCombat(me);
                        }
                        break;
                    default:
                        break;
                }
            }
 
            void GetTrashSpawnTriggers(std::list<Creature*>& triggerList, uint32 count = 1)
            {
                me->GetCreatureListWithEntryInGrid(triggerList, NPC_THORIM_EVENT_BUNNY, 100.0f);
                triggerList.remove_if([](Creature* bunny)
                {
                    if (HeightPositionCheck(false)(bunny))
                        return true;
                    return ArenaCenter.GetExactDist2dSq(bunny) < 3025.0f;
                });
 
                if (triggerList.empty())
                    return;
 
                if (count == 1)
                {
                    Creature* bunny = Trinity::Containers::SelectRandomContainerElement(triggerList);
                    triggerList.clear();
                    triggerList.push_back(bunny);
                }
                else
                    Trinity::Containers::RandomResize(triggerList, count);
            }
 
            void SummonWave()
            {
                switch (_waveType)
                {
                    case 0:
                    {
                        // Dark Rune Commoner
                        std::list<Creature*> triggers;
                        GetTrashSpawnTriggers(triggers, urand(5, 6));
 
                        for (Creature* bunny : triggers)
                            me->SummonCreature(StaticThorimTrashInfo[6 + 3].Entry, *bunny, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3s);
 
                        ++_waveType;
                        break;
                    }
                    case 1:
                        if (urand(0, 1))
                        {
                            // Dark Rune Champion or Dark Rune Evoker
                            std::list<Creature*> triggers;
                            GetTrashSpawnTriggers(triggers, urand(2, 4));
 
                            for (Creature* bunny : triggers)
                                me->SummonCreature(StaticThorimTrashInfo[6 + RAND(0, 2)].Entry, *bunny, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3s);
                        }
                        else
                        {
                            // Dark Rune Warbringer
                            std::list<Creature*> triggers;
                            GetTrashSpawnTriggers(triggers);
 
                            for (Creature* bunny : triggers)
                                me->SummonCreature(StaticThorimTrashInfo[6 + 1].Entry, *bunny, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3s);
                        }
                        --_waveType;
                        break;
                }
            }
 
            bool CanStartPhase2(Unit* actor) const
            {
                if (!actor || actor->GetTypeId() != TYPEID_PLAYER || !me->IsWithinDistInMap(actor, 10.0f))
                    return false;
 
                Creature* runicColossus = instance->GetCreature(DATA_RUNIC_COLOSSUS);
                Creature* runeGiant = instance->GetCreature(DATA_RUNE_GIANT);
                return runicColossus && !runicColossus->IsAlive() && runeGiant && !runeGiant->IsAlive();
            }
 
            void DamageTaken(Unit* attacker, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
            {
                if (events.IsInPhase(PHASE_1) && CanStartPhase2(attacker))
                {
                    Talk(SAY_JUMPDOWN);
                    events.SetPhase(PHASE_2);
                    events.ScheduleEvent(EVENT_JUMPDOWN, 8s);
                    events.ScheduleEvent(EVENT_ACTIVATE_LIGHTNING_FIELD, 15s);
                    events.RescheduleEvent(EVENT_BERSERK, 300s, 0, PHASE_2);
 
                    if (Creature* sif = instance->GetCreature(DATA_SIF))
                        sif->InterruptNonMeleeSpells(false);
 
                    // Hard Mode
                    if (_hardMode)
                        DoCastAOE(SPELL_CREDIT_SIFFED, true);
                }
                else if (me->HealthBelowPctDamaged(1, damage))
                {
                    damage = 0;
                    FinishEncounter();
                }
            }
 
        private:
            ObjectGuid _activePillarGUID;
            uint8 _killedCount;
            uint8 _waveType;
            bool _hardMode;
            bool _encounterFinished;
            bool _orbSummoned;
            bool _dontStandInTheLightning;
        };
 
        CreatureAI* GetAI(Creature* creature) const override
        {
            return GetUlduarAI<boss_thorimAI>(creature);
        }
};
 
struct npc_thorim_trashAI : public ScriptedAI
{
    npc_thorim_trashAI(Creature* creature) : ScriptedAI(creature)
    {
        _instance = creature->GetInstanceScript();
        for (uint8 i = 0; i < ThorimTrashCount; ++i)
            if (me->GetEntry() == StaticThorimTrashInfo[i].Entry)
                _info = &StaticThorimTrashInfo[i];
 
        ASSERT(_info);
        if (_info->Type == DARK_RUNE_ACOLYTE)
            me->SetCanMelee(false); // DoSpellAttackIfReady
    }
 
    struct AIHelper
    {
        static uint32 GetTotalHeal(SpellInfo const* spellInfo, Unit const* caster)
        {
            SpellEffectValue heal = 0;
            for (SpellEffectInfo const& spellEffectInfo : spellInfo->GetEffects())
            {
                if (spellEffectInfo.IsEffect(SPELL_EFFECT_HEAL))
                    heal += spellEffectInfo.CalcValue(caster);
 
                if (spellEffectInfo.IsEffect(SPELL_EFFECT_APPLY_AURA) && spellEffectInfo.IsAura(SPELL_AURA_PERIODIC_HEAL))
                    heal += spellEffectInfo.GetPeriodicTickCount() * spellEffectInfo.CalcValue(caster);
            }
            return static_cast<uint32>(heal);
        }
 
        static uint32 GetRemainingHealOn(Unit* target)
        {
            SpellEffectValue heal = 0;
            Unit::AuraEffectList const& auras = target->GetAuraEffectsByType(SPELL_AURA_PERIODIC_HEAL);
            for (AuraEffect const* aurEff : auras)
                heal += aurEff->GetAmount() * aurEff->GetRemainingTicks();
 
            return static_cast<uint32>(heal);
        }
 
        class MostHPMissingInRange
        {
            public:
                MostHPMissingInRange(Unit const* referer, float range, uint32 hp, uint32 exclAura = 0, bool exclSelf = false)
                    : _referer(referer), _range(range), _hp(hp), _exclAura(exclAura), _exclSelf(exclSelf) { }
 
                bool operator()(Unit* u)
                {
                    if (_exclSelf && u == _referer)
                        return false;
 
                    if (_exclAura && u->HasAura(_exclAura))
                        return false;
 
                    if ((u->GetHealth() + GetRemainingHealOn(u) + _hp) > u->GetMaxHealth())
                        return false;
 
                    uint32 missingHP = u->GetMaxHealth() - u->GetHealth();
                    if (u->IsAlive() && _referer->IsFriendlyTo(u) && _referer->IsWithinDistInMap(u, _range) && missingHP > _hp)
                    {
                        _hp = missingHP;
                        return true;
                    }
 
                    return false;
                }
 
            private:
                Unit const* _referer;
                float _range;
                uint32 _hp;
                uint32 _exclAura;
                bool _exclSelf;
        };
 
        static Unit* GetUnitWithMostMissingHp(SpellInfo const* spellInfo, Unit* caster)
        {
            // use positive range, it's a healing spell
            float const range = spellInfo->GetMaxRange(true);
            uint32 const heal = GetTotalHeal(spellInfo, caster);
 
            Unit* target = nullptr;
            Trinity::MostHPMissingInRange checker(caster, range, heal);
            Trinity::UnitLastSearcher<Trinity::MostHPMissingInRange> searcher(caster, target, checker);
            Cell::VisitGridObjects(caster, searcher, 60.0f);
 
            return target;
        }
 
        static Unit* GetHealTarget(SpellInfo const* spellInfo, Unit* caster)
        {
            Unit* healTarget = nullptr;
            if (!spellInfo->HasAttribute(SPELL_ATTR1_EXCLUDE_CASTER) && !roll_chance(caster->GetHealthPct()) && ((caster->GetHealth() + GetRemainingHealOn(caster) + GetTotalHeal(spellInfo, caster)) <= caster->GetMaxHealth()))
                healTarget = caster;
            else
                healTarget = GetUnitWithMostMissingHp(spellInfo, caster);
 
            return healTarget;
        }
    };
 
    bool UseAbility(uint32 spellId)
    {
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId, GetDifficulty());
        if (!spellInfo)
            return false;
 
        Unit* target = nullptr;
        if (AIHelper::GetTotalHeal(spellInfo, me))
            target = AIHelper::GetHealTarget(spellInfo, me);
        else
            target = me->GetVictim();
 
        if (!target)
            return false;
 
        if (_info->Type == MERCENARY_SOLDIER)
        {
            bool allowMove = true;
            auto [minRange, maxRange] = spellInfo->GetMinMaxRange();
            if (me->IsInRange(target, minRange, maxRange))
                allowMove = false;
 
            if (IsCombatMovementAllowed() != allowMove)
            {
                SetCombatMovement(allowMove);
 
                // need relaunch movement
                ScriptedAI::AttackStart(target);
 
                // give some time to allow reposition, try again in a second
                if (allowMove)
                    return false;
            }
        }
 
        DoCast(target, spellId);
        return true;
    }
 
    void UpdateAI(uint32 diff) final override
    {
        if (!UpdateVictim())
            return;
 
        _events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = _events.ExecuteEvent())
        {
            ExecuteEvent(eventId);
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
 
        if (_info->Type == DARK_RUNE_ACOLYTE)
            DoSpellAttackIfReady(SPELL_HOLY_SMITE);
    }
 
    virtual void ExecuteEvent(uint32 eventId) = 0;
 
protected:
    InstanceScript* _instance;
    EventMap _events;
 
    ThorimTrashInfo const* _info = nullptr;
};
 
class npc_thorim_pre_phase : public CreatureScript
{
    public:
        npc_thorim_pre_phase() : CreatureScript("npc_thorim_pre_phase") { }
 
        struct npc_thorim_pre_phaseAI : public npc_thorim_trashAI
        {
            npc_thorim_pre_phaseAI(Creature* creature) : npc_thorim_trashAI(creature)
            {
                me->setActive(true); // prevent grid unload
                me->SetFarVisible(true);
            }
 
            void Reset() override
            {
                _events.Reset();
                if (_info->PrimaryAbility)
                    _events.ScheduleEvent(EVENT_PRIMARY_ABILITY, 3s, 6s);
                if (_info->SecondaryAbility)
                {
                    if (_info->SecondaryAbility == SPELL_SHOOT)
                        _events.ScheduleEvent(EVENT_SECONDARY_ABILITY, 2s);
                    else
                        _events.ScheduleEvent(EVENT_SECONDARY_ABILITY, 12s, 15s);
                }
                if (_info->ThirdAbility)
                    _events.ScheduleEvent(EVENT_THIRD_ABILITY, 6s, 8s);
                if (_info->Type == MERCENARY_SOLDIER)
                    SetCombatMovement(false);
            }
 
            void JustDied(Unit* /*killer*/) override
            {
                if (Creature* thorim = _instance->GetCreature(DATA_THORIM))
                    thorim->AI()->DoAction(ACTION_INCREASE_PREADDS_COUNT);
            }
 
            void DamageTaken(Unit* attacker, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
            {
                // nullify spell damage
                if (!attacker || !attacker->GetAffectingPlayer())
                    damage = 0;
            }
 
            void ExecuteEvent(uint32 eventId) override
            {
                switch (eventId)
                {
                    case EVENT_PRIMARY_ABILITY:
                        if (UseAbility(_info->PrimaryAbility))
                            _events.ScheduleEvent(eventId, 15s, 20s);
                        else
                            _events.ScheduleEvent(eventId, 1s);
                        break;
                    case EVENT_SECONDARY_ABILITY:
                        if (UseAbility(_info->SecondaryAbility))
                        {
                            if (_info->SecondaryAbility == SPELL_SHOOT)
                                _events.ScheduleEvent(eventId, 2s);
                            else
                                _events.ScheduleEvent(eventId, 4s, 8s);
                        }
                        else
                            _events.ScheduleEvent(eventId, 1s);
                        break;
                    case EVENT_THIRD_ABILITY:
                        if (UseAbility(_info->ThirdAbility))
                            _events.ScheduleEvent(eventId, 6s, 8s);
                        else
                            _events.ScheduleEvent(eventId, 1s);
                        break;
                    default:
                        break;
                }
            }
        };
 
        CreatureAI* GetAI(Creature* creature) const override
        {
            return GetUlduarAI<npc_thorim_pre_phaseAI>(creature);
        }
};
 
class npc_thorim_arena_phase : public CreatureScript
{
    public:
        npc_thorim_arena_phase() : CreatureScript("npc_thorim_arena_phase") { }
 
        struct npc_thorim_arena_phaseAI : public npc_thorim_trashAI
        {
            npc_thorim_arena_phaseAI(Creature* creature) : npc_thorim_trashAI(creature)
            {
                switch (_info->Type)
                {
                    case DARK_RUNE_CHAMPION:
                    case DARK_RUNE_WARBRINGER:
                    case DARK_RUNE_COMMONER:
                    case DARK_RUNE_EVOKER:
                        _isInArena = true;
                        break;
                    case DARK_RUNE_ACOLYTE:
                    {
                        _isInArena = (_info->Entry == NPC_DARK_RUNE_ACOLYTE_PRE);
                        SetBoundary(&ArenaBoundaries, !_isInArena);
                        break;
                    }
                    default:
                        _isInArena = false;
                        break;
                }
            }
 
            bool CanAIAttack(Unit const* who) const override
            {
                // don't try to attack players in balcony
                if (_isInArena && HeightPositionCheck(true)(who))
                    return false;
 
                return IsInBoundary(who);
            }
 
            void Reset() override
            {
                _events.Reset();
                if (_info->PrimaryAbility)
                    _events.ScheduleEvent(EVENT_PRIMARY_ABILITY, 3s, 6s);
                if (_info->SecondaryAbility)
                    _events.ScheduleEvent(EVENT_SECONDARY_ABILITY, 7s, 9s);
                if (_info->ThirdAbility)
                    _events.ScheduleEvent(EVENT_THIRD_ABILITY, 6s, 8s);
                if (_info->Type == DARK_RUNE_CHAMPION)
                    _events.ScheduleEvent(EVENT_ABILITY_CHARGE, 8s);
            }
 
            void JustEngagedWith(Unit* /*who*/) override
            {
                if (_info->Type == DARK_RUNE_WARBRINGER)
                    DoCast(me, SPELL_AURA_OF_CELERITY);
 
                if (!_isInArena)
                    if (Creature* colossus = _instance->GetCreature(DATA_RUNIC_COLOSSUS))
                        colossus->AI()->DoAction(ACTION_ACTIVATE_RUNIC_SMASH);
            }
 
            void EnterEvadeMode(EvadeReason why) override
            {
                if (why != EvadeReason::NoHostiles && why != EvadeReason::Boundary)
                    return;
 
                // this should only happen if theres no alive player in the arena -> summon orb
                if (Creature* thorim = _instance->GetCreature(DATA_THORIM))
                    thorim->AI()->DoAction(ACTION_BERSERK);
                ScriptedAI::EnterEvadeMode(why);
            }
 
            void ExecuteEvent(uint32 eventId) override
            {
                switch (eventId)
                {
                    case EVENT_PRIMARY_ABILITY:
                        if (UseAbility(_info->PrimaryAbility))
                            _events.Repeat(3s, 6s);
                        else
                            _events.Repeat(1s);
                        break;
                    case EVENT_SECONDARY_ABILITY:
                        if (UseAbility(_info->SecondaryAbility))
                            _events.Repeat(12s, 16s);
                        else
                            _events.Repeat(1s);
                        break;
                    case EVENT_THIRD_ABILITY:
                        if (UseAbility(_info->ThirdAbility))
                            _events.Repeat(6s, 8s);
                        else
                            _events.Repeat(1s);
                        break;
                    case EVENT_ABILITY_CHARGE:
                    {
                        Unit* referer = me;
                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, [referer](Unit* unit){ return unit->GetTypeId() == TYPEID_PLAYER && unit->IsInRange(referer, 8.0f, 25.0f); }))
                            DoCast(target, SPELL_CHARGE);
                        _events.ScheduleEvent(eventId, 12s);
                        break;
                    }
                    default:
                        break;
                }
            }
 
        private:
            bool _isInArena;
        };
 
        CreatureAI* GetAI(Creature* creature) const override
        {
            return GetUlduarAI<npc_thorim_arena_phaseAI>(creature);
        }
};
 
struct npc_thorim_minibossAI : public ScriptedAI
{
    npc_thorim_minibossAI(Creature* creature) : ScriptedAI(creature), _summons(me)
    {
        _instance = creature->GetInstanceScript();
 
        SetBoundary(&ArenaBoundaries, true);
    }
 
    bool CanAIAttack(Unit const* who) const final override
    {
        return IsInBoundary(who);
    }
 
    void JustSummoned(Creature* summon) final override
    {
        _summons.Summon(summon);
    }
 
    void SummonedCreatureDespawn(Creature* summon) final override
    {
        _summons.Despawn(summon);
    }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_ACTIVATE_ADDS)
        {
            for (ObjectGuid const& guid : _summons)
                if (Creature* summon = ObjectAccessor::GetCreature(*me, guid))
                    summon->SetImmuneToPC(false);
        }
    }
 
protected:
    InstanceScript* _instance;
    EventMap _events;
    SummonList _summons;
};
 
class npc_runic_colossus : public CreatureScript
{
    public:
        npc_runic_colossus() : CreatureScript("npc_runic_colossus") { }
 
        struct npc_runic_colossusAI : public npc_thorim_minibossAI
        {
            npc_runic_colossusAI(Creature* creature) : npc_thorim_minibossAI(creature)
            {
                Initialize();
            }
 
            void Initialize()
            {
                _runicActive = false;
            }
 
            void Reset() override
            {
                Initialize();
                _events.Reset();
 
                // close the Runic Door
                _instance->HandleGameObject(_instance->GetGuidData(DATA_RUNIC_DOOR), false);
 
                // Spawn trashes
                _summons.DespawnAll();
                for (SummonLocation const& s : ColossusAddLocations)
                    me->SummonCreature(s.entry, s.pos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3s);
            }
 
            void MoveInLineOfSight(Unit* /*who*/) override
            {
                // don't enter combat
            }
 
            void DoAction(int32 action) override
            {
                npc_thorim_minibossAI::DoAction(action);
 
                if (_runicActive)
                    return;
 
                if (action == ACTION_ACTIVATE_RUNIC_SMASH)
                {
                    _runicActive = true;
                    _events.ScheduleEvent(EVENT_RUNIC_SMASH, 7s);
                }
            }
 
            void JustDied(Unit* /*killer*/) override
            {
                // open the Runic Door
                _instance->HandleGameObject(_instance->GetGuidData(DATA_RUNIC_DOOR), true);
 
                if (Creature* thorim = _instance->GetCreature(DATA_THORIM))
                    thorim->AI()->Talk(SAY_SPECIAL);
 
                if (Creature* giant = _instance->GetCreature(DATA_RUNE_GIANT))
                {
                    giant->SetImmuneToPC(false);
                    giant->AI()->DoAction(ACTION_ACTIVATE_ADDS);
                }
            }
 
            void JustEngagedWith(Unit* /*who*/) override
            {
                DoZoneInCombat();
                _events.Reset();
                _events.ScheduleEvent(EVENT_RUNIC_BARRIER, 12s, 15s);
                _events.ScheduleEvent(EVENT_SMASH, 15s, 18s);
                _events.ScheduleEvent(EVENT_RUNIC_CHARGE, 20s, 24s);
            }
 
            void UpdateAI(uint32 diff) override
            {
                _events.Update(diff);
 
                if (me->HasUnitState(UNIT_STATE_CASTING))
                    return;
 
                while (uint32 eventId = _events.ExecuteEvent())
                {
                    switch (eventId)
                    {
                        case EVENT_RUNIC_BARRIER:
                            Talk(EMOTE_RUNIC_BARRIER);
                            DoCastAOE(SPELL_RUNIC_BARRIER);
                            _events.Repeat(35s, 45s);
                            break;
                        case EVENT_SMASH:
                            DoCastAOE(SPELL_SMASH);
                            _events.Repeat(15s, 18s);
                            break;
                        case EVENT_RUNIC_CHARGE:
                        {
                            Unit* referer = me;
                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, [referer](Unit* unit){ return unit->GetTypeId() == TYPEID_PLAYER && unit->IsInRange(referer, 8.0f, 40.0f); }))
                                DoCast(target, SPELL_RUNIC_CHARGE);
                            _events.Repeat(20s);
                            break;
                        }
                        case EVENT_RUNIC_SMASH:
                            DoCast(me, RAND(SPELL_RUNIC_SMASH_LEFT, SPELL_RUNIC_SMASH_RIGHT));
                            _events.Repeat(6s);
                            break;
                        default:
                            break;
                    }
 
                    if (me->HasUnitState(UNIT_STATE_CASTING))
                        return;
                }
 
                if (!UpdateVictim())
                    return;
            }
 
        private:
            bool _runicActive;
        };
 
        CreatureAI* GetAI(Creature* creature) const override
        {
            return GetUlduarAI<npc_runic_colossusAI>(creature);
        }
};
 
class npc_ancient_rune_giant : public CreatureScript
{
    public:
        npc_ancient_rune_giant() : CreatureScript("npc_ancient_rune_giant") { }
 
        struct npc_ancient_rune_giantAI : public npc_thorim_minibossAI
        {
            npc_ancient_rune_giantAI(Creature* creature) : npc_thorim_minibossAI(creature) { }
 
            void Reset() override
            {
                _events.Reset();
 
                // close the Stone Door
                _instance->HandleGameObject(_instance->GetGuidData(DATA_STONE_DOOR), false);
 
                // Spawn trashes
                _summons.DespawnAll();
                for (SummonLocation const& s : GiantAddLocations)
                    me->SummonCreature(s.entry, s.pos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 3s);
            }
 
            void JustEngagedWith(Unit* /*who*/) override
            {
                DoZoneInCombat();
                _events.Reset();
                _events.ScheduleEvent(EVENT_RUNIC_FORTIFICATION, 1ms);
                _events.ScheduleEvent(EVENT_STOMP, 10s, 12s);
                _events.ScheduleEvent(EVENT_RUNE_DETONATION, 25s);
            }
 
            void JustDied(Unit* /*killer*/) override
            {
                // opem the Stone Door
                _instance->HandleGameObject(_instance->GetGuidData(DATA_STONE_DOOR), true);
            }
 
            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_RUNIC_FORTIFICATION:
                            Talk(EMOTE_RUNIC_MIGHT);
                            DoCastAOE(SPELL_RUNIC_FORTIFICATION);
                            break;
                        case EVENT_STOMP:
                            DoCastAOE(SPELL_STOMP);
                            _events.Repeat(10s, 12s);
                            break;
                        case EVENT_RUNE_DETONATION:
                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 60.0f, true))
                                DoCast(target, SPELL_RUNE_DETONATION);
                            _events.Repeat(10s, 12s);
                            break;
                        default:
                            break;
                    }
 
                    if (me->HasUnitState(UNIT_STATE_CASTING))
                        return;
                }
            }
        };
 
        CreatureAI* GetAI(Creature* creature) const override
        {
            return GetUlduarAI<npc_ancient_rune_giantAI>(creature);
        }
};
 
class npc_sif : public CreatureScript
{
    public:
        npc_sif() : CreatureScript("npc_sif") { }
 
        struct npc_sifAI : public ScriptedAI
        {
            npc_sifAI(Creature* creature) : ScriptedAI(creature)
            {
                SetCombatMovement(false);
                _instance = creature->GetInstanceScript();
            }
 
            void Reset() override
            {
                _events.Reset();
            }
 
            void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
            {
                if (spellInfo->Id == SPELL_STORMHAMMER_SIF)
                {
                    me->InterruptSpell(CURRENT_GENERIC_SPELL);
                    me->SetReactState(REACT_PASSIVE);
                    me->AttackStop();
                }
            }
 
            void DoAction(int32 action) override
            {
                if (action == ACTION_START_HARD_MODE)
                {
                    me->SetReactState(REACT_AGGRESSIVE);
                    DoZoneInCombat(me);
                    Talk(SAY_SIF_EVENT);
                    _events.Reset();
                    _events.ScheduleEvent(EVENT_FROSTBOLT, 2s);
                    _events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 15s);
                    _events.ScheduleEvent(EVENT_BLINK, 20s, 25s);
                    _events.ScheduleEvent(EVENT_BLIZZARD, 30s);
                }
            }
 
            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_BLINK:
                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100.0f, true))
                                DoCast(target, SPELL_BLINK);
                            _events.ScheduleEvent(EVENT_FROST_NOVA, 0s);
                            _events.Repeat(20s, 25s);
                            return;
                        case EVENT_FROST_NOVA:
                            DoCastAOE(SPELL_FROSTNOVA);
                            return;
                        case EVENT_FROSTBOLT:
                            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100.0f, true))
                                DoCast(target, SPELL_FROSTBOLT);
                            _events.Repeat(2s);
                            return;
                        case EVENT_FROSTBOLT_VOLLEY:
                            DoCastAOE(SPELL_FROSTBOLT_VOLLEY);
                            _events.Repeat(15s, 20s);
                            return;
                        case EVENT_BLIZZARD:
                            DoCastAOE(SPELL_BLIZZARD);
                            _events.Repeat(35s, 45s);
                            return;
                        default:
                            break;
                    }
 
                    if (me->HasUnitState(UNIT_STATE_CASTING))
                        return;
                }
 
                // no melee attack
            }
 
        private:
            EventMap _events;
            InstanceScript* _instance;
        };
 
        CreatureAI* GetAI(Creature* creature) const override
        {
            return GetUlduarAI<npc_sifAI>(creature);
        }
};
 
// 62576 - Blizzard
// 62602 - Blizzard
class spell_thorim_blizzard_effect : public SpellScriptLoader
{
    public:
        spell_thorim_blizzard_effect() : SpellScriptLoader("spell_thorim_blizzard_effect") { }
 
        class spell_thorim_blizzard_effect_AuraScript : public AuraScript
        {
            bool CheckAreaTarget(Unit* target)
            {
                if (target != GetOwner())
                {
                    // check if not stacking aura already on target
                    // this one prevents overriding auras periodically by 2 near area aura owners
                    Unit::AuraApplicationMap const& auraMap = target->GetAppliedAuras();
                    for (Unit::AuraApplicationMap::const_iterator iter = auraMap.begin(); iter != auraMap.end(); ++iter)
                    {
                        Aura const* aura = iter->second->GetBase();
                        if (GetId() == aura->GetId() && GetOwner() != aura->GetOwner() )
                            return false;
                    }
                }
 
                return true;
            }
 
            void Register() override
            {
                DoCheckAreaTarget += AuraCheckAreaTargetFn(spell_thorim_blizzard_effect_AuraScript::CheckAreaTarget);
            }
        };
 
        AuraScript* GetAuraScript() const override
        {
            return new spell_thorim_blizzard_effect_AuraScript();
        }
};
 
// 62580, 62604 - Frostbolt Volley
class spell_thorim_frostbolt_volley : public SpellScriptLoader
{
    public:
        spell_thorim_frostbolt_volley() : SpellScriptLoader("spell_thorim_frostbolt_volley") { }
 
        class spell_thorim_frostbolt_volley_SpellScript : public SpellScript
        {
            void FilterTargets(std::list<WorldObject*>& targets)
            {
                targets.remove_if([](WorldObject* object) -> bool
                {
                    if (object->GetTypeId() == TYPEID_PLAYER)
                        return false;
 
                    if (Creature* creature = object->ToCreature())
                        return !creature->IsPet();
 
                    return true;
                });
            }
 
            void Register() override
            {
                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_thorim_frostbolt_volley_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ENEMY);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_frostbolt_volley_SpellScript();
        }
};
 
// 62016 - Charge Orb
class spell_thorim_charge_orb : public SpellScriptLoader
{
    public:
        spell_thorim_charge_orb() : SpellScriptLoader("spell_thorim_charge_orb") { }
 
        class spell_thorim_charge_orb_SpellScript : public SpellScript
        {
            bool Validate(SpellInfo const* /*spellInfo*/) override
            {
                return ValidateSpellInfo({ SPELL_LIGHTNING_PILLAR_1 });
            }
 
            void FilterTargets(std::list<WorldObject*>& targets)
            {
                targets.remove_if(HeightPositionCheck(false));
 
                if (targets.empty())
                    return;
 
                WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
                targets.clear();
                targets.push_back(target);
            }
 
            void HandleScript()
            {
                if (Unit* target = GetHitUnit())
                    target->CastSpell(nullptr, SPELL_LIGHTNING_PILLAR_1, true);
            }
 
            void Register() override
            {
                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_thorim_charge_orb_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENTRY);
                AfterHit += SpellHitFn(spell_thorim_charge_orb_SpellScript::HandleScript);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_charge_orb_SpellScript();
        }
};
 
// 62466 - Lightning Charge
class spell_thorim_lightning_charge : public SpellScriptLoader
{
    public:
        spell_thorim_lightning_charge() : SpellScriptLoader("spell_thorim_lightning_charge") { }
 
        class spell_thorim_lightning_charge_SpellScript : public SpellScript
        {
            bool Validate(SpellInfo const* /*spellInfo*/) override
            {
                return ValidateSpellInfo({ SPELL_LIGHTNING_CHARGE });
            }
 
            void HandleFocus()
            {
                if (Creature* creature = GetCaster()->ToCreature())
                    creature->SetSpellFocus(GetSpell(), GetExplTargetWorldObject());
            }
 
            void HandleCharge()
            {
                GetCaster()->CastSpell(GetCaster(), SPELL_LIGHTNING_CHARGE);
            }
 
            void Register() override
            {
                BeforeCast += SpellCastFn(spell_thorim_lightning_charge_SpellScript::HandleFocus);
                AfterCast += SpellCastFn(spell_thorim_lightning_charge_SpellScript::HandleCharge);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_lightning_charge_SpellScript();
        }
};
 
// 61934 - Leap
class spell_thorim_arena_leap : public SpellScriptLoader
{
    public:
        spell_thorim_arena_leap() : SpellScriptLoader("spell_thorim_arena_leap") { }
 
        class spell_thorim_arena_leap_SpellScript : public SpellScript
        {
            bool Load() override
            {
                return GetCaster()->GetTypeId() == TYPEID_UNIT;
            }
 
            void HandleScript(SpellEffIndex /*effIndex*/)
            {
                if (Position const* pos = GetHitDest())
                    GetCaster()->ToCreature()->SetHomePosition(*pos);
            }
 
            void Register() override
            {
                OnEffectLaunch += SpellEffectFn(spell_thorim_arena_leap_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_JUMP_DEST);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_arena_leap_SpellScript();
        }
};
 
struct OutOfArenaCheck
{
    bool operator()(Position const* who) const
    {
        return !CreatureAI::IsInBounds(ArenaBoundaries, who);
    }
};
 
// 62042 - Stormhammer
class spell_thorim_stormhammer : public SpellScriptLoader
{
    public:
        spell_thorim_stormhammer() : SpellScriptLoader("spell_thorim_stormhammer") { }
 
        class spell_thorim_stormhammer_SpellScript : public SpellScript
        {
            bool Validate(SpellInfo const* /*spellInfo*/) override
            {
                return ValidateSpellInfo({ SPELL_STORMHAMMER_BOOMERANG, SPELL_DEAFENING_THUNDER });
            }
 
            void FilterTargets(std::list<WorldObject*>& targets)
            {
                targets.remove_if([](WorldObject* target) -> bool { return HeightPositionCheck(true)(target) || OutOfArenaCheck()(target); });
 
                if (targets.empty())
                {
                    FinishCast(SPELL_FAILED_NO_VALID_TARGETS);
                    return;
                }
 
                WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
                targets.clear();
                targets.push_back(target);
            }
 
            void HandleScript(SpellEffIndex /*effIndex*/)
            {
                if (Unit* target = GetHitUnit())
                {
                    target->CastSpell(target, SPELL_DEAFENING_THUNDER, true);
                    target->CastSpell(GetCaster(), SPELL_STORMHAMMER_BOOMERANG, true);
                }
            }
 
            void LoseHammer()
            {
                GetCaster()->SetVirtualItem(0, 0);
            }
 
            void Register() override
            {
                OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_thorim_stormhammer_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ENEMY);
                AfterCast += SpellCastFn(spell_thorim_stormhammer_SpellScript::LoseHammer);
                OnEffectHitTarget += SpellEffectFn(spell_thorim_stormhammer_SpellScript::HandleScript, EFFECT_2, SPELL_EFFECT_SCRIPT_EFFECT);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_stormhammer_SpellScript();
        }
};
 
// 64767 - Stormhammer
class spell_thorim_stormhammer_sif : public SpellScriptLoader
{
    public:
        spell_thorim_stormhammer_sif() : SpellScriptLoader("spell_thorim_stormhammer_sif") { }
 
        class spell_thorim_stormhammer_sif_SpellScript : public SpellScript
        {
            bool Validate(SpellInfo const* /*spellInfo*/) override
            {
                return ValidateSpellInfo({ SPELL_STORMHAMMER_BOOMERANG, SPELL_SIF_TRANSFORM });
            }
 
            void HandleScript(SpellEffIndex /*effIndex*/)
            {
                if (Unit* target = GetHitUnit())
                {
                    target->CastSpell(GetCaster(), SPELL_STORMHAMMER_BOOMERANG, true);
                    target->CastSpell(target, SPELL_SIF_TRANSFORM, true);
                }
            }
 
            void LoseHammer()
            {
                GetCaster()->SetVirtualItem(0, 0);
            }
 
            void Register() override
            {
                AfterCast += SpellCastFn(spell_thorim_stormhammer_sif_SpellScript::LoseHammer);
                OnEffectHitTarget += SpellEffectFn(spell_thorim_stormhammer_sif_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_stormhammer_sif_SpellScript();
        }
};
 
// 64909 - Stormhammer
class spell_thorim_stormhammer_boomerang : public SpellScriptLoader
{
    public:
        spell_thorim_stormhammer_boomerang() : SpellScriptLoader("spell_thorim_stormhammer_boomerang") { }
 
        class spell_thorim_stormhammer_boomerang_SpellScript : public SpellScript
        {
            void RecoverHammer(SpellEffIndex /*effIndex*/)
            {
                if (Unit* target = GetHitUnit())
                    target->SetVirtualItem(0, THORIM_WEAPON_DISPLAY_ID);
            }
 
            void Register() override
            {
                OnEffectHitTarget += SpellEffectFn(spell_thorim_stormhammer_boomerang_SpellScript::RecoverHammer, EFFECT_0, SPELL_EFFECT_DUMMY);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_stormhammer_boomerang_SpellScript();
        }
};
 
// 62057, 62058 - Runic Smash
class spell_thorim_runic_smash : public SpellScriptLoader
{
    public:
        spell_thorim_runic_smash() : SpellScriptLoader("spell_thorim_runic_smash") { }
 
        class spell_thorim_runic_smash_SpellScript : public SpellScript
        {
            bool Validate(SpellInfo const* /*spellInfo*/) override
            {
                return ValidateSpellInfo({ SPELL_RUNIC_SMASH });
            }
 
            void HandleScript(SpellEffIndex effIndex)
            {
                PreventHitDefaultEffect(effIndex);
 
                std::vector<Creature*> triggers;
                GetCaster()->GetCreatureListWithEntryInGrid(triggers, GetSpellInfo()->Id == SPELL_RUNIC_SMASH_LEFT ? NPC_GOLEM_LEFT_HAND_BUNNY : NPC_GOLEM_RIGHT_HAND_BUNNY, 150.0f);
                for (Creature* trigger : triggers)
                {
                    Milliseconds time = Milliseconds(uint64(GetCaster()->GetExactDist(trigger) * 30.f));
                    trigger->m_Events.AddEvent(new RunicSmashExplosionEvent(trigger), trigger->m_Events.CalculateTime(time));
                };
            }
 
            void Register() override
            {
                OnEffectHitTarget += SpellEffectFn(spell_thorim_runic_smash_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_TRIGGER_SPELL);
            }
        };
 
        SpellScript* GetSpellScript() const override
        {
            return new spell_thorim_runic_smash_SpellScript();
        }
};
 
class UpperOrbCheck
{
    public:
        UpperOrbCheck() : _check(true) { }
 
        bool operator() (Creature* target) const
        {
            return target->GetEntry() == NPC_THUNDER_ORB && _check(target);
        }
 
    private:
        HeightPositionCheck const _check;
};
 
// 62184 - Activate Lightning Orb Periodic
class spell_thorim_activate_lightning_orb_periodic : public SpellScriptLoader
{
    public:
        spell_thorim_activate_lightning_orb_periodic() : SpellScriptLoader("spell_thorim_activate_lightning_orb_periodic") { }
 
        class spell_thorim_activate_lightning_orb_periodic_AuraScript : public AuraScript
        {
            InstanceScript* instance = nullptr;
 
            void PeriodicTick(AuraEffect const* /*aurEff*/)
            {
                PreventDefaultAction();
 
                Unit* caster = GetCaster();
                std::vector<Creature*> triggers;
 
                UpperOrbCheck check;
                Trinity::CreatureListSearcher<UpperOrbCheck> searcher(caster, triggers, check);
                Cell::VisitGridObjects(caster, searcher, 100.f);
 
                if (!triggers.empty())
                {
                    Creature* target = Trinity::Containers::SelectRandomContainerElement(triggers);
                    if (Creature* thorim = instance->GetCreature(DATA_THORIM))
                        thorim->AI()->SetGUID(target->GetGUID(), DATA_CHARGED_PILLAR);
                }
            }
 
            bool Load() override
            {
                if (Unit* caster = GetCaster())
                    instance = caster->GetInstanceScript();
 
                return instance != nullptr;
            }
 
            void Register() override
            {
                OnEffectPeriodic += AuraEffectPeriodicFn(spell_thorim_activate_lightning_orb_periodic_AuraScript::PeriodicTick, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
            }
        };
 
        AuraScript* GetAuraScript() const override
        {
            return new spell_thorim_activate_lightning_orb_periodic_AuraScript();
        }
};
 
// 62320 - Aura of Celerity
class spell_thorim_aura_of_celerity : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_AURA_OF_CELERITY_VISUAL });
    }
 
    void AfterRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        GetTarget()->RemoveAurasDueToSpell(SPELL_AURA_OF_CELERITY_VISUAL);
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_thorim_aura_of_celerity::AfterRemove, EFFECT_0, SPELL_AURA_MOD_MELEE_RANGED_CASTING_HASTE, AURA_EFFECT_HANDLE_REAL);
    }
};
 
class condition_thorim_arena_leap : public ConditionScript
{
    public:
        condition_thorim_arena_leap() : ConditionScript("condition_thorim_arena_leap"), _check(false) { }
 
        bool OnConditionCheck(Condition const* condition, ConditionSourceInfo& sourceInfo) override
        {
            WorldObject const* target = sourceInfo.mConditionTargets[condition->ConditionTarget];
            InstanceScript* instance = target->GetInstanceScript();
 
            if (!instance)
                return false;
 
            return _check(target);
        }
 
    private:
        HeightPositionCheck _check;
};
 
void AddSC_boss_thorim()
{
    new boss_thorim();
    new npc_thorim_pre_phase();
    new npc_thorim_arena_phase();
    new npc_runic_colossus();
    new npc_ancient_rune_giant();
    new npc_sif();
    new spell_thorim_blizzard_effect();
    new spell_thorim_frostbolt_volley();
    new spell_thorim_charge_orb();
    new spell_thorim_lightning_charge();
    new spell_thorim_stormhammer();
    new spell_thorim_stormhammer_sif();
    new spell_thorim_stormhammer_boomerang();
    new spell_thorim_arena_leap();
    new spell_thorim_runic_smash();
    new spell_thorim_activate_lightning_orb_periodic();
    RegisterSpellScript(spell_thorim_aura_of_celerity);
    new condition_thorim_arena_leap();
}