void UpdateAI(const uint32 diff)
{
if (IntroStepCounter < 10)
{
if (IntroYellTimer < diff)
{
IntroYellTimer = IntroStep(++IntroStepCounter);
}
else
IntroYellTimer -= diff;
}
if (!UpdateVictim())
return;
if (SpecialTimer < diff)
{
if (pInstance->GetData(DATA_SACROLASH) == DONE)
{
AddSpellToCastWithScriptText(SPELL_SHADOW_NOVA, CAST_RANDOM_WITHOUT_TANK, EMOTE_SHADOW_NOVA, false, true);
SpecialTimer = urand(14000, 16000);
}
else
{
if(Unit* target = GetConflagTarget())
AddSpellToCastWithScriptText(target , SPELL_CONFLAGRATION, EMOTE_CONFLAGRATION, false, true);
DoScriptText(YELL_CANFLAGRATION, me);
SpecialTimer = urand(30000,35000);
}
}
else
SpecialTimer -= diff;
if (FlamesearTimer < diff)
{
AddSpellToCast(SPELL_FLAME_SEAR, CAST_SELF);
FlamesearTimer = 10000;
}
else
FlamesearTimer -=diff;
if (PyrogenicsTimer < diff)
{
AddSpellToCast(SPELL_PYROGENICS, CAST_SELF);
PyrogenicsTimer = 15000;
}
else
PyrogenicsTimer -= diff;
if (EnrageTimer < diff)
{
AddSpellToCastWithScriptText(SPELL_ENRAGE, CAST_SELF, YELL_BERSERK);
EnrageTimer = 360000;
}
else
EnrageTimer -= diff;
CastNextSpellIfAnyAndReady(diff);
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (SpecialTimer < diff)
{
if (pInstance->GetData(DATA_ALYTHESS) == DONE)
{
AddSpellToCastWithScriptText(SPELL_CONFLAGRATION, CAST_RANDOM_WITHOUT_TANK, EMOTE_CONFLAGRATION, false, true);
SpecialTimer = urand(14000, 16000);
}
else
{
if(Unit* target = GetNovaTarget())
AddSpellToCastWithScriptText(target, SPELL_SHADOW_NOVA, EMOTE_SHADOW_NOVA, false, true);
DoScriptText(YELL_SHADOW_NOVA, me);
SpecialTimer = urand(30000,35000);
}
}
else
SpecialTimer -= diff;
if (ConfoundingblowTimer < diff)
{
AddSpellToCast(SPELL_CONFOUNDING_BLOW, CAST_TANK);
ConfoundingblowTimer = urand(20000, 25000);
}
else
ConfoundingblowTimer -= diff;
if (ShadowimageTimer < diff)
{
for (int i = 0; i < 3; i++)
DoSpawnCreature(MOB_SHADOW_IMAGE, 0, 0 , 0, frand(0, 2*M_PI), TEMPSUMMON_TIMED_DESPAWN, 15000);
ShadowimageTimer = 20000;
}
else
ShadowimageTimer -= diff;
if (ShadowbladesTimer < diff)
{
AddSpellToCast(SPELL_SHADOW_BLADES, CAST_SELF);
ShadowbladesTimer = 10000;
}
else
ShadowbladesTimer -= diff;
if (EnrageTimer < diff)
{
AddSpellToCastWithScriptText(SPELL_ENRAGE, CAST_SELF, YELL_ENRAGE);
EnrageTimer = 360000;
}
else
EnrageTimer -= diff;
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void EnterPhase(PhaseHalazzi NextPhase)
{
switch(NextPhase)
{
case PHASE_LYNX:
case PHASE_ENRAGE:
if(Phase == PHASE_MERGE)
{
ForceSpellCast(m_creature, SPELL_TRANSFORM_MERGE, INTERRUPT_AND_CAST_INSTANTLY, true);
m_creature->Attack(m_creature->getVictim(), true);
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
}
if(Unit *Lynx = Unit::GetUnit(*m_creature, LynxGUID))
{
Lynx->SetVisibility(VISIBILITY_OFF);
Lynx->setDeathState(JUST_DIED);
}
m_creature->SetMaxHealth(600000);
m_creature->SetHealth(600000 - 150000 * TransformCount);
FrenzyTimer = 16000;
SaberlashTimer = 5000;
ShockTimer = 10000;
TotemTimer = 12000;
break;
case PHASE_SPLIT:
AddSpellToCastWithScriptText(m_creature, SPELL_TRANSFORM_SPLIT, YELL_SPLIT, true);
break;
case PHASE_HUMAN:
//DoCast(m_creature, SPELL_SUMMON_LYNX, true);
DoSpawnCreature(MOB_SPIRIT_LYNX, 5,5,0,0, TEMPSUMMON_CORPSE_DESPAWN, 0);
m_creature->SetMaxHealth(400000);
m_creature->SetHealth(400000);
ShockTimer = 10000;
TotemTimer = 12000;
break;
case PHASE_MERGE:
if(Unit *Lynx = Unit::GetUnit(*m_creature, LynxGUID))
{
DoScriptText(YELL_MERGE, m_creature);
Lynx->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
Lynx->GetMotionMaster()->Clear();
Lynx->GetMotionMaster()->MoveFollow(m_creature, 0, 0);
m_creature->GetMotionMaster()->Clear();
m_creature->GetMotionMaster()->MoveFollow(Lynx, 0, 0);
TransformCount++;
}break;
default:
break;
}
Phase = NextPhase;
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
//Say Aggro
if (Say_Timer && Say_Timer <= diff)
{
DoScriptText(SAY_AGGRO, m_creature);
Say_Timer = 0;
}
else
Say_Timer -= diff;
//Cleave
if (Cleave_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_CLEAVE);
Cleave_Timer = 6000+rand()%4000;
}
else
Cleave_Timer -= diff;
//Sand Breath
if (SandBreath_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), HeroicMode ? H_SPELL_SAND_BREATH : SPELL_SAND_BREATH);
SandBreath_Timer = 30000;
}
else
SandBreath_Timer -= diff;
//Time Stop
if (TimeStop_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_TIME_STOP);
TimeStop_Timer = 40000;
}
else
TimeStop_Timer -= diff;
//Frenzy
if (Frenzy_Timer < diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_ENRAGE, EMOTE_FRENZY);
Frenzy_Timer = 120000;
}
else
Frenzy_Timer -= diff;
//if event failed, remove boss from instance
if (pInstance->GetData(TYPE_MEDIVH) == FAIL)
{
m_creature->Kill(m_creature, false);
m_creature->RemoveCorpse();
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if(!UpdateVictim())
return;
if (checkTimer2 < diff)
{
if (!m_creature->IsWithinDistInMap(&wLoc, 50))
EnterEvadeMode();
else
DoZoneInCombat();
checkTimer2 = 3000;
}
else
checkTimer2 -= diff;
if(BerserkTimer < diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_BERSERK, YELL_BERSERK);
BerserkTimer = 60000;
}else BerserkTimer -= diff;
if(Phase == PHASE_LYNX || Phase == PHASE_ENRAGE)
{
if(SaberlashTimer < diff)
{
AddSpellToCastWithScriptText(m_creature->getVictim(), SPELL_SABER_LASH, RAND(YELL_SABER_ONE, YELL_SABER_TWO));
SaberlashTimer = 5000 + rand() % 10000;
}else SaberlashTimer -= diff;
if(FrenzyTimer < diff)
{
AddSpellToCast(m_creature, SPELL_FRENZY);
FrenzyTimer = (10+rand()%5)*1000;
}else FrenzyTimer -= diff;
if(Phase == PHASE_LYNX)
if(CheckTimer < diff)
{
if(m_creature->GetHealth() * 4 < m_creature->GetMaxHealth() * (3 - TransformCount))
EnterPhase(PHASE_SPLIT);
CheckTimer = 1000;
}else CheckTimer -= diff;
}
if(Phase == PHASE_HUMAN || Phase == PHASE_ENRAGE)
{
if(TotemTimer < diff)
{
AddSpellToCast(m_creature, SPELL_SUMMON_TOTEM);
TotemTimer = 20000;
}else TotemTimer -= diff;
if(ShockTimer < diff)
{
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM,0,GetSpellMaxRange(SPELL_EARTHSHOCK), true))
{
if(target->IsNonMeleeSpellCasted(false))
AddSpellToCast(target,SPELL_EARTHSHOCK);
else
AddSpellToCast(target,SPELL_FLAMESHOCK);
ShockTimer = 10000 + rand()%5000;
}
}else ShockTimer -= diff;
if(Phase == PHASE_HUMAN)
if(CheckTimer < diff)
{
if( ((m_creature->GetHealth()*100) / m_creature->GetMaxHealth() <= 20)/*m_creature->GetHealth() * 10 < m_creature->GetMaxHealth()*/)
EnterPhase(PHASE_MERGE);
else
{
Unit *Lynx = Unit::GetUnit(*m_creature, LynxGUID);
if(Lynx && ((Lynx->GetHealth()*100) / Lynx->GetMaxHealth() <= 20)/*Lynx->GetHealth() * 10 < Lynx->GetMaxHealth()*/)
EnterPhase(PHASE_MERGE);
}
CheckTimer = 1000;
}else CheckTimer -= diff;
}
if(Phase == PHASE_MERGE)
{
if(CheckTimer < diff)
{
Unit *Lynx = Unit::GetUnit(*m_creature, LynxGUID);
if(Lynx)
{
Lynx->GetMotionMaster()->MoveFollow(m_creature, 0, 0);
m_creature->GetMotionMaster()->MoveFollow(Lynx, 0, 0);
if(m_creature->IsWithinDistInMap(Lynx, 6.0f))
{
if(TransformCount < 3)
EnterPhase(PHASE_LYNX);
else
EnterPhase(PHASE_ENRAGE);
}
}
CheckTimer = 1000;
}else CheckTimer -= diff;
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void DoAction(const int32 action)
{
if (action == SISTER_DEATH)
AddSpellToCastWithScriptText(SPELL_EMPOWER, CAST_SELF, YELL_SISTER_SACROLASH_DEAD);
}
void UpdateAI(const uint32 diff)
{
if(Intro == INTRO_IN_PROGRESS)
{
if(AggroTimer < diff)
{
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_creature->SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_NONE);
Intro = INTRO_DONE;
}
else
AggroTimer -= diff;
}
if(!UpdateVictim() || Intro == INTRO_IN_PROGRESS)
return;
if (CheckTimer < diff)
{
if(!m_creature->IsWithinDistInMap(&wLoc, 90))
EnterEvadeMode();
else
DoZoneInCombat();
m_creature->SetSpeed(MOVE_RUN, 2.5);
CheckTimer = 1500;
}
else
CheckTimer -= diff;
if(SummonDoomBlossomTimer < diff)
{
AddSpellToCast(m_creature, 40188);
SummonDoomBlossomTimer = 25000+rand()%15000;
}
else
SummonDoomBlossomTimer -= diff;
if(IncinerateTimer < diff)
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 200, true, m_creature->getVictimGUID());
if(!target)
target = m_creature->getVictim();
if(target)
{
AddSpellToCastWithScriptText(target, SPELL_INCINERATE, RAND(SAY_SPECIAL1, SAY_SPECIAL2));
IncinerateTimer = urand(5000, 40000);
}
}
else
IncinerateTimer -= diff;
if(CrushingShadowsTimer < diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_CRUSHING_SHADOWS, SAY_SPELL3);
CrushingShadowsTimer = urand(17000, 42000);
}
else
CrushingShadowsTimer -= diff;
if(ShadowOfDeathTimer < diff)
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0, 100, true, m_creature->getVictimGUID());
if(target && target->isAlive() && !target->HasAura(SPELL_SHADOW_OF_DEATH, 0) && !target->HasAura(40282, 0) )
{
AddSpellToCast(target, SPELL_SHADOW_OF_DEATH, false, true);
ShadowOfDeathTimer = 30000;
}
}
else
ShadowOfDeathTimer -= diff;
if(RandomYellTimer < diff)
{
DoScriptText(RAND(SAY_SPELL1, SAY_SPELL2), m_creature);
RandomYellTimer = 50000 + rand()%51000;
}
else
RandomYellTimer -= diff;
if(!m_creature->HasAura(SPELL_BERSERK, 0))
{
if(EnrageTimer < diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_BERSERK, SAY_ENRAGE);
}
else
EnrageTimer -= diff;
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim() )
return;
//Check_Timer
if (Check_Timer < diff)
{
if (!m_creature->IsWithinDistInMap(&wLoc, 135.0f))
EnterEvadeMode();
else
DoZoneInCombat();
Check_Timer = 3000;
}
else
Check_Timer -= diff;
// Pounding
if (Pounding_Timer < diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_POUNDING, RAND(SAY_POUNDING1, SAY_POUNDING2));
if (KnockAway_Timer < 3100)
KnockAway_Timer = 3100;
Pounding_Timer = 12000;
}
else
Pounding_Timer -= diff;
// Arcane Orb
if (ArcaneOrb_Timer < diff)
{
Unit * target = SelectUnit(SELECT_TARGET_RANDOM, 0, 200.0f, true, 0, 18.0f);
if (!target)
target = m_creature->getVictim();
if (target)
if (Creature* t = DoSpawnCreature(TRIGGER, 0.0f, 0.0f, 10.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN, 40000))
t->CastSpell(target, SPELL_ARCANE_ORB, false, 0, 0, m_creature->GetGUID());
ArcaneOrb_Timer = urand(3000, 4000);
}
else
ArcaneOrb_Timer -= diff;
// Single Target knock back, reduces aggro
if (KnockAway_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_KNOCK_AWAY);
KnockAway_Timer = 30000;
}
else
KnockAway_Timer -= diff;
//Berserk
if (Berserk_Timer < diff)
{
ForceSpellCast(m_creature, SPELL_BERSERK);
Berserk_Timer = 600000;
}
else
Berserk_Timer -= diff;
m_creature->RemoveAurasWithDispelType(DISPEL_POISON);
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (pInstance->GetData(DATA_BRUTALLUS_INTRO_EVENT) == SPECIAL || pInstance->GetData(DATA_BRUTALLUS_INTRO_EVENT) == IN_PROGRESS || IntroPhase == 20)
{
if(IntroPhase < 12 && IntroPhase > 14)
{
if (CheckGroundTimer < diff)
{
float x, y, z;
me->GetPosition(x, y, z);
float ground_z = me->GetTerrain()->GetHeight(x, y, MAX_HEIGHT, true);
if(z > ground_z)
me->GetMap()->CreatureRelocation(me, x, y, z, me->GetOrientation());
CheckGroundTimer = 500;
}
else
CheckGroundTimer -= diff;
}
if (IntroPhaseTimer < diff)
DoIntro();
else
IntroPhaseTimer -= diff;
if (IntroPhase >= 7 && IntroPhase <= 9)
{
if (IntroFrostBoltTimer < diff)
{
if(Unit *pMadrigosa = me->GetUnit(pInstance->GetData64(DATA_MADRIGOSA)))
{
pMadrigosa->CastSpell(me, SPELL_INTRO_FROSTBOLT, false);
IntroFrostBoltTimer = 2000;
}
}
else
IntroFrostBoltTimer -= diff;
}
DoMeleeAttackIfReady();
CastNextSpellIfAnyAndReady();
return;
}
if (!UpdateVictim())
return;
if (CheckTimer < diff)
{
DoZoneInCombat();
me->SetSpeed(MOVE_RUN, 2.0f);
CheckTimer = 1000;
}
else
CheckTimer -= diff;
if (SlashTimer < diff)
{
AddSpellToCast(me, SPELL_METEOR_SLASH);
SlashTimer = 11000;
}
else
SlashTimer -= diff;
if (StompTimer < diff)
{
AddSpellToCastWithScriptText(me->getVictim(), SPELL_STOMP, RAND(YELL_LOVE1, YELL_LOVE2, YELL_LOVE3));
StompTimer = 30000;
}
else
StompTimer -= diff;
if (BurnTimer < diff)
{
if(Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 300.0f, true))
AddSpellToCast(pTarget, SPELL_BURN);
BurnTimer = 20000;
}
else
BurnTimer -= diff;
if (BerserkTimer < diff && !Enraged)
{
AddSpellToCastWithScriptText(me, SPELL_BERSERK, YELL_BERSERK);
Enraged = true;
}
else
BerserkTimer -= diff;
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if(waitTimer)
{
if(inMove)
if(waitTimer < diff)
{
(*m_creature).GetMotionMaster()->MovementExpired();
(*m_creature).GetMotionMaster()->MovePoint(MovePhase,NalorakkWay[MovePhase][0],NalorakkWay[MovePhase][1],NalorakkWay[MovePhase][2]);
waitTimer = 0;
}else
waitTimer -= diff;
}
if(!UpdateVictim())
return;
if (checkTimer < diff)
{
if (!m_creature->IsWithinDistInMap(&wLoc, 75) && !MoveEvent)
EnterEvadeMode();
else
DoZoneInCombat();
m_creature->SetSpeed(MOVE_RUN,2);
checkTimer = 3000;
}
else
checkTimer -= diff;
if(Berserk_Timer < diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_BERSERK, YELL_BERSERK, true);
Berserk_Timer = 600000;
}else
Berserk_Timer -= diff;
if(!inBearForm)
{
if(BrutalSwipe_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_BRUTALSWIPE);
BrutalSwipe_Timer = 7000 + rand()%5000;
}else
BrutalSwipe_Timer -= diff;
if(Mangle_Timer < diff)
{
if(m_creature->getVictim() && !m_creature->getVictim()->HasAura(SPELL_MANGLEEFFECT, 0))
{
AddSpellToCast(m_creature->getVictim(), SPELL_MANGLE);
Mangle_Timer = 1000;
}
else
Mangle_Timer = 10000 + rand()%5000;
}else
Mangle_Timer -= diff;
if(Surge_Timer < diff)
{
if(Unit *target = SelectUnit(SELECT_TARGET_RANDOM, 1, GetSpellMaxRange(SPELL_SURGE), true, m_creature->getVictimGUID()))
AddSpellToCastWithScriptText(target, SPELL_SURGE, YELL_SURGE);
Surge_Timer = 15000 + rand()%5000;
}else
Surge_Timer -= diff;
if(ShapeShift_Timer)
{
if(ShapeShift_Timer <= diff)
{
AddSpellToCastWithScriptText(m_creature, SPELL_BEARFORM, YELL_SHIFTEDTOBEAR, true);
ShapeShift_Timer = 0;
}else
ShapeShift_Timer -= diff;
}
}
else
{
if(LaceratingSlash_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_LACERATINGSLASH);
LaceratingSlash_Timer = 18000 + rand()%5000;
}else
LaceratingSlash_Timer -= diff;
if(RendFlesh_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_RENDFLESH);
RendFlesh_Timer = 5000 + rand()%5000;
}else
RendFlesh_Timer -= diff;
if(DeafeningRoar_Timer < diff)
{
AddSpellToCast(m_creature->getVictim(), SPELL_DEAFENINGROAR);
DeafeningRoar_Timer = 15000 + rand()%5000;
}else
DeafeningRoar_Timer -= diff;
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVADE_CHECK, 60.0f);
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHADOW_VOLLEY:
{
AddSpellToCast(SPELL_SHADOWVOLLEY, CAST_NULL);
events.ScheduleEvent(EVENT_SHADOW_VOLLEY, 3000);
break;
}
case EVENT_CLEAVE:
{
AddSpellToCast(SPELL_CLEAVE);
events.ScheduleEvent(EVENT_CLEAVE, urand(8000, 12000));
break;
}
case EVENT_THUNDER_CLAP:
{
AddSpellToCast(SPELL_THUNDERCLAP, CAST_SELF);
events.ScheduleEvent(EVENT_THUNDER_CLAP, urand(10000, 14000));
break;
}
case EVENT_MARKOFKAZZAK:
{
if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 60.0, true, POWER_MANA))
AddSpellToCast(pTarget, SPELL_MARKOFKAZZAK);
events.ScheduleEvent(EVENT_MARKOFKAZZAK, 20000);
break;
}
case EVENT_TWIST_REFLECT:
{
if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 100.0f, true))
AddSpellToCast(pTarget, SPELL_TWISTEDREFLECTION);
events.ScheduleEvent(EVENT_TWIST_REFLECT, 15000);
break;
}
case EVENT_VOID_BOLT:
{
AddSpellToCast(SPELL_VOIDBOLT);
events.ScheduleEvent(EVENT_VOID_BOLT, urand(15000, 18000));
break;
}
case EVENT_ENRAGE:
{
AddSpellToCastWithScriptText(me, SPELL_ENRAGE, EMOTE_FRENZY);
events.ScheduleEvent(EVENT_ENRAGE, 40000);
events.RescheduleEvent(EVENT_SHADOW_VOLLEY, 12000);
break;
}
default:
break;
}
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
DoSpecialThings(diff, DO_EVERYTHING, 120.0f);
events.Update(diff);
uint32 eventId;
while (eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_ICE_BOLT:
{
AddSpellToCast(SPELL_ICEBOLT, CAST_RANDOM);
if (++iceboltCount < 5)
events.ScheduleEvent(EVENT_ICE_BOLT, 4000);
else
events.ScheduleEvent(EVENT_FROST_BREATH, 2000);
break;
}
case EVENT_FROST_BREATH:
{
AddSpellToCastWithScriptText(SPELL_FROST_BREATH, CAST_SELF, EMOTE_BREATH);
events.ScheduleEvent(EVENT_PHASE_1, 2000);
break;
}
case EVENT_LIFE_DRAIN:
{
AddSpellToCast(SPELL_LIFE_DRAIN, CAST_RANDOM);
events.ScheduleEvent(EVENT_LIFE_DRAIN, 24000);
break;
}
case EVENT_BLIZZARD:
{
AddSpellToCast(SPELL_BLIZZARD, CAST_SELF);
events.ScheduleEvent(EVENT_BLIZZARD, 20000);
break;
}
case EVENT_PHASE_2:
{
if (HealthBelowPct(10))
break;
iceboltCount = 0;
phase = SAPPHIRON_AIR_PHASE;
events.CancelEvent(EVENT_BLIZZARD);
events.CancelEvent(EVENT_LIFE_DRAIN);
events.ScheduleEvent(EVENT_ICE_BOLT, 4000);
m_creature->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
m_creature->SetLevitate(true);
m_creature->GetMotionMaster()->Clear(false);
m_creature->GetMotionMaster()->MoveIdle();
break;
}
case EVENT_PHASE_1:
{
phase = SAPPHIRON_GROUND_PHASE;
events.ScheduleEvent(EVENT_BLIZZARD, urand(10000, 20000));
events.ScheduleEvent(EVENT_LIFE_DRAIN, urand(12000, 24000));
events.ScheduleEvent(EVENT_PHASE_2, 67000);
m_creature->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
m_creature->SetLevitate(false);
m_creature->GetMotionMaster()->Clear(false);
m_creature->GetMotionMaster()->MoveChase(m_creature->getVictim());
break;
}
}
}
if (!berserk && HealthBelowPct(10))
{
berserk = true;
ForceSpellCastWithScriptText(SPELL_BERSERK, CAST_SELF, EMOTE_ENRAGE);
}
CastNextSpellIfAnyAndReady();
if (phase == SAPPHIRON_GROUND_PHASE)
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim() )
return;
DoSpecialThings(diff, DO_EVERYTHING, 135.0f);
//Earthquake_Timer
if (Earthquake_Timer < diff)
{
if (!Earthquake)
{
AddSpellToCastWithScriptText(SPELL_EARTHQUAKE, CAST_NULL, EMOTE_EARTHQUAKE);
Earthquake = true;
Earthquake_Timer = 10000;
}
else
{
DoScriptText(RAND(SAY_SUMMON1, SAY_SUMMON2), m_creature);
for (uint8 i = 0; i < 10; ++i)
{
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0);
Creature* Murloc = m_creature->SummonCreature(MurlocCords[i][0], MurlocCords[i][1], MurlocCords[i][2], MurlocCords[i][3], MurlocCords[i][4], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 10000);
if (target && Murloc)
{
Murloc->setActive(true);
Murloc->AI()->AttackStart(target);
}
}
Earthquake = false;
Earthquake_Timer = urand(40000, 45000);
}
}
else
Earthquake_Timer -= diff;
//TidalWave_Timer
if (TidalWave_Timer < diff)
{
AddSpellToCast(SPELL_TIDAL_WAVE, CAST_NULL);
TidalWave_Timer = 20000;
}
else
TidalWave_Timer -= diff;
if (!Phase2)
{
//WateryGrave_Timer
if (WateryGrave_Timer < diff)
{
//Teleport 4 players under the waterfalls
std::list<Unit*> tmpList;
SelectUnitList(tmpList, 4, SELECT_TARGET_RANDOM, 200.0f, true, me->getVictimGUID());
int i = 0;
for (std::list<Unit*>::const_iterator itr = tmpList.begin(); itr != tmpList.end(); ++itr)
me->CastSpell(*itr, wateryGraves[i++], true);
DoScriptText(RAND(SAY_SUMMON_BUBL1, SAY_SUMMON_BUBL2), m_creature);
DoScriptText(EMOTE_WATERY_GRAVE, m_creature);
WateryGrave_Timer = 30000;
}
else
WateryGrave_Timer -= diff;
//Start Phase2
if (HealthBelowPct(25))
Phase2 = true;
}
else
{
//WateryGlobules_Timer
if (WateryGlobules_Timer < diff)
{
std::list<Unit*> tmpList;
SelectUnitList(tmpList, 4, SELECT_TARGET_RANDOM, 200.0f, true, me->getVictimGUID());
int i = 0;
for (std::list<Unit*>::const_iterator itr = tmpList.begin(); itr != tmpList.end(); ++itr)
(*itr)->CastSpell((*itr), summonGlobules[i++], true);
DoScriptText(EMOTE_WATERY_GLOBULES, m_creature);
WateryGlobules_Timer = 25000;
}
else
WateryGlobules_Timer -= diff;
}
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
