boss_anetheron.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 "hyjal.h"
#include "hyjal_trash.h"
#include "InstanceScript.h"
#include "ObjectAccessor.h"
#include "SpellScript.h"
 
enum Spells
{
    SPELL_CARRION_SWARM         = 31306,
    SPELL_SLEEP                 = 31298,
    SPELL_VAMPIRIC_AURA         = 38196,
    SPELL_VAMPIRIC_AURA_HEAL    = 31285,
    SPELL_INFERNO               = 31299,
    SPELL_IMMOLATION            = 31303,
    SPELL_INFERNO_EFFECT        = 31302
};
 
enum Texts
{
    SAY_ONDEATH         = 0,
    SAY_ONSLAY          = 1,
    SAY_SWARM           = 2,
    SAY_SLEEP           = 3,
    SAY_INFERNO         = 4,
    SAY_ONAGGRO         = 5,
};
 
static constexpr uint32 PATH_ESCORT_ANETHERON = 142466;
 
class boss_anetheron : public CreatureScript
{
public:
    boss_anetheron() : CreatureScript("boss_anetheron") { }
 
    CreatureAI* GetAI(Creature* creature) const override
    {
        return GetHyjalAI<boss_anetheronAI>(creature);
    }
 
    struct boss_anetheronAI : public hyjal_trashAI
    {
        boss_anetheronAI(Creature* creature) : hyjal_trashAI(creature)
        {
            Initialize();
            instance = creature->GetInstanceScript();
            go = false;
        }
 
        void Initialize()
        {
            SwarmTimer = 45000;
            SleepTimer = 60000;
            AuraTimer = 5000;
            InfernoTimer = 45000;
            damageTaken = 0;
        }
 
        uint32 SwarmTimer;
        uint32 SleepTimer;
        uint32 AuraTimer;
        uint32 InfernoTimer;
        bool go;
 
        void Reset() override
        {
            Initialize();
 
            if (IsEvent)
                instance->SetBossState(DATA_ANETHERON, NOT_STARTED);
        }
 
        void JustEngagedWith(Unit* /*who*/) override
        {
            if (IsEvent)
                instance->SetBossState(DATA_ANETHERON, IN_PROGRESS);
 
            Talk(SAY_ONAGGRO);
        }
 
        void KilledUnit(Unit* who) override
        {
            if (who->GetTypeId() == TYPEID_PLAYER)
                Talk(SAY_ONSLAY);
        }
 
        void WaypointReached(uint32 waypointId, uint32 /*pathId*/) override
        {
            if (waypointId == 7)
            {
                Creature* target = ObjectAccessor::GetCreature(*me, instance->GetGuidData(DATA_JAINAPROUDMOORE));
                if (target && target->IsAlive())
                    AddThreat(target, 0.0f);
            }
        }
 
        void JustDied(Unit* killer) override
        {
            hyjal_trashAI::JustDied(killer);
            if (IsEvent)
                instance->SetBossState(DATA_ANETHERON, DONE);
            Talk(SAY_ONDEATH);
        }
 
        void UpdateAI(uint32 diff) override
        {
            if (IsEvent)
            {
                //Must update EscortAI
                EscortAI::UpdateAI(diff);
                if (!go)
                {
                    go = true;
                    LoadPath(PATH_ESCORT_ANETHERON);
                    Start(false);
                    SetDespawnAtEnd(false);
                }
            }
 
            //Return since we have no target
            if (!UpdateVictim())
                return;
 
            if (SwarmTimer <= diff)
            {
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100, true))
                    DoCast(target, SPELL_CARRION_SWARM);
 
                SwarmTimer = urand(45000, 60000);
                Talk(SAY_SWARM);
            } else SwarmTimer -= diff;
 
            if (SleepTimer <= diff)
            {
                for (uint8 i = 0; i < 3; ++i)
                {
                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100, true))
                        target->CastSpell(target, SPELL_SLEEP, true);
                }
                SleepTimer = 60000;
                Talk(SAY_SLEEP);
            } else SleepTimer -= diff;
            if (AuraTimer <= diff)
            {
                DoCast(me, SPELL_VAMPIRIC_AURA, true);
                AuraTimer = urand(10000, 20000);
            } else AuraTimer -= diff;
            if (InfernoTimer <= diff)
            {
                DoCast(SelectTarget(SelectTargetMethod::Random, 0, 100, true), SPELL_INFERNO);
                InfernoTimer = 45000;
                Talk(SAY_INFERNO);
            } else InfernoTimer -= diff;
        }
    };
};
 
class npc_towering_infernal : public CreatureScript
{
public:
    npc_towering_infernal() : CreatureScript("npc_towering_infernal") { }
 
    CreatureAI* GetAI(Creature* creature) const override
    {
        return GetHyjalAI<npc_towering_infernalAI>(creature);
    }
 
    struct npc_towering_infernalAI : public ScriptedAI
    {
        npc_towering_infernalAI(Creature* creature) : ScriptedAI(creature)
        {
            ImmolationTimer = 5000;
            CheckTimer = 5000;
            instance = creature->GetInstanceScript();
        }
 
        uint32 ImmolationTimer;
        uint32 CheckTimer;
        InstanceScript* instance;
 
        void Reset() override
        {
            DoCast(me, SPELL_INFERNO_EFFECT);
            ImmolationTimer = 5000;
            CheckTimer = 5000;
        }
 
        void JustEngagedWith(Unit* /*who*/) override
        {
        }
 
        void KilledUnit(Unit* /*victim*/) override
        {
        }
 
        void JustDied(Unit* /*killer*/) override
        {
        }
 
        void MoveInLineOfSight(Unit* who) override
 
        {
            if (me->IsWithinDist(who, 50) && !me->IsInCombat() && me->IsValidAttackTarget(who))
                AttackStart(who);
        }
 
        void UpdateAI(uint32 diff) override
        {
            if (CheckTimer <= diff)
            {
                Creature* boss = instance->GetCreature(DATA_ANETHERON);
                if (!boss || boss->isDead())
                {
                    me->DespawnOrUnsummon();
                    return;
                }
                CheckTimer = 5000;
            } else CheckTimer -= diff;
 
            //Return since we have no target
            if (!UpdateVictim())
                return;
 
            if (ImmolationTimer <= diff)
            {
                DoCast(me, SPELL_IMMOLATION);
                ImmolationTimer = 5000;
            } else ImmolationTimer -= diff;
        }
    };
};
 
// 38196 - Vampiric Aura
class spell_anetheron_vampiric_aura : public SpellScriptLoader
{
    public:
        spell_anetheron_vampiric_aura() : SpellScriptLoader("spell_anetheron_vampiric_aura") { }
 
        class spell_anetheron_vampiric_aura_AuraScript : public AuraScript
        {
            bool Validate(SpellInfo const* /*spellInfo*/) override
            {
                return ValidateSpellInfo({ SPELL_VAMPIRIC_AURA_HEAL });
            }
 
            void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
            {
                PreventDefaultAction();
                DamageInfo* damageInfo = eventInfo.GetDamageInfo();
                if (!damageInfo || !damageInfo->GetDamage())
                    return;
 
                Unit* actor = eventInfo.GetActor();
                CastSpellExtraArgs args(aurEff);
                args.AddSpellMod(SPELLVALUE_BASE_POINT0, damageInfo->GetDamage() * 3);
                actor->CastSpell(actor, SPELL_VAMPIRIC_AURA_HEAL, args);
            }
 
            void Register() override
            {
                OnEffectProc += AuraEffectProcFn(spell_anetheron_vampiric_aura_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
            }
        };
 
        AuraScript* GetAuraScript() const override
        {
            return new spell_anetheron_vampiric_aura_AuraScript();
        }
};
 
void AddSC_boss_anetheron()
{
    new boss_anetheron();
    new npc_towering_infernal();
    new spell_anetheron_vampiric_aura();
}