boss_skarvald_dalronn.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/>.
 */
 
/* ScriptData
SDName: Boss_Skarvald_Dalronn
SD%Complete: 95
SDComment: Needs adjustments to blizzlike timers
SDCategory: Utgarde Keep
EndScriptData */
 
#include "ScriptMgr.h"
#include "InstanceScript.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "utgarde_keep.h"
 
enum Texts
{
    // Texts are common for both bosses and their ghosts.
    SAY_AGGRO                  = 0,
    SAY_DEATH                  = 1, // Said once both bosses are dead.
    SAY_DIED_FIRST             = 2, // Said by the first boss that dies.
    SAY_KILL                   = 3,
    SAY_DEATH_RESPONSE         = 4  // Said by the boss alive after the first one dies.
 
};
 
enum Spells
{
    // Spells of Skarvald and his Ghost
    SPELL_CHARGE                                = 43651,
    SPELL_STONE_STRIKE                          = 48583,
    SPELL_ENRAGE                                = 48193,
    SPELL_SUMMON_SKARVALD_GHOST                 = 48613,
 
    // Spells of Dalronn and his Ghost
    SPELL_SHADOW_BOLT                           = 43649,
    SPELL_SUMMON_SKELETONS                      = 52611,
    SPELL_DEBILITATE                            = 43650,
    SPELL_SUMMON_DALRONN_GHOST                  = 48612,
};
 
enum Events
{
    // Skarvald the Constructor
    EVENT_SKARVALD_CHARGE = 1,
    EVENT_STONE_STRIKE,
 
    // Dalronn the Controller
    EVENT_SHADOW_BOLT,
    EVENT_DEBILITATE,
    EVENT_SUMMON_SKELETONS,
    EVENT_DELAYED_AGGRO_SAY, // Dalronn's SAY_AGGRO is delayed so it doesn't overlap Skarvald's one.
 
    // Common event to both bosses.
    // Delays SAY_DEATH_RESPONSE so it doesn't overlap with the SAY_DIED_FIRST from the boss that has just died.
    EVENT_DEATH_RESPONSE
};
 
enum Actions
{
    ACTION_OTHER_JUST_DIED = 1,
    ACTION_DESPAWN_SUMMONS = 2 // Only needed to clear off the ghosts when the second boss dies.
};
 
class SkarvaldChargePredicate
{
    public:
        SkarvaldChargePredicate(Unit* unit) : _me(unit) { }
 
        bool operator() (WorldObject* target) const
        {
            return target->GetDistance2d(_me) >= 5.0f && target->GetDistance2d(_me) <= 30.0f;
        }
 
    private:
        Unit* _me;
};
 
struct generic_boss_controllerAI : public BossAI
{
    generic_boss_controllerAI(Creature* creature) : BossAI(creature, DATA_SKARVALD_DALRONN)
    {
        OtherBossData = 0;
        IsInGhostForm = me->GetEntry() == NPC_SKARVALD_GHOST || me->GetEntry() == NPC_DALRONN_GHOST;
    }
 
    void Reset() override
    {
        if (IsInGhostForm)
        {
            // Call this here since ghosts aren't set in combat as they spawn.
            DoZoneInCombat(me);
        }
        else
            _Reset();
    }
 
    void JustEngagedWith(Unit* who) override
    {
        if (!IsInGhostForm)
            BossAI::JustEngagedWith(who);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        if (Creature* otherBoss = ObjectAccessor::GetCreature(*me, instance->GetGuidData(OtherBossData)))
        {
            if (otherBoss->IsAlive())
            {
                Talk(SAY_DIED_FIRST);
                me->RemoveDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
                otherBoss->AI()->DoAction(ACTION_OTHER_JUST_DIED);
                DoCast(me, OtherBossData == DATA_DALRONN ? SPELL_SUMMON_SKARVALD_GHOST : SPELL_SUMMON_DALRONN_GHOST, true);
            }
            else
            {
                Talk(SAY_DEATH);
                otherBoss->AI()->DoAction(ACTION_DESPAWN_SUMMONS);
                _JustDied();
            }
        }
    }
 
    void DoAction(int32 actionId) override
    {
        switch (actionId)
        {
            case ACTION_OTHER_JUST_DIED:
                events.ScheduleEvent(EVENT_DEATH_RESPONSE, 2s);
                break;
            case ACTION_DESPAWN_SUMMONS:
                summons.DespawnAll();
                break;
            default:
                break;
        }
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        if (eventId == EVENT_DEATH_RESPONSE)
            Talk(SAY_DEATH_RESPONSE);
    }
 
    void KilledUnit(Unit* who) override
    {
        if (!IsInGhostForm && who->GetTypeId() == TYPEID_PLAYER)
            Talk(SAY_KILL);
    }
 
    protected:
        uint32 OtherBossData;
        bool IsInGhostForm;
};
 
struct boss_skarvald_the_constructor : public generic_boss_controllerAI
{
    boss_skarvald_the_constructor(Creature* creature) : generic_boss_controllerAI(creature)
    {
        OtherBossData = DATA_DALRONN;
        Enraged = false;
    }
 
    void Reset() override
    {
        Enraged = false;
        generic_boss_controllerAI::Reset();
    }
 
    void JustEngagedWith(Unit* who) override
    {
        generic_boss_controllerAI::JustEngagedWith(who);
 
        if (!IsInGhostForm)
            Talk(SAY_AGGRO);
 
        events.ScheduleEvent(EVENT_SKARVALD_CHARGE, 5s);
        events.ScheduleEvent(EVENT_STONE_STRIKE, 10s);
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_SKARVALD_CHARGE:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, SkarvaldChargePredicate(me)))
                    DoCast(target, SPELL_CHARGE);
                events.ScheduleEvent(EVENT_CHARGE, 5s, 10s);
                break;
            case EVENT_STONE_STRIKE:
                DoCastVictim(SPELL_STONE_STRIKE);
                events.ScheduleEvent(EVENT_STONE_STRIKE, 5s, 10s);
                break;
            default:
                generic_boss_controllerAI::ExecuteEvent(eventId);
                break;
        }
    }
 
    void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (!Enraged && !IsInGhostForm && me->HealthBelowPctDamaged(15, damage))
        {
            Enraged = true;
            DoCast(me, SPELL_ENRAGE);
        }
    }
    private:
        bool Enraged;
};
 
struct boss_dalronn_the_controller : public generic_boss_controllerAI
{
    boss_dalronn_the_controller(Creature* creature) : generic_boss_controllerAI(creature)
    {
        OtherBossData = DATA_SKARVALD;
    }
 
    void JustEngagedWith(Unit* who) override
    {
        generic_boss_controllerAI::JustEngagedWith(who);
 
        events.ScheduleEvent(EVENT_SHADOW_BOLT, 1s);
        events.ScheduleEvent(EVENT_DEBILITATE, 5s);
 
        if (!IsInGhostForm)
            events.ScheduleEvent(EVENT_DELAYED_AGGRO_SAY, 5s);
 
        if (IsHeroic())
            events.ScheduleEvent(EVENT_SUMMON_SKELETONS, 10s);
    }
 
    void ExecuteEvent(uint32 eventId) override
    {
        switch (eventId)
        {
            case EVENT_SHADOW_BOLT:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 45.0f, true))
                    DoCast(target, SPELL_SHADOW_BOLT);
                events.ScheduleEvent(EVENT_SHADOW_BOLT, 2100ms); //give a 100ms pause to try cast other spells
                break;
            case EVENT_DEBILITATE:
                if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 50.0f, true))
                    DoCast(target, SPELL_DEBILITATE);
                events.ScheduleEvent(EVENT_DEBILITATE, 5s, 10s);
                break;
            case EVENT_SUMMON_SKELETONS:
                DoCast(me, SPELL_SUMMON_SKELETONS);
                events.ScheduleEvent(EVENT_SUMMON_SKELETONS, 10s, 30s);
                break;
            case EVENT_DELAYED_AGGRO_SAY:
                Talk(SAY_AGGRO);
                break;
            default:
                generic_boss_controllerAI::ExecuteEvent(eventId);
                break;
        }
    }
};
 
void AddSC_boss_skarvald_dalronn()
{
    RegisterUtgardeKeepCreatureAI(boss_skarvald_the_constructor);
    RegisterUtgardeKeepCreatureAI(boss_dalronn_the_controller);
}