boss_deathbringer_saurfang.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 "icecrown_citadel.h"
#include "Containers.h"
#include "InstanceScript.h"
#include "Map.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "ScriptedGossip.h"
#include "ScriptMgr.h"
#include "SpellAuras.h"
#include "SpellScript.h"
 
enum ScriptTexts
{
    // Deathbringer Saurfang
    SAY_INTRO_ALLIANCE_2            = 0,
    SAY_INTRO_ALLIANCE_3            = 1,
    SAY_INTRO_ALLIANCE_6            = 2,
    SAY_INTRO_ALLIANCE_7            = 3,
    SAY_INTRO_HORDE_2               = 4,
    SAY_INTRO_HORDE_4               = 5,
    SAY_INTRO_HORDE_9               = 6,
    SAY_AGGRO                       = 7,
    SAY_MARK_OF_THE_FALLEN_CHAMPION = 8,
    SAY_BLOOD_BEASTS                = 9,
    SAY_KILL                        = 10,
    SAY_FRENZY                      = 11,
    SAY_BERSERK                     = 12,
    SAY_DEATH                       = 13,
    EMOTE_SCENT_OF_BLOOD            = 14,
 
    // High Overlord Saurfang
    SAY_INTRO_HORDE_1               = 0,
    SAY_INTRO_HORDE_3               = 1,
    SAY_INTRO_HORDE_5               = 2,
    SAY_INTRO_HORDE_6               = 3,
    SAY_INTRO_HORDE_7               = 4,
    SAY_INTRO_HORDE_8               = 5,
    SAY_OUTRO_ALLIANCE_8            = 6,
    SAY_OUTRO_ALLIANCE_12           = 7, // kneel after WP reached
    SAY_OUTRO_ALLIANCE_13           = 8,
    SAY_OUTRO_ALLIANCE_14           = 9,
    SAY_OUTRO_ALLIANCE_15           = 10,
    SAY_OUTRO_HORDE_1               = 11,
    SAY_OUTRO_HORDE_2               = 12,
    SAY_OUTRO_HORDE_3               = 13,
    SAY_OUTRO_HORDE_4               = 14,
 
    // Muradin Bronzebeard
    SAY_INTRO_ALLIANCE_1            = 0,
    SAY_INTRO_ALLIANCE_4            = 1,
    SAY_INTRO_ALLIANCE_5            = 2,
    SAY_OUTRO_ALLIANCE_1            = 3, 
    SAY_OUTRO_ALLIANCE_2            = 4,
    SAY_OUTRO_ALLIANCE_3            = 5,
    SAY_OUTRO_ALLIANCE_4            = 6,
    SAY_OUTRO_ALLIANCE_5            = 7,
    SAY_OUTRO_ALLIANCE_6            = 8,
    SAY_OUTRO_ALLIANCE_7            = 9,
    SAY_OUTRO_ALLIANCE_9            = 10,
    SAY_OUTRO_ALLIANCE_10           = 11,
    SAY_OUTRO_ALLIANCE_21           = 12,
 
    // Lady Jaina Proudmoore
    SAY_OUTRO_ALLIANCE_17           = 0,
    SAY_OUTRO_ALLIANCE_19           = 1,
 
    // King Varian Wrynn
    SAY_OUTRO_ALLIANCE_11           = 0,
    SAY_OUTRO_ALLIANCE_16           = 1,
    SAY_OUTRO_ALLIANCE_18           = 2,
    SAY_OUTRO_ALLIANCE_20           = 3,
};
 
enum Spells
{
    // Deathbringer Saurfang
    SPELL_ZERO_POWER                          = 72242,
    SPELL_GRIP_OF_AGONY                       = 70572, // Intro
    SPELL_BLOOD_LINK                          = 72178,
    SPELL_MARK_OF_THE_FALLEN_CHAMPION_S       = 72256,
    SPELL_RUNE_OF_BLOOD_S                     = 72408,
 
    SPELL_SUMMON_BLOOD_BEAST                  = 72172,
    SPELL_SUMMON_BLOOD_BEAST_25_MAN           = 72356, // Additional cast, does not replace
    SPELL_FRENZY                              = 72737,
    SPELL_BLOOD_NOVA_TRIGGER                  = 72378,
    SPELL_BLOOD_NOVA                          = 72380,
    SPELL_BLOOD_POWER                         = 72371,
    SPELL_BLOOD_LINK_POWER                    = 72195,
    SPELL_BLOOD_LINK_DUMMY                    = 72202,
    SPELL_MARK_OF_THE_FALLEN_CHAMPION         = 72293,
    SPELL_BOILING_BLOOD                       = 72385,
    SPELL_RUNE_OF_BLOOD                       = 72410,
 
    // Blood Beast
    SPELL_BLOOD_LINK_BEAST                    = 72176,
    SPELL_RESISTANT_SKIN                      = 72723,
    SPELL_SCENT_OF_BLOOD                      = 72769, // Heroic only
 
    SPELL_RIDE_VEHICLE                        = 70640, // Outro
    SPELL_ACHIEVEMENT                         = 72928,
    SPELL_REMOVE_MARKS_OF_THE_FALLEN_CHAMPION = 72257,
    SPELL_PERMANENT_FEIGN_DEATH               = 70628
};
 
// Helper to get id of the aura on different modes (HasAura(baseId) wont work)
#define BOILING_BLOOD_HELPER RAID_MODE<int32>(72385, 72441, 72442, 72443)
 
enum EventTypes
{
    EVENT_INTRO_ALLIANCE_1      = 1,
    EVENT_INTRO_ALLIANCE_2      = 2,
    EVENT_INTRO_ALLIANCE_3      = 3,
    EVENT_INTRO_ALLIANCE_4      = 4,
    EVENT_INTRO_ALLIANCE_5      = 5,
    EVENT_INTRO_ALLIANCE_6      = 6,
    EVENT_INTRO_ALLIANCE_7      = 7,
 
    EVENT_INTRO_HORDE_1         = 8,
    EVENT_INTRO_HORDE_2         = 9,
    EVENT_INTRO_HORDE_3         = 10,
    EVENT_INTRO_HORDE_4         = 11,
    EVENT_INTRO_HORDE_5         = 12,
    EVENT_INTRO_HORDE_6         = 13,
    EVENT_INTRO_HORDE_7         = 14,
    EVENT_INTRO_HORDE_8         = 15,
    EVENT_INTRO_HORDE_9         = 16,
 
    EVENT_INTRO_FINISH          = 17,
 
    EVENT_BERSERK               = 18,
    EVENT_SUMMON_BLOOD_BEAST    = 19,
    EVENT_BOILING_BLOOD         = 20,
    EVENT_BLOOD_NOVA            = 21,
    EVENT_RUNE_OF_BLOOD         = 22,
    EVENT_SCENT_OF_BLOOD        = 52,
 
    EVENT_OUTRO_ALLIANCE_1      = 23,
    EVENT_OUTRO_ALLIANCE_2      = 24,
    EVENT_OUTRO_ALLIANCE_3      = 25,
    EVENT_OUTRO_ALLIANCE_4      = 26,
    EVENT_OUTRO_ALLIANCE_5      = 27,
    EVENT_OUTRO_ALLIANCE_6      = 28,
    EVENT_OUTRO_ALLIANCE_7      = 29,
    EVENT_OUTRO_ALLIANCE_8      = 30,
    EVENT_OUTRO_ALLIANCE_9      = 31,
    EVENT_OUTRO_ALLIANCE_10     = 32,
    EVENT_OUTRO_ALLIANCE_11     = 33,
    EVENT_OUTRO_ALLIANCE_12     = 34,
    EVENT_OUTRO_ALLIANCE_13     = 35,
    EVENT_OUTRO_ALLIANCE_14     = 36,
    EVENT_OUTRO_ALLIANCE_15     = 37,
    EVENT_OUTRO_ALLIANCE_16     = 38,
    EVENT_OUTRO_ALLIANCE_17     = 39,
    EVENT_OUTRO_ALLIANCE_18     = 40,
    EVENT_OUTRO_ALLIANCE_19     = 41,
    EVENT_OUTRO_ALLIANCE_20     = 42,
    EVENT_OUTRO_ALLIANCE_21     = 43,
 
    EVENT_OUTRO_HORDE_1         = 44,
    EVENT_OUTRO_HORDE_2         = 45,
    EVENT_OUTRO_HORDE_3         = 46,
    EVENT_OUTRO_HORDE_4         = 47,
    EVENT_OUTRO_HORDE_5         = 48,
    EVENT_OUTRO_HORDE_6         = 49,
    EVENT_OUTRO_HORDE_7         = 50,
    EVENT_OUTRO_HORDE_8         = 51,
};
 
enum Phases
{
    PHASE_INTRO_A       = 1,
    PHASE_INTRO_H       = 2,
    PHASE_COMBAT        = 3
};
 
enum Actions
{
    ACTION_START_EVENT                  = -3781300,
    ACTION_CONTINUE_INTRO               = -3781301,
    ACTION_CHARGE                       = -3781302,
    ACTION_START_OUTRO                  = -3781303,
    ACTION_DESPAWN                      = -3781304,
    ACTION_INTERRUPT_INTRO              = -3781305,
    ACTION_MARK_OF_THE_FALLEN_CHAMPION  = -72293,
};
 
enum Misc
{
    DATA_MADE_A_MESS                    = 45374613, // 4537, 4613 are achievement IDs
 
    GOSSIP_MENU_MURADIN_BRONZEBEARD     = 10934,
    GOSSIP_MENU_HIGH_OVERLORD_SAURFANG  = 10952,
 
    SPAWN_GROUP_ENTRANCE_THE_DAMNED_EVENT   = 275,
};
 
enum MovePoints
{
    POINT_SAURFANG          = 3781300,
    POINT_FIRST_STEP        = 3781301,
    POINT_CHARGE            = 3781302,
    POINT_CHOKE             = 3781303,
    POINT_CORPSE            = 3781304,
    POINT_FINAL             = 3781305,
    POINT_EXIT              = 5,        // waypoint id
};
 
Position const deathbringerPos = {-496.3542f, 2211.33f, 541.1138f, 0.0f};
Position const firstStepPos = {-541.3177f, 2211.365f, 539.2921f, 0.0f};
 
Position const chargePos[6] =
{
    {-509.6505f, 2211.377f, 539.2872f, 0.0f}, // High Overlord Saurfang/Muradin Bronzebeard
    {-508.7480f, 2211.897f, 539.2870f, 0.0f}, // front left
    {-509.2929f, 2211.411f, 539.2870f, 0.0f}, // front right
    {-506.6607f, 2211.367f, 539.2870f, 0.0f}, // back middle
    {-506.1137f, 2213.306f, 539.2870f, 0.0f}, // back left
    {-509.0040f, 2211.743f, 539.2870f, 0.0f}  // back right
};
 
Position const chokePos[6] =
{
    {-514.4834f, 2211.334f, 549.2887f, 0.0f}, // High Overlord Saurfang/Muradin Bronzebeard
    {-510.1081f, 2211.592f, 546.3773f, 0.0f}, // front left
    {-513.3210f, 2211.396f, 551.2882f, 0.0f}, // front right
    {-507.3684f, 2210.353f, 545.7497f, 0.0f}, // back middle
    {-507.0486f, 2212.999f, 545.5512f, 0.0f}, // back left
    {-510.7041f, 2211.069f, 546.5298f, 0.0f}  // back right
};
 
Position const finalPos = {-563.7552f, 2211.328f, 538.7848f, 0.0f};
 
struct boss_deathbringer_saurfang : public BossAI
{
    boss_deathbringer_saurfang(Creature* creature) : BossAI(creature, DATA_DEATHBRINGER_SAURFANG), _introDone(false), _frenzied(false), _dead(false)
    {
        ASSERT(creature->GetVehicleKit()); // we dont actually use it, just check if exists
        _fallenChampionCastCount = 0;
    }
 
    void Reset() override
    {
        if (_dead)
            return;
        _Reset();
        events.SetPhase(PHASE_COMBAT);
        _frenzied = false;
        _dead = false;
        me->SetPower(POWER_ENERGY, 0);
        DoCastSelf(SPELL_ZERO_POWER, true);
        DoCastSelf(SPELL_BLOOD_LINK, true);
        DoCastSelf(SPELL_BLOOD_POWER, true);
        DoCastSelf(SPELL_MARK_OF_THE_FALLEN_CHAMPION_S, true);
        DoCastSelf(SPELL_RUNE_OF_BLOOD_S, true);
        me->RemoveAurasDueToSpell(SPELL_BERSERK);
        me->RemoveAurasDueToSpell(SPELL_FRENZY);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        if (_dead)
            return;
 
        if (!instance->CheckRequiredBosses(DATA_DEATHBRINGER_SAURFANG, who->ToPlayer()))
        {
            EnterEvadeMode(EvadeReason::Other);
            instance->DoCastSpellOnPlayers(LIGHT_S_HAMMER_TELEPORT);
            return;
        }
 
        // oh just screw intro, enter combat - no exploits please
        me->setActive(true);
        DoZoneInCombat();
 
        events.Reset();
        events.SetPhase(PHASE_COMBAT);
        me->SetImmuneToPC(false);
        if (!_introDone)
        {
            DoCastSelf(SPELL_GRIP_OF_AGONY);
            if (Creature* creature = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SAURFANG_EVENT_NPC)))
                creature->AI()->DoAction(ACTION_INTERRUPT_INTRO);
        }
 
        _introDone = true;
 
        Talk(SAY_AGGRO);
        events.ScheduleEvent(EVENT_SUMMON_BLOOD_BEAST, 30s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_BERSERK, IsHeroic() ? 360s : 480s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_BOILING_BLOOD, 15500ms, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_BLOOD_NOVA, 17s, 0, PHASE_COMBAT);
        events.ScheduleEvent(EVENT_RUNE_OF_BLOOD, 20s, 0, PHASE_COMBAT);
 
        _fallenChampionCastCount = 0;
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MARK_OF_THE_FALLEN_CHAMPION);
        instance->SetBossState(DATA_DEATHBRINGER_SAURFANG, IN_PROGRESS);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
    }
 
    void AttackStart(Unit* victim) override
    {
        if (me->IsImmuneToPC())
            return;
 
        ScriptedAI::AttackStart(victim);
    }
 
    void EnterEvadeMode(EvadeReason why) override
    {
        ScriptedAI::EnterEvadeMode(why);
        if (_introDone)
            me->SetImmuneToPC(false);
    }
 
    void JustReachedHome() override
    {
        if (_dead)
            return;
        _JustReachedHome();
        Reset();
        instance->SetBossState(DATA_DEATHBRINGER_SAURFANG, FAIL);
        instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_MARK_OF_THE_FALLEN_CHAMPION);
    }
 
    void KilledUnit(Unit* victim) override
    {
        if (victim->GetTypeId() == TYPEID_PLAYER)
            Talk(SAY_KILL);
    }
 
    void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (damage >= me->GetHealth())
            damage = me->GetHealth() - 1;
 
        if (!_frenzied && HealthBelowPct(31)) // AT 30%, not below
        {
            _frenzied = true;
            DoCastSelf(SPELL_FRENZY, true);
            Talk(SAY_FRENZY);
        }
 
        if (!_dead && me->GetHealth()-damage < FightWonValue)
        {
            _dead = true;
            _JustDied();
            _EnterEvadeMode();
            me->SetUninteractible(true);
            me->SetImmuneToPC(true);
            me->RemoveAurasOnEvade();
            DoCastAOE(SPELL_REMOVE_MARKS_OF_THE_FALLEN_CHAMPION);
            DoCastSelf(SPELL_ACHIEVEMENT, true);
            Talk(SAY_DEATH);
            DoCastSelf(SPELL_REPUTATION_BOSS_KILL, true);
            DoCastSelf(SPELL_PERMANENT_FEIGN_DEATH);
            if (Creature* creature = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_SAURFANG_EVENT_NPC)))
                creature->AI()->DoAction(ACTION_START_OUTRO);
        }
    }
 
    void JustSummoned(Creature* summon) override
    {
        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1, 0.0f, true))
        {
            if (target->GetTransport())
            {
                summon->DespawnOrUnsummon(1ms);
                EnterEvadeMode(EvadeReason::Other);
                return;
            }
 
            summon->AI()->AttackStart(target);
        }
 
        summon->CastSpell(summon, SPELL_BLOOD_LINK_BEAST, true);
        summon->CastSpell(summon, SPELL_RESISTANT_SKIN, true);
        summons.Summon(summon);
        DoZoneInCombat(summon);
    }
 
    void SummonedCreatureDies(Creature* summon, Unit* /*killer*/) override
    {
        summons.Despawn(summon);
    }
 
    void MovementInform(uint32 type, uint32 id) override
    {
        if (type != POINT_MOTION_TYPE && id != POINT_SAURFANG)
            return;
 
        instance->HandleGameObject(instance->GetGuidData(GO_SAURFANG_S_DOOR), false);
    }
 
    void SpellHitTarget(WorldObject* target, SpellInfo const* spellInfo) override
    {
        if (target->GetTransport())
        {
            EnterEvadeMode(EvadeReason::Other);
            return;
        }
 
        switch (spellInfo->Id)
        {
            case SPELL_MARK_OF_THE_FALLEN_CHAMPION:
                Talk(SAY_MARK_OF_THE_FALLEN_CHAMPION);
                break;
            case 72255: // Mark of the Fallen Champion, triggered id
            case 72444:
            case 72445:
            case 72446:
                if (me->GetPower(POWER_ENERGY) != me->GetMaxPower(POWER_ENERGY))
                {
                    CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
                    args.AddSpellBP0(1);
                    target->CastSpell(nullptr, SPELL_BLOOD_LINK_DUMMY, args);
                }
                break;
            default:
                break;
        }
    }
 
    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SPELL_BLOOD_LINK_POWER)
            if (Aura* bloodPower = me->GetAura(SPELL_BLOOD_POWER))
                bloodPower->RecalculateAmountOfEffects();
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim() && !(events.IsInPhase(PHASE_INTRO_A) || events.IsInPhase(PHASE_INTRO_H)))
            return;
 
        events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_INTRO_ALLIANCE_2:
                    me->SetUninteractible(false);
                    me->SetFaction(FACTION_UNDEAD_SCOURGE);
                    Talk(SAY_INTRO_ALLIANCE_2);
                    break;
                case EVENT_INTRO_ALLIANCE_3:
                    Talk(SAY_INTRO_ALLIANCE_3);
                    break;
                case EVENT_INTRO_ALLIANCE_6:
                    Talk(SAY_INTRO_ALLIANCE_6);
                    Talk(SAY_INTRO_ALLIANCE_7);
                    DoCastSelf(SPELL_GRIP_OF_AGONY);
                    break;
                case EVENT_INTRO_HORDE_2:
                    me->SetUninteractible(false);
                    me->SetFaction(FACTION_UNDEAD_SCOURGE);
                    Talk(SAY_INTRO_HORDE_2);
                    break;
                case EVENT_INTRO_HORDE_4:
                    Talk(SAY_INTRO_HORDE_4);
                    break;
                case EVENT_INTRO_HORDE_9:
                    DoCastSelf(SPELL_GRIP_OF_AGONY);
                    Talk(SAY_INTRO_HORDE_9);
                    break;
                case EVENT_INTRO_FINISH:
                    events.SetPhase(PHASE_COMBAT);
                    _introDone = true;
                    me->SetImmuneToPC(false);
                    break;
                case EVENT_SUMMON_BLOOD_BEAST:
                    for (uint32 i10 = 0; i10 < 2; ++i10)
                        DoCastSelf(SPELL_SUMMON_BLOOD_BEAST+i10);
                    if (Is25ManRaid())
                        for (uint32 i25 = 0; i25 < 3; ++i25)
                            DoCastSelf(SPELL_SUMMON_BLOOD_BEAST_25_MAN+i25);
                    Talk(SAY_BLOOD_BEASTS);
                    events.ScheduleEvent(EVENT_SUMMON_BLOOD_BEAST, 40s, 0, PHASE_COMBAT);
                    if (IsHeroic())
                        events.ScheduleEvent(EVENT_SCENT_OF_BLOOD, 10s, 0, PHASE_COMBAT);
                    break;
                case EVENT_BLOOD_NOVA:
                    DoCastAOE(SPELL_BLOOD_NOVA_TRIGGER);
                    events.ScheduleEvent(EVENT_BLOOD_NOVA, 20s, 25s, 0, PHASE_COMBAT);
                    break;
                case EVENT_RUNE_OF_BLOOD:
                    DoCastVictim(SPELL_RUNE_OF_BLOOD);
                    events.ScheduleEvent(EVENT_RUNE_OF_BLOOD, 20s, 25s, 0, PHASE_COMBAT);
                    break;
                case EVENT_BOILING_BLOOD:
                    DoCastSelf(SPELL_BOILING_BLOOD);
                    events.ScheduleEvent(EVENT_BOILING_BLOOD, 15s, 20s, 0, PHASE_COMBAT);
                    break;
                case EVENT_BERSERK:
                    DoCastSelf(SPELL_BERSERK);
                    Talk(SAY_BERSERK);
                    break;
                case EVENT_SCENT_OF_BLOOD:
                    if (!summons.empty())
                    {
                        Talk(EMOTE_SCENT_OF_BLOOD);
                        DoCastAOE(SPELL_SCENT_OF_BLOOD);
                    }
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
    uint32 GetData(uint32 type) const override
    {
        if (type == DATA_MADE_A_MESS)
            if (_fallenChampionCastCount < RAID_MODE<uint32>(3, 5, 3, 5))
                return 1;
 
        return 0;
    }
 
    // intro setup
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case PHASE_INTRO_A:
            case PHASE_INTRO_H:
            {
                // controls what events will execute
                events.SetPhase(uint32(action));
 
                me->SetHomePosition(deathbringerPos.GetPositionX(), deathbringerPos.GetPositionY(), deathbringerPos.GetPositionZ(), me->GetOrientation());
                me->GetMotionMaster()->MovePoint(POINT_SAURFANG, deathbringerPos.GetPositionX(), deathbringerPos.GetPositionY(), deathbringerPos.GetPositionZ());
 
                events.ScheduleEvent(EVENT_INTRO_ALLIANCE_2, 2500ms, 0, PHASE_INTRO_A);
                events.ScheduleEvent(EVENT_INTRO_ALLIANCE_3, 20s, 0, PHASE_INTRO_A);
 
                events.ScheduleEvent(EVENT_INTRO_HORDE_2, 5s, 0, PHASE_INTRO_H);
                break;
            }
            case ACTION_CONTINUE_INTRO:
            {
                if (_introDone)
                    return;
 
                events.ScheduleEvent(EVENT_INTRO_ALLIANCE_6, 7s, 0, PHASE_INTRO_A);
                events.ScheduleEvent(EVENT_INTRO_FINISH, 8s, 0, PHASE_INTRO_A);
 
                events.ScheduleEvent(EVENT_INTRO_HORDE_4, 6500ms, 0, PHASE_INTRO_H);
                events.ScheduleEvent(EVENT_INTRO_HORDE_9, 48200ms, 0, PHASE_INTRO_H);
                events.ScheduleEvent(EVENT_INTRO_FINISH,  55700ms, 0, PHASE_INTRO_H);
                break;
            }
            case ACTION_MARK_OF_THE_FALLEN_CHAMPION:
            {
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1, 0.0f, true, true, -SPELL_MARK_OF_THE_FALLEN_CHAMPION))
                {
                    ++_fallenChampionCastCount;
                    DoCast(target, SPELL_MARK_OF_THE_FALLEN_CHAMPION);
                    me->SetPower(POWER_ENERGY, 0);
                    if (Aura* bloodPower = me->GetAura(SPELL_BLOOD_POWER))
                        bloodPower->RecalculateAmountOfEffects();
                }
                break;
            }
            default:
                break;
        }
    }
 
    bool CanAIAttack(Unit const* target) const override
    {
        if (target->GetTransport())
            return false;
 
        return BossAI::CanAIAttack(target);
    }
 
    static uint32 const FightWonValue;
 
private:
    uint32 _fallenChampionCastCount;
    bool _introDone;
    bool _frenzied;   // faster than iterating all auras to find Frenzy
    bool _dead;
};
 
uint32 const boss_deathbringer_saurfang::FightWonValue = 100000;
 
struct npc_high_overlord_saurfang_icc : public ScriptedAI
{
    npc_high_overlord_saurfang_icc(Creature* creature) : ScriptedAI(creature)
    {
        ASSERT(creature->GetVehicleKit());
        _instance = me->GetInstanceScript();
    }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    bool OnGossipSelect(Player* player, uint32 menuId, uint32 /*gossipListId*/) override
    {
        if (menuId == GOSSIP_MENU_HIGH_OVERLORD_SAURFANG)
        {
            CloseGossipMenuFor(player);
            DoAction(ACTION_START_EVENT);
        }
        return false;
    }
 
    void GuardBroadcast(int32 action) const
    {
        std::vector<Creature*> guardList;
        GetCreatureListWithEntryInGrid(guardList, me, NPC_SE_KOR_KRON_REAVER, 100.0f);
        for (Creature* guard : guardList)
            guard->AI()->DoAction(action);
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_START_EVENT:
            {
                // Prevent crashes
                if (_events.IsInPhase(PHASE_INTRO_A) || _events.IsInPhase(PHASE_INTRO_H))
                    return;
 
                std::list<Creature*> guardList;
                GetCreatureListWithEntryInGrid(guardList, me, NPC_SE_KOR_KRON_REAVER, 20.0f);
                guardList.sort(Trinity::ObjectDistanceOrderPred(me));
                uint32 x = 1;
                for (auto itr = guardList.begin(); itr != guardList.end(); ++x, ++itr)
                    (*itr)->AI()->SetData(0, x);
 
                me->RemoveNpcFlag(UNIT_NPC_FLAG_GOSSIP);
                Talk(SAY_INTRO_HORDE_1);
                _events.SetPhase(PHASE_INTRO_H);
                _events.ScheduleEvent(EVENT_INTRO_HORDE_3, 18500ms, 0, PHASE_INTRO_H);
                _instance->HandleGameObject(_instance->GetGuidData(GO_SAURFANG_S_DOOR), true);
                if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                    deathbringer->AI()->DoAction(PHASE_INTRO_H);
                break;
            }
            case ACTION_START_OUTRO:
            {
                me->RemoveAurasDueToSpell(SPELL_GRIP_OF_AGONY);
                Talk(SAY_OUTRO_HORDE_1);
                _events.ScheduleEvent(EVENT_OUTRO_HORDE_2, 10s);   // say
                _events.ScheduleEvent(EVENT_OUTRO_HORDE_3, 18s);   // say
                _events.ScheduleEvent(EVENT_OUTRO_HORDE_4, 24s);   // cast
                _events.ScheduleEvent(EVENT_OUTRO_HORDE_5, 30s);   // move
                me->SetDisableGravity(false);
                me->GetMotionMaster()->MoveFall();
                GuardBroadcast(ACTION_DESPAWN);
                break;
            }
            case ACTION_INTERRUPT_INTRO:
            {
                _events.Reset();
                GuardBroadcast(ACTION_DESPAWN);
                break;
            }
            default:
                break;
        }
    }
 
    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SPELL_GRIP_OF_AGONY)
        {
            me->SetDisableGravity(true);
            me->GetMotionMaster()->MovePoint(POINT_CHOKE, chokePos[0]);
        }
    }
 
    void MovementInform(uint32 type, uint32 id) override
    {
        if (type == POINT_MOTION_TYPE)
        {
            switch (id)
            {
                case POINT_FIRST_STEP:
                    me->SetWalk(false);
                    Talk(SAY_INTRO_HORDE_3);
                    _events.ScheduleEvent(EVENT_INTRO_HORDE_5, 15500ms, 0, PHASE_INTRO_H);
                    _events.ScheduleEvent(EVENT_INTRO_HORDE_6, 29500ms, 0, PHASE_INTRO_H);
                    _events.ScheduleEvent(EVENT_INTRO_HORDE_7, 43800ms, 0, PHASE_INTRO_H);
                    _events.ScheduleEvent(EVENT_INTRO_HORDE_8, 47000ms, 0, PHASE_INTRO_H);
                    if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                        deathbringer->AI()->DoAction(ACTION_CONTINUE_INTRO);
                    break;
                case POINT_CORPSE:
                    if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                    {
                        deathbringer->CastSpell(me, SPELL_RIDE_VEHICLE, true);  // for the packet logs.
                        deathbringer->SetUninteractible(true);
                        deathbringer->SetUnitFlag2(UNIT_FLAG2_PLAY_DEATH_ANIM);
                        deathbringer->SetEmoteState(EMOTE_STATE_DROWNED);
                    }
                    _events.ScheduleEvent(EVENT_OUTRO_HORDE_5, 1s);    // move
                    _events.ScheduleEvent(EVENT_OUTRO_HORDE_6, 4s);    // say
                    break;
                case POINT_FINAL:
                    if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                        deathbringer->DespawnOrUnsummon();
                    me->DespawnOrUnsummon();
                    break;
                default:
                    break;
            }
        }
        else if (type == WAYPOINT_MOTION_TYPE && id == POINT_EXIT)
        {
            me->GetMap()->SpawnGroupDespawn(SPAWN_GROUP_ENTRANCE_THE_DAMNED_EVENT);
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        _events.Update(diff);
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_INTRO_HORDE_3:
                    me->SetWalk(true);
                    me->GetMotionMaster()->MovePoint(POINT_FIRST_STEP, firstStepPos.GetPositionX(), firstStepPos.GetPositionY(), firstStepPos.GetPositionZ());
                    break;
                case EVENT_INTRO_HORDE_5:
                    Talk(SAY_INTRO_HORDE_5);
                    break;
                case EVENT_INTRO_HORDE_6:
                    Talk(SAY_INTRO_HORDE_6);
                    break;
                case EVENT_INTRO_HORDE_7:
                    Talk(SAY_INTRO_HORDE_7);
                    break;
                case EVENT_INTRO_HORDE_8:
                    Talk(SAY_INTRO_HORDE_8);
                    GuardBroadcast(ACTION_CHARGE);
                    me->GetMotionMaster()->MoveCharge(chargePos[0].GetPositionX(), chargePos[0].GetPositionY(), chargePos[0].GetPositionZ(), 8.5f, POINT_CHARGE);
                    break;
                case EVENT_OUTRO_HORDE_2:   // say
                    if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                        me->SetFacingToObject(deathbringer);
                    Talk(SAY_OUTRO_HORDE_2);
                    break;
                case EVENT_OUTRO_HORDE_3:   // say
                    Talk(SAY_OUTRO_HORDE_3);
                    break;
                case EVENT_OUTRO_HORDE_4:   // move
                    if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                    {
                        float x, y, z;
                        deathbringer->GetClosePoint(x, y, z, deathbringer->GetCombatReach());
                        me->SetWalk(true);
                        me->GetMotionMaster()->MovePoint(POINT_CORPSE, x, y, z);
                    }
                    break;
                case EVENT_OUTRO_HORDE_5:   // move
                    me->GetMotionMaster()->MovePoint(POINT_FINAL, finalPos);
                    break;
                case EVENT_OUTRO_HORDE_6:   // say
                    Talk(SAY_OUTRO_HORDE_4);
                    break;
            }
        }
    }
 
private:
    EventMap _events;
    InstanceScript* _instance;
};
 
struct npc_muradin_bronzebeard_icc : public ScriptedAI
{
    npc_muradin_bronzebeard_icc(Creature* creature) : ScriptedAI(creature)
    {
        _instance = me->GetInstanceScript();
    }
 
    void Reset() override
    {
        _events.Reset();
    }
 
    bool OnGossipSelect(Player* player, uint32 menuId, uint32 /*gossipListId*/) override
    {
        if (menuId == GOSSIP_MENU_MURADIN_BRONZEBEARD)
        {
            CloseGossipMenuFor(player);
            DoAction(ACTION_START_EVENT);
        }
        return false;
    }
 
    void GuardBroadcast(int32 action) const
    {
        std::vector<Creature*> guardList;
        GetCreatureListWithEntryInGrid(guardList, me, NPC_SE_SKYBREAKER_MARINE, 100.0f);
        for (Creature* guard : guardList)
            guard->AI()->DoAction(action);
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_START_EVENT:
            {
                // Prevent crashes
                if (_events.IsInPhase(PHASE_INTRO_A) || _events.IsInPhase(PHASE_INTRO_H))
                    return;
 
                _events.SetPhase(PHASE_INTRO_A);
                std::list<Creature*> guardList;
                GetCreatureListWithEntryInGrid(guardList, me, NPC_SE_SKYBREAKER_MARINE, 20.0f);
                guardList.sort(Trinity::ObjectDistanceOrderPred(me));
                uint32 x = 1;
                for (auto itr = guardList.begin(); itr != guardList.end(); ++x, ++itr)
                    (*itr)->AI()->SetData(0, x);
 
                me->RemoveNpcFlag(UNIT_NPC_FLAG_GOSSIP);
                Talk(SAY_INTRO_ALLIANCE_1);
                _events.ScheduleEvent(EVENT_INTRO_ALLIANCE_4, 29500ms, 0, PHASE_INTRO_A);
                _instance->HandleGameObject(_instance->GetGuidData(GO_SAURFANG_S_DOOR), true);
                if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                    deathbringer->AI()->DoAction(PHASE_INTRO_A);
                break;
            }
            case ACTION_START_OUTRO:
            {
                me->RemoveAurasDueToSpell(SPELL_GRIP_OF_AGONY);
                Talk(SAY_OUTRO_ALLIANCE_1);
                me->SetDisableGravity(false);
                me->GetMotionMaster()->MoveFall();
                GuardBroadcast(ACTION_DESPAWN);
 
                // temp until outro fully done - to put deathbringer on respawn timer (until next reset)
                if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                    deathbringer->DespawnOrUnsummon(5s);
                break;
            }
            case ACTION_INTERRUPT_INTRO:
                _events.Reset();
                GuardBroadcast(ACTION_DESPAWN);
                break;
        }
    }
 
    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SPELL_GRIP_OF_AGONY)
        {
            me->SetDisableGravity(true);
            me->GetMotionMaster()->MovePoint(POINT_CHOKE, chokePos[0]);
        }
    }
 
    void MovementInform(uint32 type, uint32 id) override
    {
        if (type == POINT_MOTION_TYPE && id == POINT_FIRST_STEP)
        {
            me->SetWalk(false);
            Talk(SAY_INTRO_ALLIANCE_4);
            _events.ScheduleEvent(EVENT_INTRO_ALLIANCE_5, 5s, 0, PHASE_INTRO_A);
            if (Creature* deathbringer = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_DEATHBRINGER_SAURFANG)))
                deathbringer->AI()->DoAction(ACTION_CONTINUE_INTRO);
        }
        else if (type == WAYPOINT_MOTION_TYPE && id == POINT_EXIT)
        {
            me->GetMap()->SpawnGroupDespawn(SPAWN_GROUP_ENTRANCE_THE_DAMNED_EVENT);
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        _events.Update(diff);
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_INTRO_ALLIANCE_4:
                    me->SetWalk(true);
                    me->GetMotionMaster()->MovePoint(POINT_FIRST_STEP, firstStepPos.GetPositionX(), firstStepPos.GetPositionY(), firstStepPos.GetPositionZ());
                    break;
                case EVENT_INTRO_ALLIANCE_5:
                    Talk(SAY_INTRO_ALLIANCE_5);
                    GuardBroadcast(ACTION_CHARGE);
                    me->GetMotionMaster()->MoveCharge(chargePos[0].GetPositionX(), chargePos[0].GetPositionY(), chargePos[0].GetPositionZ(), 8.5f, POINT_CHARGE);
                    break;
            }
        }
    }
 
private:
    EventMap _events;
    InstanceScript* _instance;
};
 
struct npc_saurfang_event : public ScriptedAI
{
    npc_saurfang_event(Creature* creature) : ScriptedAI(creature)
    {
        _index = 0;
    }
 
    void SetData(uint32 type, uint32 data) override
    {
        if (!(!type && data && data < 6))
            return;
        _index = data;
    }
 
    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SPELL_GRIP_OF_AGONY)
        {
            me->SetDisableGravity(true);
            me->GetMotionMaster()->MovePoint(POINT_CHOKE, chokePos[_index]);
        }
    }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_CHARGE && _index)
            me->GetMotionMaster()->MoveCharge(chargePos[_index].GetPositionX(), chargePos[_index].GetPositionY(), chargePos[_index].GetPositionZ(), 13.0f, POINT_CHARGE);
        else if (action == ACTION_DESPAWN)
            me->DespawnOrUnsummon();
    }
 
private:
    uint32 _index;
};
 
// 72202 - Blood Link
class spell_deathbringer_blood_link : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_BLOOD_LINK_POWER, SPELL_BLOOD_POWER });
    }
 
    void HandleDummy(SpellEffIndex /*effIndex*/)
    {
        CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
        args.AddSpellBP0(GetEffectValue());
        GetHitUnit()->CastSpell(GetHitUnit(), SPELL_BLOOD_LINK_POWER, args);
        PreventHitDefaultEffect(EFFECT_0);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_deathbringer_blood_link::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 72178 - Blood Link
class spell_deathbringer_blood_link_aura : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_MARK_OF_THE_FALLEN_CHAMPION });
    }
 
    void HandlePeriodicTick(AuraEffect const* /*aurEff*/)
    {
        PreventDefaultAction();
        if (GetUnitOwner()->GetPowerType() == POWER_ENERGY && GetUnitOwner()->GetPower(POWER_ENERGY) == GetUnitOwner()->GetMaxPower(POWER_ENERGY))
            if (Creature* saurfang = GetUnitOwner()->ToCreature())
                saurfang->AI()->DoAction(ACTION_MARK_OF_THE_FALLEN_CHAMPION);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_deathbringer_blood_link_aura::HandlePeriodicTick, EFFECT_1, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 72371 - Blood Power
class spell_deathbringer_blood_power : public SpellScript
{
    void ModAuraValue()
    {
        if (Aura* aura = GetHitAura())
            aura->RecalculateAmountOfEffects();
    }
 
    void Register() override
    {
        AfterHit += SpellHitFn(spell_deathbringer_blood_power::ModAuraValue);
    }
};
 
class spell_deathbringer_blood_power_aura : public AuraScript
{
    void RecalculateHook(AuraEffect const* /*aurEffect*/, SpellEffectValue& amount, bool& canBeRecalculated)
    {
        amount = GetUnitOwner()->GetPower(POWER_ENERGY);
        canBeRecalculated = true;
    }
 
    void Register() override
    {
        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_deathbringer_blood_power_aura::RecalculateHook, EFFECT_0, SPELL_AURA_MOD_SCALE);
        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_deathbringer_blood_power_aura::RecalculateHook, EFFECT_1, SPELL_AURA_MOD_DAMAGE_PERCENT_DONE);
    }
};
 
// 72409, 72447, 72448, 72449 - Rune of Blood
class spell_deathbringer_rune_of_blood : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_BLOOD_LINK_DUMMY });
    }
 
    void HandleScript(SpellEffIndex effIndex)
    {
        PreventHitDefaultEffect(effIndex);  // make this the default handler
        GetHitUnit()->CastSpell(nullptr, SPELL_BLOOD_LINK_DUMMY, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellBP0(1));
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_deathbringer_rune_of_blood::HandleScript, EFFECT_1, SPELL_EFFECT_SCRIPT_EFFECT);
    }
};
 
// 72176 - Blood Beast's Blood Link
class spell_deathbringer_blood_beast_blood_link : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_BLOOD_LINK_DUMMY });
    }
 
    void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
    {
        PreventDefaultAction();
        eventInfo.GetProcTarget()->CastSpell(nullptr, SPELL_BLOOD_LINK_DUMMY, CastSpellExtraArgs(aurEff).AddSpellBP0(3));
    }
 
    void Register() override
    {
        OnEffectProc += AuraEffectProcFn(spell_deathbringer_blood_beast_blood_link::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
    }
};
 
// 72380, 72438, 72439, 72440 - Blood Nova
class spell_deathbringer_blood_nova : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_BLOOD_LINK_DUMMY });
    }
 
    void HandleScript(SpellEffIndex effIndex)
    {
        PreventHitDefaultEffect(effIndex);  // make this the default handler
        GetHitUnit()->CastSpell(nullptr, SPELL_BLOOD_LINK_DUMMY, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellBP0(2));
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_deathbringer_blood_nova::HandleScript, EFFECT_1, SPELL_EFFECT_SCRIPT_EFFECT);
    }
};
 
// 72378, 73058 - Blood Nova
class spell_deathbringer_blood_nova_targeting : public SpellScript
{
public:
    spell_deathbringer_blood_nova_targeting()
    {
        target = nullptr;
    }
 
private:
    void FilterTargetsInitial(std::list<WorldObject*>& targets)
    {
        if (targets.empty())
            return;
 
        // select one random target, preferring ranged targets
        uint32 targetsAtRange = 0;
        uint32 const minTargets = uint32(GetCaster()->GetMap()->Is25ManRaid() ? 10 : 4);
        targets.sort(Trinity::ObjectDistanceOrderPred(GetCaster(), false));
 
        // get target count at range
        for (std::list<WorldObject*>::iterator itr = targets.begin(); itr != targets.end(); ++itr, ++targetsAtRange)
            if ((*itr)->GetDistance(GetCaster()) < 12.0f)
                break;
 
        // If not enough ranged targets are present just select anyone
        if (targetsAtRange < minTargets)
            targetsAtRange = uint32(targets.size());
 
        std::list<WorldObject*>::const_iterator itr = targets.begin();
        std::advance(itr, urand(0, targetsAtRange - 1));
        target = *itr;
        targets.clear();
        targets.push_back(target);
    }
 
    // use the same target for first and second effect
    void FilterTargetsSubsequent(std::list<WorldObject*>& unitList)
    {
        unitList.clear();
        if (!target)
            return;
 
        unitList.push_back(target);
    }
 
    void HandleForceCast(SpellEffIndex /*effIndex*/)
    {
        GetCaster()->CastSpell(GetHitUnit(), uint32(GetEffectValueAsInt()), TRIGGERED_FULL_MASK);
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_deathbringer_blood_nova_targeting::FilterTargetsInitial, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_deathbringer_blood_nova_targeting::FilterTargetsSubsequent, EFFECT_1, TARGET_UNIT_SRC_AREA_ENEMY);
        OnEffectHitTarget += SpellEffectFn(spell_deathbringer_blood_nova_targeting::HandleForceCast, EFFECT_0, SPELL_EFFECT_FORCE_CAST);
    }
 
    WorldObject* target;
};
 
// 72385, 72441, 72442, 72443 - Boiling Blood
class spell_deathbringer_boiling_blood : public SpellScript
{
    bool Load() override
    {
        return GetCaster()->GetTypeId() == TYPEID_UNIT;
    }
 
    void FilterTargets(std::list<WorldObject*>& targets)
    {
        targets.remove(GetCaster()->GetVictim());
        if (targets.empty())
            return;
 
        WorldObject* target = Trinity::Containers::SelectRandomContainerElement(targets);
        targets.clear();
        targets.push_back(target);
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_deathbringer_boiling_blood::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
    }
};
 
// 72257 - Remove Marks of the Fallen Champion
class spell_deathbringer_remove_marks : public SpellScript
{
    void HandleScript(SpellEffIndex effIndex)
    {
        PreventHitDefaultEffect(effIndex);
        GetHitUnit()->RemoveAurasDueToSpell(uint32(GetEffectValueAsInt()));
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_deathbringer_remove_marks::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
    }
};
 
class achievement_ive_gone_and_made_a_mess : public AchievementCriteriaScript
{
    public:
        achievement_ive_gone_and_made_a_mess() : AchievementCriteriaScript("achievement_ive_gone_and_made_a_mess") { }
 
        bool OnCheck(Player* /*source*/, Unit* target) override
        {
            if (target)
                if (Creature* saurfang = target->ToCreature())
                    if (saurfang->AI()->GetData(DATA_MADE_A_MESS))
                        return true;
 
            return false;
        }
};
 
void AddSC_boss_deathbringer_saurfang()
{
    // Creatures
    RegisterIcecrownCitadelCreatureAI(boss_deathbringer_saurfang);
    RegisterIcecrownCitadelCreatureAI(npc_high_overlord_saurfang_icc);
    RegisterIcecrownCitadelCreatureAI(npc_muradin_bronzebeard_icc);
    RegisterIcecrownCitadelCreatureAI(npc_saurfang_event);
 
    // Spells
    RegisterSpellScript(spell_deathbringer_blood_link);
    RegisterSpellScript(spell_deathbringer_blood_link_aura);
    RegisterSpellAndAuraScriptPair(spell_deathbringer_blood_power, spell_deathbringer_blood_power_aura);
    RegisterSpellScript(spell_deathbringer_rune_of_blood);
    RegisterSpellScript(spell_deathbringer_blood_beast_blood_link);
    RegisterSpellScript(spell_deathbringer_blood_nova);
    RegisterSpellScript(spell_deathbringer_blood_nova_targeting);
    RegisterSpellScript(spell_deathbringer_boiling_blood);
    RegisterSpellScript(spell_deathbringer_remove_marks);
 
    // Achievements
    new achievement_ive_gone_and_made_a_mess();
}