boss_four_horsemen.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 "GameTime.h"
#include "InstanceScript.h"
#include "Log.h"
#include "Map.h"
#include "MotionMaster.h"
#include "naxxramas.h"
#include "ObjectAccessor.h"
#include "Player.h"
#include "ScriptedCreature.h"
#include "SpellInfo.h"
#include "SpellScript.h"
 
enum Horseman
{
    THANE   = DATA_THANE,
    LADY    = DATA_LADY,
    BARON   = DATA_BARON,
    SIR     = DATA_SIR,
};
static const std::vector<Horseman> horsemen = { THANE, LADY, BARON, SIR };  // for iterating
 
enum Spells
{
    /* all */
    SPELL_MARK_DAMAGE      = 28836,
    SPELL_BERSERK          = 26662,
    SPELL_ENCOUNTER_CREDIT = 59450,
 
    /* baron */
    SPELL_BARON_MARK       = 28834,
 
    /* thane */
    SPELL_THANE_MARK       = 28832,
 
    /* lady */
    SPELL_LADY_MARK        = 28833,
    SPELL_UNYIELDING_PAIN  = 57381,
 
    /* sir */
    SPELL_SIR_MARK         = 28835,
    SPELL_CONDEMNATION     = 57377
};
 
#define SPELL_UNHOLY_SHADOW RAID_MODE<uint32>(28882, 57369) // Rivendare: Unholy Shadow
#define SPELL_METEOR RAID_MODE<uint32>(28884, 57467) // Korth'azz: Meteor
#define SPELL_SHADOW_BOLT RAID_MODE<uint32>(57374, 57464) // Blaumeux : Shadow Bolt
#define SPELL_VOID_ZONE RAID_MODE<uint32>(28863, 57463) // Blaumeux : Void Zone
#define SPELL_HOLY_BOLT RAID_MODE<uint32>(57376, 57465) // Zeliek : Holy Bolt
#define SPELL_HOLY_WRATH RAID_MODE<uint32>(28883, 57466) // Zeliek: Holy Wrath
 
enum Actions
{
    ACTION_BEGIN_MOVEMENT = 1,
    ACTION_BEGIN_FIGHTING
};
 
enum HorsemenData
{
    DATA_HORSEMEN_IS_TIMED_KILL = NAXData::DATA_HORSEMEN_CHECK_ACHIEVEMENT_CREDIT, // inherit from naxxramas.h - this needs to be the first entry to ensure that there are no conflicts
    DATA_MOVEMENT_FINISHED,
    DATA_DEATH_TIME
};
 
enum Events
{
    /* all */
    EVENT_BERSERK = 1,
    EVENT_MARK,
 
    /* rivendare */
    EVENT_UNHOLYSHADOW,
 
    /* thane */
    EVENT_METEOR,
 
    /* lady */
    EVENT_VOIDZONE,
 
    /* sir */
    EVENT_HOLYWRATH
};
 
enum Yells
{
    SAY_AGGRO       = 0,
    SAY_SPECIAL     = 2,
    SAY_SLAY        = 3,
    SAY_DEATH       = 4,
 
    EMOTE_RAGECAST  = 7
};
 
static const Position baronPath[3] = { { 2552.427f, -2969.737f, 241.3021f },{ 2566.759f, -2972.535f, 241.3217f },{ 2584.32f, -2971.96f, 241.3489f } };
static const Position thanePath[3] = { { 2540.095f, -2983.192f, 241.3344f },{ 2546.005f, -2999.826f, 241.3665f },{ 2542.697f, -3014.055f, 241.3371f } };
static const Position ladyPath[3] = { { 2507.94f, -2961.444f, 242.4557f },{ 2488.763f, -2960.007f, 241.2757f },{ 2468.26f, -2947.499f, 241.2753f } };
static const Position sirPath[3] = { { 2533.141f, -2922.14f, 241.2764f },{ 2525.254f, -2905.907f, 241.2761f },{ 2517.636f, -2897.253f, 241.2758f } };
 
struct boss_four_horsemen_baseAI : public BossAI
{
    public:
        Creature* getHorsemanHandle(Horseman who) const
        {
            if (_which == who)
                return me;
            else
                return ObjectAccessor::GetCreature(*me, instance->GetGuidData(who));
        }
        boss_four_horsemen_baseAI(Creature* creature, Horseman which, Position const* initialPath) :
            BossAI(creature, BOSS_HORSEMEN), _which(which), _initialPath(initialPath), _myMovementFinished(false), _nextMovement(0), _timeDied(0), _ourMovementFinished(false)
        {
            if (!me->IsAlive() && instance->GetBossState(BOSS_HORSEMEN) != DONE)
                me->SetRespawnTime(10);
        }
 
        uint32 GetData(uint32 type) const override
        {
            switch (type)
            {
                case DATA_MOVEMENT_FINISHED:
                    return _myMovementFinished ? 1 : 0;
                case DATA_DEATH_TIME:
                    return _timeDied;
                case DATA_HORSEMEN_IS_TIMED_KILL:
                {
                    uint32 minTime = 0, maxTime = 0;
                    for (Horseman boss : horsemen)
                        if (Creature* cBoss = getHorsemanHandle(boss))
                        {
                            uint32 deathTime = cBoss->AI()->GetData(DATA_DEATH_TIME);
                            if (!deathTime)
                            {
                                TC_LOG_WARN("scripts", "FourHorsemenAI: Checking for achievement credit but horseman {} is reporting not dead", cBoss->GetName());
                                return 0;
                            }
                            if (!minTime || deathTime < minTime)
                                minTime = deathTime;
                            if (!maxTime || deathTime > maxTime)
                                maxTime = deathTime;
                        }
                        else
                        {
                            TC_LOG_WARN("scripts", "FourHorsemenAI: Checking for achievement credit but horseman with id {} is not present", uint32(boss));
                            return 0;
                        }
                    return (getMSTimeDiff(minTime, maxTime) <= 15 * IN_MILLISECONDS) ? 1 : 0;
                }
                default:
                    return 0;
            }
        }
 
        void DoAction(int32 action) override
        {
            switch (action)
            {
                case ACTION_BEGIN_MOVEMENT:
                    me->GetMotionMaster()->MovePoint(1, _initialPath[0], true);
                    break;
                case ACTION_BEGIN_FIGHTING:
                    if (_ourMovementFinished)
                        break;
                    BeginFighting();
                    _ourMovementFinished = true;
                    break;
            }
        }
 
        void CheckIsMovementFinished()
        {
            for (Horseman boss : horsemen)
            {
                if (Creature* cBoss = getHorsemanHandle(boss))
                {
                    if (cBoss->IsAlive() && !cBoss->AI()->GetData(DATA_MOVEMENT_FINISHED))
                        return;
                }
                else
                {
                    TC_LOG_WARN("scripts", "FourHorsemenAI: Checking if movement is finished but horseman with id {} is not present", uint32(boss));
                    ResetEncounter();
                    return;
                }
            }
 
            for (Horseman boss : horsemen)
                if (Creature* cBoss = getHorsemanHandle(boss))
                    cBoss->AI()->DoAction(ACTION_BEGIN_FIGHTING);
        }
 
        void BeginEncounter()
        {
            if (instance->GetBossState(BOSS_HORSEMEN) == IN_PROGRESS)
                return;
            if (!instance->CheckRequiredBosses(BOSS_HORSEMEN))
            {
                ResetEncounter();
                return;
            }
            instance->SetBossState(BOSS_HORSEMEN, IN_PROGRESS);
            Map::PlayerList const& players = me->GetMap()->GetPlayers();
            if (players.empty()) // sanity check
                ResetEncounter();
 
            for (Horseman boss : horsemen)
            {
                if (Creature* cBoss = getHorsemanHandle(boss))
                {
                    if (!cBoss->IsAlive())
                    {
                        ResetEncounter();
                        return;
                    }
                    cBoss->SetReactState(REACT_PASSIVE);
                    cBoss->AttackStop(); // clear initial target that was set on enter combat
                    cBoss->setActive(true);
                    cBoss->SetFarVisible(true);
 
                    for (Map::PlayerList::const_iterator it = players.begin(); it != players.end(); ++it)
                    {
                        if (Player* player = it->GetSource())
                        {
                            if (player->IsGameMaster())
                                continue;
 
                            if (player->IsAlive())
                                AddThreat(player, 0.0f, cBoss);
                        }
                    }
 
                    /* Why do the Four Horsemen run to opposite corners of the room when engaged?          *
                    * They saw all the mobs leading up to them being AoE'd down and made a judgment call. */
                    cBoss->AI()->DoAction(ACTION_BEGIN_MOVEMENT);
                }
                else
                {
                    TC_LOG_WARN("scripts", "FourHorsemenAI: Encounter starting but horseman with id {} is not present", uint32(boss));
                    ResetEncounter();
                    return;
                }
            }
        }
 
        void ResetEncounter()
        {
            if (instance->GetBossState(BOSS_HORSEMEN) == NOT_STARTED || instance->GetBossState(BOSS_HORSEMEN) == DONE)
                return;
            instance->SetBossState(BOSS_HORSEMEN, NOT_STARTED);
            for (Horseman boss : horsemen)
            {
                if (Creature* cBoss = getHorsemanHandle(boss))
                    cBoss->DespawnOrUnsummon(0s, 15s);
                else
                    TC_LOG_WARN("scripts", "FourHorsemenAI: Encounter resetting but horseman with id {} is not present", uint32(boss));
            }
        }
 
        void EncounterCleared()
        {
            if (instance->GetBossState(BOSS_HORSEMEN) == DONE)
                return;
            instance->SetBossState(BOSS_HORSEMEN, DONE);
            //instance->DoUpdateCriteria(CRITERIA_TYPE_BE_SPELL_TARGET, SPELL_ENCOUNTER_CREDIT);
            DoCastAOE(SPELL_ENCOUNTER_CREDIT, true);
        }
 
        void JustEngagedWith(Unit* /*who*/) override
        {
            if (instance->GetBossState(BOSS_HORSEMEN) == IN_PROGRESS || instance->GetBossState(BOSS_HORSEMEN) == DONE) // another horseman already did it
                return;
            Talk(SAY_AGGRO);
            BeginEncounter();
        }
 
        void EnterEvadeMode(EvadeReason /*why*/) override
        {
            ResetEncounter();
        }
 
        void Reset() override
        {
            if (!me->IsAlive())
                return;
            _myMovementFinished = false;
            _nextMovement = 0;
            _timeDied = 0;
            _ourMovementFinished = false;
            me->SetReactState(REACT_AGGRESSIVE);
            SetCombatMovement(false);
            me->ResetLootMode();
            events.Reset();
            summons.DespawnAll();
        }
 
        void KilledUnit(Unit* victim) override
        {
            if (victim->GetTypeId() == TYPEID_PLAYER)
                Talk(SAY_SLAY, victim);
        }
 
        void JustDied(Unit* /*killer*/) override
        {
            if (instance->GetBossState(BOSS_HORSEMEN) != IN_PROGRESS) // necessary in case a horseman gets one-shot
            {
                BeginEncounter();
                return;
            }
 
            Talk(SAY_DEATH);
            _timeDied = GameTime::GetGameTimeMS();
            for (Horseman boss : horsemen)
            {
                if (Creature* cBoss = getHorsemanHandle(boss))
                {
                    if (cBoss->IsAlive())
                    {
                        // in case a horseman dies while moving (unlikely but possible especially in non-335 branch)
                        CheckIsMovementFinished();
                        return;
                    }
                }
                else
                {
                    TC_LOG_WARN("scripts", "FourHorsemenAI: {} died but horseman with id {} is not present", me->GetName(), uint32(boss));
                    ResetEncounter();
                }
            }
 
            EncounterCleared();
        }
 
        void MovementInform(uint32 type, uint32 i) override
        {
            if (type != POINT_MOTION_TYPE)
                return;
            if (i < 3)
                _nextMovement = i; // delay to next updateai to prevent it from instantly expiring
            else
            {
                _myMovementFinished = true;
                CheckIsMovementFinished();
            }
        }
 
        void UpdateAI(uint32 diff) override
        {
            if (_nextMovement)
            {
                me->GetMotionMaster()->MovePoint(_nextMovement + 1, _initialPath[_nextMovement], true);
                _nextMovement = 0;
            }
            _UpdateAI(diff);
        }
 
        virtual void BeginFighting() = 0;
        virtual void _UpdateAI(uint32 /*diff*/) = 0;
 
    private:
        const Horseman _which;
        Position const* _initialPath;
        bool _myMovementFinished;
        uint8 _nextMovement;
        uint32 _timeDied;
    protected:
        bool _ourMovementFinished;
};
 
struct boss_four_horsemen_baron : public boss_four_horsemen_baseAI
{
    boss_four_horsemen_baron(Creature* creature) : boss_four_horsemen_baseAI(creature, BARON, baronPath) { }
    void BeginFighting() override
    {
        SetCombatMovement(true);
        me->SetReactState(REACT_AGGRESSIVE);
        ThreatManager& threat = me->GetThreatManager();
        if (threat.IsThreatListEmpty())
        {
            if (Unit* nearest = me->SelectNearestPlayer(5000.0f))
            {
                AddThreat(nearest, 1.0f);
                AttackStart(nearest);
            }
            else
                ResetEncounter();
        }
        else
            AttackStart(threat.GetCurrentVictim());
 
        events.ScheduleEvent(EVENT_BERSERK, 10min);
        events.ScheduleEvent(EVENT_MARK, 24s);
        events.ScheduleEvent(EVENT_UNHOLYSHADOW, randtime(Seconds(3), Seconds(7)));
    }
 
    void _UpdateAI(uint32 diff) override
    {
        if (!_ourMovementFinished || !UpdateVictim())
            return;
        events.Update(diff);
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_BERSERK:
                    DoCastAOE(SPELL_BERSERK, true);
                    break;
                case EVENT_MARK:
                    DoCastAOE(SPELL_BARON_MARK, true);
                    events.Repeat(Seconds(12));
                    break;
                case EVENT_UNHOLYSHADOW:
                    DoCastVictim(SPELL_UNHOLY_SHADOW);
                    events.Repeat(randtime(Seconds(10), Seconds(30)));
                    break;
            }
        }
    }
 
    void SpellHitTarget(WorldObject* /*target*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SPELL_UNHOLY_SHADOW)
            Talk(SAY_SPECIAL);
    }
};
 
struct boss_four_horsemen_thane : public boss_four_horsemen_baseAI
{
    boss_four_horsemen_thane(Creature* creature) : boss_four_horsemen_baseAI(creature, THANE, thanePath), _shouldSay(true) { }
    void BeginFighting() override
    {
        SetCombatMovement(true);
        me->SetReactState(REACT_AGGRESSIVE);
        ThreatManager& threat = me->GetThreatManager();
        if (threat.IsThreatListEmpty())
        {
            if (Unit* nearest = me->SelectNearestPlayer(5000.0f))
            {
                AddThreat(nearest, 1.0f);
                AttackStart(nearest);
            }
            else
                ResetEncounter();
        }
        else
            AttackStart(threat.GetCurrentVictim());
 
        events.ScheduleEvent(EVENT_BERSERK, 10min);
        events.ScheduleEvent(EVENT_MARK, 24s);
        events.ScheduleEvent(EVENT_METEOR, randtime(Seconds(10), Seconds(25)));
    }
    void _UpdateAI(uint32 diff) override
    {
        if (!_ourMovementFinished || !UpdateVictim())
            return;
        events.Update(diff);
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_BERSERK:
                    DoCastAOE(SPELL_BERSERK, true);
                    break;
                case EVENT_MARK:
                    DoCastAOE(SPELL_THANE_MARK, true);
                    events.Repeat(Seconds(12));
                    break;
                case EVENT_METEOR:
                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 20.0f, true))
                    {
                        DoCast(target, SPELL_METEOR);
                        _shouldSay = true;
                    }
                    events.Repeat(randtime(Seconds(13), Seconds(17)));
                    break;
            }
        }
    }
 
    void SpellHitTarget(WorldObject* /*target*/, SpellInfo const* spellInfo) override
    {
        if (_shouldSay && spellInfo->Id == SPELL_METEOR)
        {
            Talk(SAY_SPECIAL);
            _shouldSay = false;
        }
    }
 
    private:
        bool _shouldSay; // throttle to make sure we only talk on first target hit by meteor
};
 
struct boss_four_horsemen_lady : public boss_four_horsemen_baseAI
{
    boss_four_horsemen_lady(Creature* creature) : boss_four_horsemen_baseAI(creature, LADY, ladyPath)
    {
        me->SetCanMelee(false);
    }
 
    void BeginFighting() override
    {
        events.ScheduleEvent(EVENT_BERSERK, 10min);
        events.ScheduleEvent(EVENT_MARK, 24s);
        events.ScheduleEvent(EVENT_VOIDZONE, randtime(Seconds(5), Seconds(10)));
    }
 
    void _UpdateAI(uint32 diff) override
    {
        if (!me->IsInCombat())
            return;
        if (!_ourMovementFinished)
            return;
        if (me->GetThreatManager().IsThreatListEmpty())
        {
            EnterEvadeMode(EvadeReason::NoHostiles);
            return;
        }
 
        events.Update(diff);
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_BERSERK:
                    DoCastAOE(SPELL_BERSERK, true);
                    break;
                case EVENT_MARK:
                    DoCastAOE(SPELL_LADY_MARK, true);
                    events.Repeat(Seconds(15));
                    break;
                case EVENT_VOIDZONE:
                    if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 45.0f, true))
                    {
                        DoCast(target, SPELL_VOID_ZONE, true);
                        Talk(SAY_SPECIAL);
                    }
                    events.Repeat(randtime(Seconds(12), Seconds(18)));
                    break;
            }
        }
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        if (Unit* target = SelectTarget(SelectTargetMethod::MinDistance, 0, 45.0f, true))
            DoCast(target, SPELL_SHADOW_BOLT);
        else
        {
            DoCastAOE(SPELL_UNYIELDING_PAIN);
            Talk(EMOTE_RAGECAST);
        }
    }
};
 
struct boss_four_horsemen_sir : public boss_four_horsemen_baseAI
{
    boss_four_horsemen_sir(Creature* creature) : boss_four_horsemen_baseAI(creature, SIR, sirPath), _shouldSay(true)
    {
        me->SetCanMelee(false);
    }
 
    void BeginFighting() override
    {
        events.ScheduleEvent(EVENT_BERSERK, 10min);
        events.ScheduleEvent(EVENT_MARK, 24s);
        events.ScheduleEvent(EVENT_HOLYWRATH, randtime(Seconds(13), Seconds(18)));
    }
 
    void _UpdateAI(uint32 diff) override
    {
        if (!me->IsInCombat())
            return;
        if (!_ourMovementFinished)
            return;
        if (me->GetThreatManager().IsThreatListEmpty())
        {
            EnterEvadeMode(EvadeReason::NoHostiles);
            return;
        }
 
        events.Update(diff);
 
        while (uint32 eventId = events.ExecuteEvent())
        {
            switch (eventId)
            {
                case EVENT_BERSERK:
                    DoCastAOE(SPELL_BERSERK, true);
                    break;
                case EVENT_MARK:
                    DoCastAOE(SPELL_SIR_MARK, true);
                    events.Repeat(Seconds(15));
                    break;
                case EVENT_HOLYWRATH:
                    if (Unit* target = SelectTarget(SelectTargetMethod::MinDistance, 0, 45.0f, true))
                    {
                        DoCast(target, SPELL_HOLY_WRATH, true);
                        _shouldSay = true;
                    }
                    events.Repeat(randtime(Seconds(10), Seconds(18)));
                    break;
            }
        }
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        if (Unit* target = SelectTarget(SelectTargetMethod::MinDistance, 0, 45.0f, true))
            DoCast(target, SPELL_HOLY_BOLT);
        else
        {
            DoCastAOE(SPELL_CONDEMNATION);
            Talk(EMOTE_RAGECAST);
        }
    }
 
    void SpellHitTarget(WorldObject* /*target*/, SpellInfo const* spellInfo) override
    {
        if (_shouldSay && spellInfo->Id == SPELL_HOLY_WRATH)
        {
            Talk(SAY_SPECIAL);
            _shouldSay = false;
        }
    }
 
    private:
        bool _shouldSay; // throttle to make sure we only talk on first target hit by holy wrath
};
 
// 28832 - Mark of Korth'azz
// 28833 - Mark of Blaumeux
// 28834 - Mark of Rivendare
// 28835 - Mark of Zeliek
class spell_four_horsemen_mark : public AuraScript
{
    void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (Unit* caster = GetCaster())
        {
            int32 damage;
            switch (GetStackAmount())
            {
                case 1:
                    damage = 0;
                    break;
                case 2:
                    damage = 500;
                    break;
                case 3:
                    damage = 1000;
                    break;
                case 4:
                    damage = 1500;
                    break;
                case 5:
                    damage = 4000;
                    break;
                case 6:
                    damage = 12000;
                    break;
                default:
                    damage = 20000 + 1000 * (GetStackAmount() - 7);
                    break;
            }
            if (damage)
            {
                CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
                args.AddSpellBP0(damage);
                caster->CastSpell(GetTarget(), SPELL_MARK_DAMAGE, args);
            }
        }
    }
 
    void Register() override
    {
        AfterEffectApply += AuraEffectApplyFn(spell_four_horsemen_mark::OnApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
    }
};
 
void AddSC_boss_four_horsemen()
{
    RegisterNaxxramasCreatureAI(boss_four_horsemen_baron);
    RegisterNaxxramasCreatureAI(boss_four_horsemen_thane);
    RegisterNaxxramasCreatureAI(boss_four_horsemen_lady);
    RegisterNaxxramasCreatureAI(boss_four_horsemen_sir);
    RegisterSpellScript(spell_four_horsemen_mark);
}