boss_emalon.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 "Containers.h"
#include "InstanceScript.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "SpellAuras.h"
#include "vault_of_archavon.h"
 
enum EmalonTexts
{
    EMOTE_OVERCHARGE            = 0,
    EMOTE_MINION_RESPAWN        = 1,
    EMOTE_BERSERK               = 2
};
 
enum EmalonSpells
{
    SPELL_OVERCHARGE            = 64218,    // Cast every 45 sec on a random Tempest Minion
    SPELL_BERSERK               = 26662,
 
    SPELL_SHOCK                 = 64363,
    SPELL_OVERCHARGED           = 64217,
    SPELL_OVERCHARGED_BLAST     = 64219,    // Cast when Overcharged reaches 10 stacks. Mob dies after that
    SPELL_CHAIN_LIGHTNING       = 64213,
    SPELL_LIGHTNING_NOVA        = 64216
};
 
enum EmalonEvents
{
    EVENT_CHAIN_LIGHTNING = 1,
    EVENT_LIGHTNING_NOVA,
    EVENT_OVERCHARGE,
    EVENT_BERSERK,
    EVENT_SHOCK
};
 
enum EmalonMisc
{
    NPC_TEMPEST_MINION          = 33998,
    MAX_TEMPEST_MINIONS         = 4
};
 
Position const TempestMinions[MAX_TEMPEST_MINIONS] =
{
    {-203.980103f, -281.287720f, 91.650223f, 1.598807f},
    {-233.489410f, -281.139282f, 91.652412f, 1.598807f},
    {-233.267578f, -297.104645f, 91.681915f, 1.598807f},
    {-203.842529f, -297.097015f, 91.745163f, 1.598807f}
};
 
struct boss_emalon : public BossAI
{
    boss_emalon(Creature* creature) : BossAI(creature, DATA_EMALON) { }
 
    void Reset() override
    {
        _Reset();
 
        for (uint8 i = 0; i < MAX_TEMPEST_MINIONS; ++i)
            me->SummonCreature(NPC_TEMPEST_MINION, TempestMinions[i], TEMPSUMMON_CORPSE_DESPAWN);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        if (!summons.empty())
        {
            for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
            {
                Creature* minion = ObjectAccessor::GetCreature(*me, *itr);
                if (minion && minion->IsAlive() && !minion->GetVictim() && minion->AI())
                    minion->AI()->AttackStart(who);
            }
        }
 
        events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 5s);
        events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40s);
        events.ScheduleEvent(EVENT_BERSERK, 6min);
        events.ScheduleEvent(EVENT_OVERCHARGE, 45s);
 
        BossAI::JustEngagedWith(who);
    }
 
    void JustSummoned(Creature* summoned) override
    {
        BossAI::JustSummoned(summoned);
 
        // AttackStart has nullptr-check for victim
        if (summoned->AI())
            summoned->AI()->AttackStart(me->GetVictim());
    }
 
    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_CHAIN_LIGHTNING:
                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
                        DoCast(target, SPELL_CHAIN_LIGHTNING);
                    events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, 25s);
                    break;
                case EVENT_LIGHTNING_NOVA:
                    DoCastAOE(SPELL_LIGHTNING_NOVA);
                    events.ScheduleEvent(EVENT_LIGHTNING_NOVA, 40s);
                    break;
                case EVENT_OVERCHARGE:
                    if (!summons.empty())
                    {
                        Creature* minion = ObjectAccessor::GetCreature(*me, Trinity::Containers::SelectRandomContainerElement(summons));
                        if (minion && minion->IsAlive())
                        {
                            minion->CastSpell(me, SPELL_OVERCHARGED, true);
                            minion->SetFullHealth();
                            Talk(EMOTE_OVERCHARGE);
                            events.ScheduleEvent(EVENT_OVERCHARGE, 45s);
                        }
                    }
                    break;
                case EVENT_BERSERK:
                    DoCast(me, SPELL_BERSERK);
                    Talk(EMOTE_BERSERK);
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
};
 
struct npc_tempest_minion : public ScriptedAI
{
    npc_tempest_minion(Creature* creature) : ScriptedAI(creature)
    {
        Initialize();
        _instance = creature->GetInstanceScript();
    }
 
    void Initialize()
    {
        _overchargedTimer = 0;
    }
 
    void Reset() override
    {
        _events.Reset();
        Initialize();
    }
 
    void JustEngagedWith(Unit* who) override
    {
        DoZoneInCombat();
        _events.ScheduleEvent(EVENT_SHOCK, 20s);
 
        if (Creature* pEmalon = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_EMALON)))
        {
            if (!pEmalon->GetVictim() && pEmalon->AI())
                pEmalon->AI()->AttackStart(who);
        }
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        if (Creature* emalon = ObjectAccessor::GetCreature(*me, _instance->GetGuidData(DATA_EMALON)))
        {
            if (emalon->IsAlive())
            {
                emalon->SummonCreature(NPC_TEMPEST_MINION, 0, 0, 0, 0, TEMPSUMMON_CORPSE_DESPAWN);
                Talk(EMOTE_MINION_RESPAWN);
            }
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        _events.Update(diff);
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        if (Aura const* overchargedAura = me->GetAura(SPELL_OVERCHARGED))
        {
            if (overchargedAura->GetStackAmount() < 10)
            {
                if (_overchargedTimer <= diff)
                {
                    DoCast(me, SPELL_OVERCHARGED);
                    _overchargedTimer = 2000; // ms
                }
                else
                    _overchargedTimer -= diff;
            }
            else
            {
                if (overchargedAura->GetStackAmount() == 10)
                {
                    DoCast(me, SPELL_OVERCHARGED_BLAST);
                    me->DespawnOrUnsummon();
                    Talk(EMOTE_MINION_RESPAWN);
                }
            }
        }
 
        if (_events.ExecuteEvent() == EVENT_SHOCK)
        {
            DoCastVictim(SPELL_SHOCK);
            _events.ScheduleEvent(EVENT_SHOCK, 20s);
        }
    }
 
private:
    InstanceScript* _instance;
    EventMap _events;
    uint32 _overchargedTimer;
};
 
void AddSC_boss_emalon()
{
    RegisterVaultOfArchavonCreatureAI(boss_emalon);
    RegisterVaultOfArchavonCreatureAI(npc_tempest_minion);
}