void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
//ManaBurn_Timer
if (ManaBurn_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_MANABURN);
ManaBurn_Timer = 8000 + rand()%8000;
} else ManaBurn_Timer -= diff;
//Sleep_Timer
if (Sleep_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_SLEEP);
Sleep_Timer = 12000 + rand()%8000;
} else Sleep_Timer -= diff;
//Illusions_Timer
if (Illusions_Timer <= diff)
{
//We will summon 3 illusions that will spawn on a random gamer and attack this gamer
//We will just use one model for the beginning
Unit* target = NULL;
for (uint8 i = 0; i < 3; ++i)
{
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (!target)
return;
Creature* Illusion = me->SummonCreature(15163, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 30000);
if (Illusion)
Illusion->AI()->AttackStart(target);
}
Illusions_Timer = 15000 + rand()%10000;
} else Illusions_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!m_creature->SelectHostilTarget() || !m_creature->getVictim())
return;
//BrainWashTotem_Timer
if (BrainWashTotem_Timer < diff)
{
DoCast(m_creature, SPELL_BRAINWASHTOTEM);
BrainWashTotem_Timer = 18000 + rand()%8000;
}else BrainWashTotem_Timer -= diff;
//HealingWard_Timer
if (HealingWard_Timer < diff)
{
//DoCast(m_creature, SPELL_POWERFULLHEALINGWARD);
HealingWard = m_creature->SummonCreature(14987, m_creature->GetPositionX()+3, m_creature->GetPositionY()-2, m_creature->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN,30000);
HealingWard_Timer = 14000 + rand()%6000;
}else HealingWard_Timer -= diff;
//Hex_Timer
if (Hex_Timer < diff)
{
DoCast(m_creature->getVictim(), SPELL_HEX);
if(m_creature->getThreatManager().getThreat(m_creature->getVictim()))
m_creature->getThreatManager().modifyThreatPercent(m_creature->getVictim(),-80);
Hex_Timer = 12000 + rand()%8000;
}else Hex_Timer -= diff;
//Casting the delusion curse with a shade. So shade will attack the same target with the curse.
if (Delusions_Timer < diff)
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
DoCast(target, SPELL_DELUSIONSOFJINDO);
Shade = m_creature->SummonCreature(14986, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Shade->AI()->AttackStart(target);
Delusions_Timer = 4000 + rand()%8000;
}else Delusions_Timer -= diff;
//Teleporting a random gamer and spawning 9 skeletons that will attack this gamer
if (Teleport_Timer < diff)
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target && target->GetTypeId() == TYPEID_PLAYER)
{
DoTeleportPlayer(target, -11583.7783,-1249.4278,77.5471,4.745);
if(m_creature->getThreatManager().getThreat(m_creature->getVictim()))
m_creature->getThreatManager().modifyThreatPercent(target,-100);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX()+2, target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX()-2, target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX()+4, target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX()-4, target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX(), target->GetPositionY()+2, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX(), target->GetPositionY()-2, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX(), target->GetPositionY()+4, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX(), target->GetPositionY()-4, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
Skeletons = m_creature->SummonCreature(14826, target->GetPositionX()+3, target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Skeletons->AI()->AttackStart(target);
}
Teleport_Timer = 15000 + rand()%8000;
}else Teleport_Timer -= diff;
DoMeleeAttackIfReady();
}
void SpellCast(float val)
{
if (_unit->GetCurrentSpell() == NULL && _unit->GetAIInterface()->getNextTarget())
{
float comulativeperc = 0;
Unit* target = NULL;
for (uint8 i = 0; i < nrspells; i++)
{
if (!spells[i].perctrigger)
continue;
if (m_spellcheck[i])
{
target = _unit->GetAIInterface()->getNextTarget();
switch (spells[i].targettype)
{
case TARGET_SELF:
case TARGET_VARIOUS:
_unit->CastSpell(_unit, spells[i].info, spells[i].instant);
break;
case TARGET_RANDOM_SINGLE:
case TARGET_ATTACKING:
_unit->CastSpell(target, spells[i].info, spells[i].instant);
break;
case TARGET_DESTINATION:
_unit->CastSpellAoF(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), spells[i].info, spells[i].instant);
break;
}
m_spellcheck[i] = false;
return;
}
if (val > comulativeperc && val <= (comulativeperc + spells[i].perctrigger))
{
_unit->setAttackTimer(spells[i].attackstoptimer, false);
m_spellcheck[i] = true;
}
comulativeperc += spells[i].perctrigger;
}
RemoveAIUpdateEvent();
RegisterAIUpdateEvent(50000);
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
target = SelectTarget(SELECT_TARGET_TOPAGGRO, 0, 200, true);
if (SpellTimer<=uiDiff)
{
if (target && me->IsInRange(target,5,40,false))
{
switch (urand(0,7))
{
case 0:
case 1:
case 2:
DoCastAOE(SHIELD_BREAKER, true);
break;
case 3:
case 4:
case 5:
case 6:
DoCastAOE(CHARGE, true);
break;
case 7:
me->CastSpell(me, DEFEND, true);
break;
}
}
else
{
switch (urand(0,4))
{
case 0:
me->CastSpell(me, DEFEND, true);
break;
case 1:
case 2:
case 3:
case 4:
DoCastAOE(THRUST, true);
break;
}
}
SpellTimer= urand(1000,2000);
} else
SpellTimer -= uiDiff;
if (MoviTimer<=uiDiff)
{
x = urand(0,7);
y = urand(0,7);
switch (urand(0,3))
{
case 0:
me->GetMotionMaster()->MovePoint(0, (target->GetPositionX()+x), (target->GetPositionY()+y), target->GetPositionZ());
break;
case 1:
me->GetMotionMaster()->MovePoint(0, (target->GetPositionX()-x), (target->GetPositionY()+y), target->GetPositionZ());
break;
case 2:
me->GetMotionMaster()->MovePoint(0, (target->GetPositionX()+x), (target->GetPositionY()-y), target->GetPositionZ());
break;
case 3:
me->GetMotionMaster()->MovePoint(0, (target->GetPositionX()-x), (target->GetPositionY()-y), target->GetPositionZ());
break;
}
MoviTimer = urand(1000,2000);
} else
MoviTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (m_bTargetDied || !UpdateVictim())
return;
if (Unit* target = Unit::GetPlayer(*me, m_uiTargetGUID))
{
if (!target->isAlive())
{
if (m_pInstance)
{
Unit* gormok = ObjectAccessor::GetCreature(*me, m_pInstance->GetData64(NPC_GORMOK));
if (gormok && gormok->isAlive())
{
SetCombatMovement(false);
m_bTargetDied = true;
me->GetMotionMaster()->MoveJump(gormok->GetPositionX(), gormok->GetPositionY(), gormok->GetPositionZ(), 15.0f, 15.0f);
}
else if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
m_uiTargetGUID = target->GetGUID();
me->GetMotionMaster()->MoveJump(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 15.0f, 15.0f);
}
}
}
}
if (m_uiFireBombTimer < uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_FIRE_BOMB);
m_uiFireBombTimer = 20000;
}
else m_uiFireBombTimer -= uiDiff;
if (m_uiBatterTimer < uiDiff)
{
if (Unit* target = Unit::GetPlayer(*me, m_uiTargetGUID))
DoCast(target, SPELL_BATTER);
m_uiBatterTimer = 10000;
}
else m_uiBatterTimer -= uiDiff;
if (m_uiHeadCrackTimer < uiDiff)
{
if (Unit* target = Unit::GetPlayer(*me, m_uiTargetGUID))
DoCast(target, SPELL_HEAD_CRACK);
m_uiHeadCrackTimer = 35000;
}
else m_uiHeadCrackTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (me->getVictim() && me->isAlive())
{
if (HealthAbovePct(50))
{
if (Charge_Timer <= diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
{
DoCast(pTarget, SPELL_CHARGE);
AttackStart(pTarget);
}
Charge_Timer = 15000 + rand()%15000;
} else Charge_Timer -= diff;
if (SonicBurst_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_SONICBURST);
SonicBurst_Timer = 8000 + rand()%5000;
} else SonicBurst_Timer -= diff;
if (Screech_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_SCREECH);
Screech_Timer = 18000 + rand()%8000;
} else Screech_Timer -= diff;
if (SpawnBats_Timer <= diff)
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
Creature* Bat = NULL;
Bat = me->SummonCreature(11368, -12291.6220f, -1380.2640f, 144.8304f, 5.483f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (pTarget && Bat) Bat ->AI()->AttackStart(pTarget);
Bat = me->SummonCreature(11368, -12289.6220f, -1380.2640f, 144.8304f, 5.483f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (pTarget && Bat) Bat ->AI()->AttackStart(pTarget);
Bat = me->SummonCreature(11368, -12293.6220f, -1380.2640f, 144.8304f, 5.483f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (pTarget && Bat) Bat ->AI()->AttackStart(pTarget);
Bat = me->SummonCreature(11368, -12291.6220f, -1380.2640f, 144.8304f, 5.483f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (pTarget && Bat) Bat ->AI()->AttackStart(pTarget);
Bat = me->SummonCreature(11368, -12289.6220f, -1380.2640f, 144.8304f, 5.483f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (pTarget && Bat) Bat ->AI()->AttackStart(pTarget);
Bat = me->SummonCreature(11368, -12293.6220f, -1380.2640f, 144.8304f, 5.483f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (pTarget && Bat) Bat ->AI()->AttackStart(pTarget);
SpawnBats_Timer = 60000;
} else SpawnBats_Timer -= diff;
}
else
{
if (PhaseTwo)
{
if (PhaseTwo && ShadowWordPain_Timer <= diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
{
DoCast(pTarget, SPELL_SHADOW_WORD_PAIN);
ShadowWordPain_Timer = 12000 + rand()%6000;
}
}ShadowWordPain_Timer -=diff;
if (MindFlay_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_MIND_FLAY);
MindFlay_Timer = 16000;
}MindFlay_Timer -=diff;
if (ChainMindFlay_Timer <= diff)
{
me->InterruptNonMeleeSpells(false);
DoCast(me->getVictim(), SPELL_CHAIN_MIND_FLAY);
ChainMindFlay_Timer = 15000 + rand()%15000;
}ChainMindFlay_Timer -=diff;
if (GreaterHeal_Timer <= diff)
{
me->InterruptNonMeleeSpells(false);
DoCast(me, SPELL_GREATERHEAL);
GreaterHeal_Timer = 25000 + rand()%10000;
}GreaterHeal_Timer -=diff;
if (SpawnFlyingBats_Timer <= diff)
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!pTarget)
return;
Creature* FlyingBat = me->SummonCreature(14965, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ()+15, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (FlyingBat)
FlyingBat->AI()->AttackStart(pTarget);
SpawnFlyingBats_Timer = 10000 + rand()%5000;
} else SpawnFlyingBats_Timer -=diff;
}
else
{
me->SetDisplayId(15219);
DoResetThreat();
PhaseTwo = true;
}
}
DoMeleeAttackIfReady();
}
}
void UpdateAI(const uint32 diff)
{
switch(Phase)
{
case FLYING:
if(!UpdateVictim())
return;
if(me->GetPositionX() >= 515)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
if(!m_bSaidEmote)
{
DoScriptText(EMOTE_RANGE, me);
m_bSaidEmote = true;
}
} else {
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE);
m_bSaidEmote = false;
}
if(m_uiMountTimer && m_uiMountTimer <= diff)
{
me->Mount(DATA_MOUNT);
me->SetFlying(true);
m_uiMountTimer = 0;
} else m_uiMountTimer -= diff;
if(m_uiSummonTimer <= diff)
{
SpawnMobs();
m_uiSummonTimer = 25000;
} else m_uiSummonTimer -= diff;
if(BreathSide != NONE)
{
if(m_uiSpawnTriggerTimer <= diff)
{
me->SummonCreature(CREATURE_TRIGGER,Location[m_LocCount]);
m_uiSpawnTriggerTimer = 125;
m_LocCount++;
if(m_LocCount > m_End)
BreathSide = NONE;
} else m_uiSpawnTriggerTimer -= diff;
}
if(m_uiMovementTimer <= diff)
{
switch(m_uiWaypointId)
{
case 0:
me->GetMotionMaster()->MovePoint(0, Location[1].GetPositionX(), Location[1].GetPositionY(), Location[1].GetPositionZ());
m_uiMovementTimer = 5000;
break;
case 1:
me->GetMotionMaster()->MovePoint(2, Location[2].GetPositionX(), Location[2].GetPositionY(), Location[2].GetPositionZ());
m_uiMovementTimer = 2000;
break;
case 2:
me->GetMotionMaster()->MovePoint(3, Location[3].GetPositionX(), Location[3].GetPositionY(), Location[3].GetPositionZ());
m_uiMovementTimer = 15000;
break;
case 3:
switch(urand(0,1))
{
case 0:
BreathSide = LEFT;
m_Start = 8;
m_End = 37;
m_LocNr = 69;
break;
case 1:
BreathSide = RIGHT;
m_Start = 38;
m_End = 68;
m_LocNr = 70;
break;
}
me->GetMotionMaster()->MovePoint(4, Location[m_LocNr].GetPositionX(), Location[m_LocNr].GetPositionY(), Location[m_LocNr].GetPositionZ());
DoScriptText(RAND(SAY_DRAKE_BREATH_1,SAY_DRAKE_BREATH_2), me);
DoScriptText(EMOTE_BREATH, me);
m_uiMovementTimer = 2500;
m_uiSpawnTriggerTimer = 3000;
m_LocCount = m_Start;
break;
case 4:
me->GetMotionMaster()->MovePoint(5, Location[71].GetPositionX(), Location[71].GetPositionY(), Location[71].GetPositionZ());
m_uiMovementTimer = 2000;
// if there are harpoon hits at this point, disable achievement
if(m_uiSpellHitCount)
m_bAchiev = false;
break;
case 5:
me->GetMotionMaster()->MovePoint(6, Location[72].GetPositionX(), Location[72].GetPositionY(), Location[72].GetPositionZ());
m_uiMovementTimer = 15000;
break;
case 6:
me->GetMotionMaster()->MovePoint(3, Location[3].GetPositionX(), Location[3].GetPositionY(), Location[3].GetPositionZ());
m_uiWaypointId = 2;
m_uiMovementTimer = 15000;
break;
}
m_uiWaypointId++;
} else m_uiMovementTimer -= diff;
break;
case SKADI:
//Return since we have no target
if(!UpdateVictim())
return;
if(!me->HasAura(DUNGEON_MODE(SPELL_WHIRLWIND, H_SPELL_WHIRLWIND)))
{
if(m_isWhirling)
{
m_isWhirling = false;
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MoveChase(me->getVictim());
m_uiWhirlwindTimer = 13000;
}
if(m_uiCrushTimer <= diff)
{
if(!me->IsNonMeleeSpellCasted(false))
{
DoCastVictim(DUNGEON_MODE(SPELL_CRUSH, H_SPELL_CRUSH));
m_uiCrushTimer = urand(8000, 12000);
}
} else m_uiCrushTimer -= diff;
if(m_uiPoisonedSpearTimer <= diff)
{
if(!me->IsNonMeleeSpellCasted(false))
{
if(Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM))
DoCast(pTarget, DUNGEON_MODE(SPELL_POISONED_SPEAR, H_SPELL_POISONED_SPEAR));
m_uiPoisonedSpearTimer = urand(10000, 12000);
}
} else m_uiPoisonedSpearTimer -= diff;
}
if(!m_isWhirling)
{
if(m_uiWhirlwindTimer <= diff)
{
if(!me->IsNonMeleeSpellCasted(false))
{
if(Unit* newTarget = SelectTarget(SELECT_TARGET_RANDOM, 1))
m_uiWhirlGUID = newTarget->GetGUID();
DoCast(DUNGEON_MODE(SPELL_WHIRLWIND, H_SPELL_WHIRLWIND));
m_isWhirling = true;
}
} else m_uiWhirlwindTimer -= diff;
}
if(m_isWhirling) //somewhat hacky to get skadi move during whirlwind
{
if(m_uiWhirlwindTimer <= diff)
{
Unit* whirlTarget = Unit::GetUnit(*me, m_uiWhirlGUID);
if(whirlTarget && whirlTarget->isAlive()) {
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MovePoint(0,whirlTarget->GetPositionX(),whirlTarget->GetPositionY(),whirlTarget->GetPositionZ());
} else if(Unit* newTarget = SelectTarget(SELECT_TARGET_RANDOM, 1)) { //Whirl target died
me->GetMotionMaster()->Clear();
m_uiWhirlGUID = newTarget->GetGUID();
me->GetMotionMaster()->MovePoint(0,newTarget->GetPositionX(),newTarget->GetPositionY(),newTarget->GetPositionZ());
} else {
me->GetMotionMaster()->Clear();
me->GetMotionMaster()->MoveChase(me->getVictim());
}
m_uiWhirlwindTimer = 500;
} else m_uiWhirlwindTimer -= diff;
}
DoMeleeAttackIfReady();
break;
}
}
void HandleFlightSequence()
{
switch(FlightCount)
{
case 0:
//me->AttackStop();
sLog->outError("prevent fly phase");
me->GetMotionMaster()->Clear(false);
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING + MOVEMENTFLAG_ONTRANSPORT);
me->StopMoving();
DoScriptText(YELL_TAKEOFF, me);
Timer[EVENT_FLIGHT_SEQUENCE] = 2000;
break;
case 1:
sLog->outError("Move to Fly point");
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()+1, me->GetPositionY(), me->GetPositionZ()+10);
Timer[EVENT_FLIGHT_SEQUENCE] = 0;
break;
case 2:
{
sLog->outError("Summon Vapor case 2");
Unit* target;
target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if(!target) target = Unit::GetUnit((*me), pInstance->GetData64(DATA_PLAYER_GUID));
if(target)
{
Creature* Vapor = me->SummonCreature(MOB_VAPOR, target->GetPositionX()-5+rand()%10, target->GetPositionY()-5+rand()%10, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
if(Vapor)
{
Vapor->AI()->AttackStart(target);
me->InterruptNonMeleeSpells(false);
me->CastSpell(Vapor, SPELL_VAPOR_CHANNEL, false); // core bug
Vapor->CastSpell(Vapor, SPELL_VAPOR_TRIGGER, true);
}
}
else
{
//EnterEvadeMode();
//return;
}
Timer[EVENT_FLIGHT_SEQUENCE] = 10000;
break;
}
case 3:
{
DespawnSummons(MOB_VAPOR_TRAIL);
sLog->outError("Summon Vapor case3");
//me->CastSpell(me, SPELL_VAPOR_SELECT); need core support
Unit* target;
target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if(!target) target = Unit::GetUnit((*me), pInstance->GetData64(DATA_PLAYER_GUID));
if(target)
{
//target->CastSpell(target, SPELL_VAPOR_SUMMON, true); need core support
Creature* Vapor = me->SummonCreature(MOB_VAPOR, target->GetPositionX()-5+rand()%10, target->GetPositionY()-5+rand()%10, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
if(Vapor)
{
Vapor->AI()->AttackStart(target);
me->InterruptNonMeleeSpells(false);
me->CastSpell(Vapor, SPELL_VAPOR_CHANNEL, false); // core bug
Vapor->CastSpell(Vapor, SPELL_VAPOR_TRIGGER, true);
}
}
else
{
//EnterEvadeMode();
//return;
}
Timer[EVENT_FLIGHT_SEQUENCE] = 10000;
break;
}
case 4:
DespawnSummons(MOB_VAPOR_TRAIL);
Timer[EVENT_FLIGHT_SEQUENCE] = 1;
break;
case 5:
{
//Unit* target;
//target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
//if(!target) target = Unit::GetUnit((*me), pInstance->GetData64(DATA_PLAYER_GUID));
//if(target)
//{
//BreathX = target->GetPositionX();
//BreathY = target->GetPositionY();
float x, y, z;
//target->GetContactPoint(me, x, y, z, 70);
GetRandFlyPos(x,y,z);
me->GetMotionMaster()->MovePoint(0, x,y,z);
//if(rand()%2 == 0)
// me->GetMotionMaster()->MovePoint(0, FLIGHT_1_X , FLIGHT_1_Y, FLIGHT_1_Z);
//else
// me->GetMotionMaster()->MovePoint(0, FLIGHT_2_X , FLIGHT_2_Y, FLIGHT_2_Z);
//}else
//{
// EnterEvadeMode();
// return;
//}
Timer[EVENT_FLIGHT_SEQUENCE] = 0;
break;
}
case 6:
//me->SetOrientation(me->GetAngle(BreathX, BreathY));
me->SetOrientation(me->GetAngle(me->GetPositionX(), MIDDLE_Y));
me->StopMoving();
//DoTextEmote("takes a deep breath.", NULL);
Timer[EVENT_FLIGHT_SEQUENCE] = 10000;
break;
case 7:
me->CastSpell(me, SPELL_FOG_BREATH, true);
{
float x, y, z;
GetNextFlyPos(x,y,z);
//me->GetPosition(x, y, z);
//x = 2 * BreathX - x;
//y = 2 * BreathY - y;
//if(me->GetPositionY() > 600)
// me->GetMotionMaster()->MovePoint(0, FLIGHT_1_X , FLIGHT_1_Y, FLIGHT_1_Z);
//else
// me->GetMotionMaster()->MovePoint(0, FLIGHT_2_X , FLIGHT_2_Y, FLIGHT_2_Z);
me->GetMotionMaster()->MovePoint(5, x,y,z);
}
Timer[EVENT_SUMMON_FOG] = 1;
Timer[EVENT_FLIGHT_SEQUENCE] = 0;
break;
case 8:
me->RemoveAurasDueToSpell(SPELL_FOG_BREATH);
BreathCount++;
Timer[EVENT_SUMMON_FOG] = 0;
Timer[EVENT_FLIGHT_SEQUENCE] = 1;
if(BreathCount < 3) FlightCount = 5;
break;
case 9:
if(Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO, 0))
{
float x, y, z;
target->GetContactPoint(me, x, y, z);
me->GetMotionMaster()->MovePoint(0, x, y, z);
}
else
{
float x,y,z;
x = 1435;
y = MIDDLE_Y;
z = 0;
me->UpdateGroundPositionZ(x, y, z);
me->GetMotionMaster()->MovePoint(0, x, y, z);
//EnterEvadeMode();
//return;
}
Timer[EVENT_FLIGHT_SEQUENCE] = 0;
break;
case 10:
me->RemoveUnitMovementFlag(MOVEMENTFLAG_LEVITATING + MOVEMENTFLAG_ONTRANSPORT);
me->StopMoving();
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
EnterPhase(PHASE_GROUND);
//me->AI()->AttackStart(SelectTarget(SELECT_TARGET_TOPAGGRO, 0));
DoStartMovement(SelectTarget(SELECT_TARGET_TOPAGGRO, 0));
break;
default:
break;
}
FlightCount++;
}
void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
{
Unit * caster = GetCaster();
for (int i = 0; i < 2; ++i)
{
Unit* Summoned = caster->SummonCreature(42321, caster->GetPositionX(), caster->GetPositionY(), caster->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 240000);
/*if (Summoned)
{
Unit *target = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (target)
Summoned->AddThreat(target, 1.0f);
}*/
}
}
bool SummonCyclonian(uint32 i, Spell* pSpell)
{
if ( pSpell == NULL || pSpell->u_caster == NULL )
return true;
Unit *pUnit = pSpell->u_caster;
Creature *pCreature = pUnit->GetMapMgr()->GetInterface()->SpawnCreature( 6239, pUnit->GetPositionX(), pUnit->GetPositionY(), pUnit->GetPositionZ(), pUnit->GetOrientation(), true, false, 0, 0 );
if ( pCreature != NULL )
{
pCreature->Despawn( 600000, 0 );
}
return true;
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STAT_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BONE_SPIKE_GRAVEYARD:
if (IsHeroic() || !me->HasAura(SPELL_BONE_STORM))
DoCast(me, SPELL_BONE_SPIKE_GRAVEYARD);
events.ScheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, urand(15000, 20000), EVENT_GROUP_SPECIAL);
break;
case EVENT_COLDFLAME:
_coldflameLastPos.Relocate(me);
_coldflameTarget = 0LL;
if (!me->HasAura(SPELL_BONE_STORM))
DoCastAOE(SPELL_COLDFLAME_NORMAL);
else
DoCast(me, SPELL_COLDFLAME_BONE_STORM);
events.ScheduleEvent(EVENT_COLDFLAME, 5000, EVENT_GROUP_SPECIAL);
break;
case EVENT_WARN_BONE_STORM:
_boneSlice = false;
Talk(EMOTE_BONE_STORM);
me->FinishSpell(CURRENT_MELEE_SPELL, false);
DoCast(me, SPELL_BONE_STORM);
events.DelayEvents(3000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_BONE_STORM_BEGIN, 3050);
events.ScheduleEvent(EVENT_WARN_BONE_STORM, urand(90000, 95000));
break;
case EVENT_BONE_STORM_BEGIN:
if (Aura* pStorm = me->GetAura(SPELL_BONE_STORM))
pStorm->SetDuration(int32(_boneStormDuration));
me->SetSpeed(MOVE_RUN, _baseSpeed*3.0f, true);
Talk(SAY_BONE_STORM);
events.ScheduleEvent(EVENT_BONE_STORM_END, _boneStormDuration+1);
// no break here
case EVENT_BONE_STORM_MOVE:
{
events.ScheduleEvent(EVENT_BONE_STORM_MOVE, _boneStormDuration/3);
Unit* unit = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!unit)
unit = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (unit)
me->GetMotionMaster()->MovePoint(POINT_TARGET_BONESTORM_PLAYER, unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
break;
}
case EVENT_BONE_STORM_END:
if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
me->GetMotionMaster()->MovementExpired();
DoStartMovement(me->getVictim());
me->SetSpeed(MOVE_RUN, _baseSpeed, true);
events.CancelEvent(EVENT_BONE_STORM_MOVE);
events.ScheduleEvent(EVENT_ENABLE_BONE_SLICE, 10000);
if (!IsHeroic())
events.RescheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, urand(15000, 20000), EVENT_GROUP_SPECIAL);
break;
case EVENT_ENABLE_BONE_SLICE:
_boneSlice = true;
break;
case EVENT_ENRAGE:
DoCast(me, SPELL_BERSERK, true);
Talk(SAY_BERSERK);
break;
}
}
// We should not melee attack when storming
if (me->HasAura(SPELL_BONE_STORM))
return;
// 10 seconds since encounter start Bone Slice replaces melee attacks
if (_boneSlice && !me->GetCurrentSpell(CURRENT_MELEE_SPELL))
DoCastVictim(SPELL_BONE_SLICE);
DoMeleeAttackIfReady();
}
void HandleFlightSequence()
{
switch (uiFlightCount)
{
case 0:
//me->AttackStop();
me->GetMotionMaster()->Clear(false);
me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);
me->StopMoving();
DoScriptText(YELL_TAKEOFF, me);
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 2000);
break;
case 1:
me->GetMotionMaster()->MovePoint(0, me->GetPositionX()+1, me->GetPositionY(), me->GetPositionZ()+10);
break;
case 2:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if (!target)
target = Unit::GetUnit(*me, pInstance ? pInstance->GetData64(DATA_PLAYER_GUID) : 0);
if (!target)
{
EnterEvadeMode();
return;
}
Creature* Vapor = me->SummonCreature(MOB_VAPOR, target->GetPositionX()-5+rand()%10, target->GetPositionY()-5+rand()%10, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
if (Vapor)
{
Vapor->AI()->AttackStart(target);
me->InterruptNonMeleeSpells(false);
DoCast(Vapor, SPELL_VAPOR_CHANNEL, false); // core bug
Vapor->CastSpell(Vapor, SPELL_VAPOR_TRIGGER, true);
}
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 10000);
break;
}
case 3:
{
DespawnSummons(MOB_VAPOR_TRAIL);
//DoCast(me, SPELL_VAPOR_SELECT); need core support
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if (!target)
target = Unit::GetUnit(*me, pInstance ? pInstance->GetData64(DATA_PLAYER_GUID) : 0);
if (!target)
{
EnterEvadeMode();
return;
}
//pTarget->CastSpell(target, SPELL_VAPOR_SUMMON, true); need core support
Creature* pVapor = me->SummonCreature(MOB_VAPOR, target->GetPositionX()-5+rand()%10, target->GetPositionY()-5+rand()%10, target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
if (pVapor)
{
if (pVapor->AI())
pVapor->AI()->AttackStart(target);
me->InterruptNonMeleeSpells(false);
DoCast(pVapor, SPELL_VAPOR_CHANNEL, false); // core bug
pVapor->CastSpell(pVapor, SPELL_VAPOR_TRIGGER, true);
}
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 10000);
break;
}
case 4:
DespawnSummons(MOB_VAPOR_TRAIL);
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 1);
break;
case 5:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150, true);
if (!target)
target = Unit::GetUnit(*me, pInstance ? pInstance->GetData64(DATA_PLAYER_GUID) : 0);
if (!target)
{
EnterEvadeMode();
return;
}
breathX = target->GetPositionX();
breathY = target->GetPositionY();
float x, y, z;
target->GetContactPoint(me, x, y, z, 70);
me->GetMotionMaster()->MovePoint(0, x, y, z+10);
break;
}
case 6:
me->SetOrientation(me->GetAngle(breathX, breathY));
me->StopMoving();
//DoTextEmote("takes a deep breath.", NULL);
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 10000);
break;
case 7:
{
DoCast(me, SPELL_FOG_BREATH, true);
float x, y, z;
me->GetPosition(x, y, z);
x = 2 * breathX - x;
y = 2 * breathY - y;
me->GetMotionMaster()->MovePoint(0, x, y, z);
events.ScheduleEvent(EVENT_SUMMON_FOG, 1);
break;
}
case 8:
me->CastStop(SPELL_FOG_BREATH);
me->RemoveAurasDueToSpell(SPELL_FOG_BREATH);
++uiBreathCount;
events.ScheduleEvent(EVENT_FLIGHT_SEQUENCE, 1);
if (uiBreathCount < 3)
uiFlightCount = 4;
break;
case 9:
if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
DoStartMovement(target);
else
{
EnterEvadeMode();
return;
}
break;
case 10:
me->RemoveUnitMovementFlag(MOVEMENTFLAG_LEVITATING);
me->HandleEmoteCommand(EMOTE_ONESHOT_LAND);
EnterPhase(PHASE_GROUND);
AttackStart(SelectTarget(SELECT_TARGET_TOPAGGRO));
break;
}
++uiFlightCount;
}
void SpellCast(float val)
{
if (_unit->GetCurrentSpell() == NULL && _unit->GetAIInterface()->getNextTarget())
{
float comulativeperc = 0;
Unit* target = NULL;
for (uint8 i = 0; i < nrspells; i++)
{
spells[i].casttime--;
if (m_spellcheck[i])
{
spells[i].casttime = spells[i].cooldown;
target = _unit->GetAIInterface()->getNextTarget();
switch (spells[i].targettype)
{
case TARGET_SELF:
case TARGET_VARIOUS:
_unit->CastSpell(_unit, spells[i].info, spells[i].instant);
break;
case TARGET_ATTACKING:
_unit->CastSpell(target, spells[i].info, spells[i].instant);
break;
case TARGET_DESTINATION:
_unit->CastSpellAoF(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), spells[i].info, spells[i].instant);
break;
}
if (spells[i].speech != "")
{
_unit->SendChatMessage(CHAT_MSG_MONSTER_YELL, LANG_UNIVERSAL, spells[i].speech.c_str());
_unit->PlaySoundToSet(spells[i].soundid);
}
m_spellcheck[i] = false;
return;
}
if ((val > comulativeperc && val <= (comulativeperc + spells[i].perctrigger)) || !spells[i].casttime)
{
_unit->setAttackTimer(spells[i].attackstoptimer, false);
m_spellcheck[i] = true;
}
comulativeperc += spells[i].perctrigger;
}
}
}
void UpdateAI(const uint32 uiDiff) override
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
{ return; }
if (m_uiCarnivorousBiteTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature, m_bIsRegularMode ? SPELL_CARNIVOROUS_BITE : SPELL_CARNIVOROUS_BITE_H) == CAST_OK)
{ m_uiCarnivorousBiteTimer = urand(4000, 10000); }
}
else
{ m_uiCarnivorousBiteTimer -= uiDiff; }
if (m_uiAttractMagicTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature, SPELL_ATTRACT_MAGIC) == CAST_OK)
{ m_uiAttractMagicTimer = urand(25000, 38000); }
}
else
{ m_uiAttractMagicTimer -= uiDiff; }
if (m_uiFocusFireTimer < uiDiff)
{
++m_uiFocusFireCount;
Unit* pTarget = NULL;
switch (m_uiFocusFireCount)
{
case 1:
{
// engage the target
pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1, uint32(0), SELECT_FLAG_PLAYER);
if (!pTarget)
{ pTarget = m_creature->getVictim(); }
DoScriptText(EMOTE_FOCUS, m_creature, pTarget);
m_focusTargetGuid = pTarget->GetObjectGuid();
// no break;
}
case 2:
// we have a delay of 1 sec between the summons
m_uiFocusFireTimer = 1000;
break;
case 3:
// reset the timers and the summon count
m_uiFocusFireCount = 0;
m_uiFocusFireTimer = 15000;
break;
}
if (!pTarget)
{ pTarget = m_creature->GetMap()->GetUnit(m_focusTargetGuid); }
// Summon focus fire at target location
if (pTarget)
{ m_creature->SummonCreature(NPC_FOCUS_FIRE, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 10000); }
}
else
{ m_uiFocusFireTimer -= uiDiff; }
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (m_bSummonKilrek)
{
if (m_uiSummonKilrekTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature, SPELL_SUMMON_IMP) == CAST_OK)
{
m_uiSummonKilrekTimer = 45000;
m_bSummonKilrek = false;
}
}
else
m_uiSummonKilrekTimer -= uiDiff;
}
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (m_uiSacrifice_Timer < uiDiff)
{
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
if (pTarget && pTarget->isAlive() && pTarget->GetTypeId() == TYPEID_PLAYER)
{
DoCastSpellIfCan(pTarget, SPELL_SACRIFICE, CAST_TRIGGERED);
Creature* pChains = m_creature->SummonCreature(NPC_DEMONCHAINS, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN, 21000);
if (pChains)
{
((mob_demon_chainAI*)pChains->AI())->m_uiSacrificeGUID = pTarget->GetGUID();
pChains->CastSpell(pChains, SPELL_DEMON_CHAINS, true);
DoScriptText(urand(0, 1) ? SAY_SACRIFICE1 : SAY_SACRIFICE2, m_creature);
m_uiSacrifice_Timer = 30000;
}
}
}
else
m_uiSacrifice_Timer -= uiDiff;
if (m_uiShadowbolt_Timer < uiDiff)
{
DoCastSpellIfCan(m_creature->getVictim(), SPELL_SHADOW_BOLT);
m_uiShadowbolt_Timer = 10000;
}
else
m_uiShadowbolt_Timer -= uiDiff;
if (!m_bSummonedPortals)
{
if (m_uiSummon_Timer < uiDiff)
{
if (DoCastSpellIfCan(m_creature, SPELL_FIENDISH_PORTAL, CAST_INTERRUPT_PREVIOUS) == CAST_OK)
{
DoScriptText(urand(0, 1) ? SAY_SUMMON1 : SAY_SUMMON2, m_creature);
m_bSummonedPortals = true;
}
}
else
m_uiSummon_Timer -= uiDiff;
}
if (!m_bBerserk)
{
if (m_uiBerserk_Timer < uiDiff)
{
DoCastSpellIfCan(m_creature, SPELL_BERSERK, CAST_INTERRUPT_PREVIOUS);
m_bBerserk = true;
}
else
m_uiBerserk_Timer -= uiDiff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
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 = 15000 + rand()%15000;
} else Invisible_Timer -= diff;
if (Invisible)
{
if (Ambush_Timer <= diff)
{
Unit *pTarget = NULL;
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (pTarget)
{
DoTeleportTo(pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ());
DoCast(pTarget, 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)
{
Unit *pTarget = NULL;
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (DoGetThreat(me->getVictim()))
DoModifyThreatPercent(me->getVictim(), -50);
if (pTarget)
AttackStart(pTarget);
Aggro_Timer = 7000 + rand()%13000;
} else Aggro_Timer -= diff;
}
if (!Invisible)
{
if (ThousandBlades_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_THOUSANDBLADES);
ThousandBlades_Timer = 7000 + rand()%5000;
} else ThousandBlades_Timer -= diff;
}
DoMeleeAttackIfReady();
}
bool
FleeingMovementGenerator<T>::_setMoveData(T &owner)
{
float cur_dist_xyz = owner.GetDistance(i_caster_x, i_caster_y, i_caster_z);
if (i_to_distance_from_caster > 0.0f)
{
if ((i_last_distance_from_caster > i_to_distance_from_caster && cur_dist_xyz < i_to_distance_from_caster) ||
// if we reach lower distance
(i_last_distance_from_caster > i_to_distance_from_caster && cur_dist_xyz > i_last_distance_from_caster) ||
// if we can't be close
(i_last_distance_from_caster < i_to_distance_from_caster && cur_dist_xyz > i_to_distance_from_caster) ||
// if we reach bigger distance
(cur_dist_xyz > MAX_QUIET_DISTANCE) || // if we are too far
(i_last_distance_from_caster > MIN_QUIET_DISTANCE && cur_dist_xyz < MIN_QUIET_DISTANCE))
// if we leave 'quiet zone'
{
// we are very far or too close, stopping
i_to_distance_from_caster = 0.0f;
i_nextCheckTime.Reset(urand(500,1000));
return false;
}
else
{
// now we are running, continue
i_last_distance_from_caster = cur_dist_xyz;
return true;
}
}
float cur_dist;
float angle_to_caster;
Unit * fright = ObjectAccessor::GetUnit(owner, i_frightGUID);
if (fright)
{
cur_dist = fright->GetDistance(&owner);
if (cur_dist < cur_dist_xyz)
{
i_caster_x = fright->GetPositionX();
i_caster_y = fright->GetPositionY();
i_caster_z = fright->GetPositionZ();
angle_to_caster = fright->GetAngle(&owner);
}
else
{
cur_dist = cur_dist_xyz;
angle_to_caster = owner.GetAngle(i_caster_x, i_caster_y) + M_PI;
}
}
else
{
cur_dist = cur_dist_xyz;
angle_to_caster = owner.GetAngle(i_caster_x, i_caster_y) + M_PI;
}
// if we too close may use 'path-finding' else just stop
i_only_forward = cur_dist >= MIN_QUIET_DISTANCE/3;
//get angle and 'distance from caster' to run
float angle;
if (i_cur_angle == 0.0f && i_last_distance_from_caster == 0.0f) //just started, first time
{
angle = rand_norm()*(1.0f - cur_dist/MIN_QUIET_DISTANCE) * M_PI/3 + rand_norm()*M_PI*2/3;
i_to_distance_from_caster = MIN_QUIET_DISTANCE;
i_only_forward = true;
}
else if (cur_dist < MIN_QUIET_DISTANCE)
{
angle = M_PI/6 + rand_norm()*M_PI*2/3;
i_to_distance_from_caster = cur_dist*2/3 + rand_norm()*(MIN_QUIET_DISTANCE - cur_dist*2/3);
}
else if (cur_dist > MAX_QUIET_DISTANCE)
{
angle = rand_norm()*M_PI/3 + M_PI*2/3;
i_to_distance_from_caster = MIN_QUIET_DISTANCE + 2.5f + rand_norm()*(MAX_QUIET_DISTANCE - MIN_QUIET_DISTANCE - 2.5f);
}
else
{
angle = rand_norm()*M_PI;
i_to_distance_from_caster = MIN_QUIET_DISTANCE + 2.5f + rand_norm()*(MAX_QUIET_DISTANCE - MIN_QUIET_DISTANCE - 2.5f);
}
int8 sign = rand_norm() > 0.5f ? 1 : -1;
i_cur_angle = sign*angle + angle_to_caster;
// current distance
i_last_distance_from_caster = cur_dist;
return true;
}
void UpdateAI(uint32 const diff)
{
if (!UpdateVictim() || !CheckInRoom())
return;
events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CHECK_PLAYERS:
instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_TANK_MARKER);
events.ScheduleEvent(EVENT_CHECK_PLAYERS, 2000);
break;
case EVENT_PREPARE_BONE_SPIKE_GRAVEYARD:
events.CancelEvent(EVENT_CHECK_PLAYERS);
break;
case EVENT_BONE_SPIKE_GRAVEYARD:
if (IsHeroic() || !me->HasAura(SPELL_BONE_STORM))
DoCast(me, SPELL_BONE_SPIKE_GRAVEYARD);
events.ScheduleEvent(EVENT_PREPARE_BONE_SPIKE_GRAVEYARD, 12000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, 18000, EVENT_GROUP_SPECIAL);
events.ScheduleEvent(EVENT_CHECK_PLAYERS, 4000);
break;
case EVENT_COLDFLAME:
_coldflameLastPos.Relocate(me);
_coldflameTarget = 0LL;
if (!me->HasAura(SPELL_BONE_STORM))
DoCastAOE(SPELL_COLDFLAME_NORMAL);
else
DoCast(me, SPELL_COLDFLAME_BONE_STORM);
events.ScheduleEvent(EVENT_COLDFLAME, 5000, EVENT_GROUP_SPECIAL);
break;
case EVENT_WARN_BONE_STORM:
_boneSlice = false;
Talk(EMOTE_BONE_STORM);
me->FinishSpell(CURRENT_MELEE_SPELL, false);
DoCast(me, SPELL_BONE_STORM);
events.DelayEvents(3000, EVENT_GROUP_SPECIAL);
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, true);
events.ScheduleEvent(EVENT_BONE_STORM_BEGIN, 3050);
events.ScheduleEvent(EVENT_WARN_BONE_STORM, 90000);
break;
case EVENT_BONE_STORM_BEGIN:
if (AuraPtr pStorm = me->GetAura(SPELL_BONE_STORM))
pStorm->SetDuration(int32(_boneStormDuration));
me->SetSpeed(MOVE_RUN, _baseSpeed*3.0f, true);
Talk(SAY_BONE_STORM);
events.ScheduleEvent(EVENT_BONE_STORM_END, _boneStormDuration+1);
// no break here
case EVENT_BONE_STORM_MOVE:
{
events.ScheduleEvent(EVENT_BONE_STORM_MOVE, IsHeroic() ? _boneStormDuration/5 : _boneStormDuration/4);
Unit* unit = SelectTarget(SELECT_TARGET_FARTHEST, 0, 60.0f);
if (!unit || unit->isPet() || unit->isTotem() || !me->IsWithinLOSInMap(unit))
unit = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true);
if (unit)
if (unit->isPet() || unit->isTotem() || !me->IsWithinLOSInMap(unit))
unit = SelectTarget(SELECT_TARGET_RANDOM, 1);
else
me->GetMotionMaster()->MovePoint(POINT_TARGET_BONESTORM_PLAYER, unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ());
break;
}
case EVENT_BONE_STORM_END:
if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == POINT_MOTION_TYPE)
me->GetMotionMaster()->MovementExpired();
me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_ATTACK_ME, false);
DoStartMovement(me->getVictim());
me->SetSpeed(MOVE_RUN, _baseSpeed, true);
events.CancelEvent(EVENT_BONE_STORM_MOVE);
events.ScheduleEvent(EVENT_ENABLE_BONE_SLICE, 10000);
if (!IsHeroic())
events.RescheduleEvent(EVENT_BONE_SPIKE_GRAVEYARD, 15000, EVENT_GROUP_SPECIAL);
break;
case EVENT_ENABLE_BONE_SLICE:
_boneSlice = true;
break;
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
Talk(SAY_BERSERK);
break;
}
}
// We should not melee attack when storming
if (me->HasAura(SPELL_BONE_STORM))
return;
// 10 seconds since encounter start Bone Slice replaces melee attacks
if (_boneSlice && !me->GetCurrentSpell(CURRENT_MELEE_SPELL))
DoCastVictim(SPELL_BONE_SLICE);
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_BERSERK:
DoCast(me, SPELL_BERSERK, true);
break;
case EVENT_FLAME:
DoCast(me, SPELL_MOLTEN_PUNCH);
events.DelayEvents(1500, GCD_CAST);
events.ScheduleEvent(EVENT_FLAME, 20000, GCD_CAST);
break;
case EVENT_HATEFUL_STRIKE:
if (Unit* target = CalculateHatefulStrikeTarget())
DoCast(target, SPELL_HATEFUL_STRIKE);
events.DelayEvents(1000, GCD_CAST);
events.ScheduleEvent(EVENT_HATEFUL_STRIKE, 5000, GCD_CAST, PHASE_STRIKE);
break;
case EVENT_SWITCH_TARGET:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true))
{
DoResetThreat();
me->AddThreat(target, 5000000.0f);
DoScriptText(EMOTE_NEW_TARGET, me);
}
events.ScheduleEvent(EVENT_SWITCH_TARGET, 10000, 0, PHASE_CHASE);
break;
case EVENT_VOLCANO:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 999, true);
if (!target) target = me->getVictim();
if (target)
{
//DoCast(target, SPELL_VOLCANIC_SUMMON);//movement bugged
me->SummonCreature(CREATURE_VOLCANO, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
DoScriptText(EMOTE_GROUND_CRACK, me);
events.DelayEvents(1500, GCD_CAST);
}
events.ScheduleEvent(EVENT_VOLCANO, 10000, GCD_CAST, PHASE_CHASE);
return;
}
case EVENT_SWITCH_PHASE:
ChangePhase();
break;
}
}
DoMeleeAttackIfReady();
}
bool CrystalSpikes(uint32 i, Spell* pSpell)
{
if(pSpell->u_caster == NULL)
return true;
Unit* pCaster = pSpell->u_caster;
for(int i = 1; i < 6; ++i)
{
pCaster->GetMapMgr()->GetInterface()->SpawnCreature(CN_CRYSTAL_SPIKE, pCaster->GetPositionX() + (3 * i) + rand() % 3 , pCaster->GetPositionY() + (3 * i) + rand() % 3 , pCaster->GetPositionZ(), pCaster->GetOrientation(), true, false, 0, 0);
};
for(int i = 1; i < 6; ++i)
{
pCaster->GetMapMgr()->GetInterface()->SpawnCreature(CN_CRYSTAL_SPIKE, pCaster->GetPositionX() - (3 * i) - rand() % 3 , pCaster->GetPositionY() + (3 * i) + rand() % 3 , pCaster->GetPositionZ(), pCaster->GetOrientation(), true, false, 0, 0);
};
for(int i = 1; i < 6; ++i)
{
pCaster->GetMapMgr()->GetInterface()->SpawnCreature(CN_CRYSTAL_SPIKE, pCaster->GetPositionX() + (3 * i) + rand() % 3 , pCaster->GetPositionY() - (3 * i) - rand() % 3 , pCaster->GetPositionZ(), pCaster->GetOrientation(), true, false, 0, 0);
};
for(int i = 1; i < 6; ++i)
{
pCaster->GetMapMgr()->GetInterface()->SpawnCreature(CN_CRYSTAL_SPIKE, pCaster->GetPositionX() - (3 * i) - rand() % 3 , pCaster->GetPositionY() - (3 * i) - rand() % 3 , pCaster->GetPositionZ(), pCaster->GetOrientation(), true, false, 0, 0);
};
return true;
}
void UpdateAI(const uint32 diff)
{
//Inhibitmagic_Timer
if (Inhibitmagic_Timer <= diff)
{
float dist;
Map* map = me->GetMap();
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player* i_pl = i->getSource())
if (i_pl->isAlive() && (dist = i_pl->IsWithinDist(me, 45)))
{
i_pl->RemoveAurasDueToSpell(SPELL_INHIBITMAGIC);
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 35)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 25)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 15)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
}
Inhibitmagic_Timer = 3000+(rand()%1000);
} else Inhibitmagic_Timer -= diff;
//Return since we have no target
if (!UpdateVictim())
return;
//Attractmagic_Timer
if (Attractmagic_Timer <= diff)
{
DoCast(me, SPELL_ATTRACTMAGIC);
Attractmagic_Timer = 30000;
Carnivorousbite_Timer = 1500;
} else Attractmagic_Timer -= diff;
//Carnivorousbite_Timer
if (Carnivorousbite_Timer <= diff)
{
DoCast(me, SPELL_CARNIVOROUSBITE);
Carnivorousbite_Timer = 10000;
} else Carnivorousbite_Timer -= diff;
//FocusFire_Timer
if (FocusFire_Timer <= diff)
{
// Summon Focus Fire & Emote
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (target && target->GetTypeId() == TYPEID_PLAYER && target->isAlive())
{
FocusedTargetGUID = target->GetGUID();
me->SummonCreature(ENTRY_FOCUS_FIRE, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 5500);
// TODO: Find better way to handle emote
// Emote
std::string emote(EMOTE_FOCUSES_ON);
emote.append(target->GetName());
emote.push_back('!');
me->MonsterTextEmote(emote.c_str(), 0, true);
}
FocusFire_Timer = 15000+(rand()%5000);
} else FocusFire_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (me->getVictim() && me->isAlive())
{
if (PoisonVolley_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_POISONVOLLEY);
PoisonVolley_Timer = urand(10000, 20000);
} else PoisonVolley_Timer -= diff;
if (!PhaseTwo && Aspect_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_ASPECT_OF_MARLI);
Aspect_Timer = urand(13000, 18000);
} else Aspect_Timer -= diff;
if (!Spawned && SpawnStartSpiders_Timer <= diff)
{
Talk(SAY_SPIDER_SPAWN);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (!target)
return;
Creature* Spider = NULL;
Spider = me->SummonCreature(15041, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Spider)
Spider->AI()->AttackStart(target);
Spider = me->SummonCreature(15041, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Spider)
Spider->AI()->AttackStart(target);
Spider = me->SummonCreature(15041, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Spider)
Spider->AI()->AttackStart(target);
Spider = me->SummonCreature(15041, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Spider)
Spider->AI()->AttackStart(target);
Spawned = true;
} else SpawnStartSpiders_Timer -= diff;
if (SpawnSpider_Timer <= diff)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (!target)
return;
Creature* Spider = me->SummonCreature(15041, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Spider)
Spider->AI()->AttackStart(target);
SpawnSpider_Timer = urand(12000, 17000);
} else SpawnSpider_Timer -= diff;
if (!PhaseTwo && Transform_Timer <= diff)
{
Talk(SAY_TRANSFORM);
DoCast(me, SPELL_SPIDER_FORM);
const CreatureTemplate* cinfo = me->GetCreatureTemplate();
me->SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, (cinfo->mindmg +((cinfo->mindmg/100) * 35)));
me->SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, (cinfo->maxdmg +((cinfo->maxdmg/100) * 35)));
me->UpdateDamagePhysical(BASE_ATTACK);
DoCast(me->getVictim(), SPELL_ENVOLWINGWEB);
if (DoGetThreat(me->getVictim()))
DoModifyThreatPercent(me->getVictim(), -100);
PhaseTwo = true;
Transform_Timer = urand(35000, 60000);
} else Transform_Timer -= diff;
if (PhaseTwo)
{
if (Charge_Timer <= diff)
{
Unit* target = NULL;
int i = 0;
while (i < 3) // max 3 tries to get a random target with power_mana
{
++i;
target = SelectTarget(SELECT_TARGET_RANDOM, 1, 100, true); // not aggro leader
if (target && target->getPowerType() == POWER_MANA)
i = 3;
}
if (target)
{
DoCast(target, SPELL_CHARGE);
//me->SetPosition(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0);
//me->SendMonsterMove(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, true, 1);
AttackStart(target);
}
Charge_Timer = 8000;
} else Charge_Timer -= diff;
if (TransformBack_Timer <= diff)
{
me->SetDisplayId(15220);
const CreatureTemplate* cinfo = me->GetCreatureTemplate();
me->SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, (cinfo->mindmg +((cinfo->mindmg/100) * 1)));
me->SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, (cinfo->maxdmg +((cinfo->maxdmg/100) * 1)));
me->UpdateDamagePhysical(BASE_ATTACK);
PhaseTwo = false;
TransformBack_Timer = urand(25000, 40000);
} else TransformBack_Timer -= diff;
}
DoMeleeAttackIfReady();
}
}
void UpdateAI(const uint32 diff)
{
//Check if we have a target
if (!UpdateVictim())
return;
//EvadeTimer
if (!me->IsWithinMeleeRange(me->getVictim()))
{
if (EvadeTimer <= diff)
{
if (Unit* p = Unit::GetUnit(*me, Portal))
p->Kill(p);
//Dissapear and reappear at new position
me->SetVisible(false);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (!target)
{
me->Kill(me);
return;
}
if (!target->HasAura(SPELL_DIGESTIVE_ACID))
{
me->SetPosition(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0);
if (Creature* pPortal = me->SummonCreature(MOB_GIANT_PORTAL, *me, TEMPSUMMON_CORPSE_DESPAWN))
{
pPortal->SetReactState(REACT_PASSIVE);
Portal = pPortal->GetGUID();
}
GroundRuptureTimer = 500;
HamstringTimer = 2000;
ThrashTimer = 5000;
EvadeTimer = 5000;
AttackStart(target);
}
me->SetVisible(true);
} else EvadeTimer -= diff;
}
//GroundRuptureTimer
if (GroundRuptureTimer <= diff)
{
DoCast(me->getVictim(), SPELL_GROUND_RUPTURE);
GroundRuptureTimer = 30000;
} else GroundRuptureTimer -= diff;
//ThrashTimer
if (ThrashTimer <= diff)
{
DoCast(me->getVictim(), SPELL_THRASH);
ThrashTimer = 10000;
} else ThrashTimer -= diff;
//HamstringTimer
if (HamstringTimer <= diff)
{
DoCast(me->getVictim(), SPELL_HAMSTRING);
HamstringTimer = 10000;
} else HamstringTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
//MortalWound_Timer
if (MortalWound_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_MORTAL_WOUND);
MortalWound_Timer = 10000 + rand()%10000;
} else MortalWound_Timer -= diff;
//Summon 1-3 Spawns of Fankriss at random time.
if (SpawnSpawns_Timer <= diff)
{
switch (urand(0, 2))
{
case 0:
SummonSpawn(SelectUnit(SELECT_TARGET_RANDOM, 0));
break;
case 1:
SummonSpawn(SelectUnit(SELECT_TARGET_RANDOM, 0));
SummonSpawn(SelectUnit(SELECT_TARGET_RANDOM, 0));
break;
case 2:
SummonSpawn(SelectUnit(SELECT_TARGET_RANDOM, 0));
SummonSpawn(SelectUnit(SELECT_TARGET_RANDOM, 0));
SummonSpawn(SelectUnit(SELECT_TARGET_RANDOM, 0));
break;
}
SpawnSpawns_Timer = 30000 + rand()%30000;
} else SpawnSpawns_Timer -= diff;
// Teleporting Random Target to one of the three tunnels and spawn 4 hatchlings near the gamer.
//We will only telport if fankriss has more than 3% of hp so teleported gamers can always loot.
if (HealthAbovePct(3))
{
if (SpawnHatchlings_Timer <= diff)
{
Unit *pTarget = NULL;
pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (pTarget && pTarget->GetTypeId() == TYPEID_PLAYER)
{
DoCast(pTarget, SPELL_ROOT);
if (DoGetThreat(pTarget))
DoModifyThreatPercent(pTarget, -100);
switch(urand(0, 2))
{
case 0:
DoTeleportPlayer(pTarget, -8106.0142f, 1289.2900f, -74.419533f, 5.112f);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-3, pTarget->GetPositionY()-3, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-3, pTarget->GetPositionY()+3, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-5, pTarget->GetPositionY()-5, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-5, pTarget->GetPositionY()+5, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
break;
case 1:
DoTeleportPlayer(pTarget, -7990.135354f, 1155.1907f, -78.849319f, 2.608f);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-3, pTarget->GetPositionY()-3, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-3, pTarget->GetPositionY()+3, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-5, pTarget->GetPositionY()-5, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-5, pTarget->GetPositionY()+5, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
break;
case 2:
DoTeleportPlayer(pTarget, -8159.7753f, 1127.9064f, -76.868660f, 0.675f);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-3, pTarget->GetPositionY()-3, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-3, pTarget->GetPositionY()+3, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-5, pTarget->GetPositionY()-5, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
Hatchling = me->SummonCreature(15962, pTarget->GetPositionX()-5, pTarget->GetPositionY()+5, pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
if (Hatchling)
Hatchling->AI()->AttackStart(pTarget);
break;
}
}
SpawnHatchlings_Timer = 45000 + rand()%15000;
} else SpawnHatchlings_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!UpdateVictim())
return;
switch (m_uiStage)
{
case 0:
if (m_uiFerociousButtTimer <= uiDiff)
{
DoCastVictim(SPELL_FEROCIOUS_BUTT);
m_uiFerociousButtTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else m_uiFerociousButtTimer -= uiDiff;
if (m_uiArticBreathTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_ARCTIC_BREATH);
m_uiArticBreathTimer = urand(25*IN_MILLISECONDS, 40*IN_MILLISECONDS);
} else m_uiArticBreathTimer -= uiDiff;
if (m_uiWhirlTimer <= uiDiff)
{
DoCastAOE(SPELL_WHIRL);
m_uiWhirlTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS);
} else m_uiWhirlTimer -= uiDiff;
if (m_uiMassiveCrashTimer <= uiDiff)
{
me->GetMotionMaster()->MoveJump(ToCCommonLoc[1].GetPositionX(), ToCCommonLoc[1].GetPositionY(), ToCCommonLoc[1].GetPositionZ(), 10.0f, 20.0f); // 1: Middle of the room
m_uiStage = 7; //Invalid (Do nothing more than move)
m_uiMassiveCrashTimer = 30*IN_MILLISECONDS;
} else m_uiMassiveCrashTimer -= uiDiff;
DoMeleeAttackIfReady();
break;
case 1:
DoCastAOE(SPELL_MASSIVE_CRASH);
m_uiStage = 2;
break;
case 2:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0, true))
{
m_uiTrampleTargetGUID = target->GetGUID();
me->SetTarget(m_uiTrampleTargetGUID);
DoScriptText(SAY_TRAMPLE_STARE, me, target);
m_bTrampleCasted = false;
SetCombatMovement(false);
me->GetMotionMaster()->MoveIdle();
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_uiTrampleTimer = 4*IN_MILLISECONDS;
m_uiStage = 3;
} else m_uiStage = 6;
break;
case 3:
if (m_uiTrampleTimer <= uiDiff)
{
if (Unit* target = Unit::GetPlayer(*me, m_uiTrampleTargetGUID))
{
m_bTrampleCasted = false;
m_bMovementStarted = true;
m_fTrampleTargetX = target->GetPositionX();
m_fTrampleTargetY = target->GetPositionY();
m_fTrampleTargetZ = target->GetPositionZ();
me->GetMotionMaster()->MoveJump(2*me->GetPositionX()-m_fTrampleTargetX,
2*me->GetPositionY()-m_fTrampleTargetY,
me->GetPositionZ(),
10.0f, 20.0f); // 2: Hop Backwards
m_uiStage = 7; //Invalid (Do nothing more than move)
} else m_uiStage = 6;
} else m_uiTrampleTimer -= uiDiff;
break;
case 4:
DoScriptText(SAY_TRAMPLE_START, me);
me->GetMotionMaster()->MoveCharge(m_fTrampleTargetX, m_fTrampleTargetY, m_fTrampleTargetZ+2, 42, 1);
me->SetTarget(0);
m_uiStage = 5;
break;
case 5:
if (m_bMovementFinish)
{
if (m_uiTrampleTimer <= uiDiff) DoCastAOE(SPELL_TRAMPLE);
m_bMovementFinish = false;
m_uiStage = 6;
return;
}
if (m_uiTrampleTimer <= uiDiff)
{
Map::PlayerList const &lPlayers = me->GetMap()->GetPlayers();
for (Map::PlayerList::const_iterator itr = lPlayers.begin(); itr != lPlayers.end(); ++itr)
{
if (Unit* player = itr->getSource())
if (player->isAlive() && player->IsWithinDistInMap(me, 6.0f))
{
DoCastAOE(SPELL_TRAMPLE);
m_uiTrampleTimer = IN_MILLISECONDS;
break;
}
}
} else m_uiTrampleTimer -= uiDiff;
break;
case 6:
if (!m_bTrampleCasted)
{
DoCast(me, SPELL_STAGGERED_DAZE);
DoScriptText(SAY_TRAMPLE_FAIL, me);
}
m_bMovementStarted = false;
me->GetMotionMaster()->MovementExpired();
me->GetMotionMaster()->MoveChase(me->getVictim());
SetCombatMovement(true);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
m_uiStage = 0;
break;
}
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (me->getVictim() && me->isAlive())
{
if (!CombatStart)
{
//At combat Start Mandokir is mounted so we must unmount it first
me->Dismount();
//And summon his raptor
me->SummonCreature(14988, me->getVictim()->GetPositionX(), me->getVictim()->GetPositionY(), me->getVictim()->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 35000);
CombatStart = true;
}
if (Watch_Timer <= diff) //Every 20 Sec Mandokir will check this
{
if (WatchTarget) //If someone is watched and If the Position of the watched target is different from the one stored, or are attacking, mandokir will charge him
{
Unit* unit = Unit::GetUnit(*me, WatchTarget);
if (unit && (
targetX != unit->GetPositionX() ||
targetY != unit->GetPositionY() ||
targetZ != unit->GetPositionZ() ||
unit->isInCombat()))
{
if (me->IsWithinMeleeRange(unit))
{
DoCast(unit, 24316);
}
else
{
DoCast(unit, SPELL_CHARGE);
//me->SendMonsterMove(unit->GetPositionX(), unit->GetPositionY(), unit->GetPositionZ(), 0, true, 1);
AttackStart(unit);
}
}
}
someWatched = false;
Watch_Timer = 20000;
} else Watch_Timer -= diff;
if ((Watch_Timer < 8000) && !someWatched) //8 sec(cast time + expire time) before the check for the watch effect mandokir will cast watch debuff on a random target
{
if (Unit* p = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
DoScriptText(SAY_WATCH, me, p);
DoCast(p, SPELL_WATCH);
WatchTarget = p->GetGUID();
someWatched = true;
endWatch = true;
}
}
if ((Watch_Timer < 1000) && endWatch) //1 sec before the debuf expire, store the target position
{
Unit* unit = Unit::GetUnit(*me, WatchTarget);
if (unit)
{
targetX = unit->GetPositionX();
targetY = unit->GetPositionY();
targetZ = unit->GetPositionZ();
}
endWatch = false;
}
if (!someWatched)
{
//Cleave
if (Cleave_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_CLEAVE);
Cleave_Timer = 7000;
} else Cleave_Timer -= diff;
//Whirlwind
if (Whirlwind_Timer <= diff)
{
DoCast(me, SPELL_WHIRLWIND);
Whirlwind_Timer = 18000;
} else Whirlwind_Timer -= diff;
//If more then 3 targets in melee range mandokir will cast fear
if (Fear_Timer <= diff)
{
TargetInRange = 0;
std::list<HostileReference*>::const_iterator i = me->getThreatManager().getThreatList().begin();
for (; i != me->getThreatManager().getThreatList().end(); ++i)
{
Unit* unit = Unit::GetUnit(*me, (*i)->getUnitGuid());
if (unit && me->IsWithinMeleeRange(unit))
++TargetInRange;
}
if (TargetInRange > 3)
DoCast(me->getVictim(), SPELL_FEAR);
Fear_Timer = 4000;
} else Fear_Timer -=diff;
//Mortal Strike if target below 50% hp
if (me->getVictim() && me->getVictim()->HealthBelowPct(50))
{
if (MortalStrike_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_MORTAL_STRIKE);
MortalStrike_Timer = 15000;
} else MortalStrike_Timer -= diff;
}
}
//Checking if Ohgan is dead. If yes Mandokir will enrage.
if (Check_Timer <= diff)
{
if (instance)
{
if (instance->GetData(DATA_OHGAN) == DONE)
{
if (!RaptorDead)
{
DoCast(me, SPELL_ENRAGE);
RaptorDead = true;
}
}
}
Check_Timer = 1000;
} else Check_Timer -= diff;
DoMeleeAttackIfReady();
}
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_SHIELD:
DoCast(me, SPELL_TIDAL_SHIELD, true);
ResetTimer(45000);
break;
case EVENT_BERSERK:
DoScriptText(SAY_ENRAGE2, me);
DoCast(me, SPELL_BERSERK, true);
events.DelayEvents(15000, GCD_YELL);
break;
case EVENT_SPINE:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target) target = me->getVictim();
if (target)
{
DoCast(target, SPELL_IMPALING_SPINE, true);
SpineTargetGUID = target->GetGUID();
//must let target summon, otherwise you cannot click the spine
target->SummonGameObject(GOBJECT_SPINE, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), me->GetOrientation(), 0, 0, 0, 0, 30);
DoScriptText(urand(0, 1) ? SAY_NEEDLE1 : SAY_NEEDLE2, me);
events.DelayEvents(1500, GCD_CAST);
events.DelayEvents(15000, GCD_YELL);
}
events.ScheduleEvent(EVENT_SPINE, 21000, GCD_CAST);
return;
}
case EVENT_NEEDLE:
{
//DoCast(me, SPELL_NEEDLE_SPINE, true);
std::list<Unit*> targets;
SelectTargetList(targets, 3, SELECT_TARGET_RANDOM, 80, true);
for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)
DoCast(*i, 39835, true);
events.ScheduleEvent(EVENT_NEEDLE, urand(15000, 25000), GCD_CAST);
events.DelayEvents(1500, GCD_CAST);
return;
}
case EVENT_YELL:
DoScriptText(RAND(SAY_SPECIAL1, SAY_SPECIAL2), me);
events.ScheduleEvent(EVENT_YELL, urand(25000, 100000), GCD_YELL);
events.DelayEvents(15000, GCD_YELL);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Check if we have a target
if (!m_creature->SelectHostilTarget() || !m_creature->getVictim())
return;
//No instance
if (!pInstance)
return;
switch (pInstance->GetData(DATA_CTHUN_PHASE))
{
case 0:
{
//BeamTimer
if (BeamTimer < diff)
{
//SPELL_GREEN_BEAM
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target)
{
m_creature->InterruptNonMeleeSpells(false);
DoCast(target,SPELL_GREEN_BEAM);
//Correctly update our target
m_creature->SetUInt64Value(UNIT_FIELD_TARGET, target->GetGUID());
}
//Beam every 3 seconds
BeamTimer = 3000;
}else BeamTimer -= diff;
//ClawTentacleTimer
if (ClawTentacleTimer < diff)
{
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target)
{
Creature* Spawned = NULL;
//Spawn claw tentacle on the random target
Spawned = (Creature*)m_creature->SummonCreature(MOB_CLAW_TENTACLE,target->GetPositionX(),target->GetPositionY(),target->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,500);
if (Spawned)
Spawned->AI()->AttackStart(target);
}
//One claw tentacle every 12.5 seconds
ClawTentacleTimer = 12500;
}else ClawTentacleTimer -= diff;
//EyeTentacleTimer
if (EyeTentacleTimer < diff)
{
//Spawn the 8 Eye Tentacles in the corret spots
SpawnEyeTentacle(0, 20); //south
SpawnEyeTentacle(10, 10); //south west
SpawnEyeTentacle(20, 0); //west
SpawnEyeTentacle(10, -10); //north west
SpawnEyeTentacle(0, -20); //north
SpawnEyeTentacle(-10, -10); //north east
SpawnEyeTentacle(-20, 0); // east
SpawnEyeTentacle(-10, 10); // south east
//No point actually putting a timer here since
//These shouldn't trigger agian until after phase shifts
EyeTentacleTimer = 45000;
}else EyeTentacleTimer -= diff;
//PhaseTimer
if (PhaseTimer < diff)
{
//Switch to Dark Beam
pInstance->SetData(DATA_CTHUN_PHASE, 1);
m_creature->InterruptNonMeleeSpells(false);
//Select random target for dark beam to start on
Unit* target = NULL;
target = SelectUnit(SELECT_TARGET_RANDOM,0);
if (target)
{
//Correctly update our target
m_creature->SetUInt64Value(UNIT_FIELD_TARGET, target->GetGUID());
//Face our target
DarkGlareAngle = m_creature->GetAngle(target);
DarkGlareTickTimer = 1000;
DarkGlareTick = 0;
ClockWise = rand()%2;
}
//Add red coloration to C'thun
DoCast(m_creature,SPELL_RED_COLORATION);
//Freeze animation
//Darkbeam for 35 seconds
PhaseTimer = 35000;
}else PhaseTimer -= diff;
}
break;
case 1:
{
//EyeTentacleTimer
if (DarkGlareTick < 35)
if (DarkGlareTickTimer < diff)
{
//Remove any target
m_creature->SetUInt64Value(UNIT_FIELD_TARGET, 0);
//Set angle and cast
if (ClockWise)
m_creature->SetOrientation(DarkGlareAngle + ((float)DarkGlareTick*PI/35));
else m_creature->SetOrientation(DarkGlareAngle - ((float)DarkGlareTick*PI/35));
m_creature->StopMoving();
//Actual dark glare cast, maybe something missing here?
m_creature->CastSpell(NULL, SPELL_DARK_GLARE, false);
//Increase tick
DarkGlareTick++;
//1 second per tick
DarkGlareTickTimer = 1000;
}else DarkGlareTickTimer -= diff;
//PhaseTimer
if (PhaseTimer < diff)
{
//Switch to Eye Beam
pInstance->SetData(DATA_CTHUN_PHASE, 0);
BeamTimer = 3000;
EyeTentacleTimer = 45000; //Always spawns 5 seconds before Dark Beam
ClawTentacleTimer = 12500; //4 per Eye beam phase (unsure if they spawn durring Dark beam)
m_creature->InterruptNonMeleeSpells(false);
//Remove Red coloration from c'thun
m_creature->RemoveAurasDueToSpell(SPELL_RED_COLORATION);
//Freeze animation
m_creature->SetUInt32Value(UNIT_FIELD_FLAGS, 0);
//Eye Beam for 50 seconds
PhaseTimer = 50000;
}else PhaseTimer -= diff;
}break;
//Transition phase
case 2:
{
//Remove any target
m_creature->SetUInt64Value(UNIT_FIELD_TARGET, 0);
m_creature->SetHealth(0);
}
//Dead phase
case 5:
{
m_creature->DealDamage(m_creature, m_creature->GetMaxHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NONE, NULL, false);
}
}
}
void Spell::AddChainTargets(uint32 i, uint32 TargetType, float r, uint32 maxtargets)
{
if(!m_caster->IsInWorld())
return;
Object* targ = m_caster->GetMapMgr()->_GetObject(m_targets.m_unitTarget);
if(targ == NULL)
return;
//if selected target is party member, then jumps on party
Unit* firstTarget = NULL;
if(targ->IsUnit())
firstTarget = TO_UNIT(targ);
else
firstTarget = u_caster;
bool RaidOnly = false;
float range = GetDBCMaxRange(dbcSpellRange.LookupEntry(m_spellInfo->rangeIndex));//this is probably wrong,
//this is cast distance, not searching distance
range *= range;
//is this party only?
Player* casterFrom = NULL;
if(u_caster->IsPlayer())
casterFrom = TO_PLAYER(u_caster);
Player* pfirstTargetFrom = NULL;
if(firstTarget->IsPlayer())
pfirstTargetFrom = TO_PLAYER(firstTarget);
if(casterFrom != NULL && pfirstTargetFrom != NULL && casterFrom->GetGroup() == pfirstTargetFrom->GetGroup())
RaidOnly = true;
uint32 jumps = m_spellInfo->EffectChainTarget[i];
//range
range /= jumps; //hacky, needs better implementation!
if(m_spellInfo->SpellGroupType && u_caster != NULL)
SM_FIValue(u_caster->SM[SMT_JUMP_REDUCE][0], (int32*)&jumps, m_spellInfo->SpellGroupType);
AddTarget(i, TargetType, firstTarget);
if(jumps <= 1 || ManagedTargets.size() == 0) //1 because we've added the first target, 0 size if spell is resisted
return;
ObjectSet::iterator itr;
for(itr = firstTarget->GetInRangeSetBegin(); itr != firstTarget->GetInRangeSetEnd(); itr++)
{
if(!(*itr)->IsUnit() || !TO_UNIT((*itr))->isAlive())
continue;
if(RaidOnly)
{
if(!(*itr)->IsPlayer())
continue;
if(!pfirstTargetFrom->IsGroupMember(TO_PLAYER(*itr)))
continue;
}
//healing spell, full health target = NONO
if(IsHealingSpell(m_spellInfo) && TO_UNIT(*itr)->GetHealthPct() == 100)
continue;
size_t oldsize;
if(IsInrange(firstTarget->GetPositionX(), firstTarget->GetPositionY(), firstTarget->GetPositionZ(), (*itr), range))
{
oldsize = ManagedTargets.size();
AddTarget(i, TargetType, (*itr));
if(ManagedTargets.size() == oldsize || ManagedTargets.size() >= jumps) //either out of jumps or a resist
return;
}
}
}
void UpdateAI(uint32 diff) override
{
if (TalkTimer)
{
if (!TalkSequence)
{
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE + UNIT_FLAG_NOT_SELECTABLE);
me->InterruptNonMeleeSpells(true);
me->RemoveAllAuras();
me->DeleteThreatList();
me->CombatStop();
++TalkSequence;
}
if (TalkTimer <= diff)
{
if (isFriendly)
GoodEnding();
else
BadEnding();
++TalkSequence;
} else TalkTimer -= diff;
}
else
{
if (bJustReset)
{
if (ResetTimer <= diff)
{
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
me->SetDisableGravity(false);
me->SetVisible(true);
me->SetStandState(UNIT_STAND_STATE_SLEEP);
ResetTimer = 10000;
bJustReset = false;
} else ResetTimer -= diff;
return;
}
if (!UpdateVictim())
return;
if (CheckTimer <= diff)
{
if (me->GetDistance(CENTER_X, CENTER_Y, DRAGON_REALM_Z) >= 75)
{
EnterEvadeMode();
return;
}
if (HealthBelowPct(10) && !isEnraged)
{
if (Creature* Sath = ObjectAccessor::GetCreature(*me, SathGUID))
Sath->AI()->DoAction(DO_ENRAGE);
DoAction(DO_ENRAGE);
}
if (!isBanished && HealthBelowPct(1))
{
if (Creature* Sath = ObjectAccessor::GetCreature(*me, SathGUID))
{
if (Sath->HasAura(SPELL_BANISH))
{
Sath->DealDamage(Sath, Sath->GetHealth());
return;
}
else
DoAction(DO_BANISH);
}
else
{
TC_LOG_ERROR("scripts", "Didn't find Shathrowar. Kalecgos event reseted.");
EnterEvadeMode();
return;
}
}
CheckTimer = 1000;
} else CheckTimer -= diff;
if (ArcaneBuffetTimer <= diff)
{
DoCastAOE(SPELL_ARCANE_BUFFET);
ArcaneBuffetTimer = 8000;
} else ArcaneBuffetTimer -= diff;
if (FrostBreathTimer <= diff)
{
DoCastAOE(SPELL_FROST_BREATH);
FrostBreathTimer = 15000;
} else FrostBreathTimer -= diff;
if (TailLashTimer <= diff)
{
DoCastAOE(SPELL_TAIL_LASH);
TailLashTimer = 15000;
} else TailLashTimer -= diff;
if (WildMagicTimer <= diff)
{
DoCastAOE(WildMagic[rand()%6]);
WildMagicTimer = 20000;
} else WildMagicTimer -= diff;
if (SpectralBlastTimer <= diff)
{
ThreatContainer::StorageType const& m_threatlist = me->getThreatManager().getThreatList();
std::list<Unit*> targetList;
for (ThreatContainer::StorageType::const_iterator itr = m_threatlist.begin(); itr!= m_threatlist.end(); ++itr)
{
Unit* target = (*itr)->getTarget();
if (target
&& target->GetTypeId() == TYPEID_PLAYER
&& (!target->GetVictim() || target->GetGUID() != me->EnsureVictim()->GetGUID())
&& target->GetPositionZ() > me->GetPositionZ() - 5
&& !target->HasAura(AURA_SPECTRAL_EXHAUSTION))
{
targetList.push_back(target);
}
}
if (targetList.empty())
{
SpectralBlastTimer = 1000;
return;
}
std::list<Unit*>::const_iterator i = targetList.begin();
advance(i, rand()%targetList.size());
if ((*i))
{
(*i)->CastSpell((*i), SPELL_SPECTRAL_BLAST, true);
SpectralBlastTimer = 20000+rand()%5000;
} else SpectralBlastTimer = 1000;
} else SpectralBlastTimer -= diff;
DoMeleeAttackIfReady();
}
}
