void Reset()
{
_Reset();
events.Reset();
SpawnAdds();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim()) return;
if (spawntimer < diff)
{
SpawnAdds();
spawntimer = urand(35000,40000);
} else spawntimer -= diff;
if (roottimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
m_creature->CastSpell(target, SPELL_ENTANGLING_ROOTS, false);
roottimer = urand(15000,30000);
}
if (bashtimer < diff)
{
m_creature->CastSpell(m_creature->getVictim(), SPELL_BASH, false);
bashtimer = urand(15000,30000);
} else bashtimer -= diff;
if (bolttimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
m_creature->CastSpell(target, SPELL_VENOM_BOLT_VOLLEY, false);
bolttimer = urand(15000,30000);
} else bolttimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
if (uiSpawnTimer <= diff)
{
SpawnAdds();
uiSpawnTimer = urand(35*IN_MILLISECONDS, 40*IN_MILLISECONDS);
} else uiSpawnTimer -= diff;
if (uiRootTimer <= diff)
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(pTarget, SPELL_ENTANGLING_ROOTS);
uiRootTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else uiRootTimer -= diff;
if (uiBashTimer <= diff)
{
DoCastVictim(SPELL_BASH);
uiBashTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else uiBashTimer -= diff;
if (uiBoltTimer <= diff)
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(pTarget, SPELL_VENOM_BOLT_VOLLEY);
uiBoltTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else uiBoltTimer -= diff;
DoMeleeAttackIfReady();
}
void EnterCombat(Unit* /*who*/)
{
if (instance)
instance->SetData(DATA_ZULJINEVENT, IN_PROGRESS);
DoZoneInCombat();
Talk(YELL_INTRO);
SpawnAdds();
EnterPhase(0);
}
void EnterCombat(Unit * /*who*/)
{
if (pInstance)
pInstance->SetData(DATA_ZULJINEVENT, IN_PROGRESS);
DoZoneInCombat();
me->MonsterYell(YELL_INTRO,LANG_UNIVERSAL,NULL);
DoPlaySoundToSet(me, SOUND_INTRO);
SpawnAdds();
EnterPhase(0);
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim())
return;
if (uiSpawnTimer <= diff)
{
SpawnAdds();
uiSpawnTimer = 20*IN_MILLISECONDS;
} else uiSpawnTimer -= diff;
if (uiMiniTimer <= diff)
{
if(!me->IsNonMeleeSpellCasted(false))
{
DoCast(SPELL_MINI);
uiMiniTimer = urand(25*IN_MILLISECONDS, 30*IN_MILLISECONDS);
}
} else uiMiniTimer -= diff;
if (uiRootTimer <= diff)
{
if(!me->IsNonMeleeSpellCasted(false))
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_ENTANGLING_ROOTS);
uiRootTimer = urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS);
}
} else uiRootTimer -= diff;
if (uiBashTimer <= diff)
{
if(!me->IsNonMeleeSpellCasted(false))
{
DoCastVictim(SPELL_BASH);
uiBashTimer = urand(7*IN_MILLISECONDS, 12*IN_MILLISECONDS);
}
} else uiBashTimer -= diff;
if (uiBoltTimer <= diff)
{
if(!me->IsNonMeleeSpellCasted(false))
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_VENOM_BOLT_VOLLEY);
uiBoltTimer = urand(18*IN_MILLISECONDS, 22*IN_MILLISECONDS);
}
} else uiBoltTimer -= diff;
DoMeleeAttackIfReady();
}
void Reset() override
{
Vanish_Timer = 30000;
Blind_Timer = 35000;
Gouge_Timer = 23000;
Wait_Timer = 0;
CheckAdds_Timer = 5000;
Enrage = false;
InVanish = false;
if (me->IsAlive())
SpawnAdds();
if (instance)
instance->SetData(TYPE_MOROES, NOT_STARTED);
}
void Reset() {
Vanish_Timer = 30000;
Blind_Timer = 35000;
Gouge_Timer = 23000;
Wait_Timer = 0;
CheckAdds_Timer = 5000;
Enrage = false;
InVanish = false;
if (me->GetHealth() > 0) {
SpawnAdds();
}
if (pInstance)
pInstance->SetData(TYPE_MOROES, NOT_STARTED);
}
void Reset() {
if (pInstance)
pInstance->SetData(DATA_HEXLORDEVENT, NOT_STARTED);
SpiritBolts_Timer = 20000;
DrainPower_Timer = 60000;
SiphonSoul_Timer = 100000;
PlayerAbility_Timer = 99999;
CheckAddState_Timer = 5000;
ResetTimer = 5000;
SpawnAdds();
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, 46916);
me->SetByteValue(UNIT_FIELD_BYTES_2, 0, SHEATH_STATE_MELEE);
}
void Reset()
{
if (pInstance)
pInstance->SetData(DATA_HEXLORDEVENT, NOT_STARTED);
SpiritBolts_Timer = 20000;
DrainPower_Timer = 60000;
SiphonSoul_Timer = 100000;
PlayerAbility_Timer = 99999;
CheckAddState_Timer = 5000;
ResetTimer = 5000;
SpawnAdds();
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, 46916);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO, 50268674);
me->SetSheath(SHEATH_STATE_MELEE);
}
void UpdateAI(uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
switch (events.GetEvent())
{
case EVENT_AMANITAR_SPAWN:
{
SpawnAdds();
events.RepeatEvent(urand(35000, 40000));
break;
}
case EVENT_AMANITAR_ROOTS:
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
me->CastSpell(pTarget, SPELL_ENTANGLING_ROOTS, false);
events.RepeatEvent(urand(15000, 20000));
break;
}
case EVENT_AMANITAR_BASH:
{
me->CastSpell(me->GetVictim(), SPELL_BASH, false);
events.RepeatEvent(urand(15000, 20000));
break;
}
case EVENT_AMANITAR_BOLT:
{
if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
me->CastSpell(pTarget, SPELL_VENOM_BOLT_VOLLEY, false);
events.RepeatEvent(urand(15000, 20000));
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_SPAWN:
SpawnAdds();
events.ScheduleEvent(EVENT_SPAWN, 20 * IN_MILLISECONDS);
break;
case EVENT_MINI:
DoCast(SPELL_MINI);
events.ScheduleEvent(EVENT_MINI, urand(25, 30) * IN_MILLISECONDS);
break;
case EVENT_ROOT:
DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true), SPELL_ENTANGLING_ROOTS, true);
events.ScheduleEvent(EVENT_ROOT, urand(10, 15) * IN_MILLISECONDS);
break;
case EVENT_BASH:
DoCastVictim(SPELL_BASH);
events.ScheduleEvent(EVENT_BASH, urand(7, 12) * IN_MILLISECONDS);
break;
case EVENT_BOLT:
DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true), SPELL_VENOM_BOLT_VOLLEY, true);
events.ScheduleEvent(EVENT_BOLT, urand(18, 22) * IN_MILLISECONDS);
break;
default:
break;
}
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
}
DoMeleeAttackIfReady();
}
void Reset()
{
Vanish_Timer = 30000;
Blind_Timer = 35000;
Gouge_Timer = 23000;
Wait_Timer = 0;
NonAttackable_Timer = 0;
CheckAdds_Timer = 5000;
Enrage = false;
InVanish = false;
NonAttackable = false;
if(m_creature->GetHealth() > 0)
{
SpawnAdds();
}
if(m_creature->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
{
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
}
if(pInstance && pInstance->GetData(DATA_MOROES_EVENT) != DONE)
pInstance->SetData(DATA_MOROES_EVENT, NOT_STARTED);
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
if(phase != PHASE_COMBAT)
{
if(phase == PHASE_FESTERGUT)
{
if (m_uiMalleableGooTimer < uiDiff)
{
if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1))
DoCast(pTarget, SPELL_MALLABLE_GOO_H);
m_uiMalleableGooTimer = urand(16000, 20000);
} else m_uiMalleableGooTimer -= uiDiff;
if (m_uiSayDieTimer < uiDiff)
{
if(fDie)
{
DoScriptText(SAY_FESTERGUT_DEATH, me);
fDie = false;
}
EnterEvadeMode();
m_uiSayDieTimer = 4000;
} else m_uiSayDieTimer -= uiDiff;
}
else
{
if (m_uiVileGasTimer < uiDiff)
{
for (uint8 i = 1; i <= 3; i++)
{
if(Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1))
{
DoCast(pTarget, SPELL_VILE_GAS);
}
}
m_uiVileGasTimer = urand (16000, 20000);
} else m_uiVileGasTimer -= uiDiff;
if (m_uiSayDieTimer < uiDiff)
{
if(rDie)
{
DoScriptText(SAY_ROTFACE_DEATH, me);
rDie = false;
}
EnterEvadeMode();
m_uiSayDieTimer = 4000;
} else m_uiSayDieTimer -= uiDiff;
}
}
if(phase == PHASE_COMBAT)
{
if (m_uiBerserkTimer < uiDiff)
{
DoCast(me, SPELL_BERSERK);
DoScriptText(SAY_BERSERK,me);
m_uiBerserkTimer = 600000;
} else m_uiBerserkTimer -= uiDiff;
if((me->GetHealth()*100) / me->GetMaxHealth() < 81 && PhaseSwitch1 == false)
{
PhaseSwitch();
PhaseSwitch1 = true;
}
if((me->GetHealth()*100) / me->GetMaxHealth() < 36 && PhaseSwitch2 == false)
{
PhaseSwitch();
PhaseSwitch2 = true;
}
if (m_uiPhase == 1)
{
if (m_uiUnstableExperimentTimer < uiDiff)
{
SpawnAdds();
DoCast(SPELL_UNSTABLE_EXPERIMENT);
me->MonsterTextEmote(EMOTE_UNSTABLE_EXPERIMENT, NULL);
m_uiUnstableExperimentTimer = 40000;
} else m_uiUnstableExperimentTimer -= uiDiff;
if (m_uiPuddleTimer < uiDiff)
{
Puddle();
m_uiPuddleTimer = 17000;
} else m_uiPuddleTimer -= uiDiff;
}
if (m_uiPhase == 2)
{
if (m_uiUnstableExperimentTimer < uiDiff)
{
DoCast(me, SPELL_UNSTABLE_EXPERIMENT);
me->MonsterTextEmote(EMOTE_UNSTABLE_EXPERIMENT,NULL);
TwoAdds();
m_uiUnstableExperimentTimer = 40000;
} else m_uiUnstableExperimentTimer -= uiDiff;
if (m_uiPuddleTimer < uiDiff)
{
Puddle();
m_uiPuddleTimer = 17000;
} else m_uiPuddleTimer -= uiDiff;
if (m_uiMalleableTimer < uiDiff)
{
if(Unit* pTarget = SelectUnit(SELECT_TARGET_FARTHEST, 1))
{
DoCast(pTarget, SPELL_MALLEABLE_GOO);
m_uiMalleableTimer = 16000;
}
} else m_uiMalleableTimer -= uiDiff;
if (m_uiBombTimer < uiDiff)
{
DoCast(SPELL_CHOKING_GAS_BOMB);
m_uiBombTimer = 21000;
} else m_uiBombTimer -= uiDiff;
}
if (m_uiPhase == 3)
{
if(!me->HasAura(SPELL_STRENGTH))
{
DoCast(me, SPELL_STRENGTH);
}
if (m_uiPuddleTimer < uiDiff)
{
Puddle();
m_uiPuddleTimer = 17000;
} else m_uiPuddleTimer -= uiDiff;
if (m_uiMalleableTimer < uiDiff)
{
if(Unit* pTarget = SelectUnit(SELECT_TARGET_FARTHEST,1))
{
DoCast(pTarget, SPELL_MALLEABLE_GOO);
m_uiMalleableTimer = 16000;
}
} else m_uiMalleableTimer -= uiDiff;
if (m_uiBombTimer < uiDiff)
{
DoCast(SPELL_CHOKING_GAS_BOMB);
m_uiBombTimer = 21000;
} else m_uiBombTimer -= uiDiff;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
//Return since we have no target
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
// corrupted form
if (m_bCorruptedForm)
{
//MarkOfCorruption_Timer
if (m_uiMarkOfCorruption_Timer < uiDiff)
{
if (m_uiMarkOfCorruption_Count <= 5)
{
uint32 uiMarkSpell = 0;
switch (m_uiMarkOfCorruption_Count)
{
case 0: uiMarkSpell = SPELL_MARK_OF_CORRUPTION1; break;
case 1: uiMarkSpell = SPELL_MARK_OF_CORRUPTION2; break;
case 2: uiMarkSpell = SPELL_MARK_OF_CORRUPTION3; break;
case 3: uiMarkSpell = SPELL_MARK_OF_CORRUPTION4; break;
case 4: uiMarkSpell = SPELL_MARK_OF_CORRUPTION5; break;
case 5: uiMarkSpell = SPELL_MARK_OF_CORRUPTION6; break;
}
DoCastSpellIfCan(m_creature->getVictim(), uiMarkSpell);
if (m_uiMarkOfCorruption_Count < 5)
++m_uiMarkOfCorruption_Count;
}
m_uiMarkOfCorruption_Timer = 15000;
}else m_uiMarkOfCorruption_Timer -= uiDiff;
//VileSludge_Timer
if (m_uiVileSludge_Timer < uiDiff)
{
if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
DoCastSpellIfCan(pTarget, SPELL_VILE_SLUDGE);
m_uiVileSludge_Timer = 15000;
}else m_uiVileSludge_Timer -= uiDiff;
//PosCheck_Timer
if (m_uiPosCheck_Timer < uiDiff)
{
float fPosX, fPosY, fPosZ;
m_creature->GetCombatStartPosition(fPosX, fPosY, fPosZ);
if (m_creature->IsWithinDist2d(fPosX, fPosY, SWITCH_RADIUS))
{
DoScriptText(SAY_SWITCH_TO_CLEAN, m_creature);
// switch to clean form
m_creature->SetDisplayId(MODEL_CLEAN);
m_uiMarkOfHydross_Count = 0;
DoResetThreat();
// spawn 4 adds
SpawnAdds();
m_creature->SetMeleeDamageSchool(SPELL_SCHOOL_FROST);
m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, true);
m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, false);
m_bCorruptedForm = false;
}
m_uiPosCheck_Timer = 2500;
}else m_uiPosCheck_Timer -=uiDiff;
}
// clean form
else
{
//MarkOfHydross_Timer
if (m_uiMarkOfHydross_Timer < uiDiff)
{
if (m_uiMarkOfHydross_Count <= 5)
{
uint32 uiMarkSpell;
switch (m_uiMarkOfHydross_Count)
{
case 0: uiMarkSpell = SPELL_MARK_OF_HYDROSS1; break;
case 1: uiMarkSpell = SPELL_MARK_OF_HYDROSS2; break;
case 2: uiMarkSpell = SPELL_MARK_OF_HYDROSS3; break;
case 3: uiMarkSpell = SPELL_MARK_OF_HYDROSS4; break;
case 4: uiMarkSpell = SPELL_MARK_OF_HYDROSS5; break;
case 5: uiMarkSpell = SPELL_MARK_OF_HYDROSS6; break;
}
DoCastSpellIfCan(m_creature->getVictim(), uiMarkSpell);
if (m_uiMarkOfHydross_Count < 5)
++m_uiMarkOfHydross_Count;
}
m_uiMarkOfHydross_Timer = 15000;
}else m_uiMarkOfHydross_Timer -= uiDiff;
//WaterTomb_Timer
if (m_uiWaterTomb_Timer < uiDiff)
{
if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
DoCastSpellIfCan(pTarget, SPELL_WATER_TOMB);
m_uiWaterTomb_Timer = 7000;
}else m_uiWaterTomb_Timer -= uiDiff;
//PosCheck_Timer
if (m_uiPosCheck_Timer < uiDiff)
{
float fPosX, fPosY, fPosZ;
m_creature->GetCombatStartPosition(fPosX, fPosY, fPosZ);
if (!m_creature->IsWithinDist2d(fPosX, fPosY, SWITCH_RADIUS))
{
DoScriptText(SAY_SWITCH_TO_CORRUPT, m_creature);
// switch to corrupted form
m_creature->SetDisplayId(MODEL_CORRUPT);
m_uiMarkOfCorruption_Count = 0;
DoResetThreat();
// spawn 4 adds
SpawnAdds();
m_creature->SetMeleeDamageSchool(SPELL_SCHOOL_NATURE);
m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_NATURE, true);
m_creature->ApplySpellImmune(0, IMMUNITY_SCHOOL, SPELL_SCHOOL_MASK_FROST, false);
m_bCorruptedForm = true;
}
m_uiPosCheck_Timer = 2500;
}else m_uiPosCheck_Timer -=uiDiff;
}
//EnrageTimer
if (m_uiEnrageTimer < uiDiff)
{
DoCastSpellIfCan(m_creature, SPELL_ENRAGE);
m_uiEnrageTimer = 60000;
}else m_uiEnrageTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
{
if (Phase == PHASE_INTRO)
{
if (m_uiEventTimer <= uiDiff)
{
switch(subevent)
{
case 0:
if (lInitiates.size() < SUMMONS_NUMBER)
SpawnAdds(lInitiates, NPC_TWILIGHT_INITIATE);
else
++subevent;
m_uiEventTimer = 1500;
break;
case 1:
case 2:
case 3:
case 4:
case 5:
DoScriptText(SayPreaching[subevent], m_creature);
m_uiEventTimer = 10000;
++subevent;
break;
case 6:
if (!lInitiates.empty())
for (GuidList::iterator itr = lInitiates.begin(); itr != lInitiates.end(); ++itr)
{
if (Unit* pUnit = m_creature->GetMap()->GetUnit(*itr))
pUnit->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
}
subevent = 0;
Phase = PHASE_AFTER_INTRO;
m_uiEventTimer = 1500;
break;
default: break;
}
} else m_uiEventTimer -= uiDiff;
}
return;
}
if (Phase == PHASE_SACRIFICE_SEQUENCE)
{
if (m_uiEventTimer <= uiDiff)
{
if (!m_pInstance)
{
// this should not happen!
Phase = PHASE_READY_TO_ATTACK;
return;
}
Creature* pController = m_pInstance->GetSingleCreatureFromStorage(NPC_JEDOGA_CONTROLLER);
if (!pController)
{
// this should not happen!
Phase = PHASE_READY_TO_ATTACK;
return;
}
switch(subevent)
{
case 0:
MoveToPosition(true);
++subevent;
break;
case 1:
if (lVolunteers.size() < SUMMONS_NUMBER)
SpawnAdds(lVolunteers, NPC_TWILIGHT_VOLUNTEER);
else
{
DoScriptText(urand(0, 1) ? SAY_VOLUNTEER_CHOOSEN : SAY_VOLUNTEER_SACRIFICED, m_creature);
++subevent;
}
break;
case 2:
pController->CastSpell(pController, SPELL_SACRIFICE_VISUAL, false);
DoCastSpellIfCan(m_creature, SPELL_SACRIFICE_BEAM);
++subevent;
break;
case 3:
{
GuidList::iterator itr = lVolunteers.begin();
advance(itr, (rand()% (lVolunteers.size())));
if (Creature* pVolunteer = m_creature->GetMap()->GetCreature(*itr))
{
pVolunteer->RemoveAurasDueToSpell(SPELL_VOLUNTEER_SPHERE);
float x, y, z;
pController->GetPosition(x, y, z);
pVolunteer->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
pVolunteer->GetMotionMaster()->MovePoint(7, SpawnNode[8][0], SpawnNode[8][1], SpawnNode[8][2],false);
DoScriptText(SAY_VOLUNTEER_CHOOSEN, pVolunteer);
}
++subevent;
}
break;
case 4:
if (m_creature->HasAura(SPELL_GIFT_OF_THE_HERALD))
m_bSacrifice = true;
if (m_bSacrifice)
{
pController->RemoveAurasDueToSpell(SPELL_SACRIFICE_VISUAL);
MoveToPosition(false);
Phase = PHASE_READY_TO_ATTACK;
subevent = 0;
return;
}
break;
default: break;
}
m_uiEventTimer = 1500;
}
else
m_uiEventTimer -= uiDiff;
return;
}
if(!m_bSacrifice && m_creature->GetHealthPercent() < 50.0f)
{
Phase = PHASE_SACRIFICE_SEQUENCE;
return;
}
if(m_uiCycloneStrikeTimer < uiDiff)
{
DoCastSpellIfCan(m_creature->getVictim(), m_bIsRegularMode ? SPELL_CYCLONE_STRIKE : SPELL_CYCLONE_STRIKE_H);
m_uiCycloneStrikeTimer = urand(10000, 20000);
}
else
m_uiCycloneStrikeTimer -= uiDiff;
if(m_uiLightningBoltTimer < uiDiff)
{
if(Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_LIGHTNING_BOLT : SPELL_LIGHTNING_BOLT_H);
m_uiLightningBoltTimer = urand(3000, 8000);
}
else
m_uiLightningBoltTimer -= uiDiff;
if(m_uiThundershockTimer < uiDiff)
{
if(Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM,0))
DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_THUNDERSHOCK : SPELL_THUNDERSHOCK_H);
m_uiThundershockTimer = urand(8000, 16000);
}
else
m_uiThundershockTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
//Return since we have no target
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (m_uiPhase == 1 || m_uiPhase == 2)
{
// tank out of range
if (m_creature->GetDistance2d(m_creature->getVictim()) > m_creature->GetAttackDistance(m_creature->getVictim()))
{
if (m_uiRange_Timer <= uiDiff)
{
DoCast(m_creature, SPELL_FROST_BREATH);
m_uiRange_Timer = 10000;
}m_uiRange_Timer -= uiDiff;
}else m_uiRange_Timer = 10000;
//Pull
if (m_uiPullTimer < uiDiff)
{
PullAll();
m_uiPullTimer = 15000;
}
else m_uiPullTimer -= uiDiff;
//Smash
if (m_uiSmashTimer < uiDiff)
{
DoCast(m_creature, SPELL_SMASH);
m_uiSmashTimer = 17000;
}
else m_uiSmashTimer -= uiDiff;
//Cleave
if (m_uiCleaveTimer < uiDiff)
{
DoCastSpellIfCan(m_creature->getVictim(), SPELL_CLEAVE);
m_uiCleaveTimer = urand(5000, 8000);
}
else m_uiCleaveTimer -= uiDiff;
if (m_uiPhase == 1 && m_creature->GetHealthPercent() <= 50.0f)
{
m_creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->RemoveAllAuras();
m_creature->CastSpell(m_creature, SPELL_ICE_BLOCK, true);
SpawnAdds();
m_uiPhase = 2;
return;
}
}
else if (m_uiPhase == 2)
{
if (m_uiAddCheck_Timer <= uiDiff)
{
CreatureList adds;
GetCreatureListWithEntryInGrid(adds, m_creature, NPC_ADD, 5.0f);
if (!adds.empty())
{
adds.clear();
GetCreatureListWithEntryInGrid(adds, m_creature, NPC_ADD, 45.0f);
for(CreatureList::iterator iter = adds.begin(); iter != adds.end(); ++iter)
{
if (!(*iter)->isAlive())
continue;
(*iter)->SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
m_creature->CastSpell(*iter, SPELL_LINK, true);
m_creature->CastSpell(m_creature, SPELL_DMG, true);
}
m_uiPhase = 3;
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->RemoveAllAuras();
PullAll();
m_uiPullTimer = 15000;
m_uiSmashTimer = 17000;
m_uiCleaveTimer = urand(5000, 8000);
m_uiRange_Timer = 10000;
return;
}
m_uiAddCheck_Timer = 2000;
}else m_uiAddCheck_Timer -= uiDiff;
if (m_uiBlizzard_Timer <= uiDiff)
{
if (Unit* target = m_creature->SelectAttackingPlayer(ATTACKING_TARGET_RANDOM, 0))
DoCast(target,SPELL_BLIZZARD);
m_uiBlizzard_Timer = 10000;
}else m_uiBlizzard_Timer -= uiDiff;
//we dont wanna melee
return;
}
DoMeleeAttackIfReady();
}
