boss_blood_prince_council.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 "InstanceScript.h"
#include "Map.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "PassiveAI.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "ScriptMgr.h"
#include "SpellAuraEffects.h"
#include "SpellInfo.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
 
enum Texts
{
    // Blood Queen Lana'Thel
    SAY_INTRO_1                 = 0,
    SAY_INTRO_2                 = 1,
 
    // Prince Keleseth
    SAY_KELESETH_INVOCATION     = 0,
    EMOTE_KELESETH_INVOCATION   = 1,
    SAY_KELESETH_SPECIAL        = 2,
    SAY_KELESETH_KILL           = 3,
    EMOTE_KELESETH_BERSERK      = 4,
    SAY_KELESETH_DEATH          = 5,
 
    // Prince Taldaram
    SAY_TALDARAM_INVOCATION     = 0,
    EMOTE_TALDARAM_INVOCATION   = 1,
    SAY_TALDARAM_SPECIAL        = 2,
    EMOTE_TALDARAM_FLAME        = 3,
    SAY_TALDARAM_KILL           = 4,
    EMOTE_TALDARAM_BERSERK      = 5,
    EMOTE_TALDARAM_DEATH        = 6,
 
    // Prince Valanar
    SAY_VALANAR_INVOCATION      = 0,
    EMOTE_VALANAR_INVOCATION    = 1,
    SAY_VALANAR_SPECIAL         = 2,
    EMOTE_VALANAR_SHOCK_VORTEX  = 3,
    SAY_VALANAR_KILL            = 4,
    SAY_VALANAR_BERSERK         = 5,
    SAY_VALANAR_DEATH           = 6
};
 
enum Spells
{
    SPELL_FEIGN_DEATH                   = 71598,
    SPELL_OOC_INVOCATION_VISUAL         = 70934,
    SPELL_INVOCATION_VISUAL_ACTIVE      = 71596,
 
    // Heroic mode
    SPELL_SHADOW_PRISON                 = 72998,
    SPELL_SHADOW_PRISON_DAMAGE          = 72999,
    SPELL_SHADOW_PRISON_DUMMY           = 73001,
 
    // Prince Keleseth
    SPELL_INVOCATION_OF_BLOOD_KELESETH  = 70981,
    SPELL_SHADOW_RESONANCE              = 71943,
    SPELL_SHADOW_LANCE                  = 71405,
    SPELL_EMPOWERED_SHADOW_LANCE        = 71815,
 
    // Dark Nucleus
    SPELL_SHADOW_RESONANCE_AURA         = 72980,
    SPELL_SHADOW_RESONANCE_RESIST       = 71822,
 
    // Prince Taldaram
    SPELL_INVOCATION_OF_BLOOD_TALDARAM  = 70982,
    SPELL_GLITTERING_SPARKS             = 71806,
    SPELL_CONJURE_FLAME                 = 71718,
    SPELL_CONJURE_EMPOWERED_FLAME       = 72040,
 
    // Ball of Flame
    SPELL_FLAME_SPHERE_SPAWN_EFFECT     = 55891,
    SPELL_BALL_OF_FLAMES_VISUAL         = 71706,
    SPELL_BALL_OF_FLAMES                = 71714,
    SPELL_FLAMES                        = 71393,
    SPELL_FLAME_SPHERE_DEATH_EFFECT     = 55947,
 
    // Ball of Inferno Flame
    SPELL_BALL_OF_FLAMES_PROC           = 71756,
    SPELL_BALL_OF_FLAMES_PERIODIC       = 71709,
 
    // Prince Valanar
    SPELL_INVOCATION_OF_BLOOD_VALANAR   = 70952,
    SPELL_KINETIC_BOMB_TARGET           = 72053,
    SPELL_KINETIC_BOMB                  = 72080,
    SPELL_SHOCK_VORTEX                  = 72037,
    SPELL_EMPOWERED_SHOCK_VORTEX        = 72039,
    SPELL_REMOVE_EMPOWERED_BLOOD        = 72131,
 
    // Kinetic Bomb
    SPELL_UNSTABLE                      = 72059,
    SPELL_KINETIC_BOMB_VISUAL           = 72054,
    SPELL_KINETIC_BOMB_EXPLOSION        = 72052,
    SPELL_KINETIC_BOMB_KNOCKBACK        = 72087,
 
    // Shock Vortex
    SPELL_SHOCK_VORTEX_PERIODIC         = 71945,
    SPELL_SHOCK_VORTEX_DUMMY            = 72633,
 
    // Visual Spells
    SPELL_INVOCATION_VISUAL_VALANAR     = 71070,
    SPELL_INVOCATION_VISUAL_TALDARAM    = 71081,
    SPELL_INVOCATION_VISUAL_KELESETH    = 71080
};
 
enum Events
{
    EVENT_INTRO_1               = 1,
    EVENT_INTRO_2,
 
    EVENT_INVOCATION_OF_BLOOD,
    EVENT_BERSERK,
 
    // Keleseth
    EVENT_SHADOW_RESONANCE,
    EVENT_SHADOW_LANCE,
 
    // Taldaram
    EVENT_GLITTERING_SPARKS,
    EVENT_CONJURE_FLAME,
 
    // Valanar
    EVENT_KINETIC_BOMB,
    EVENT_SHOCK_VORTEX,
    EVENT_BOMB_DESPAWN,
    EVENT_CONTINUE_FALLING
};
 
enum Actions
{
    ACTION_START_INTRO          = 1,
    ACTION_INTRO_DONE,
    ACTION_STAND_UP,
    ACTION_CAST_INVOCATION,
    ACTION_REMOVE_INVOCATION,
    ACTION_KINETIC_BOMB_JUMP,
    ACTION_FLAME_BALL_CHASE
};
 
enum Points
{
    POINT_INTRO_DESPAWN         = 380040,
    POINT_KINETIC_BOMB_IMPACT   = 384540
};
 
enum Misc
{
    DISPLAY_KINETIC_BOMB        = 31095,
    SUMMON_PRINCES_GROUP        = 1,
    DATA_INTRO                  = 2,
    DATA_INTRO_DONE             = 3,
    DATA_PRINCE_EVADE           = 4,
    DATA_CHASE_TARGET_GUID      = 5,
};
 
class StandUpEvent : public BasicEvent
{
    public:
        StandUpEvent(Creature* owner) : BasicEvent(), _owner(owner) { }
 
        bool Execute(uint64 /*eventTime*/, uint32 /*diff*/) override
        {
            _owner->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
            _owner->SetReactState(REACT_AGGRESSIVE);
            return true;
        }
 
    private:
        Creature* _owner;
};
 
class VortexEvent : public BasicEvent
{
public:
    VortexEvent(Creature* owner) : _owner(owner) { }
 
        bool Execute(uint64 /*eventTime*/, uint32 /*diff*/) override
        {
            _owner->CastSpell(_owner, SPELL_SHOCK_VORTEX_PERIODIC, true);
            return true;
        }
 
private:
    Creature* _owner;
};
 
Position const introFinalPos = {4660.490f, 2769.200f, 430.0000f, 0.000000f};
Position const triggerPos    = {4680.231f, 2769.134f, 379.9256f, 3.121708f};
Position const triggerEndPos = {4680.180f, 2769.150f, 365.5000f, 3.121708f};
 
uint32 const PrincesData[] =
{
    DATA_PRINCE_KELESETH,
    DATA_PRINCE_TALDARAM,
    DATA_PRINCE_VALANAR
};
 
struct boss_blood_council_controller : public BossAI
{
    boss_blood_council_controller(Creature* creature) : BossAI(creature, DATA_BLOOD_PRINCE_COUNCIL)
    {
        Initialize();
        SetCombatMovement(false);
    }
 
    void Initialize()
    {
        _invocationStage = 0;
        _resetCounter = 0;
    }
 
    void Reset() override
    {
        _Reset();
        Initialize();
        me->SummonCreatureGroup(SUMMON_PRINCES_GROUP);
 
        if (!instance->GetData(DATA_BLOOD_PRINCE_COUNCIL_INTRO))
            for (uint32 bossData : PrincesData)
                if (Creature* prince = ObjectAccessor::GetCreature(*me, instance->GetGuidData(bossData)))
                {
                    prince->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
                    prince->SetImmuneToPC(false);
                    if (bossData == DATA_PRINCE_VALANAR)
                    {
                        prince->SetHealth(prince->GetMaxHealth());
                        prince->CastSpell(prince, SPELL_REMOVE_EMPOWERED_BLOOD, true);
                    }
                }
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        for (uint32 bossData : PrincesData)
            if (Creature* prince = ObjectAccessor::GetCreature(*me, instance->GetGuidData(bossData)))
                instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, prince);
 
        summons.DespawnAll();
        _DespawnAtEvade();
    }
 
    void JustEngagedWith(Unit* who) override
    {
        if (instance->GetBossState(DATA_BLOOD_PRINCE_COUNCIL) == IN_PROGRESS)
            return;
 
        if (!instance->CheckRequiredBosses(DATA_BLOOD_PRINCE_COUNCIL, who->ToPlayer()))
        {
            EnterEvadeMode(EvadeReason::SequenceBreak);
            instance->DoCastSpellOnPlayers(LIGHT_S_HAMMER_TELEPORT);
            return;
        }
 
        me->setActive(true);
        DoZoneInCombat();
        instance->SetBossState(DATA_BLOOD_PRINCE_COUNCIL, IN_PROGRESS);
 
        DoCastSelf(SPELL_INVOCATION_OF_BLOOD_VALANAR);
 
        for (uint32 bossData : PrincesData)
            if (Creature* prince = ObjectAccessor::GetCreature(*me, instance->GetGuidData(bossData)))
            {
                instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, prince);
                DoZoneInCombat(prince);
            }
 
        events.ScheduleEvent(EVENT_INVOCATION_OF_BLOOD, Seconds(46) + Milliseconds(500));
 
        _invocationOrder[0] = InvocationData(instance->GetGuidData(DATA_PRINCE_VALANAR), SPELL_INVOCATION_OF_BLOOD_VALANAR, EMOTE_VALANAR_INVOCATION, SPELL_INVOCATION_VISUAL_VALANAR);
        if (roll_chance(50))
        {
            _invocationOrder[1] = InvocationData(instance->GetGuidData(DATA_PRINCE_TALDARAM), SPELL_INVOCATION_OF_BLOOD_TALDARAM, EMOTE_TALDARAM_INVOCATION, SPELL_INVOCATION_VISUAL_TALDARAM);
            _invocationOrder[2] = InvocationData(instance->GetGuidData(DATA_PRINCE_KELESETH), SPELL_INVOCATION_OF_BLOOD_KELESETH, EMOTE_KELESETH_INVOCATION, SPELL_INVOCATION_VISUAL_KELESETH);
        }
        else
        {
            _invocationOrder[1] = InvocationData(instance->GetGuidData(DATA_PRINCE_KELESETH), SPELL_INVOCATION_OF_BLOOD_KELESETH, EMOTE_KELESETH_INVOCATION, SPELL_INVOCATION_VISUAL_KELESETH);
            _invocationOrder[2] = InvocationData(instance->GetGuidData(DATA_PRINCE_TALDARAM), SPELL_INVOCATION_OF_BLOOD_TALDARAM, EMOTE_TALDARAM_INVOCATION, SPELL_INVOCATION_VISUAL_TALDARAM);
        }
    }
 
    void SetData(uint32 /*type*/, uint32 data) override
    {
        _resetCounter += uint8(data);
        if (_resetCounter == 3)
            EnterEvadeMode(EvadeReason::Other);
    }
 
    uint32 GetData(uint32 data) const override
    {
        if (data == DATA_INTRO && !instance->GetData(DATA_BLOOD_PRINCE_COUNCIL_INTRO))
            return DATA_INTRO_DONE;
        return 0;
    }
 
    void JustDied(Unit* killer) override
    {
        events.Reset();
        instance->SetBossState(DATA_BLOOD_PRINCE_COUNCIL, DONE);
        // Kill all prices
        for (uint8 i = 0; i < 3; ++i)
        {
            if (++_invocationStage == 3)
                _invocationStage = 0;
 
            if (Creature* prince = ObjectAccessor::GetCreature(*me, _invocationOrder[_invocationStage].guid))
            {
                // Make sure looting is allowed
                prince->LowerPlayerDamageReq(prince->GetMaxHealth());
                Unit::Kill(killer, prince);
            }
        }
    }
 
    void DoAction(int32 actionId) override
    {
        if (actionId == ACTION_START_INTRO && instance->GetData(DATA_BLOOD_PRINCE_COUNCIL_INTRO) && instance->GetBossState(DATA_BLOOD_PRINCE_COUNCIL) != DONE)
        {
            instance->SetData(DATA_BLOOD_PRINCE_COUNCIL_INTRO, 0);
            if (Creature* bloodQueen = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_BLOOD_QUEEN_LANA_THEL_COUNCIL)))
                bloodQueen->AI()->DoAction(ACTION_START_INTRO);
        }
        else if (actionId == ACTION_INTRO_DONE)
        {
            // Remove feigh death from princes
            for (uint32 bossData : PrincesData)
                if (Creature* prince = ObjectAccessor::GetCreature(*me, instance->GetGuidData(bossData)))
                {
                    prince->AI()->DoAction(ACTION_STAND_UP);
                    if (bossData == DATA_PRINCE_VALANAR)
                        prince->SetHealth(prince->GetMaxHealth());
                }
        }
    }
 
    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_INVOCATION_OF_BLOOD:
                {
                    Creature* oldPrince = ObjectAccessor::GetCreature(*me, _invocationOrder[_invocationStage].guid);
                    if (++_invocationStage == 3)
                        _invocationStage = 0;
 
                    Creature* newPrince = ObjectAccessor::GetCreature(*me, _invocationOrder[_invocationStage].guid);
                    if (oldPrince)
                    {
                        oldPrince->AI()->DoAction(ACTION_REMOVE_INVOCATION);
                        if (newPrince)
                            oldPrince->CastSpell(newPrince, _invocationOrder[_invocationStage].visualSpell, true);
                    }
 
                    if (newPrince)
                    {
                        newPrince->SetHealth(me->GetHealth());
                        newPrince->AI()->Talk(uint8(_invocationOrder[_invocationStage].textId));
                    }
 
                    DoCastSelf(_invocationOrder[_invocationStage].spellId);
                    events.Repeat(Seconds(46) + Milliseconds(500));
                    break;
                }
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
private:
    struct InvocationData
    {
        ObjectGuid guid;
        uint32 spellId;
        uint32 textId;
        uint32 visualSpell;
 
        InvocationData(ObjectGuid _guid, uint32 _spellId, uint32 _textId, uint32 _visualSpell)
        {
            guid = _guid;
            spellId = _spellId;
            textId = _textId;
            visualSpell = _visualSpell;
        }
 
        InvocationData() : spellId(0), textId(0), visualSpell(0) { }
    } _invocationOrder[3];
 
    uint32 _invocationStage;
    uint32 _resetCounter;
};
 
struct BloodPrincesBossAI : public BossAI
{
    BloodPrincesBossAI(Creature* creature, uint32 bossId) : BossAI(creature, bossId), _spawnHealth (creature->GetMaxHealth()), _isEmpowered(false)
    {
        SetBoundary(instance->GetBossBoundary(DATA_BLOOD_PRINCE_COUNCIL));
    }
 
    void InitializeAI() override
    {
        _spawnHealth = 1;
        if (!me->isDead())
            JustAppeared();
    }
 
    void Reset() override
    {
        events.Reset();
        summons.DespawnAll();
 
        me->SetImmuneToPC(false);
        _isEmpowered = false;
        me->SetHealth(_spawnHealth);
        instance->SetData(DATA_ORB_WHISPERER_ACHIEVEMENT, uint32(true));
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        me->setActive(true);
        if (Creature* controller = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_BLOOD_PRINCES_CONTROL)))
            DoZoneInCombat(controller);
        ScheduleEvents();
    }
 
    virtual void ScheduleEvents() = 0;
 
    void JustDied(Unit* /*killer*/) override
    {
        events.Reset();
        summons.DespawnAll();
        instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
 
        switch (me->GetEntry())
        {
            case NPC_PRINCE_KELESETH:
                Talk(SAY_KELESETH_DEATH);
                break;
            case NPC_PRINCE_TALDARAM:
                Talk(EMOTE_TALDARAM_DEATH);
                break;
            case NPC_PRINCE_VALANAR:
                Talk(SAY_VALANAR_DEATH);
                break;
            default:
                break;
        }
    }
 
    void JustAppeared() override
    {
        if (Creature* controller = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_BLOOD_PRINCES_CONTROL)))
            if (controller->AI()->GetData(DATA_INTRO) != DATA_INTRO_DONE)
                DoCastSelf(SPELL_FEIGN_DEATH);
 
        me->SetHealth(_spawnHealth);
    }
 
    void DamageTaken(Unit* attacker, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (!_isEmpowered)
        {
            AddThreat(attacker, float(damage));
            damage = 0;
        }
    }
 
    void KilledUnit(Unit* victim) override
    {
        if (victim->GetTypeId() == TYPEID_PLAYER)
            switch (me->GetEntry())
            {
                case NPC_PRINCE_KELESETH:
                    Talk(SAY_KELESETH_KILL);
                    break;
                case NPC_PRINCE_TALDARAM:
                    Talk(SAY_TALDARAM_KILL);
                    break;
                case NPC_PRINCE_VALANAR:
                    Talk(SAY_VALANAR_KILL);
                    break;
                default:
                    break;
            }
    }
 
    void JustReachedHome() override
    {
        instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, me);
        me->SetHealth(_spawnHealth);
        _isEmpowered = false;
        if (Creature* controller = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_BLOOD_PRINCES_CONTROL)))
        {
            me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
            controller->AI()->SetData(DATA_PRINCE_EVADE, 1);
        }
    }
 
    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SelectInvocationSpell())
            DoAction(ACTION_CAST_INVOCATION);
    }
 
    void DamageDealt(Unit* /*target*/, uint32& damage, DamageEffectType damageType) override
    {
        if (damageType != SPELL_DIRECT_DAMAGE)
            return;
 
        if (damage > RAID_MODE<uint32>(23000, 25000, 23000, 25000))
            instance->SetData(DATA_ORB_WHISPERER_ACHIEVEMENT, uint32(false));
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_STAND_UP:
                me->RemoveAurasDueToSpell(SPELL_FEIGN_DEATH);
                me->SetUninteractible(false);
                me->SetImmuneToPC(false);
                me->RemoveUnitFlag3(UNIT_FLAG3_FAKE_DEAD);
                me->m_Events.AddEvent(new StandUpEvent(me), me->m_Events.CalculateTime(1s));
                break;
            case ACTION_CAST_INVOCATION:
                Talk(SelectInvocationSay());
                DoCastSelf(SPELL_INVOCATION_VISUAL_ACTIVE, true);
                _isEmpowered = true;
                break;
            case ACTION_REMOVE_INVOCATION:
                me->SetHealth(_spawnHealth);
                me->RemoveAurasDueToSpell(SPELL_INVOCATION_VISUAL_ACTIVE);
                me->RemoveAurasDueToSpell(SelectInvocationSpell());
                _isEmpowered = false;
                break;
            default:
                break;
        }
    }
 
    uint32 SelectInvocationSay()
    {
        switch (me->GetEntry())
        {
            case NPC_PRINCE_KELESETH:
                return SAY_KELESETH_INVOCATION;
            case NPC_PRINCE_TALDARAM:
                return SAY_TALDARAM_INVOCATION;
            case NPC_PRINCE_VALANAR:
                return SAY_KELESETH_INVOCATION;
            default: // Should never happen
                return 0;
        }
    }
 
    uint32 SelectInvocationSpell()
    {
        switch (me->GetEntry())
        {
            case NPC_PRINCE_KELESETH:
                return SPELL_INVOCATION_OF_BLOOD_KELESETH;
            case NPC_PRINCE_TALDARAM:
                return SPELL_INVOCATION_OF_BLOOD_TALDARAM;
            case NPC_PRINCE_VALANAR:
                return SPELL_INVOCATION_OF_BLOOD_VALANAR;
            default: // Should never happen
                return 0;
        }
    }
 
protected:
    uint32 _spawnHealth;
    bool _isEmpowered;
};
 
struct boss_prince_keleseth_icc : public BloodPrincesBossAI
{
    boss_prince_keleseth_icc(Creature* creature) : BloodPrincesBossAI(creature, DATA_PRINCE_KELESETH)
    {
        me->SetCanMelee(false);
    }
 
    void ScheduleEvents() override
    {
        events.ScheduleEvent(EVENT_BERSERK, 10min);
        events.ScheduleEvent(EVENT_SHADOW_RESONANCE, 10s, 15s);
        events.ScheduleEvent(EVENT_SHADOW_LANCE, 2s);
 
        if (IsHeroic())
        {
            DoCastSelf(SPELL_SHADOW_PRISON, true);
            DoCastSelf(SPELL_SHADOW_PRISON_DUMMY);
        }
    }
 
    void JustSummoned(Creature* summon) override
    {
        summons.Summon(summon);
        Position pos = me->GetPosition();
        float maxRange = me->GetDistance2d(summon);
        float angle = me->GetAbsoluteAngle(summon);
        me->MovePositionToFirstCollision(pos, maxRange, angle);
        summon->NearTeleportTo(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation());
        summon->ToTempSummon()->SetTempSummonType(TEMPSUMMON_CORPSE_DESPAWN);
    }
 
    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_BERSERK:
                    DoCastSelf(SPELL_BERSERK);
                    Talk(EMOTE_KELESETH_BERSERK);
                    break;
                case EVENT_SHADOW_RESONANCE:
                    Talk(SAY_KELESETH_SPECIAL);
                    DoCastSelf(SPELL_SHADOW_RESONANCE);
                    events.Repeat(Seconds(10), Seconds(15));
                    break;
                case EVENT_SHADOW_LANCE:
                    _isEmpowered ? DoCastVictim(SPELL_EMPOWERED_SHADOW_LANCE) : DoCastVictim(SPELL_SHADOW_LANCE);
                    events.Repeat(Seconds(2));
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
};
 
struct boss_prince_taldaram_icc : public BloodPrincesBossAI
{
    boss_prince_taldaram_icc(Creature* creature) : BloodPrincesBossAI(creature, DATA_PRINCE_TALDARAM) { }
 
    void ScheduleEvents() override
    {
        events.ScheduleEvent(EVENT_BERSERK, 10min);
        events.ScheduleEvent(EVENT_GLITTERING_SPARKS, 12s, 15s);
        events.ScheduleEvent(EVENT_CONJURE_FLAME, 20s);
        if (IsHeroic())
            DoCastSelf(SPELL_SHADOW_PRISON, true);
    }
 
    void JustSummoned(Creature* summon) override
    {
        summons.Summon(summon);
        Unit* target = SelectTarget(SelectTargetMethod::Random, 1, -10.0f, true); // first try at distance
        if (!target)
            target = SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true);     // too bad for you raiders, its going to boom
 
        if (summon->GetEntry() == NPC_BALL_OF_INFERNO_FLAME && target)
            Talk(EMOTE_TALDARAM_FLAME, target);
 
        if (target)
            summon->AI()->SetGUID(target->GetGUID(), DATA_CHASE_TARGET_GUID);
    }
 
    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_BERSERK:
                    DoCastSelf(SPELL_BERSERK);
                    Talk(EMOTE_TALDARAM_BERSERK);
                    break;
                case EVENT_GLITTERING_SPARKS:
                    DoCastVictim(SPELL_GLITTERING_SPARKS);
                    events.Repeat(Seconds(15), Seconds(50));
                    break;
                case EVENT_CONJURE_FLAME:
                    if (_isEmpowered)
                    {
                        DoCastSelf(SPELL_CONJURE_EMPOWERED_FLAME);
                        events.Repeat(Seconds(15), Seconds(25));
                    }
                    else
                    {
                        DoCastSelf(SPELL_CONJURE_FLAME);
                        events.Repeat(Seconds(20), Seconds(30));
                    }
                    Talk(SAY_TALDARAM_SPECIAL);
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
};
 
struct boss_prince_valanar_icc : public BloodPrincesBossAI
{
    boss_prince_valanar_icc(Creature* creature) : BloodPrincesBossAI(creature, DATA_PRINCE_VALANAR) { }
 
    void ScheduleEvents() override
    {
        events.ScheduleEvent(EVENT_BERSERK, 10min);
        events.ScheduleEvent(EVENT_KINETIC_BOMB, 18s, 24s);
        events.ScheduleEvent(EVENT_SHOCK_VORTEX, 15s, 20s);
        if (IsHeroic())
            DoCastSelf(SPELL_SHADOW_PRISON, true);
    }
 
    void JustSummoned(Creature* summon) override
    {
        switch (summon->GetEntry())
        {
            case NPC_KINETIC_BOMB_TARGET:
                summon->SetReactState(REACT_PASSIVE);
                summon->CastSpell(summon, SPELL_KINETIC_BOMB, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
                    .SetOriginalCaster(me->GetGUID()));
                break;
            case NPC_KINETIC_BOMB:
            {
                float x, y, z;
                summon->GetPosition(x, y, z);
                float ground_Z = summon->GetMap()->GetHeight(summon->GetPhaseShift(), x, y, z, true, 500.0f);
                summon->GetMotionMaster()->MovePoint(POINT_KINETIC_BOMB_IMPACT, x, y, ground_Z);
                summon->SetUninteractible(false);
                break;
            }
            case NPC_SHOCK_VORTEX:
                summon->CastSpell(summon, SPELL_SHOCK_VORTEX_DUMMY, true);
                summon->m_Events.AddEvent(new VortexEvent(summon), summon->m_Events.CalculateTime(5s));
                break;
            default:
                break;
        }
 
        summons.Summon(summon);
        if (me->IsInCombat())
            DoZoneInCombat(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_BERSERK:
                    DoCastSelf(SPELL_BERSERK);
                    Talk(SAY_VALANAR_BERSERK);
                    break;
                case EVENT_KINETIC_BOMB:
                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1, 0.0f, true))
                    {
                        DoCast(target, SPELL_KINETIC_BOMB_TARGET);
                        Talk(SAY_VALANAR_SPECIAL);
                    }
                    events.Repeat(Seconds(18), Seconds(24));
                    break;
                case EVENT_SHOCK_VORTEX:
                    if (_isEmpowered)
                    {
                        DoCastSelf(SPELL_EMPOWERED_SHOCK_VORTEX);
                        Talk(EMOTE_VALANAR_SHOCK_VORTEX);
                        events.Repeat(Seconds(30));
                    }
                    else
                    {
                        if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1, 0.0f, true))
                            DoCast(target, SPELL_SHOCK_VORTEX);
                        events.Repeat(Seconds(18), Seconds(23));
                    }
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
};
 
struct npc_blood_queen_lana_thel : public PassiveAI
{
    npc_blood_queen_lana_thel(Creature* creature) : PassiveAI(creature), _instance(creature->GetInstanceScript()) { }
 
    void Reset() override
    {
        _events.Reset();
        me->SetDisableGravity(true);
        _instance->GetBossState(DATA_BLOOD_PRINCE_COUNCIL) != DONE ? me->SetVisible(true) : me->SetVisible(false);
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_START_INTRO:
                Talk(SAY_INTRO_1);
                _events.SetPhase(1);
                _events.ScheduleEvent(EVENT_INTRO_1, Seconds(14));
                // summon a visual trigger
                if (Creature* summon = DoSummon(NPC_FLOATING_TRIGGER, triggerPos, 15s, TEMPSUMMON_TIMED_DESPAWN))
                {
                    summon->CastSpell(summon, SPELL_OOC_INVOCATION_VISUAL, true);
                    summon->SetSpeedRate(MOVE_RUN, 0.14f);
                    summon->GetMotionMaster()->MovePoint(0, triggerEndPos);
                }
                break;
            default:
                break;
        }
    }
 
    void MovementInform(uint32 type, uint32 id) override
    {
        if (type == POINT_MOTION_TYPE && id == POINT_INTRO_DESPAWN)
            me->SetVisible(false);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!_events.GetPhaseMask())
            return;
 
        _events.Update(diff);
 
        if (_events.ExecuteEvent() == EVENT_INTRO_1)
        {
            Talk(SAY_INTRO_2);
            me->GetMotionMaster()->MovePoint(POINT_INTRO_DESPAWN, introFinalPos);
            _events.Reset();
 
            if (Creature* controller = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_BLOOD_PRINCES_CONTROL)))
                controller->AI()->DoAction(ACTION_INTRO_DONE);
        }
    }
 
private:
    EventMap _events;
    InstanceScript* _instance;
};
 
struct npc_ball_of_flame : public ScriptedAI
{
    npc_ball_of_flame(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
    void Reset() override
    {
        DoCastSelf(SPELL_FLAME_SPHERE_SPAWN_EFFECT, true);
        DoCastSelf(SPELL_BALL_OF_FLAMES_VISUAL, true);
        if (me->GetEntry() == NPC_BALL_OF_INFERNO_FLAME)
        {
            DoCastSelf(SPELL_BALL_OF_FLAMES_PROC, true);
            DoCastSelf(SPELL_BALL_OF_FLAMES_PERIODIC, true);
        }
    }
 
    void MovementInform(uint32 type, uint32 id) override
    {
        if (type == CHASE_MOTION_TYPE && id == _chaseGUID.GetCounter() && !_chaseGUID.IsEmpty())
        {
            me->RemoveAurasDueToSpell(SPELL_BALL_OF_FLAMES_PERIODIC);
            DoCastSelf(SPELL_FLAMES);
            _scheduler.Schedule(Seconds(2), [this](TaskContext const& /*context*/)
            {
                DoCastSelf(SPELL_FLAME_SPHERE_DEATH_EFFECT);
            });
            _chaseGUID.Clear();
        }
    }
 
    void SetGUID(ObjectGuid const& guid, int32 id) override
    {
        if (id != DATA_CHASE_TARGET_GUID)
            return;
 
        _chaseGUID = guid;
    }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_FLAME_BALL_CHASE)
            if (Player* target = ObjectAccessor::GetPlayer(*me, _chaseGUID))
            {
                // need to clear states now because this call is before AuraEffect is fully removed
                me->ClearUnitState(UNIT_STATE_CASTING | UNIT_STATE_STUNNED);
                if (me->Attack(target, true))
                    me->GetMotionMaster()->MoveChase(target, 1.0f);
            }
    }
 
    void DamageDealt(Unit* /*target*/, uint32& damage, DamageEffectType damageType) override
    {
        if (damageType != SPELL_DIRECT_DAMAGE)
            return;
 
        if (damage > RAID_MODE<uint32>(23000, 25000, 23000, 25000))
            _instance->SetData(DATA_ORB_WHISPERER_ACHIEVEMENT, uint32(false));
    }
 
    void UpdateAI(uint32 diff) override
    {
        _scheduler.Update(diff);
    }
 
private:
    ObjectGuid _chaseGUID;
    InstanceScript* _instance;
    TaskScheduler _scheduler;
};
 
struct npc_kinetic_bomb : public ScriptedAI
{
    npc_kinetic_bomb(Creature* creature) : ScriptedAI(creature), _x(0.f), _y(0.f), _groundZ(0.f) { }
 
    void Reset() override
    {
        _events.Reset();
        me->SetWalk(true);
        DoCastSelf(SPELL_UNSTABLE, true);
        DoCastSelf(SPELL_KINETIC_BOMB_VISUAL, true);
        me->SetReactState(REACT_PASSIVE);
        me->GetPosition(_x, _y, _groundZ);
        me->DespawnOrUnsummon(60s);
        _groundZ = me->GetMap()->GetHeight(me->GetPhaseShift(), _x, _y, _groundZ, true, 500.0f);
    }
 
    void DoAction(int32 action) override
    {
        if (action == SPELL_KINETIC_BOMB_EXPLOSION)
            _events.ScheduleEvent(EVENT_BOMB_DESPAWN, 1s);
 
        else if (action == ACTION_KINETIC_BOMB_JUMP)
        {
            if (!me->HasAura(SPELL_KINETIC_BOMB_KNOCKBACK))
            {
                me->GetMotionMaster()->Clear();
                me->GetMotionMaster()->MoveCharge(_x, _y, me->GetPositionZ() + 100.0f, me->GetSpeed(MOVE_RUN), POINT_KINETIC_BOMB_IMPACT);
            }
            _events.RescheduleEvent(EVENT_CONTINUE_FALLING, Seconds(3));
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        _events.Update(diff);
 
        while (uint32 eventId = _events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_BOMB_DESPAWN:
                    me->SetVisible(false);
                    me->DespawnOrUnsummon(5s);
                    break;
                case EVENT_CONTINUE_FALLING:
                    me->GetMotionMaster()->Clear();
                    me->GetMotionMaster()->MoveCharge(_x, _y, _groundZ, me->GetSpeed(MOVE_RUN), POINT_KINETIC_BOMB_IMPACT);
                    break;
                default:
                    break;
            }
        }
    }
 
private:
    EventMap _events;
    float _x;
    float _y;
    float _groundZ;
};
 
struct npc_dark_nucleus : public ScriptedAI
{
    npc_dark_nucleus(Creature* creature) : ScriptedAI(creature) { }
 
    void Reset() override
    {
        me->SetReactState(REACT_DEFENSIVE);
        DoCastSelf(SPELL_SHADOW_RESONANCE_AURA, true);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        _scheduler.Schedule(Seconds(1), [this](TaskContext& targetAuraCheck)
        {
            if (Unit* victim = me->GetVictim())
            {
                if (me->GetDistance(victim) < 15.0f && !victim->HasAura(SPELL_SHADOW_RESONANCE_RESIST, me->GetGUID()))
                    DoCast(victim, SPELL_SHADOW_RESONANCE_RESIST);
                else
                    MoveInLineOfSight(me->GetVictim());
            }
            targetAuraCheck.Repeat();
        });
 
        if (me->GetDistance(who) >= 15.0f)
        {
            DoStartMovement(who);
            return;
        }
 
        DoCast(who, SPELL_SHADOW_RESONANCE_RESIST);
    }
 
    void DamageTaken(Unit* attacker, uint32& /*damage*/, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (attacker == me)
            return;
 
        me->GetThreatManager().ResetAllThreat();
        AddThreat(attacker, 500000000.0f);
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        _scheduler.Update(diff);
    }
 
private:
    TaskScheduler _scheduler;
};
 
// 71806 - Glittering Sparks
class spell_taldaram_glittering_sparks : public SpellScript
{
    void HandleScript(SpellEffIndex effIndex)
    {
        PreventHitDefaultEffect(effIndex);
        GetCaster()->CastSpell(GetCaster(), uint32(GetEffectValueAsInt()), true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_taldaram_glittering_sparks::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
    }
};
 
/* 71718 - Conjure Flame
   72040 - Conjure Empowered Flame */
class spell_taldaram_summon_flame_ball : public SpellScript
{
    void HandleScript(SpellEffIndex effIndex)
    {
        PreventHitDefaultEffect(effIndex);
        GetCaster()->CastSpell(GetCaster(), uint32(GetEffectValueAsInt()), true);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_taldaram_summon_flame_ball::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
/* 55891 - Flame Sphere Spawn Effect
   55947 - Flame Sphere Death Effect */
class spell_taldaram_flame_ball_visual : public AuraScript
{
    bool Load() override
    {
        if (GetCaster()->GetEntry() == NPC_BALL_OF_FLAME || GetCaster()->GetEntry() == NPC_BALL_OF_INFERNO_FLAME)
            return true;
        return false;
    }
 
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_BALL_OF_FLAMES });
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        Creature* target = GetTarget()->ToCreature();
        if (!target)
            return;
 
        // SPELL_FLAME_SPHERE_SPAWN_EFFECT
        if (GetSpellInfo()->Id == SPELL_FLAME_SPHERE_SPAWN_EFFECT)
        {
            target->CastSpell(target, SPELL_BALL_OF_FLAMES, true);
            target->AI()->DoAction(ACTION_FLAME_BALL_CHASE);
        }
        else // SPELL_FLAME_SPHERE_DEATH_EFFECT
            target->DespawnOrUnsummon();
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_taldaram_flame_ball_visual::OnRemove, EFFECT_0, SPELL_AURA_MOD_STUN, AURA_EFFECT_HANDLE_REAL);
    }
};
 
/* 71756 - Ball of Flames Proc
   72782 - Ball of Flames Proc
   72783 - Ball of Flames Proc
   72784 - Ball of Flames Proc */
class spell_taldaram_ball_of_inferno_flame : public SpellScript
{
    void ModAuraStack()
    {
        if (Aura* aur = GetHitAura())
            aur->SetStackAmount(uint8(GetSpellInfo()->StackAmount));
    }
 
    void Register() override
    {
        AfterHit += SpellHitFn(spell_taldaram_ball_of_inferno_flame::ModAuraStack);
    }
};
 
class spell_taldaram_ball_of_inferno_flame_aura : public AuraScript
{
    void HandleStackDrop(ProcEventInfo& /*eventInfo*/)
    {
        ModStackAmount(-1);
    }
 
    void Register() override
    {
        OnProc += AuraProcFn(spell_taldaram_ball_of_inferno_flame_aura::HandleStackDrop);
    }
};
 
// 72080 - Kinetic Bomb
class spell_valanar_kinetic_bomb : public SpellScript
{
    void SetDest(SpellDestination& dest)
    {
        Position const offset = { 0.0f, 0.0f, 20.0f, 0.0f };
        dest.RelocateOffset(offset);
    }
 
    void Register() override
    {
        OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_valanar_kinetic_bomb::SetDest, EFFECT_0, TARGET_DEST_CASTER);
    }
};
 
class spell_valanar_kinetic_bomb_aura : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_KINETIC_BOMB_EXPLOSION, SPELL_KINETIC_BOMB_VISUAL });
    }
 
    void HandleDummyTick(AuraEffect const* /*aurEff*/)
    {
        Unit* target = GetTarget();
        if (target->GetTypeId() != TYPEID_UNIT)
            return;
 
        if (Creature* bomb = target->FindNearestCreature(NPC_KINETIC_BOMB, 1.0f, true))
        {
            bomb->CastSpell(bomb, SPELL_KINETIC_BOMB_EXPLOSION, true);
            bomb->RemoveAurasDueToSpell(SPELL_KINETIC_BOMB_VISUAL);
            target->RemoveAura(GetAura());
            bomb->AI()->DoAction(SPELL_KINETIC_BOMB_EXPLOSION);
        }
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_valanar_kinetic_bomb_aura::HandleDummyTick, EFFECT_1, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 72087 - Kinetic Bomb Knockback
class spell_valanar_kinetic_bomb_knockback : public SpellScript
{
    void KnockIntoAir(SpellMissInfo missInfo)
    {
        if (missInfo != SPELL_MISS_NONE)
            return;
 
        if (Creature* target = GetHitCreature())
            target->AI()->DoAction(ACTION_KINETIC_BOMB_JUMP);
    }
 
    void Register() override
    {
        BeforeHit += BeforeSpellHitFn(spell_valanar_kinetic_bomb_knockback::KnockIntoAir);
    }
};
 
// 72054 - Kinetic Bomb Visual
class spell_valanar_kinetic_bomb_absorb : public AuraScript
{
    void OnAbsorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
    {
        absorbAmount = CalculatePct(dmgInfo.GetDamage(), aurEff->GetAmount());
        RoundToInterval<uint32>(absorbAmount, 0, dmgInfo.GetDamage());
        dmgInfo.AbsorbDamage(absorbAmount);
    }
 
    void Register() override
    {
        OnEffectAbsorb += AuraEffectAbsorbFn(spell_valanar_kinetic_bomb_absorb::OnAbsorb, EFFECT_0);
    }
};
 
// 73001 - Shadow Prison
class spell_blood_council_shadow_prison : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_SHADOW_PRISON_DAMAGE });
    }
 
    void HandleDummyTick(AuraEffect const* aurEff)
    {
        if (GetTarget()->isMoving())
            GetTarget()->CastSpell(GetTarget(), SPELL_SHADOW_PRISON_DAMAGE, aurEff);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_blood_council_shadow_prison::HandleDummyTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
// 72999 - Shadow Prison
class spell_blood_council_shadow_prison_damage : public SpellScript
{
    void CalculateDamage(SpellEffectInfo const& /*spellEffectInfo*/, Unit const* victim, int32& /*damage*/, int32& flatMod, float& /*pctMod*/) const
    {
        if (Aura const* aur = victim->GetAura(GetSpellInfo()->Id))
            if (AuraEffect const* eff = aur->GetEffect(EFFECT_1))
                flatMod += eff->GetAmountAsInt();
    }
 
    void Register() override
    {
        CalcDamage += SpellCalcDamageFn(spell_blood_council_shadow_prison_damage::CalculateDamage);
    }
};
 
class at_blood_prince_council_start_intro : public AreaTriggerScript
{
    public:
        at_blood_prince_council_start_intro() : AreaTriggerScript("at_blood_prince_council_start_intro") { }
 
        bool OnTrigger(Player* player, AreaTriggerEntry const* /*areaTrigger*/) override
        {
            if (InstanceScript* instance = player->GetInstanceScript())
                if (Creature* controller = ObjectAccessor::GetCreature(*player, instance->GetGuidData(DATA_BLOOD_PRINCES_CONTROL)))
                    controller->AI()->DoAction(ACTION_START_INTRO);
 
            return true;
        }
};
 
void AddSC_boss_blood_prince_council()
{
    // Creatures
    RegisterIcecrownCitadelCreatureAI(boss_blood_council_controller);
    RegisterIcecrownCitadelCreatureAI(boss_prince_keleseth_icc);
    RegisterIcecrownCitadelCreatureAI(boss_prince_taldaram_icc);
    RegisterIcecrownCitadelCreatureAI(boss_prince_valanar_icc);
    RegisterIcecrownCitadelCreatureAI(npc_blood_queen_lana_thel);
    RegisterIcecrownCitadelCreatureAI(npc_ball_of_flame);
    RegisterIcecrownCitadelCreatureAI(npc_kinetic_bomb);
    RegisterIcecrownCitadelCreatureAI(npc_dark_nucleus);
 
    // Spells
    RegisterSpellScript(spell_taldaram_glittering_sparks);
    RegisterSpellScript(spell_taldaram_summon_flame_ball);
    RegisterSpellScript(spell_taldaram_flame_ball_visual);
    RegisterSpellAndAuraScriptPair(spell_taldaram_ball_of_inferno_flame, spell_taldaram_ball_of_inferno_flame_aura);
    RegisterSpellAndAuraScriptPair(spell_valanar_kinetic_bomb, spell_valanar_kinetic_bomb_aura);
    RegisterSpellScript(spell_valanar_kinetic_bomb_knockback);
    RegisterSpellScript(spell_valanar_kinetic_bomb_absorb);
    RegisterSpellScript(spell_blood_council_shadow_prison);
    RegisterSpellScript(spell_blood_council_shadow_prison_damage);
 
    // AreaTriggers
    new at_blood_prince_council_start_intro();
}