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_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
_events.Repeat(randtime(Seconds(10), Seconds(16)));
break;
case EVENT_STRIKE:
DoCastVictim(SPELL_STRIKE);
_events.Repeat(randtime(Seconds(15), Seconds(19)));
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void EnterCombat(Unit* who) override
{
BossAI::EnterCombat(who);
if (GameObject* door = instance->GetGameObject(DATA_ANUBARAK_WALL))
door->SetGoState(GO_STATE_ACTIVE); // open door for now
Talk(SAY_AGGRO);
instance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_GOTTA_GO_START_EVENT);
events.SetPhase(PHASE_EMERGE);
events.ScheduleEvent(EVENT_CLOSE_DOOR, Seconds(5));
events.ScheduleEvent(EVENT_POUND, randtime(Seconds(2), Seconds(4)), 0, PHASE_EMERGE);
events.ScheduleEvent(EVENT_LEECHING_SWARM, randtime(Seconds(5), Seconds(7)), 0, PHASE_EMERGE);
events.ScheduleEvent(EVENT_CARRION_BEETLES, randtime(Seconds(14), Seconds(17)), 0, PHASE_EMERGE);
// set up world triggers
std::list<TempSummon*> summoned;
me->SummonCreatureGroup(SUMMON_GROUP_WORLD_TRIGGER_GUARDIAN, &summoned);
if (summoned.empty()) // something went wrong
{
EnterEvadeMode(EVADE_REASON_OTHER);
return;
}
_guardianTrigger = (*summoned.begin())->GetGUID();
if (Creature* trigger = DoSummon(NPC_WORLD_TRIGGER, me->GetPosition(), 0u, TEMPSUMMON_MANUAL_DESPAWN))
_assassinTrigger = trigger->GetGUID();
else
{
EnterEvadeMode(EVADE_REASON_OTHER);
return;
}
}
void DoAction(int32 action) override
{
switch (action)
{
case ACTION_PET_DIED:
if (!_petCount) // underflow check - something has gone horribly wrong
{
EnterEvadeMode(EVADE_REASON_OTHER);
return;
}
if (!--_petCount) // last pet died, emerge
{
me->RemoveAurasDueToSpell(SPELL_SUBMERGE);
me->RemoveAurasDueToSpell(SPELL_IMPALE_AURA);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
DoCastSelf(SPELL_EMERGE);
events.SetPhase(PHASE_EMERGE);
events.ScheduleEvent(EVENT_POUND, randtime(Seconds(13), Seconds(18)), 0, PHASE_EMERGE);
events.ScheduleEvent(EVENT_LEECHING_SWARM, randtime(Seconds(3), Seconds(7)), 0, PHASE_EMERGE);
events.ScheduleEvent(EVENT_CARRION_BEETLES, randtime(Seconds(10), Seconds(15)), 0, PHASE_EMERGE);
}
break;
case ACTION_PET_EVADE:
EnterEvadeMode(EVADE_REASON_OTHER);
break;
}
}
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_ANUBAR_CHARGE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_CHARGE);
_events.Repeat(randtime(Seconds(20), Seconds(25)));
break;
case EVENT_BACKSTAB:
if (me->GetVictim() && me->GetVictim()->isInBack(me))
DoCastVictim(SPELL_BACKSTAB);
_events.Repeat(randtime(Seconds(10), Seconds(13)));
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
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 (ObjectGuid target = Trinity::Containers::SelectRandomContainerElement(guardCorpses))
if (Creature* creatureTarget = ObjectAccessor::GetCreature(*me, target))
{
creatureTarget->CastSpell(creatureTarget, SPELL_SUMMON_CORPSE_SCARABS_MOB, 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, 3s);
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, 10min);
break;
}
}
if (events.IsInPhase(PHASE_NORMAL))
DoMeleeAttackIfReady();
}
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());
}
}
}
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_SHADOW_BOLT:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
DoCast(target, SPELL_SHADOW_BOLT);
_events.Repeat(randtime(Seconds(2), Seconds(4)));
break;
case EVENT_SHADOW_NOVA:
DoCastVictim(SPELL_SHADOW_NOVA);
_events.Repeat(randtime(Seconds(10), Seconds(16)));
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
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)));
}
void JustEngagedWith(Unit* /*who*/) override
{
_JustEngagedWith();
events.ScheduleEvent(EVENT_WRAP, Seconds(20));
events.ScheduleEvent(EVENT_SPRAY, Seconds(40));
events.ScheduleEvent(EVENT_SHOCK, randtime(Seconds(5), Seconds(10)));
events.ScheduleEvent(EVENT_POISON, randtime(Seconds(10), Seconds(15)));
events.ScheduleEvent(EVENT_SUMMON, Seconds(30));
}
void EnterCombat(Unit* /*who*/) override
{
events.ScheduleEvent(EVENT_LEECH_POISON, randtime(Seconds(5), Seconds(7)));
events.ScheduleEvent(EVENT_ACID_CLOUD, randtime(Seconds(7), Seconds(13)));
events.ScheduleEvent(EVENT_WEB_GRAB, randtime(Seconds(13), Seconds(19)));
events.ScheduleEvent(EVENT_PIERCE_ARMOR, randtime(Seconds(4), Seconds(7)));
events.ScheduleEvent(EVENT_PLAYER_CHECK, Seconds(1));
me->setActive(true);
}
void EnterCombat(Unit* /*who*/) override
{
_EnterCombat();
events.ScheduleEvent(EVENT_WRAP, Seconds(20));
events.ScheduleEvent(EVENT_SPRAY, Seconds(40));
events.ScheduleEvent(EVENT_SHOCK, randtime(Seconds(5), Seconds(10)));
events.ScheduleEvent(EVENT_POISON, randtime(Seconds(10), Seconds(15)));
events.ScheduleEvent(EVENT_SUMMON, Seconds(30));
}
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 DoEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_CRUSHING_WEBS:
DoCastVictim(SPELL_CRUSHING_WEBS);
_events.Repeat(randtime(Seconds(12), Seconds(16)));
break;
case EVENT_INFECTED_WOUND:
DoCastVictim(SPELL_INFECTED_WOUND);
_events.Repeat(randtime(Seconds(16), Seconds(25)));
break;
}
}
void DoEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_REND:
DoCastVictim(SPELL_REND);
_events.Repeat(randtime(Seconds(12), Seconds(16)));
break;
case EVENT_PUMMEL:
DoCastVictim(SPELL_PUMMEL);
_events.Repeat(randtime(Seconds(12), Seconds(17)));
break;
}
}
void DoEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_SHADOW_BOLT:
DoCastVictim(SPELL_SHADOW_BOLT);
_events.Repeat(randtime(Seconds(2), Seconds(5)));
break;
case EVENT_ANIMATE_BONES:
DoCastVictim(urand(0, 1) ? SPELL_ANIMATE_BONES_2 : SPELL_ANIMATE_BONES_1);
_events.Repeat(randtime(Seconds(35), Seconds(50)));
break;
}
}
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(SELECT_TARGET_RANDOM, 0, 20.0f, true))
{
DoCast(target, SPELL_METEOR);
_shouldSay = true;
}
events.Repeat(randtime(Seconds(13), Seconds(17)));
break;
}
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
DoMeleeAttackIfReady();
}
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;
}
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
DoMeleeAttackIfReady();
}
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)));
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ATTACK:
SetCombatMovement(true);
if (Unit* victim = me->GetVictim())
me->GetMotionMaster()->MoveChase(victim);
break;
case EVENT_STRIKE:
DoCastVictim(SPELL_UNBALANCING_STRIKE);
events.Repeat(Seconds(6));
return;
case EVENT_SHOUT:
DoCastAOE(SPELL_DISRUPTING_SHOUT);
events.Repeat(Seconds(16));
return;
case EVENT_KNIFE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 45.0f))
DoCast(target, SPELL_JAGGED_KNIFE);
events.Repeat(randtime(Seconds(10), Seconds(15)));
return;
}
}
DoMeleeAttackIfReady();
}
void DoEvent(uint32 eventId) override
{
switch (eventId)
{
case EVENT_SMASH:
DoCastVictim(SPELL_SMASH);
_events.Repeat(randtime(Seconds(13), Seconds(21)));
break;
}
}
void EnterCombat(Unit* who) override
{
_petsInCombat = false;
me->SetReactState(REACT_AGGRESSIVE);
summons.DoZoneInCombat();
events.CancelEvent(EVENT_SEND_GROUP);
events.ScheduleEvent(EVENT_SWARM, Seconds(5));
events.ScheduleEvent(EVENT_MIND_FLAY, randtime(Seconds(1), Seconds(3)));
BossAI::EnterCombat(who);
}
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_POISON:
if (!me->HasAura(SPELL_WIDOWS_EMBRACE_HELPER))
DoCastAOE(SPELL_POISON_BOLT_VOLLEY);
events.Repeat(randtime(Seconds(8), Seconds(15)));
break;
case EVENT_FIRE:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_RAIN_OF_FIRE);
events.Repeat(randtime(Seconds(6), Seconds(18)));
break;
case EVENT_FRENZY:
if (Aura* widowsEmbrace = me->GetAura(SPELL_WIDOWS_EMBRACE_HELPER))
events.ScheduleEvent(EVENT_FRENZY, Milliseconds(widowsEmbrace->GetDuration()+1));
else
{
DoCast(SPELL_FRENZY);
Talk(EMOTE_FRENZY);
events.Repeat(Minutes(1) + randtime(Seconds(0), Seconds(20)));
}
break;
}
}
DoMeleeAttackIfReady();
}
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_POISON_SPRAY:
DoCastVictim(SPELL_POISON_SPRAY);
_events.Repeat(randtime(Seconds(13), Seconds(19)));
break;
case EVENT_WEB_WRAP:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_WEB_WRAP);
_events.Repeat(randtime(Seconds(13), Seconds(17)));
break;
case EVENT_INFECTED_BITE:
DoCastVictim(SPELL_INFECTED_BITE);
_events.Repeat(randtime(Seconds(20), Seconds(24)));
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim() && !_petsInCombat)
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
if (me->HealthBelowPct(10) && !_hadFrenzy)
{
_hadFrenzy = true;
events.ScheduleEvent(EVENT_FRENZY, Seconds(1));
}
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SEND_GROUP:
DoCastAOE(SPELL_SUBBOSS_AGGRO_TRIGGER, true);
events.Repeat(Seconds(70));
break;
case EVENT_SWARM:
DoCastAOE(SPELL_SWARM);
Talk(SAY_SWARM);
break;
case EVENT_MIND_FLAY:
DoCastVictim(SPELL_MIND_FLAY);
events.Repeat(randtime(Seconds(9), Seconds(11)));
break;
case EVENT_FRENZY:
DoCastSelf(SPELL_FRENZY);
DoCastAOE(SPELL_CURSE_OF_FATIGUE);
events.Repeat(Seconds(15));
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void _EnterCombat() override
{
_events.ScheduleEvent(EVENT_SMASH, randtime(Seconds(8), Seconds(12)));
if (_myPack != SUMMON_GROUP_CRUSHER_1)
return;
if (Creature* hadronox = _instance->GetCreature(DATA_HADRONOX))
{
if (hadronox->AI()->GetData(DATA_HADRONOX_ENTERED_COMBAT))
return;
hadronox->AI()->DoAction(ACTION_CRUSHER_ENGAGED);
}
Talk(CRUSHER_SAY_AGGRO);
}
void _UpdateAI(uint32 diff) override
{
if (!me->IsInCombat())
return;
if (!_ourMovementFinished)
return;
if (me->getThreatManager().isThreatListEmpty())
{
EnterEvadeMode(EVADE_REASON_NO_HOSTILES);
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(SELECT_TARGET_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(SELECT_TARGET_NEAREST, 0, 45.0f, true))
DoCast(target, SPELL_SHADOW_BOLT);
else
{
DoCastAOE(SPELL_UNYIELDING_PAIN);
Talk(EMOTE_RAGECAST);
}
}
void _UpdateAI(uint32 diff) override
{
if (!me->IsInCombat())
return;
if (!_ourMovementFinished)
return;
if (me->getThreatManager().isThreatListEmpty())
{
EnterEvadeMode(EVADE_REASON_NO_HOSTILES);
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(SELECT_TARGET_NEAREST, 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(SELECT_TARGET_NEAREST, 0, 45.0f, true))
DoCast(target, SPELL_HOLY_BOLT);
else
{
DoCastAOE(SPELL_CONDEMNATION);
Talk(EMOTE_RAGECAST);
}
}
void BeginFighting() override
{
SetCombatMovement(true);
me->SetReactState(REACT_AGGRESSIVE);
ThreatManager& threat = me->getThreatManager();
if (threat.isThreatListEmpty())
{
if (Unit* nearest = me->SelectNearestPlayer(5000.0f))
{
me->AddThreat(nearest, 1.0f);
AttackStart(nearest);
}
else
ResetEncounter();
}
else
AttackStart(threat.getHostilTarget());
events.ScheduleEvent(EVENT_BERSERK, Minutes(10));
events.ScheduleEvent(EVENT_MARK, Seconds(24));
events.ScheduleEvent(EVENT_METEOR, randtime(Seconds(10), Seconds(25)));
}
void _EnterCombat() override
{
_events.ScheduleEvent(EVENT_SHADOW_BOLT, Seconds(4));
_events.ScheduleEvent(EVENT_SHADOW_NOVA, randtime(Seconds(10), Seconds(14)));
}
void _EnterCombat() override
{
_events.ScheduleEvent(EVENT_ANUBAR_CHARGE, randtime(Seconds(6), Seconds(8)));
_events.ScheduleEvent(EVENT_BACKSTAB, randtime(Seconds(7), Seconds(9)));
}
