void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
if (ChaseTimer <= diff)
{
if (!IsChasing)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
{
Talk(SAY_WOLF_HOOD);
DoCast(target, SPELL_LITTLE_RED_RIDING_HOOD, true);
TempThreat = GetThreat(target);
if (TempThreat)
ModifyThreatByPercent(target, -100);
HoodGUID = target->GetGUID();
AddThreat(target, 1000000.0f);
ChaseTimer = 20000;
IsChasing = true;
}
}
else
{
IsChasing = false;
if (Unit* target = ObjectAccessor::GetUnit(*me, HoodGUID))
{
HoodGUID.Clear();
if (GetThreat(target))
ModifyThreatByPercent(target, -100);
AddThreat(target, TempThreat);
TempThreat = 0;
}
ChaseTimer = 40000;
}
} else ChaseTimer -= diff;
if (IsChasing)
return;
if (FearTimer <= diff)
{
DoCastVictim(SPELL_TERRIFYING_HOWL);
FearTimer = urand(25000, 35000);
} else FearTimer -= diff;
if (SwipeTimer <= diff)
{
DoCastVictim(SPELL_WIDE_SWIPE);
SwipeTimer = urand(25000, 30000);
} else SwipeTimer -= diff;
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CLEAVE:
DoCastVictim(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, 7s);
break;
case EVENT_BLASTWAVE:
DoCastVictim(SPELL_BLASTWAVE);
events.ScheduleEvent(EVENT_BLASTWAVE, 8s, 16s);
break;
case EVENT_MORTALSTRIKE:
DoCastVictim(SPELL_MORTALSTRIKE);
events.ScheduleEvent(EVENT_MORTALSTRIKE, 25s, 35s);
break;
case EVENT_KNOCKBACK:
DoCastVictim(SPELL_KNOCKBACK);
if (GetThreat(me->GetVictim()))
ModifyThreatByPercent(me->GetVictim(), -50);
events.ScheduleEvent(EVENT_KNOCKBACK, 15s, 30s);
break;
case EVENT_CHECK:
if (me->GetDistance(me->GetHomePosition()) > 150.0f)
{
Talk(SAY_LEASH);
EnterEvadeMode(EVADE_REASON_BOUNDARY);
}
events.ScheduleEvent(EVENT_CHECK, 1s);
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_CURSE_OF_BLOOD:
DoCastVictim(SPELL_CURSE_OF_BLOOD);
events.ScheduleEvent(EVENT_CURSE_OF_BLOOD, 30000);
break;
case EVENT_ILLUSION:
DoCast(SPELL_ILLUSION);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(11686); // Invisible Model
ModifyThreatByPercent(me->GetVictim(), -99);
events.ScheduleEvent(EVENT_SET_VISIBILITY, 3000);
events.ScheduleEvent(EVENT_ILLUSION, 25000);
break;
case EVENT_SET_VISIBILITY:
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetDisplayId(11073); //Jandice Model
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
//Return since we have no target
if (!UpdateVictim())
return;
//Charge_Timer
if (Charge_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
DoCast(target, SPELL_CHARGE);
//me->SendMonsterMove(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, true, 1);
AttackStart(target);
}
Charge_Timer = urand(8000, 16000);
} else Charge_Timer -= diff;
//KnockBack_Timer
if (KnockBack_Timer <= diff)
{
DoCastVictim(SPELL_KNOCKBACK);
if (GetThreat(me->GetVictim()))
ModifyThreatByPercent(me->GetVictim(), -80);
KnockBack_Timer = urand(15000, 25000);
} else KnockBack_Timer -= diff;
//Enrage_Timer
if (!Enraged && Enrage_Timer <= diff)
{
DoCast(me, SPELL_ENRAGE);
Enraged = true;
} else Charge_Timer -= diff;
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_SHADOWFLAME:
DoCastVictim(SPELL_SHADOWFLAME);
events.ScheduleEvent(EVENT_SHADOWFLAME, urand(10000, 20000));
break;
case EVENT_WINGBUFFET:
DoCastVictim(SPELL_WINGBUFFET);
if (GetThreat(me->GetVictim()))
ModifyThreatByPercent(me->GetVictim(), -75);
events.ScheduleEvent(EVENT_WINGBUFFET, 30000);
break;
case EVENT_FRENZY:
Talk(EMOTE_FRENZY);
DoCast(me, SPELL_FRENZY);
events.ScheduleEvent(EVENT_FRENZY, urand(8000, 10000));
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void DoAction(int32 actionId) override
{
if (actionId == ACTION_STORE_OLD_TARGET)
{
if (Unit* victim = me->GetVictim())
{
_oldTargetGUID = victim->GetGUID();
_tempThreat = GetThreat(victim);
}
}
else if (actionId == ACTION_RESET_THREAT)
{
if (Unit* oldTarget = ObjectAccessor::GetUnit(*me, _oldTargetGUID))
{
if (Unit* current = me->GetVictim())
ModifyThreatByPercent(current, -100);
AddThreat(oldTarget, _tempThreat);
AttackStart(oldTarget);
_oldTargetGUID.Clear();
_tempThreat = 0.0f;
}
}
}
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_BRAIN_WASH_TOTEM:
DoCast(me, SPELL_BRAIN_WASH_TOTEM);
events.ScheduleEvent(EVENT_BRAIN_WASH_TOTEM, 18s, 26s);
break;
case EVENT_POWERFULL_HEALING_WARD:
DoCast(me, SPELL_POWERFULL_HEALING_WARD);
events.ScheduleEvent(EVENT_POWERFULL_HEALING_WARD, 14s, 20s);
break;
case EVENT_HEX:
if (Unit* target = me->GetVictim())
{
DoCast(target, SPELL_HEX, true);
if (GetThreat(target))
ModifyThreatByPercent(target, -80);
}
events.ScheduleEvent(EVENT_HEX, 12s, 20s);
break;
case EVENT_DELUSIONS_OF_JINDO:
// Casting the delusion curse with a shade so shade will attack the same target with the curse.
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
{
DoCast(target, SPELL_SHADE_OF_JINDO, true);
DoCast(target, SPELL_DELUSIONS_OF_JINDO);
}
events.ScheduleEvent(EVENT_DELUSIONS_OF_JINDO, 4s, 12s);
break;
case EVENT_TELEPORT:
// Teleports a random player and spawns 9 Sacrificed Trolls to attack player
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
{
DoTeleportPlayer(target, TeleportLoc.GetPositionX(), TeleportLoc.GetPositionY(), TeleportLoc.GetPositionZ(), TeleportLoc.GetOrientation());
if (GetThreat(me->GetVictim()))
ModifyThreatByPercent(target, -100);
// Summon a formation of trolls
for (uint8 i = 0; i < 10; ++i)
if (Creature* SacrificedTroll = me->SummonCreature(NPC_SACRIFICED_TROLL, Formation[i].GetPositionX(), Formation[i].GetPositionY(), Formation[i].GetPositionZ(), Formation[i].GetOrientation(), TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000))
SacrificedTroll->AI()->AttackStart(target);
}
events.ScheduleEvent(EVENT_TELEPORT, 15s, 23s);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
//Invisible_Timer
if (Invisible_Timer <= diff)
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
SetEquipmentSlots(false, EQUIP_UNEQUIP, EQUIP_NO_CHANGE, EQUIP_NO_CHANGE);
me->SetDisplayId(11686);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Invisible = true;
Invisible_Timer = urand(15000, 30000);
} else Invisible_Timer -= diff;
if (Invisible)
{
if (Ambush_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
{
DoTeleportTo(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
DoCast(target, SPELL_AMBUSH);
}
Ambushed = true;
Ambush_Timer = 3000;
} else Ambush_Timer -= diff;
}
if (Ambushed)
{
if (Visible_Timer <= diff)
{
me->InterruptSpell(CURRENT_GENERIC_SPELL);
me->SetDisplayId(15268);
SetEquipmentSlots(false, EQUIP_ID_MAIN_HAND, EQUIP_NO_CHANGE, EQUIP_NO_CHANGE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Invisible = false;
Visible_Timer = 4000;
} else Visible_Timer -= diff;
}
//Resetting some aggro so he attacks other gamers
if (!Invisible)
{
if (Aggro_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true))
{
if (GetThreat(me->GetVictim()))
ModifyThreatByPercent(me->GetVictim(), -50);
AttackStart(target);
}
Aggro_Timer = urand(7000, 20000);
} else Aggro_Timer -= diff;
if (ThousandBlades_Timer <= diff)
{
DoCastVictim(SPELL_THOUSANDBLADES);
ThousandBlades_Timer = urand(7000, 12000);
} else ThousandBlades_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
//SweepingStrikes_Timer
if (SweepingStrikes_Timer <= diff)
{
DoCastVictim(SPELL_SWEEPINGSTRIKES);
SweepingStrikes_Timer = 22000 + rand32() % 4000;
} else SweepingStrikes_Timer -= diff;
//SinisterStrike_Timer
if (SinisterStrike_Timer <= diff)
{
DoCastVictim(SPELL_SINISTERSTRIKE);
SinisterStrike_Timer = 8000 + rand32() % 8000;
} else SinisterStrike_Timer -= diff;
//Gouge_Timer
if (Gouge_Timer <= diff)
{
DoCastVictim(SPELL_GOUGE);
if (GetThreat(me->GetVictim()))
ModifyThreatByPercent(me->GetVictim(), -100);
Gouge_Timer = 17000 + rand32() % 10000;
} else Gouge_Timer -= diff;
//Kick_Timer
if (Kick_Timer <= diff)
{
DoCastVictim(SPELL_KICK);
Kick_Timer = 15000 + rand32() % 10000;
} else Kick_Timer -= diff;
//Blind_Timer
if (Blind_Timer <= diff)
{
DoCastVictim(SPELL_BLIND);
Blind_Timer = 10000 + rand32() % 10000;
} else Blind_Timer -= diff;
//Check_Timer for the death of LorKhan and Zath.
if (!FakeDeath && Check_Timer <= diff)
{
if (instance->GetBossState(DATA_LORKHAN) == SPECIAL)
{
//Resurrect LorKhan
if (Unit* pLorKhan = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_LORKHAN)))
{
pLorKhan->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
pLorKhan->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pLorKhan->SetFaction(14);
pLorKhan->SetFullHealth();
}
}
if (instance->GetBossState(DATA_THEKAL) == SPECIAL)
{
//Resurrect Thekal
if (Unit* pThekal = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_THEKAL)))
{
pThekal->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
pThekal->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pThekal->SetFaction(14);
pThekal->SetFullHealth();
}
}
Check_Timer = 5000;
} else Check_Timer -= diff;
if (!HealthAbovePct(5))
{
me->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE_PERCENT);
me->RemoveAurasByType(SPELL_AURA_PERIODIC_DAMAGE);
me->RemoveAurasByType(SPELL_AURA_PERIODIC_LEECH);
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
me->SetStandState(UNIT_STAND_STATE_SLEEP);
me->SetFaction(35);
me->AttackStop();
instance->SetBossState(DATA_ZATH, SPECIAL);
FakeDeath = true;
}
DoMeleeAttackIfReady();
}
