boss_illidari_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 "ScriptMgr.h"
#include "black_temple.h"
#include "CellImpl.h"
#include "Containers.h"
#include "GridNotifiersImpl.h"
#include "InstanceScript.h"
#include "PassiveAI.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "SpellScript.h"
 
enum Says
{
    SAY_COUNCIL_AGRO     = 0,
    SAY_COUNCIL_ENRAGE   = 1,
    SAY_COUNCIL_SPECIAL  = 2,
    SAY_COUNCIL_SLAY     = 3,
    SAY_COUNCIL_COMNT    = 4,
    SAY_COUNCIL_DEATH    = 5
};
 
enum Spells
{
    // Illidari Council (Trigger)
    SPELL_EMPYREAL_BALANCE         = 41499,
    SPELL_EMPYREAL_EQUIVALENCY     = 41333,
 
    // Generic
    SPELL_SHARED_RULE              = 41342,
    SPELL_BERSERK                  = 45078,
    SPELL_BALANCE_OF_POWER         = 41341,
    SPELL_QUIET_SUICIDE            = 3617,
 
    // High Nethermancer Zerevor's
    SPELL_FLAMESTRIKE              = 41481,
    SPELL_BLIZZARD                 = 41482,
    SPELL_ARCANE_BOLT              = 41483,
    SPELL_ARCANE_EXPLOSION         = 41524,
    SPELL_DAMPEN_MAGIC             = 41478,
 
    // Lady Malande's
    SPELL_EMPOWERED_SMITE          = 41471,
    SPELL_CIRCLE_OF_HEALING        = 41455,
    SPELL_REFLECTIVE_SHIELD        = 41475,
    SPELL_REFLECTIVE_SHIELD_DAMAGE = 33619,
    SPELL_DIVINE_WRATH             = 41472,
 
    // Gathios the Shatterer's
    SPELL_BLESS_PROTECTION         = 41450,
    SPELL_BLESS_SPELL_WARDING      = 41451,
    SPELL_CONSECRATION             = 41541,
    SPELL_HAMMER_OF_JUSTICE        = 41468,
    SPELL_SEAL_OF_COMMAND          = 41469,
    SPELL_SEAL_OF_BLOOD            = 41459,
    SPELL_CHROMATIC_AURA           = 41453,
    SPELL_DEVOTION_AURA            = 41452,
    SPELL_JUDGEMENT_PRIMER         = 41473,
    SPELL_JUDGEMENT                = 41467,
    SPELL_JUDGEMENT_OF_COMMAND     = 41470,
    SPELL_JUDGEMENT_OF_BLOOD       = 41461,
 
    // Veras Darkshadow's
    SPELL_DEADLY_STRIKE             = 41480,
    SPELL_DEADLY_POISON             = 41485,
    SPELL_ENVENOM                   = 41487,
    SPELL_ENVENOM_VISUAL            = 41509,
    SPELL_VANISH                    = 41476,
    SPELL_VANISH_TELEPORT           = 41479,
 
    // Veras Vanish Effect
    SPELL_BIRTH                     = 40031,
    SPELL_ENVENOM_DUMMY             = 41510
};
 
enum IllidariEvents
{
    EVENT_EMPYREAL_EQUIVALENCY = 1,
    EVENT_VANISH,
    EVENT_FLAMESTRIKE,
    EVENT_BLIZZARD,
    EVENT_ARCANE_EXPLOSION,
    EVENT_ARCANE_EXPLOSION_CHECK,
    EVENT_DAMPEN_MAGIC,
    EVENT_BLESS,
    EVENT_CONSECRATION,
    EVENT_AURA,
    EVENT_JUDGEMENT,
    EVENT_HAMMER_OF_JUSTICE,
    EVENT_CIRCLE_OF_HEALING,
    EVENT_REFLECTIVE_SHIELD,
    EVENT_DIVINE_WRATH,
    EVENT_BERSERK
};
 
enum IllidariMisc
{
    SUMMON_COUNCIL_GROUP = 1,
    ACTION_REFRESH_DAMPEN
};
 
uint32 const CouncilData[4] =
{
    DATA_GATHIOS_THE_SHATTERER,
    DATA_HIGH_NETHERMANCER_ZEREVOR,
    DATA_LADY_MALANDE,
    DATA_VERAS_DARKSHADOW
};
 
static uint32 GetRandomBossExcept(uint32 exception)
{
    std::vector<uint32> bossData;
    for (uint32 data : CouncilData)
        if (data != exception)
            bossData.emplace_back(data);
 
    return Trinity::Containers::SelectRandomContainerElement(bossData);
}
 
struct boss_illidari_council : public BossAI
{
    boss_illidari_council(Creature* creature) : BossAI(creature, DATA_ILLIDARI_COUNCIL), _inCombat(false) { }
 
    void Reset() override
    {
        _Reset();
        _inCombat = false;
        me->SummonCreatureGroup(SUMMON_COUNCIL_GROUP);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        if (!_inCombat)
        {
            _inCombat = true;
            BossAI::JustEngagedWith(who);
            DoCastSelf(SPELL_EMPYREAL_BALANCE, true);
            for (uint32 bossData : CouncilData)
            {
                if (Creature* council = instance->GetCreature(bossData))
                {
                    instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, council);
                    DoZoneInCombat(council);
                }
            }
            events.ScheduleEvent(EVENT_EMPYREAL_EQUIVALENCY, 2s);
            events.ScheduleEvent(EVENT_BERSERK, 15min);
            if (Creature* council = instance->GetCreature(CouncilData[urand(0, 3)]))
                council->AI()->Talk(SAY_COUNCIL_AGRO);
        }
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        if (!me->IsInEvadeMode())
        {
            _inCombat = false;
            for (uint32 bossData : CouncilData)
                if (Creature* council = instance->GetCreature(bossData))
                    instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, council);
 
            summons.DespawnAll();
            _DespawnAtEvade();
        }
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        _inCombat = false;
        events.Reset();
        instance->SetBossState(DATA_ILLIDARI_COUNCIL, DONE);
 
        for (uint32 bossData : CouncilData)
        {
            if (Creature* council = instance->GetCreature(bossData))
            {
                // Allow loot
                instance->SendEncounterUnit(ENCOUNTER_FRAME_DISENGAGE, council);
                council->LowerPlayerDamageReq(council->GetMaxHealth());
                council->CastSpell(council, SPELL_QUIET_SUICIDE, 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_EMPYREAL_EQUIVALENCY:
                    DoCastSelf(SPELL_EMPYREAL_EQUIVALENCY, true);
                    events.Repeat(Seconds(2));
                    break;
                case EVENT_BERSERK:
                    for (uint32 bossData : CouncilData)
                    {
                        if (Creature* council = instance->GetCreature(bossData))
                        {
                            council->CastSpell(council, SPELL_BERSERK, true);
                            council->AI()->Talk(SAY_COUNCIL_ENRAGE);
                        }
                    }
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
private:
    bool _inCombat;
};
 
struct IllidariCouncilBossAI : public BossAI
{
    IllidariCouncilBossAI(Creature* creature, uint32 bossId) : BossAI(creature, bossId), _bossId(bossId)
    {
        SetBoundary(instance->GetBossBoundary(DATA_ILLIDARI_COUNCIL));
    }
 
    void Reset() override
    {
        events.Reset();
        DoCastSelf(SPELL_BALANCE_OF_POWER, true);
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        me->setActive(true);
        if (Creature* illidari = instance->GetCreature(DATA_ILLIDARI_COUNCIL))
            DoZoneInCombat(illidari);
        ScheduleEvents();
    }
 
    virtual void ScheduleEvents() = 0;
 
    void JustDied(Unit* /*killer*/) override
    {
        Talk(SAY_COUNCIL_DEATH);
    }
 
    void EnterEvadeMode(EvadeReason why) override
    {
        if (Creature* illidari = instance->GetCreature(DATA_ILLIDARI_COUNCIL))
            illidari->AI()->EnterEvadeMode(why);
    }
 
    void DamageTaken(Unit* who, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (damage >= me->GetHealth() && (!who || who->GetGUID() != me->GetGUID()))
            damage = me->GetHealth() - 1;
    }
 
    void KilledUnit(Unit* victim) override
    {
        if (victim->GetTypeId() == TYPEID_PLAYER)
            Talk(SAY_COUNCIL_SLAY);
 
        if (roll_chance(30))
            if (Creature* boss = instance->GetCreature(GetRandomBossExcept(_bossId)))
                boss->AI()->Talk(SAY_COUNCIL_COMNT);
    }
 
private:
    uint32 _bossId;
};
 
class HammerTargetSelector
{
public:
    HammerTargetSelector(Unit const* unit) : _me(unit) { }
 
    bool operator()(Unit* unit) const
    {
        return _me->IsInRange(unit, 10.0f, 40.0f);
    }
 
private:
    Unit const* _me;
};
 
struct boss_gathios_the_shatterer : public IllidariCouncilBossAI
{
    boss_gathios_the_shatterer(Creature* creature) : IllidariCouncilBossAI(creature, DATA_GATHIOS_THE_SHATTERER) { }
 
    void ScheduleEvents() override
    {
        DoCastSelf(SPELL_SEAL_OF_BLOOD);
        events.ScheduleEvent(EVENT_BLESS, 20s);
        events.ScheduleEvent(EVENT_CONSECRATION, 10s);
        events.ScheduleEvent(EVENT_HAMMER_OF_JUSTICE, 10s);
        events.ScheduleEvent(EVENT_JUDGEMENT, 15s);
        events.ScheduleEvent(EVENT_AURA, 6s);
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_BLESS:
            {
                std::list<Unit*> TargetList;
                Trinity::AnyFriendlyUnitInObjectRangeCheck checker(me, me, 100.0f);
                Trinity::UnitListSearcher<Trinity::AnyFriendlyUnitInObjectRangeCheck> searcher(me, TargetList, checker);
                Cell::VisitAllObjects(me, searcher, 100.0f);
 
                if (!TargetList.empty())
                {
                    Unit* target = Trinity::Containers::SelectRandomContainerElement(TargetList);
                    DoCast(target, RAND(SPELL_BLESS_PROTECTION, SPELL_BLESS_SPELL_WARDING));
                }
                events.Repeat(Seconds(30), Seconds(45));
                break;
            }
            case EVENT_AURA:
                DoCastSelf(RAND(SPELL_CHROMATIC_AURA, SPELL_DEVOTION_AURA));
                events.Repeat(Seconds(30));
                break;
            case EVENT_HAMMER_OF_JUSTICE:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 1, HammerTargetSelector(me)))
                    DoCast(target, SPELL_HAMMER_OF_JUSTICE);
                events.Repeat(Seconds(20));
                break;
            case EVENT_JUDGEMENT:
                DoCastVictim(SPELL_JUDGEMENT);
                events.Repeat(Seconds(15));
                break;
            case EVENT_CONSECRATION:
                DoCastSelf(SPELL_CONSECRATION);
                events.Repeat(Seconds(30), Seconds(35));
                break;
            default:
                break;
        }
    }
};
 
struct boss_high_nethermancer_zerevor : public IllidariCouncilBossAI
{
    boss_high_nethermancer_zerevor(Creature* creature) : IllidariCouncilBossAI(creature, DATA_HIGH_NETHERMANCER_ZEREVOR), _canUseArcaneExplosion(true) { }
 
    void Reset() override
    {
        IllidariCouncilBossAI::Reset();
        _canUseArcaneExplosion = true;
        DoCastSelf(SPELL_DAMPEN_MAGIC);
    }
 
    void ScheduleEvents() override
    {
        events.ScheduleEvent(EVENT_FLAMESTRIKE, 8s);
        events.ScheduleEvent(EVENT_BLIZZARD, 25s);
        events.ScheduleEvent(EVENT_ARCANE_EXPLOSION, 5s);
        DoCastSelf(SPELL_DAMPEN_MAGIC);
    }
 
    void DoAction(int32 actionId) override
    {
        if (actionId == ACTION_REFRESH_DAMPEN)
            events.ScheduleEvent(EVENT_DAMPEN_MAGIC, 50s);
    }
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_FLAMESTRIKE:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
                    DoCast(target, SPELL_FLAMESTRIKE);
                Talk(SAY_COUNCIL_SPECIAL);
                events.Repeat(Seconds(40));
                break;
            case EVENT_BLIZZARD:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
                    DoCast(target, SPELL_BLIZZARD);
                events.Repeat(Seconds(15), Seconds(40));
                break;
            case EVENT_ARCANE_EXPLOSION_CHECK:
                _canUseArcaneExplosion = true;
                break;
            case EVENT_ARCANE_EXPLOSION:
                if (_canUseArcaneExplosion && SelectTarget(SelectTargetMethod::Random, 0, 10.0f))
                {
                    DoCastSelf(SPELL_ARCANE_EXPLOSION);
                    _canUseArcaneExplosion = false;
                    events.ScheduleEvent(EVENT_ARCANE_EXPLOSION_CHECK, 5s);
                }
                events.Repeat(Seconds(1));
                break;
            case EVENT_DAMPEN_MAGIC:
                DoCastSelf(SPELL_DAMPEN_MAGIC);
                break;
            default:
                break;
        }
    }
 
    void UpdateAI(uint32 diff) 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;
        }
 
        DoSpellAttackIfReady(SPELL_ARCANE_BOLT);
    }
 
private:
    bool _canUseArcaneExplosion;
};
 
struct boss_lady_malande : public IllidariCouncilBossAI
{
    boss_lady_malande(Creature* creature) : IllidariCouncilBossAI(creature, DATA_LADY_MALANDE)
    {
        me->SetCanMelee(false); // DoSpellAttackIfReady
    }
 
    void ScheduleEvents() override
    {
        events.ScheduleEvent(EVENT_CIRCLE_OF_HEALING, 20s);
        events.ScheduleEvent(EVENT_REFLECTIVE_SHIELD, 25s);
        events.ScheduleEvent(EVENT_DIVINE_WRATH, 32s);
    }
 
    void HealReceived(Unit* /*who*/, uint32& addhealth) override
    {
        // Need be negative to heal trigger
        me->CastSpell(nullptr, SPELL_SHARED_RULE, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellBP0(-int32(addhealth)));
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_CIRCLE_OF_HEALING:
                DoCastSelf(SPELL_CIRCLE_OF_HEALING);
                events.Repeat(Seconds(20), Seconds(35));
                break;
            case EVENT_REFLECTIVE_SHIELD:
                DoCastSelf(SPELL_REFLECTIVE_SHIELD);
                Talk(SAY_COUNCIL_SPECIAL);
                events.Repeat(Seconds(40));
                break;
            case EVENT_DIVINE_WRATH:
                DoCastVictim(SPELL_DIVINE_WRATH);
                events.Repeat(Seconds(20));
                break;
            default:
                break;
        }
    }
 
    void UpdateAI(uint32 diff) 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;
        }
 
        DoSpellAttackIfReady(SPELL_EMPOWERED_SMITE);
    }
};
 
struct boss_veras_darkshadow : public IllidariCouncilBossAI
{
    boss_veras_darkshadow(Creature* creature) : IllidariCouncilBossAI(creature, DATA_VERAS_DARKSHADOW) { }
 
    void ScheduleEvents() override
    {
        events.ScheduleEvent(EVENT_VANISH, 18s);
    }
 
    bool CanSeeAlways(WorldObject const* who) override
    {
        return me->HasAura(SPELL_VANISH) ? true : ScriptedAI::CanSeeAlways(who);
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_VANISH:
                Talk(SAY_COUNCIL_SPECIAL);
                DoCastSelf(SPELL_VANISH);
                DoCastSelf(SPELL_DEADLY_STRIKE);
                events.Repeat(Seconds(60));
                break;
            default:
                break;
        }
    }
};
 
struct npc_veras_vanish_effect : public PassiveAI
{
    npc_veras_vanish_effect(Creature* creature) : PassiveAI(creature) { }
 
    void Reset() override
    {
        DoCastSelf(SPELL_BIRTH, true);
        _scheduler.Schedule(Seconds(1), [this](TaskContext const& /*context*/)
        {
            DoCastSelf(SPELL_ENVENOM_DUMMY, true);
        });
    }
 
    void UpdateAI(uint32 diff) override
    {
        _scheduler.Update(diff);
    }
 
private:
    TaskScheduler _scheduler;
};
 
// 41499 - Empyreal Balance
class spell_illidari_council_empyreal_balance : public SpellScript
{
    void HandleDummy(SpellEffIndex /*effIndex*/)
    {
        Unit* target = GetHitUnit();
        uint32 health = GetCaster()->CountPctFromCurHealth(25);
        target->SetMaxHealth(health);
        target->SetHealth(health);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_illidari_council_empyreal_balance::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 41333 - Empyreal Equivalency
class spell_illidari_council_empyreal_equivalency : public SpellScript
{
    void HandleScript(SpellEffIndex /*effIndex*/)
    {
        GetHitUnit()->SetHealth(GetCaster()->CountPctFromCurHealth(25));
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_illidari_council_empyreal_equivalency::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 41341 - Balance of Power
class spell_illidari_council_balance_of_power : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_SHARED_RULE });
    }
 
    void Absorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& /*absorbAmount*/)
    {
        PreventDefaultAction();
        GetTarget()->CastSpell(nullptr, SPELL_SHARED_RULE, CastSpellExtraArgs(aurEff).AddSpellBP0(dmgInfo.GetDamage()));
    }
 
    void Register() override
    {
        OnEffectAbsorb += AuraEffectAbsorbFn(spell_illidari_council_balance_of_power::Absorb, EFFECT_0);
    }
};
 
// 41480 - Deadly Strike
class spell_illidari_council_deadly_strike : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_DEADLY_POISON });
    }
 
    void OnTrigger(AuraEffect const* aurEff)
    {
        PreventDefaultAction();
 
        if (Unit* victim = GetTarget()->GetAI()->SelectTarget(SelectTargetMethod::Random, 0, 0.0f, true, true))
            GetTarget()->CastSpell(victim, SPELL_DEADLY_POISON, aurEff);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_illidari_council_deadly_strike::OnTrigger, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
    }
};
 
// 41485 - Deadly Poison
class spell_illidari_council_deadly_poison : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_ENVENOM, SPELL_ENVENOM_VISUAL });
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (Unit* caster = GetCaster())
        {
            Unit* target = GetTarget();
            caster->CastSpell(target, SPELL_ENVENOM, true);
            target->CastSpell(nullptr, SPELL_ENVENOM_VISUAL, true);
        }
    }
 
    void Register() override
    {
        OnEffectRemove += AuraEffectRemoveFn(spell_illidari_council_deadly_poison::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 41476 - Vanish
class spell_illidari_council_vanish : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_VANISH_TELEPORT });
    }
 
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        GetTarget()->CastSpell(GetTarget(), SPELL_VANISH_TELEPORT, true);
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_illidari_council_vanish::OnRemove, EFFECT_0, SPELL_AURA_MOD_ROOT, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 41475 - Reflective Shield
class spell_illidari_council_reflective_shield : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_REFLECTIVE_SHIELD_DAMAGE });
    }
 
    void OnAbsorb(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount)
    {
        Unit* target = GetTarget();
        if (dmgInfo.GetAttacker() == target)
            return;
 
        target->CastSpell(dmgInfo.GetAttacker(), SPELL_REFLECTIVE_SHIELD_DAMAGE, CastSpellExtraArgs(aurEff).AddSpellBP0(absorbAmount/2));
    }
 
    void Register() override
    {
        AfterEffectAbsorb += AuraEffectAbsorbFn(spell_illidari_council_reflective_shield::OnAbsorb, EFFECT_0);
    }
};
 
// 41467 - Judgement
class spell_illidari_council_judgement : public SpellScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo(
        {
            SPELL_JUDGEMENT_OF_BLOOD,
            SPELL_JUDGEMENT_OF_COMMAND,
            SPELL_JUDGEMENT_PRIMER
        });
    }
 
    void HandleScript(SpellEffIndex /*effIndex*/)
    {
        Unit* caster = GetCaster();
        Unit* target = GetHitUnit();
        uint32 judgementId = caster->HasAura(SPELL_SEAL_OF_BLOOD) ? SPELL_JUDGEMENT_OF_BLOOD : SPELL_JUDGEMENT_OF_COMMAND;
        caster->CastSpell(target, SPELL_JUDGEMENT_PRIMER, true);
        caster->CastSpell(target, judgementId, true);
    }
 
    void OnFinishCast()
    {
        if (Creature* caster = GetCaster()->ToCreature())
            caster->AI()->Talk(SAY_COUNCIL_SPECIAL);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_illidari_council_judgement::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
        AfterCast += SpellCastFn(spell_illidari_council_judgement::OnFinishCast);
    }
};
 
/* 41469 - Seal of Command
   41459 - Seal of Blood */
class spell_illidari_council_seal : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo(
        {
            SPELL_SEAL_OF_COMMAND,
            SPELL_SEAL_OF_BLOOD
        });
    }
 
    void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
    {
        Unit* target = GetTarget();
        if (target->IsInWorld() && target->IsAlive())
        {
            uint32 spellId = aurEff->GetId() == SPELL_SEAL_OF_COMMAND ? SPELL_SEAL_OF_BLOOD : SPELL_SEAL_OF_COMMAND;
            target->CastSpell(target, spellId, true);
        }
    }
 
    void Register() override
    {
        OnEffectRemove += AuraEffectRemoveFn(spell_illidari_council_seal::OnRemove, EFFECT_2, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 41478 - Dampen Magic
class spell_illidari_dampen_magic : public AuraScript
{
    void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (Creature* target = GetTarget()->ToCreature())
        {
            AuraRemoveMode mode = GetTargetApplication()->GetRemoveMode();
            if (mode == AURA_REMOVE_BY_ENEMY_SPELL || mode == AURA_REMOVE_BY_EXPIRE)
                target->AI()->DoAction(ACTION_REFRESH_DAMPEN);
        }
    }
 
    void Register() override
    {
        OnEffectRemove += AuraEffectRemoveFn(spell_illidari_dampen_magic::OnRemove, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN, AURA_EFFECT_HANDLE_REAL);
    }
};
 
void AddSC_boss_illidari_council()
{
    RegisterBlackTempleCreatureAI(boss_illidari_council);
    RegisterBlackTempleCreatureAI(boss_gathios_the_shatterer);
    RegisterBlackTempleCreatureAI(boss_lady_malande);
    RegisterBlackTempleCreatureAI(boss_veras_darkshadow);
    RegisterBlackTempleCreatureAI(boss_high_nethermancer_zerevor);
    RegisterBlackTempleCreatureAI(npc_veras_vanish_effect);
    RegisterSpellScript(spell_illidari_council_empyreal_balance);
    RegisterSpellScript(spell_illidari_council_empyreal_equivalency);
    RegisterSpellScript(spell_illidari_council_balance_of_power);
    RegisterSpellScript(spell_illidari_council_deadly_strike);
    RegisterSpellScript(spell_illidari_council_deadly_poison);
    RegisterSpellScript(spell_illidari_council_vanish);
    RegisterSpellScript(spell_illidari_council_reflective_shield);
    RegisterSpellScript(spell_illidari_council_judgement);
    RegisterSpellScript(spell_illidari_council_seal);
    RegisterSpellScript(spell_illidari_dampen_magic);
}