boss_chrono_lord_epoch.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 "culling_of_stratholme.h"
#include "InstanceScript.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "ScriptMgr.h"
#include "SpellInfo.h"
#include <vector>
 
enum Spells
{
 SPELL_CURSE_OF_EXERTION = 52772,
 SPELL_TIME_WARP = 52766,
 SPELL_TIME_STOP = 58848,
 SPELL_TIME_STEP_DUMMY = 52736,
};
 
#define SPELL_TIME_STEP_CHARGE DUNGEON_MODE(52737,58829)
#define SPELL_WOUNDING_STRIKE DUNGEON_MODE(52771,58830)
 
enum Yells
{
 SAY_TIME_WARP = 2,
 SAY_SLAY = 3,
};
 
enum Events
{
 EVENT_CURSE_OF_EXERTION = 1,
 EVENT_TIME_WARP,
 EVENT_TIME_STOP,
 EVENT_WOUNDING_STRIKE,
 EVENT_TIME_STEP
};
 
class boss_epoch : public CreatureScript
{
 public:
 boss_epoch() : CreatureScript("boss_epoch") { }
 
 struct boss_epochAI : public BossAI
 {
 boss_epochAI(Creature* creature) : BossAI(creature, DATA_EPOCH), _stepTargetIndex(0) { }
 
 void InitializeAI() override
 {
 if (instance->GetBossState(DATA_EPOCH) == DONE)
 me->RemoveLootMode(LOOT_MODE_DEFAULT);
 }
 
 void JustEngagedWith(Unit* who) override
 {
 BossAI::JustEngagedWith(who);
 
 _stepTargetIndex = 0;
 _stepTargets.clear();
 events.ScheduleEvent(EVENT_WOUNDING_STRIKE, Seconds(4), Seconds(6));
 events.ScheduleEvent(EVENT_CURSE_OF_EXERTION, Seconds(10), Seconds(17));
 events.ScheduleEvent(EVENT_TIME_WARP, Seconds(25));
 if (IsHeroic())
 events.ScheduleEvent(EVENT_TIME_STOP, Seconds(15));
 }
 
 void ExecuteEvent(uint32 eventId) override
 {
 switch (eventId)
 {
 case EVENT_CURSE_OF_EXERTION:
 if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100.0f, true))
 DoCast(target, SPELL_CURSE_OF_EXERTION);
 events.ScheduleEvent(EVENT_CURSE_OF_EXERTION, 9300ms);
 break;
 case EVENT_TIME_WARP:
 Talk(SAY_TIME_WARP);
 DoCastAOE(SPELL_TIME_WARP);
 DoCastAOE(SPELL_TIME_STEP_DUMMY);
 events.Repeat(Seconds(25));
 break;
 case EVENT_TIME_STOP:
 DoCastAOE(SPELL_TIME_STOP);
 events.Repeat(Seconds(25));
 break;
 case EVENT_WOUNDING_STRIKE:
 DoCastVictim(SPELL_WOUNDING_STRIKE);
 events.Repeat(Seconds(12), Seconds(18));
 break;
 case EVENT_TIME_STEP:
 {
 // In each step, we charge to a random target that was previously hit by SPELL_TIME_STEP_DUMMY
 // Once we run out of targets, we charge back to the tank, then stop
 uint32 nTargets = _stepTargets.size();
 Unit* target = nullptr;
 while (nTargets > _stepTargetIndex)
 {
 uint32 selected = urand(_stepTargetIndex, nTargets - 1);
 if (_stepTargetIndex != selected)
 std::swap(_stepTargets[_stepTargetIndex], _stepTargets[selected]);
 if ((target = ObjectAccessor::GetUnit(*me, _stepTargets[_stepTargetIndex++])))
 break;
 }
 if (target)
 events.Repeat(Milliseconds(500));
 else
 target = me->GetVictim();
 
 if (target)
 DoCast(target, SPELL_TIME_STEP_CHARGE, true);
 break;
 }
 default:
 break;
 }
 }
 
 void SpellHitTarget(WorldObject* target, SpellInfo const* spellInfo) override
 {
 if (spellInfo->Id == SPELL_TIME_STEP_DUMMY && me->IsHostileTo(target))
 {
 _stepTargets.push_back(target->GetGUID());
 events.RescheduleEvent(EVENT_TIME_STEP, Milliseconds(500));
 }
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 _JustDied();
 }
 
 void KilledUnit(Unit* victim) override
 {
 if (victim->GetTypeId() == TYPEID_PLAYER)
 Talk(SAY_SLAY);
 }
 
 private:
 uint32 _stepTargetIndex;
 std::vector<ObjectGuid> _stepTargets;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetCullingOfStratholmeAI<boss_epochAI>(creature);
 }
};
 
void AddSC_boss_epoch()
{
 new boss_epoch();
}