static void ResetSpellCooldowns(Player* player, bool onStartDuel)
{
// remove cooldowns on spells that have < 10 min CD > 30 sec and has no onHold
player->GetSpellHistory()->ResetCooldowns([player, onStartDuel](SpellHistory::CooldownStorageType::iterator itr) -> bool
{
SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(itr->first);
uint32 remainingCooldown = player->GetSpellHistory()->GetRemainingCooldown(spellInfo);
int32 totalCooldown = spellInfo->RecoveryTime;
int32 categoryCooldown = spellInfo->CategoryRecoveryTime;
player->ApplySpellMod(spellInfo->Id, SPELLMOD_COOLDOWN, totalCooldown, nullptr);
if (int32 cooldownMod = player->GetTotalAuraModifier(SPELL_AURA_MOD_COOLDOWN))
totalCooldown += cooldownMod * IN_MILLISECONDS;
if (!spellInfo->HasAttribute(SPELL_ATTR6_IGNORE_CATEGORY_COOLDOWN_MODS))
player->ApplySpellMod(spellInfo->Id, SPELLMOD_COOLDOWN, categoryCooldown, nullptr);
return remainingCooldown > 0
&& !itr->second.OnHold
&& Milliseconds(totalCooldown) < Minutes(10)
&& Milliseconds(categoryCooldown) < Minutes(10)
&& Milliseconds(remainingCooldown) < Minutes(10)
&& (onStartDuel ? Milliseconds(totalCooldown - remainingCooldown) > Seconds(30) : true)
&& (onStartDuel ? Milliseconds(categoryCooldown - remainingCooldown) > Seconds(30) : true);
}, true);
// pet cooldowns
if (Pet* pet = player->GetPet())
pet->GetSpellHistory()->ResetAllCooldowns();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_IMPALE:
if (events.GetTimeUntilEvent(EVENT_LOCUST) < 5 * IN_MILLISECONDS) break; // don't chain impale tank -> locust swarm
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_IMPALE);
else
EnterEvadeMode();
events.Repeat(randtime(Seconds(10), Seconds(20)));
break;
case EVENT_SCARABS:
if (!guardCorpses.empty())
{
if (Creature* creatureTarget = ObjectAccessor::GetCreature(*me, Trinity::Containers::SelectRandomContainerElement(guardCorpses)))
{
creatureTarget->CastSpell(creatureTarget, SPELL_SUMMON_CORPSE_SCARABS_MOB, true, nullptr, nullptr, me->GetGUID());
creatureTarget->AI()->Talk(EMOTE_SCARAB);
creatureTarget->DespawnOrUnsummon();
}
}
events.Repeat(randtime(Seconds(40), Seconds(60)));
break;
case EVENT_LOCUST:
Talk(EMOTE_LOCUST);
events.SetPhase(PHASE_SWARM);
DoCast(me, SPELL_LOCUST_SWARM);
events.ScheduleEvent(EVENT_SPAWN_GUARD, Seconds(3));
events.ScheduleEvent(EVENT_LOCUST_ENDS, RAID_MODE(Seconds(19), Seconds(23)));
events.Repeat(Minutes(1)+Seconds(30));
break;
case EVENT_LOCUST_ENDS:
events.SetPhase(PHASE_NORMAL);
events.ScheduleEvent(EVENT_IMPALE, randtime(Seconds(10), Seconds(20)), 0, PHASE_NORMAL);
events.ScheduleEvent(EVENT_SCARABS, randtime(Seconds(20), Seconds(30)), 0, PHASE_NORMAL);
break;
case EVENT_SPAWN_GUARD:
me->SummonCreatureGroup(GROUP_SINGLE_SPAWN);
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
events.ScheduleEvent(EVENT_BERSERK, Minutes(10));
break;
}
}
if (events.IsInPhase(PHASE_NORMAL))
DoMeleeAttackIfReady();
}
void Reset() override
{
_Reset();
DoCastSelf(SPELL_SHADOW_CAGE_C);
me->SummonCreatureGroup(SUMMON_GROUP_CHANNELERS);
events.SetPhase(PHASE_BANISH);
_channelersCount = 5;
events.ScheduleEvent(EVENT_TAUNT, Minutes(4), Minutes(5));
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
events.SetPhase(PHASE_ONE);
events.ScheduleEvent(EVENT_SUMMON, Seconds(25), 0, PHASE_ONE);
events.ScheduleEvent(EVENT_DOORS_UNLOCK, Minutes(3) + Seconds(25), 0, PHASE_ONE);
events.ScheduleEvent(EVENT_PHASE_TWO, Minutes(4) + Seconds(30), 0, PHASE_ONE);
Talk(SAY_INTRO_1);
events.ScheduleEvent(EVENT_INTRO_2, Seconds(4));
events.ScheduleEvent(EVENT_INTRO_3, Seconds(9));
events.ScheduleEvent(EVENT_INTRO_4, Seconds(14));
instance->SetData(DATA_GOTHIK_GATE, GO_STATE_READY);
_gateIsOpen = false;
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
Talk(SAY_AGGRO);
_safeSection = 0;
events.ScheduleEvent(EVENT_DISRUPT, randtime(Seconds(15), Seconds(20)), 0, PHASE_FIGHT);
events.ScheduleEvent(EVENT_FEVER, randtime(Seconds(10), Seconds(20)), 0, PHASE_FIGHT);
events.ScheduleEvent(EVENT_DANCE, Minutes(1) + Seconds(30), 0, PHASE_FIGHT);
events.ScheduleEvent(EVENT_ERUPT, Seconds(15));
_safetyDance = true;
// figure out the current GUIDs of our eruption tiles and which segment they belong in
std::unordered_multimap<uint32, GameObject*> const& mapGOs = me->GetMap()->GetGameObjectBySpawnIdStore();
uint32 spawnId = firstEruptionDBGUID;
for (uint8 section = 0; section < numSections; ++section)
{
_eruptTiles[section].clear();
for (uint8 i = 0; i < numEruptions[section]; ++i)
{
auto tileIt = mapGOs.equal_range(spawnId++);
for (auto it = tileIt.first; it != tileIt.second; ++it)
_eruptTiles[section].push_back(it->second->GetGUID());
}
}
}
int TradingPeriod::Now(Time now, Time *remaining, Time delayed) {
int ret = NONE, wall_st_hours_from_gmt, hours_to_wall_st = WallStHoursFromLocal(&wall_st_hours_from_gmt);
Time days_away = Time(0);
struct tm t;
for (;; days_away += Hours(24)) {
// Find next trading day
for (;; days_away += Hours(24)) {
WallStTime(now + days_away, &t, hours_to_wall_st);
bool week_day = t.tm_wday >= 1 && t.tm_wday <= 5;
if (week_day && !TradingHoliday(t.tm_year+1900, t.tm_mon+1, t.tm_mday)) break;
}
if (days_away != Time(0)) days_away -= SinceDayBegan(now + days_away, wall_st_hours_from_gmt);
Time trading_day_elapsed = SinceDayBegan(now + days_away, wall_st_hours_from_gmt);
// Find next trading period
static int trading_period_id [] = { NONE, PRE_MARKET, MARKET, AFTER_MARKET };
static Time trading_period_time[] = { Hours(4), Hours(9)+Minutes(30), Hours(16), Hours(20), };
for (int i=0, l=sizeofarray(trading_period_id); i<l; i++)
if (trading_day_elapsed < (trading_period_time[i] + delayed)) {
if (remaining) *remaining = (trading_period_time[i] + delayed - trading_day_elapsed) + days_away;
return trading_period_id[i];
}
}
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
Talk(SAY_AGGRO);
summons.DoZoneInCombat();
events.SetPhase(PHASE_NORMAL);
events.ScheduleEvent(EVENT_IMPALE, randtime(Seconds(10), Seconds(20)), 0, PHASE_NORMAL);
events.ScheduleEvent(EVENT_SCARABS, randtime(Seconds(20), Seconds(30)), 0, PHASE_NORMAL);
events.ScheduleEvent(EVENT_LOCUST, Minutes(1)+randtime(Seconds(40), Seconds(60)), 0, PHASE_NORMAL);
events.ScheduleEvent(EVENT_BERSERK, Minutes(10));
if (!Is25ManRaid())
events.ScheduleEvent(EVENT_SPAWN_GUARD, randtime(Seconds(15), Seconds(20)));
}
TEST(DurationTest, OutputFormat)
{
EXPECT_EQ("1ns", stringify(Nanoseconds(1)));
EXPECT_EQ("2ns", stringify(Nanoseconds(2)));
// Truncated. Seconds in 15 digits of precision, max of double
// type's precise digits.
EXPECT_EQ("3.141592653secs",
stringify(Duration::create(3.14159265358979).get()));
EXPECT_EQ("3140ms", stringify(Duration::create(3.14).get()));
EXPECT_EQ("10hrs", stringify(Hours(10)));
EXPECT_EQ("-10hrs", stringify(Hours(-10)));
// "10days" reads better than "1.42857142857143weeks" so it is
// printed out in the lower unit.
EXPECT_EQ("10days", stringify(Days(10)));
// We go one-level down and it is still not a whole number so we
// print it out using the higher unit.
EXPECT_EQ("1.1875days", stringify(Days(1) + Hours(4) + Minutes(30)));
// "2weeks" reads better than "14days" so we use the higher unit
// here.
EXPECT_EQ("2weeks", stringify(Days(14)));
// Boundary cases.
EXPECT_EQ("0ns", stringify(Duration::zero()));
EXPECT_EQ("15250.2844524715weeks", stringify(Duration::max()));
EXPECT_EQ("-15250.2844524715weeks", stringify(Duration::min()));
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
ChangePhase();
events.ScheduleEvent(EVENT_BERSERK, Minutes(15));
events.ScheduleEvent(EVENT_FLAME, Seconds(20));
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
events.ScheduleEvent(EVENT_NECROTIC_AURA, Seconds(17));
events.ScheduleEvent(EVENT_DEATHBLOOM, Seconds(5));
events.ScheduleEvent(EVENT_SPORE, Seconds(18));
events.ScheduleEvent(EVENT_INEVITABLE_DOOM, Minutes(2));
}
void JustEngagedWith(Unit* /*who*/) override
{
_JustEngagedWith();
events.ScheduleEvent(EVENT_NECROTIC_AURA, Seconds(17));
events.ScheduleEvent(EVENT_DEATHBLOOM, Seconds(5));
events.ScheduleEvent(EVENT_SPORE, Seconds(18));
events.ScheduleEvent(EVENT_INEVITABLE_DOOM, Minutes(2));
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
Talk(SAY_AGGRO);
summons.DoZoneInCombat();
events.ScheduleEvent(EVENT_POISON, randtime(Seconds(10), Seconds(15)));
events.ScheduleEvent(EVENT_FIRE, randtime(Seconds(6), Seconds(18)));
events.ScheduleEvent(EVENT_FRENZY, Minutes(1)+randtime(Seconds(0), Seconds(20)));
}
TEST(DurationTest, ParseAndTry)
{
EXPECT_SOME_EQ(Hours(3), Duration::parse("3hrs"));
EXPECT_SOME_EQ(Hours(3) + Minutes(30), Duration::parse("3.5hrs"));
EXPECT_SOME_EQ(Nanoseconds(3141592653), Duration::create(3.141592653));
// Duration can hold only 9.22337e9 seconds.
EXPECT_ERROR(Duration::create(10 * 1e9));
EXPECT_ERROR(Duration::create(-10 * 1e9));
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
Enraged = false;
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_HATEFUL, Seconds(1));
events.ScheduleEvent(EVENT_BERSERK, Minutes(6));
instance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_MAKE_QUICK_WERK_OF_HIM_STARTING_EVENT);
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
me->CastSpell(me, SPELL_FROST_AURA, true);
events.SetPhase(PHASE_GROUND);
events.ScheduleEvent(EVENT_CHECK_RESISTS, Seconds(0));
events.ScheduleEvent(EVENT_BERSERK, Minutes(15));
EnterPhaseGround(true);
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
Talk(SAY_AGGRO);
events.ScheduleEvent(EVENT_SILENCING_SHRIEK, Seconds(22));
events.ScheduleEvent(EVENT_PRISMATIC_SHIELD, Seconds(15));
events.ScheduleEvent(EVENT_FATAL_ATTRACTION, Seconds(35));
events.ScheduleEvent(EVENT_RANDOM_BEAM, Seconds(6));
events.ScheduleEvent(EVENT_BERSERK, Minutes(10));
events.ScheduleEvent(EVENT_TAUNT, Seconds(35));
}
void DoAction(int32 action) override
{
switch (action)
{
case ACTION_BEGIN_ENCOUNTER:
if (instance->GetBossState(BOSS_KELTHUZAD) != NOT_STARTED)
return;
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
instance->SetBossState(BOSS_KELTHUZAD, IN_PROGRESS);
events.SetPhase(PHASE_ONE);
DoZoneInCombat();
DoCastAOE(SPELL_VISUAL_CHANNEL);
Talk(SAY_SUMMON_MINIONS);
for (uint8 group = SUMMON_GROUP_MINION_FIRST; group < SUMMON_GROUP_MINION_FIRST + nMinionGroups; ++group)
{
std::list<TempSummon*> summoned;
me->SummonCreatureGroup(group, &summoned);
for (TempSummon* summon : summoned)
{
summon->SetReactState(REACT_PASSIVE);
summon->AI()->SetData(DATA_MINION_POCKET_ID, group);
}
}
events.ScheduleEvent(EVENT_SKELETON, Seconds(5), 0, PHASE_ONE);
events.ScheduleEvent(EVENT_BANSHEE, Seconds(30), 0, PHASE_ONE);
events.ScheduleEvent(EVENT_ABOMINATION, Seconds(30), 0, PHASE_ONE);
events.ScheduleEvent(EVENT_DESPAWN_MINIONS, Minutes(3) + Seconds(33), 0, PHASE_ONE);
events.ScheduleEvent(EVENT_PHASE_TWO, Minutes(3) + Seconds(48), 0, PHASE_ONE);
break;
case ACTION_ABOMINATION_DIED:
++_abominationDeathCount;
break;
default:
break;
}
}
void Reset() override
{
_scheduler.CancelAll();
_combatScheduler.CancelAll();
_scheduler.Schedule(Seconds(1), [this](TaskContext context)
{
// Find a spell that targets friendly and applies an aura (these are generally buffs)
if (SpellInfo const* spellInfo = SelectSpell(me, 0, 0, SELECT_TARGET_ANY_FRIEND, 0, 0, 0, 0, SELECT_EFFECT_AURA))
DoCast(me, spellInfo->Id);
context.Repeat(Minutes(10));
});
}
void JustEngagedWith(Unit* /*who*/) override
{
Talk(ANGER_SAY_FREED);
events.ScheduleEvent(EVENT_START_CHECK_TANKER, 5s);
events.ScheduleEvent(EVENT_SOUL_SCREAM, 11s);
events.ScheduleEvent(EVENT_SPITE, 20s);
events.ScheduleEvent(EVENT_FREED_2, Seconds(1), Minutes(3));
me->SetCombatPulseDelay(5);
me->setActive(true);
DoZoneInCombat();
}
namespace slave {
const Duration EXECUTOR_REGISTRATION_TIMEOUT = Minutes(1);
const Duration EXECUTOR_SHUTDOWN_GRACE_PERIOD = Seconds(5);
const Duration EXECUTOR_REREGISTER_TIMEOUT = Seconds(2);
const Duration EXECUTOR_SIGNAL_ESCALATION_TIMEOUT = Seconds(3);
const Duration STATUS_UPDATE_RETRY_INTERVAL_MIN = Seconds(10);
const Duration STATUS_UPDATE_RETRY_INTERVAL_MAX = Minutes(10);
const Duration REGISTRATION_BACKOFF_FACTOR = Seconds(1);
const Duration REGISTER_RETRY_INTERVAL_MAX = Minutes(1);
const Duration GC_DELAY = Weeks(1);
const double GC_DISK_HEADROOM = 0.1;
const Duration DISK_WATCH_INTERVAL = Minutes(1);
const Duration RECOVERY_TIMEOUT = Minutes(15);
const Duration RESOURCE_MONITORING_INTERVAL = Seconds(1);
const uint32_t MAX_COMPLETED_FRAMEWORKS = 50;
const uint32_t MAX_COMPLETED_EXECUTORS_PER_FRAMEWORK = 150;
const uint32_t MAX_COMPLETED_TASKS_PER_EXECUTOR = 200;
const double DEFAULT_CPUS = 1;
const Bytes DEFAULT_MEM = Gigabytes(1);
const Bytes DEFAULT_DISK = Gigabytes(10);
const std::string DEFAULT_PORTS = "[31000-32000]";
#ifdef WITH_NETWORK_ISOLATOR
const uint16_t DEFAULT_EPHEMERAL_PORTS_PER_CONTAINER = 1024;
#endif
const Duration DOCKER_REMOVE_DELAY = Hours(6);
const Duration DOCKER_INSPECT_DELAY = Seconds(1);
// TODO(tnachen): Make this a flag.
const Duration DOCKER_VERSION_WAIT_TIMEOUT = Seconds(5);
const std::string DEFAULT_AUTHENTICATEE = "crammd5";
Duration DEFAULT_MASTER_PING_TIMEOUT()
{
return master::DEFAULT_SLAVE_PING_TIMEOUT *
master::DEFAULT_MAX_SLAVE_PING_TIMEOUTS;
}
} // namespace slave {
TEST(DurationTest, Comparison)
{
EXPECT_EQ(Duration::zero(), Seconds(0));
EXPECT_EQ(Minutes(180), Hours(3));
EXPECT_EQ(Seconds(10800), Hours(3));
EXPECT_EQ(Milliseconds(10800000), Hours(3));
EXPECT_EQ(Milliseconds(1), Microseconds(1000));
EXPECT_EQ(Milliseconds(1000), Seconds(1));
EXPECT_GT(Weeks(1), Days(6));
EXPECT_LT(Hours(23), Days(1));
EXPECT_LE(Hours(24), Days(1));
EXPECT_GE(Hours(24), Days(1));
EXPECT_NE(Minutes(59), Hours(1));
// Maintains precision for a 100 year duration.
EXPECT_GT(Weeks(5217) + Nanoseconds(1), Weeks(5217));
EXPECT_LT(Weeks(5217) - Nanoseconds(1), Weeks(5217));
}
void EnterPhaseGround(bool initial)
{
me->SetReactState(REACT_AGGRESSIVE);
events.ScheduleEvent(EVENT_CLEAVE, randtime(Seconds(5), Seconds(15)), 0, PHASE_GROUND);
events.ScheduleEvent(EVENT_TAIL, randtime(Seconds(7), Seconds(10)), 0, PHASE_GROUND);
events.ScheduleEvent(EVENT_BLIZZARD, randtime(Seconds(5), Seconds(10)), 0, PHASE_GROUND);
if (initial)
{
events.ScheduleEvent(EVENT_DRAIN, randtime(Seconds(22), Seconds(28)));
events.ScheduleEvent(EVENT_FLIGHT, Seconds(48) + Milliseconds(500), 0, PHASE_GROUND);
}
else
events.ScheduleEvent(EVENT_FLIGHT, Minutes(1), 0, PHASE_GROUND);
}
void DoAction(int32 action) override
{
if (action == ACTION_START_CHANNELERS_EVENT && events.IsInPhase(PHASE_BANISH))
{
events.SetPhase(PHASE_1);
Talk(EMOTE_WEAKEN, me);
summons.DoZoneInCombat(NPC_HELLFIRE_CHANNELLER);
events.ScheduleEvent(EVENT_START_FIGHT, Minutes(2));
events.ScheduleEvent(EVENT_NEARLY_EMOTE, Seconds(60));
events.CancelEvent(EVENT_TAUNT);
instance->SetBossState(DATA_MAGTHERIDON, IN_PROGRESS);
instance->SetData(DATA_CALL_WARDERS, ACTION_ENABLE);
}
}
void ScheduleTasks() override
{
scheduler.Schedule(Minutes(10), [this](TaskContext /*context*/)
{
if (Creature* entropius = ObjectAccessor::GetCreature(*me, _entropiusGUID))
entropius->CastSpell(entropius, SPELL_ENRAGE);
DoCast(me, SPELL_ENRAGE);
_hasEnraged = true;
});
scheduler.Schedule(Seconds(10), [this](TaskContext /*context*/)
{
DoCast(me, SPELL_SUMMON_BLOOD_ELVES_SCRIPT, true);
DoCast(me, SPELL_SUMMON_BLOOD_ELVES_PERIODIC, true);
});
}
namespace master {
const int MAX_OFFERS_PER_FRAMEWORK = 50;
const double MIN_CPUS = 0.01;
const Bytes MIN_MEM = Megabytes(32);
const Duration SLAVE_PING_TIMEOUT = Seconds(15);
const uint32_t MAX_SLAVE_PING_TIMEOUTS = 5;
const Duration MIN_SLAVE_REREGISTER_TIMEOUT = Minutes(10);
const double RECOVERY_SLAVE_REMOVAL_PERCENT_LIMIT = 1.0; // 100%.
const size_t MAX_REMOVED_SLAVES = 100000;
const uint32_t MAX_COMPLETED_FRAMEWORKS = 50;
const uint32_t MAX_COMPLETED_TASKS_PER_FRAMEWORK = 1000;
const Duration WHITELIST_WATCH_INTERVAL = Seconds(5);
const uint32_t TASK_LIMIT = 100;
const std::string MASTER_INFO_LABEL = "info";
const Duration ZOOKEEPER_SESSION_TIMEOUT = Seconds(10);
} // namespace master {
bool AchievementGlobalMgr::IsRealmCompleted(AchievementEntry const* achievement) const
{
auto itr = _allCompletedAchievements.find(achievement->ID);
if (itr == _allCompletedAchievements.end())
return false;
if (itr->second == std::chrono::system_clock::time_point::min())
return false;
// Allow completing the realm first kill for entire minute after first person did it
// it may allow more than one group to achieve it (highly unlikely)
// but apparently this is how blizz handles it as well
if (achievement->Flags & ACHIEVEMENT_FLAG_REALM_FIRST_KILL)
return (std::chrono::system_clock::now() - itr->second) > Minutes(1);
return true;
}
void DamageTaken(Unit* /*attacker*/, uint32 &damage) override
{
if (damage > me->GetHealth() || me->HealthBelowPctDamaged(20, damage))
{
damage = 0;
_events.Reset();
me->RestoreFaction();
me->RemoveAllAuras();
me->DeleteThreatList();
me->CombatStop(true);
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
Talk(SAY_DEFEATED);
_events.ScheduleEvent(EVENT_EVADE, Minutes(1));
}
}
void DamageTaken(Unit* /*attacker*/, uint32 &damage) override
{
if (damage > me->GetHealth() || me->HealthBelowPctDamaged(20, damage))
{
damage = 0;
_events.Reset();
me->RestoreFaction();
me->RemoveAllAuras();
me->GetThreatManager().ClearAllThreat();
me->CombatStop(true);
me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER);
me->SetImmuneToPC(true);
Talk(SAY_DEFEATED);
_events.ScheduleEvent(EVENT_EVADE, Minutes(1));
}
}
void PreparePhase(Phases phase)
{
//events.SetPhase(phase);
switch (phase)
{
case PHASE_ONE:
scheduler.Schedule(Milliseconds(8500), [this](TaskContext context)
{
me->AddAura(SPELL_INCENDIARY_SOUL, me); // No cast
DoCastVictim(SPELL_BLAZE_OF_GLORY);
context.Repeat(Milliseconds(11500));
});
scheduler.Schedule(Seconds(5), [this](TaskContext context)
{
DoCastAOE(SPELL_SHARDS_OF_TORMENT);
context.Repeat(Seconds(34));
});
if (me->GetMap()->IsHeroic())
{
scheduler.Schedule(Seconds(26), [this](TaskContext context)
{
DoCastAOE(SPELL_COUNTDOWN);
context.Repeat(Seconds(48));
});
}
scheduler.Schedule(Milliseconds(30500), [this](TaskContext context)
{
DoCastSelf(SPELL_BLADES_OF_BALEROC);
context.Repeat(Seconds(47));
});
scheduler.Schedule(Minutes(6), [this](TaskContext)
{
Talk(SAY_ENRAGE);
Talk(EMOTE_ENRAGE);
DoCastSelf(SPELL_BERSERK);
});
break;
default:
break;
}
}
void EnterCombat(Unit* /*who*/) override
{
if (!_inCombat)
{
_inCombat = true;
_EnterCombat();
for (uint32 bossData : CouncilData)
{
if (Creature* council = instance->GetCreature(bossData))
{
instance->SendEncounterUnit(ENCOUNTER_FRAME_ENGAGE, council);
DoZoneInCombat(council);
}
}
events.ScheduleEvent(EVENT_EMPYREAL_EQUIVALENCY, Seconds(2));
events.ScheduleEvent(EVENT_BERSERK, Minutes(15));
if (Creature* council = instance->GetCreature(CouncilData[urand(0, 3)]))
council->AI()->Talk(SAY_COUNCIL_AGRO);
}
}
