boss_anubarak.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "ScriptMgr.h"
#include "AreaBoundary.h"
#include "azjol_nerub.h"
#include "Containers.h"
#include "GameObject.h"
#include "InstanceScript.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "PassiveAI.h"
#include "ScriptedCreature.h"
#include "SpellInfo.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
 
enum Spells
{
    SPELL_EMERGE                = 53500,
    SPELL_SUBMERGE              = 53421,
    SPELL_IMPALE_AURA           = 53456,
    SPELL_IMPALE_VISUAL         = 53455,
    SPELL_IMPALE_DAMAGE         = 53454,
    SPELL_LEECHING_SWARM        = 53467,
    SPELL_POUND                 = 59433,
    SPELL_POUND_DAMAGE          = 59432,
    SPELL_CARRION_BEETLES       = 53520,
    SPELL_CARRION_BEETLE        = 53521,
 
    SPELL_SUMMON_DARTER         = 53599,
    SPELL_SUMMON_ASSASSIN       = 53609,
    SPELL_SUMMON_GUARDIAN       = 53614,
    SPELL_SUMMON_VENOMANCER     = 53615,
 
    SPELL_DART                  = 59349,
    SPELL_BACKSTAB              = 52540,
    SPELL_ASSASSIN_VISUAL       = 53611,
    SPELL_SUNDER_ARMOR          = 53618,
    SPELL_POISON_BOLT           = 53617
};
 
enum Creatures
{
    NPC_WORLD_TRIGGER           = 22515,
};
 
enum Yells
{
    SAY_AGGRO       = 0,
    SAY_SLAY        = 1,
    SAY_DEATH       = 2,
    SAY_LOCUST      = 3,
    SAY_SUBMERGE    = 4,
    SAY_INTRO       = 5
};
 
enum Events
{
    EVENT_POUND = 1,
    EVENT_IMPALE,
    EVENT_LEECHING_SWARM,
    EVENT_CARRION_BEETLES,
    EVENT_SUBMERGE, // use event for this so we don't submerge mid-cast
    EVENT_DARTER,
    EVENT_ASSASSIN,
    EVENT_GUARDIAN,
    EVENT_VENOMANCER,
    EVENT_CLOSE_DOOR
};
 
enum Actions
{
    ACTION_PET_DIED = 1,
    ACTION_PET_EVADE
};
 
enum Misc
{
    ACHIEV_GOTTA_GO_START_EVENT = 20381,
};
 
enum Phases
{
    PHASE_EMERGE = 1,
    PHASE_SUBMERGE
};
 
enum GUIDTypes
{
    GUID_TYPE_PET = 0,
    GUID_TYPE_IMPALE
};
 
enum SummonGroups
{
    SUMMON_GROUP_WORLD_TRIGGER_GUARDIAN = 1
};
 
struct boss_anub_arak : public BossAI
{
    boss_anub_arak(Creature* creature) : BossAI(creature, DATA_ANUBARAK), _nextSubmerge(0), _petCount(0), _assassinCount(0), _guardianCount(0), _venomancerCount(0) { }
 
    void Reset() override
    {
        BossAI::Reset();
        me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
        me->SetUninteractible(false);
        _nextSubmerge = 75;
        _petCount = 0;
    }
 
    bool CanAIAttack(Unit const* /*who*/) const override { return true; } // do not check boundary here
 
    void JustEngagedWith(Unit* who) override
    {
        BossAI::JustEngagedWith(who);
 
        if (GameObject* door = instance->GetGameObject(DATA_ANUBARAK_WALL))
            door->SetGoState(GO_STATE_ACTIVE); // open door for now
        if (GameObject* door2 = instance->GetGameObject(DATA_ANUBARAK_WALL_2))
            door2->SetGoState(GO_STATE_ACTIVE);
 
        Talk(SAY_AGGRO);
        instance->TriggerGameEvent(ACHIEV_GOTTA_GO_START_EVENT);
 
        events.SetPhase(PHASE_EMERGE);
        events.ScheduleEvent(EVENT_CLOSE_DOOR, 5s);
        events.ScheduleEvent(EVENT_POUND, 2s, 4s, 0, PHASE_EMERGE);
        events.ScheduleEvent(EVENT_LEECHING_SWARM, 5s, 7s, 0, PHASE_EMERGE);
        events.ScheduleEvent(EVENT_CARRION_BEETLES, 14s, 17s, 0, PHASE_EMERGE);
 
        // set up world triggers
        std::list<TempSummon*> summoned;
        me->SummonCreatureGroup(SUMMON_GROUP_WORLD_TRIGGER_GUARDIAN, &summoned);
        if (summoned.empty()) // something went wrong
        {
            EnterEvadeMode(EvadeReason::Other);
            return;
        }
        _guardianTrigger = (*summoned.begin())->GetGUID();
 
        if (Creature* trigger = DoSummon(NPC_WORLD_TRIGGER, me->GetPosition(), 0s, TEMPSUMMON_MANUAL_DESPAWN))
            _assassinTrigger = trigger->GetGUID();
        else
        {
            EnterEvadeMode(EvadeReason::Other);
            return;
        }
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        summons.DespawnAll();
        _DespawnAtEvade();
    }
 
    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_CLOSE_DOOR:
                    if (GameObject* door = instance->GetGameObject(DATA_ANUBARAK_WALL))
                        door->SetGoState(GO_STATE_READY);
                    if (GameObject* door2 = instance->GetGameObject(DATA_ANUBARAK_WALL_2))
                        door2->SetGoState(GO_STATE_READY);
                    break;
                case EVENT_POUND:
                    DoCastVictim(SPELL_POUND);
                    events.Repeat(26s, 32s);
                    break;
                case EVENT_LEECHING_SWARM:
                    Talk(SAY_LOCUST);
                    DoCastAOE(SPELL_LEECHING_SWARM);
                    events.Repeat(25s, 28s);
                    break;
                case EVENT_CARRION_BEETLES:
                    DoCastAOE(SPELL_CARRION_BEETLES);
                    events.Repeat(24s, 27s);
                    break;
                case EVENT_IMPALE:
                    if (Creature* impaleTarget = ObjectAccessor::GetCreature(*me, _impaleTarget))
                        DoCast(impaleTarget, SPELL_IMPALE_DAMAGE, true);
                    break;
                case EVENT_SUBMERGE:
                    Talk(SAY_SUBMERGE);
                    DoCastSelf(SPELL_SUBMERGE);
                    break;
                case EVENT_DARTER:
                {
                    std::list<Creature*> triggers;
                    me->GetCreatureListWithEntryInGrid(triggers, NPC_WORLD_TRIGGER);
                    if (!triggers.empty())
                    {
                        Creature* trigger = Trinity::Containers::SelectRandomContainerElement(triggers);
                        trigger->CastSpell(trigger, SPELL_SUMMON_DARTER, true);
 
                        events.Repeat(11s);
                    }
                    else
                        EnterEvadeMode(EvadeReason::Other);
                    break;
                }
                case EVENT_ASSASSIN:
                    if (Creature* trigger = ObjectAccessor::GetCreature(*me, _assassinTrigger))
                    {
                        trigger->CastSpell(trigger, SPELL_SUMMON_ASSASSIN, true);
                        trigger->CastSpell(trigger, SPELL_SUMMON_ASSASSIN, true);
                        if (_assassinCount > 2)
                        {
                            _assassinCount -= 2;
                            events.Repeat(20s);
                        }
                        else
                            _assassinCount = 0;
                    }
                    else // something went wrong
                        EnterEvadeMode(EvadeReason::Other);
                    break;
                case EVENT_GUARDIAN:
                    if (Creature* trigger = ObjectAccessor::GetCreature(*me, _guardianTrigger))
                    {
                        trigger->CastSpell(trigger, SPELL_SUMMON_GUARDIAN, true);
                        trigger->CastSpell(trigger, SPELL_SUMMON_GUARDIAN, true);
                        if (_guardianCount > 2)
                        {
                            _guardianCount -= 2;
                            events.Repeat(20s);
                        }
                        else
                            _guardianCount = 0;
                    }
                    else
                        EnterEvadeMode(EvadeReason::Other);
                    break;
                case EVENT_VENOMANCER:
                    if (Creature* trigger = ObjectAccessor::GetCreature(*me, _guardianTrigger))
                    {
                        trigger->CastSpell(trigger, SPELL_SUMMON_VENOMANCER, true);
                        trigger->CastSpell(trigger, SPELL_SUMMON_VENOMANCER, true);
                        if (_venomancerCount > 2)
                        {
                            _venomancerCount -= 2;
                            events.Repeat(20s);
                        }
                        else
                            _venomancerCount = 0;
                    }
                    else
                        EnterEvadeMode(EvadeReason::Other);
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        _JustDied();
        Talk(SAY_DEATH);
    }
 
    void KilledUnit(Unit* victim) override
    {
        if (victim->GetTypeId() == TYPEID_PLAYER)
            Talk(SAY_SLAY);
    }
 
    void SetGUID(ObjectGuid const& guid, int32 id) override
    {
        switch (id)
        {
            case GUID_TYPE_PET:
            {
                if (Creature* creature = ObjectAccessor::GetCreature(*me, guid))
                    JustSummoned(creature);
                else // something has gone horribly wrong
                    EnterEvadeMode(EvadeReason::Other);
                break;
            }
            case GUID_TYPE_IMPALE:
                _impaleTarget = guid;
                events.ScheduleEvent(EVENT_IMPALE, 4s);
                break;
        }
    }
 
    void DoAction(int32 action) override
    {
        switch (action)
        {
            case ACTION_PET_DIED:
                if (!_petCount) // underflow check - something has gone horribly wrong
                {
                    EnterEvadeMode(EvadeReason::Other);
                    return;
                }
                if (!--_petCount) // last pet died, emerge
                {
                    me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
                    me->RemoveAurasDueToSpell(SPELL_IMPALE_AURA);
                    me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
                    me->SetUninteractible(false);
                    DoCastSelf(SPELL_EMERGE);
                    events.SetPhase(PHASE_EMERGE);
                    events.ScheduleEvent(EVENT_POUND, 13s, 18s, 0, PHASE_EMERGE);
                    events.ScheduleEvent(EVENT_LEECHING_SWARM, 3s, 7s, 0, PHASE_EMERGE);
                    events.ScheduleEvent(EVENT_CARRION_BEETLES, 10s, 15s, 0, PHASE_EMERGE);
                }
                break;
            case ACTION_PET_EVADE:
                EnterEvadeMode(EvadeReason::Other);
                break;
        }
    }
 
    void DamageTaken(Unit* /*source*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (me->HasAura(SPELL_SUBMERGE))
            damage = 0;
        else
            if (_nextSubmerge && me->HealthBelowPctDamaged(_nextSubmerge, damage))
            {
                events.RescheduleEvent(EVENT_SUBMERGE, 0s, 0, PHASE_EMERGE);
                _nextSubmerge = _nextSubmerge-25;
            }
    }
 
    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SPELL_SUBMERGE)
        {
            me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
            me->SetUninteractible(true);
            me->RemoveAurasDueToSpell(SPELL_LEECHING_SWARM);
            DoCastSelf(SPELL_IMPALE_AURA, true);
 
            events.SetPhase(PHASE_SUBMERGE);
            switch (_nextSubmerge)
            {
                case 50: // first submerge phase
                    _assassinCount = 4;
                    _guardianCount = 2;
                    _venomancerCount = 0;
                    break;
                case 25: // second submerge phase
                    _assassinCount = 6;
                    _guardianCount = 2;
                    _venomancerCount = 2;
                    break;
                case 0:  // third submerge phase
                    _assassinCount = 6;
                    _guardianCount = 2;
                    _venomancerCount = 2;
                    events.ScheduleEvent(EVENT_DARTER, 0s, 0, PHASE_SUBMERGE);
                    break;
            }
            _petCount = _guardianCount + _venomancerCount;
            if (_assassinCount)
                events.ScheduleEvent(EVENT_ASSASSIN, 0s, 0, PHASE_SUBMERGE);
            if (_guardianCount)
                events.ScheduleEvent(EVENT_GUARDIAN, 4s, 0, PHASE_SUBMERGE);
            if (_venomancerCount)
                events.ScheduleEvent(EVENT_VENOMANCER, 20s, 0, PHASE_SUBMERGE);
        }
    }
 
    private:
        ObjectGuid _impaleTarget;
        uint32 _nextSubmerge;
        uint32 _petCount;
        ObjectGuid _guardianTrigger;
        ObjectGuid _assassinTrigger;
        uint8 _assassinCount;
        uint8 _guardianCount;
        uint8 _venomancerCount;
};
 
class npc_anubarak_pet_template : public ScriptedAI
{
    public:
        npc_anubarak_pet_template(Creature* creature, bool isLarge) : ScriptedAI(creature), _instance(creature->GetInstanceScript()), _isLarge(isLarge) { }
 
        void InitializeAI() override
        {
            ScriptedAI::InitializeAI();
            if (Creature* anubarak = _instance->GetCreature(DATA_ANUBARAK))
                anubarak->AI()->SetGUID(me->GetGUID(), GUID_TYPE_PET);
            else
                me->DespawnOrUnsummon();
        }
 
        void JustDied(Unit* killer) override
        {
            ScriptedAI::JustDied(killer);
            if (_isLarge)
                if (Creature* anubarak = _instance->GetCreature(DATA_ANUBARAK))
                    anubarak->AI()->DoAction(ACTION_PET_DIED);
        }
 
        void EnterEvadeMode(EvadeReason /*why*/) override
        {
            if (Creature* anubarak = _instance->GetCreature(DATA_ANUBARAK))
                anubarak->AI()->DoAction(ACTION_PET_EVADE);
            else
                me->DespawnOrUnsummon();
        }
 
    protected:
        InstanceScript* _instance;
    private:
        bool const _isLarge;
};
 
struct npc_anubarak_anub_ar_darter : public npc_anubarak_pet_template
{
    npc_anubarak_anub_ar_darter(Creature* creature) : npc_anubarak_pet_template(creature, false) { }
 
    void InitializeAI() override
    {
        npc_anubarak_pet_template::InitializeAI();
        DoCastAOE(SPELL_DART);
    }
};
 
struct npc_anubarak_anub_ar_assassin : public npc_anubarak_pet_template
{
    npc_anubarak_anub_ar_assassin(Creature* creature) : npc_anubarak_pet_template(creature, false){ }
 
    void InitializeAI() override
    {
        npc_anubarak_pet_template::InitializeAI();
        CreatureBoundary const* boundary = _instance->GetBossBoundary(DATA_ANUBARAK);
        if (Creature* anubarak = _instance->GetCreature(DATA_ANUBARAK))
        {
            Position jumpTo;
            uint32 attempts = 0;
            do
                jumpTo = anubarak->GetRandomPoint(anubarak->GetPosition(), 30.0f, 10.f);
            while (!CreatureAI::IsInBounds(*boundary, &jumpTo) && attempts < 10);
            me->GetMotionMaster()->MoveJump(EVENT_JUMP, jumpTo, 24.0f, 20.0f, 30.0f);
            DoCastSelf(SPELL_ASSASSIN_VISUAL, true);
        }
    }
 
    void Reset() override
    {
        _scheduler.CancelAll();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        _scheduler.Schedule(6s, [this](TaskContext& task)
        {
            if (me->GetVictim() && me->GetVictim()->isInBack(me))
                DoCastVictim(SPELL_BACKSTAB);
 
            task.Repeat();
        });
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        _scheduler.Update(diff);
    }
 
    void MovementInform(uint32 /*type*/, uint32 id) override
    {
        if (id == EVENT_JUMP)
        {
            me->RemoveAurasDueToSpell(SPELL_ASSASSIN_VISUAL);
            DoZoneInCombat();
        }
    }
 
private:
    TaskScheduler _scheduler;
};
 
struct npc_anubarak_anub_ar_guardian : public npc_anubarak_pet_template
{
    npc_anubarak_anub_ar_guardian(Creature* creature) : npc_anubarak_pet_template(creature, true) { }
 
    void Reset() override
    {
        _scheduler.CancelAll();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        _scheduler.Schedule(6s, [this](TaskContext& task)
        {
            DoCastVictim(SPELL_SUNDER_ARMOR);
            task.Repeat(12s);
        });
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        _scheduler.Update(diff);
    }
 
private:
    TaskScheduler _scheduler;
};
 
struct npc_anubarak_anub_ar_venomancer : public npc_anubarak_pet_template
{
    npc_anubarak_anub_ar_venomancer(Creature* creature) : npc_anubarak_pet_template(creature, true) { }
 
    void Reset() override
    {
        _scheduler.CancelAll();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        _scheduler.Schedule(5s, [this](TaskContext& task)
        {
            DoCastVictim(SPELL_POISON_BOLT);
            task.Repeat(2s, 3s);
        });
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        _scheduler.Update(diff);
    }
 
private:
    TaskScheduler _scheduler;
};
 
struct npc_anubarak_impale_target : public NullCreatureAI
{
    npc_anubarak_impale_target(Creature* creature) : NullCreatureAI(creature) { }
 
    void InitializeAI() override
    {
        if (Creature* anubarak = me->GetInstanceScript()->GetCreature(DATA_ANUBARAK))
        {
            DoCastSelf(SPELL_IMPALE_VISUAL);
            me->DespawnOrUnsummon(6s);
            anubarak->AI()->SetGUID(me->GetGUID(), GUID_TYPE_IMPALE);
        }
        else
            me->DespawnOrUnsummon();
    }
};
 
// 53472, 59433 - Pound
class spell_anubarak_pound : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_POUND_DAMAGE });
    }
 
    void AfterApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (Unit* target = GetTarget())
            GetCaster()->CastSpell(target, SPELL_POUND_DAMAGE, true);
    }
 
    void Register() override
    {
        AfterEffectApply += AuraEffectApplyFn(spell_anubarak_pound::AfterApply, EFFECT_2, SPELL_AURA_FLY, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 53520 - Carrion Beetles
class spell_anubarak_carrion_beetles : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_CARRION_BEETLE });
    }
 
    void HandlePeriodic(AuraEffect const* /*eff*/)
    {
        GetCaster()->CastSpell(GetCaster(), SPELL_CARRION_BEETLE, true);
        GetCaster()->CastSpell(GetCaster(), SPELL_CARRION_BEETLE, true);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_anubarak_carrion_beetles::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
    }
};
 
void AddSC_boss_anub_arak()
{
    RegisterAzjolNerubCreatureAI(boss_anub_arak);
 
    RegisterAzjolNerubCreatureAI(npc_anubarak_anub_ar_darter);
    RegisterAzjolNerubCreatureAI(npc_anubarak_anub_ar_assassin);
    RegisterAzjolNerubCreatureAI(npc_anubarak_anub_ar_guardian);
    RegisterAzjolNerubCreatureAI(npc_anubarak_anub_ar_venomancer);
    RegisterAzjolNerubCreatureAI(npc_anubarak_impale_target);
 
    RegisterSpellScript(spell_anubarak_pound);
    RegisterSpellScript(spell_anubarak_carrion_beetles);
}