void UpdateAI(uint32 diff)
{
if (!TankGUID)
{
if (!UpdateVictim())
return;
if (me->GetHealth() < health_20 * (4 - Phase))
EnterPhase(Phase + 1);
}
if (Berserk_Timer <= diff)
{
DoCast(me, SPELL_BERSERK, true);
Talk(YELL_BERSERK);
Berserk_Timer = 60000;
} else Berserk_Timer -= diff;
switch (Phase)
{
case 0:
if (Intro_Timer)
{
if (Intro_Timer <= diff)
{
Talk(YELL_AGGRO);
Intro_Timer = 0;
} else Intro_Timer -= diff;
}
if (Whirlwind_Timer <= diff)
{
DoCast(me, SPELL_WHIRLWIND);
Whirlwind_Timer = urand(15000, 20000);
} else Whirlwind_Timer -= diff;
if (Grievous_Throw_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_GRIEVOUS_THROW, false);
Grievous_Throw_Timer = 10000;
} else Grievous_Throw_Timer -= diff;
break;
case 1:
if (Creeping_Paralysis_Timer <= diff)
{
DoCast(me, SPELL_CREEPING_PARALYSIS);
Creeping_Paralysis_Timer = 20000;
} else Creeping_Paralysis_Timer -= diff;
if (Overpower_Timer <= diff)
{
// implemented in DoMeleeAttackIfReady()
Overpower_Timer = 0;
} else Overpower_Timer -= diff;
break;
case 2:
return;
case 3:
if (Claw_Rage_Timer <= diff)
{
if (!TankGUID)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
TankGUID = me->getVictim()->GetGUID();
me->SetSpeed(MOVE_RUN, 5.0f);
AttackStart(target); // change victim
Claw_Rage_Timer = 0;
Claw_Loop_Timer = 500;
Claw_Counter = 0;
}
}
else if (!Claw_Rage_Timer) // do not do this when Lynx_Rush
{
if (Claw_Loop_Timer <= diff)
{
Unit* target = me->getVictim();
if (!target || !target->isTargetableForAttack()) target = Unit::GetUnit(*me, TankGUID);
if (!target || !target->isTargetableForAttack()) target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
{
AttackStart(target);
if (me->IsWithinMeleeRange(target))
{
DoCast(target, SPELL_CLAW_RAGE_DAMAGE, true);
++Claw_Counter;
if (Claw_Counter == 12)
{
Claw_Rage_Timer = urand(15000, 20000);
me->SetSpeed(MOVE_RUN, 1.2f);
AttackStart(Unit::GetUnit(*me, TankGUID));
TankGUID = 0;
return;
}
else
Claw_Loop_Timer = 500;
}
}
else
{
EnterEvadeMode(); // if (target)
return;
}
} else Claw_Loop_Timer -= diff;
} //if (TankGUID)
} else Claw_Rage_Timer -= diff;
if (Lynx_Rush_Timer <= diff)
{
if (!TankGUID)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
TankGUID = me->getVictim()->GetGUID();
me->SetSpeed(MOVE_RUN, 5.0f);
AttackStart(target); // change victim
Lynx_Rush_Timer = 0;
Claw_Counter = 0;
}
}
else if (!Lynx_Rush_Timer)
{
Unit* target = me->getVictim();
if (!target || !target->isTargetableForAttack())
{
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
AttackStart(target);
}
if (target)
{
if (me->IsWithinMeleeRange(target))
{
DoCast(target, SPELL_LYNX_RUSH_DAMAGE, true);
++Claw_Counter;
if (Claw_Counter == 9)
{
Lynx_Rush_Timer = urand(15000, 20000);
me->SetSpeed(MOVE_RUN, 1.2f);
AttackStart(Unit::GetUnit(*me, TankGUID));
TankGUID = 0;
}
else
AttackStart(SelectTarget(SELECT_TARGET_RANDOM, 0));
}
}
else
{
EnterEvadeMode(); // if (target)
return;
}
} //if (TankGUID)
} else Lynx_Rush_Timer -= diff;
break;
case 4:
if (Flame_Whirl_Timer <= diff)
{
DoCast(me, SPELL_FLAME_WHIRL);
Flame_Whirl_Timer = 12000;
}Flame_Whirl_Timer -= diff;
if (Pillar_Of_Fire_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_SUMMON_PILLAR);
Pillar_Of_Fire_Timer = 10000;
} else Pillar_Of_Fire_Timer -= diff;
if (Flame_Breath_Timer <= diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
me->SetInFront(target);
DoCast(me, SPELL_FLAME_BREATH);
Flame_Breath_Timer = 10000;
} else Flame_Breath_Timer -= diff;
break;
default:
break;
}
if (!TankGUID)
DoMeleeAttackIfReady();
}
boss_chromaggusAI(Creature *c) : ScriptedAI(c)
{
//Select the 2 breaths that we are going to use until despawned
//5 possiblities for the first breath, 4 for the second, 20 total possiblites
//This way we don't end up casting 2 of the same breath
//TL TL would be stupid
switch (urand(0,19))
{
//B1 - Incin
case 0:
Breath1_Spell = SPELL_INCINERATE;
Breath2_Spell = SPELL_TIMELAPSE;
break;
case 1:
Breath1_Spell = SPELL_INCINERATE;
Breath2_Spell = SPELL_CORROSIVEACID;
break;
case 2:
Breath1_Spell = SPELL_INCINERATE;
Breath2_Spell = SPELL_IGNITEFLESH;
break;
case 3:
Breath1_Spell = SPELL_INCINERATE;
Breath2_Spell = SPELL_FROSTBURN;
break;
//B1 - TL
case 4:
Breath1_Spell = SPELL_TIMELAPSE;
Breath2_Spell = SPELL_INCINERATE;
break;
case 5:
Breath1_Spell = SPELL_TIMELAPSE;
Breath2_Spell = SPELL_CORROSIVEACID;
break;
case 6:
Breath1_Spell = SPELL_TIMELAPSE;
Breath2_Spell = SPELL_IGNITEFLESH;
break;
case 7:
Breath1_Spell = SPELL_TIMELAPSE;
Breath2_Spell = SPELL_FROSTBURN;
break;
//B1 - Acid
case 8:
Breath1_Spell = SPELL_CORROSIVEACID;
Breath2_Spell = SPELL_INCINERATE;
break;
case 9:
Breath1_Spell = SPELL_CORROSIVEACID;
Breath2_Spell = SPELL_TIMELAPSE;
break;
case 10:
Breath1_Spell = SPELL_CORROSIVEACID;
Breath2_Spell = SPELL_IGNITEFLESH;
break;
case 11:
Breath1_Spell = SPELL_CORROSIVEACID;
Breath2_Spell = SPELL_FROSTBURN;
break;
//B1 - Ignite
case 12:
Breath1_Spell = SPELL_IGNITEFLESH;
Breath2_Spell = SPELL_INCINERATE;
break;
case 13:
Breath1_Spell = SPELL_IGNITEFLESH;
Breath2_Spell = SPELL_CORROSIVEACID;
break;
case 14:
Breath1_Spell = SPELL_IGNITEFLESH;
Breath2_Spell = SPELL_TIMELAPSE;
break;
case 15:
Breath1_Spell = SPELL_IGNITEFLESH;
Breath2_Spell = SPELL_FROSTBURN;
break;
//B1 - Frost
case 16:
Breath1_Spell = SPELL_FROSTBURN;
Breath2_Spell = SPELL_INCINERATE;
break;
case 17:
Breath1_Spell = SPELL_FROSTBURN;
Breath2_Spell = SPELL_TIMELAPSE;
break;
case 18:
Breath1_Spell = SPELL_FROSTBURN;
Breath2_Spell = SPELL_CORROSIVEACID;
break;
case 19:
Breath1_Spell = SPELL_FROSTBURN;
Breath2_Spell = SPELL_IGNITEFLESH;
break;
};
EnterEvadeMode();
}
void UpdateAI(const uint32 uiDiff) override
{
// so many things are based in this script on instance data
// so if we don't have access to it better do nothing
if (!m_pInstance)
return;
// OOC Intro part triggered by Altar activation
if (m_pInstance->GetData(TYPE_ARCHAEDAS) == SPECIAL)
{
if (m_uiAwakeningTimer <= uiDiff)
{
switch (m_uiSubevent)
{
case 0:
DoCastSpellIfCan(m_creature, SPELL_ARCHAEDAS_AWAKEN_VISUAL);
m_uiAwakeningTimer = 2000;
break;
case 1:
DoScriptText(EMOTE_BREAKS_FREE, m_creature);
m_uiAwakeningTimer = 3000;
break;
case 2:
DoScriptText(SAY_AGGRO, m_creature);
m_creature->RemoveAurasDueToSpell(SPELL_FREEZE_ANIM);
m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
// Attack player
if (Player* pPlayer = m_creature->GetMap()->GetPlayer(m_pInstance->GetGuid(DATA_EVENT_STARTER)))
AttackStart(pPlayer);
else
EnterEvadeMode();
break;
default:
break;
}
++m_uiSubevent;
}
else
m_uiAwakeningTimer -= uiDiff;
}
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
// Phase switch
if (m_creature->GetHealthPercent() < 100.0f - 33.4f * (float)m_uiHpPhaseCheck)
{
if (DoCastSpellIfCan(m_creature, m_uiHpPhaseCheck == 1 ? SPELL_AWAKEN_EARTHEN_GUARDIAN : SPELL_AWAKEN_VAULT_WARDER) == CAST_OK)
{
DoScriptText(m_uiHpPhaseCheck == 1 ? SAY_AWAKE_GUARDIANS : SAY_AWAKE_WARDERS, m_creature);
++m_uiHpPhaseCheck;
}
}
// Awake random Dwarf
if (!m_bDwarvesAwaken && m_creature->GetHealthPercent() >= 33.0f)
{
if (m_uiAwakeDwarfTimer < uiDiff)
{
if (Creature* pEarthen = m_pInstance->GetClosestDwarfNotInCombat(m_creature))
{
if (DoCastSpellIfCan(pEarthen, SPELL_AWAKEN_EARTHEN_DWARF) == CAST_OK)
m_uiAwakeDwarfTimer = urand(9000, 12000);
}
else
m_bDwarvesAwaken = true;
}
else
m_uiAwakeDwarfTimer -= uiDiff;
}
if (m_uiTremorTimer < uiDiff)
{
if (DoCastSpellIfCan(m_creature, SPELL_GROUND_TREMOR) == CAST_OK)
m_uiTremorTimer = urand(8000, 17000);
}
else
m_uiTremorTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!bDone && GrandChampionsOutVehicle(me))
{
bDone = true;
if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_1))
me->SetHomePosition(739.678f, 662.541f, 412.393f, 4.49f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_2))
me->SetHomePosition(746.71f, 661.02f, 411.69f, 4.6f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_3))
me->SetHomePosition(754.34f, 660.70f, 412.39f, 4.79f);
EnterEvadeMode();
bHome = true;
}
if (uiPhaseTimer <= uiDiff)
{
if (uiPhase == 1)
{
AggroAllPlayers(me);
uiPhase = 0;
}
}else uiPhaseTimer -= uiDiff;
if (!UpdateVictim() || me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT))
return;
if (uiInterceptTimer <= uiDiff)
{
Map::PlayerList const& players = me->GetMap()->GetPlayers();
if (me->GetMap()->IsDungeon() && !players.isEmpty())
{
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = itr->getSource();
if (player && !player->isGameMaster() && me->IsInRange(player, 8.0f, 25.0f, false))
{
DoResetThreat();
me->AddThreat(player, 5.0f);
DoCast(player, SPELL_INTERCEPT);
break;
}
}
}
uiInterceptTimer = 7000;
} else uiInterceptTimer -= uiDiff;
if (uiBladeStormTimer <= uiDiff)
{
DoCastVictim(SPELL_BLADESTORM);
uiBladeStormTimer = urand(15000, 20000);
} else uiBladeStormTimer -= uiDiff;
if (uiMortalStrikeTimer <= uiDiff)
{
DoCastVictim(SPELL_MORTAL_STRIKE);
uiMortalStrikeTimer = urand(8000, 12000);
} else uiMortalStrikeTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 uiDiff)
{
if (!bDone && GrandChampionsOutVehicle(me))
{
bDone = true;
if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_1))
me->SetHomePosition(739.678f, 662.541f, 412.393f, 4.49f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_2))
me->SetHomePosition(746.71f, 661.02f, 411.69f, 4.6f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_3))
me->SetHomePosition(754.34f, 660.70f, 412.39f, 4.79f);
if (pInstance)
pInstance->SetData(BOSS_GRAND_CHAMPIONS, IN_PROGRESS);
EnterEvadeMode();
bHome = true;
}
if (uiPhaseTimer <= uiDiff)
{
if (uiPhase == 1)
{
AggroAllPlayers(me);
uiPhase = 0;
}
}else uiPhaseTimer -= uiDiff;
if (!UpdateVictim() || me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT))
return;
if (uiChainLightningTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_CHAIN_LIGHTNING);
uiChainLightningTimer = 16000;
} else uiChainLightningTimer -= uiDiff;
if (uiHealingWaveTimer <= uiDiff)
{
bool bChance = urand(0, 1);
if (!bChance)
{
if (Unit* pFriend = DoSelectLowestHpFriendly(40))
DoCast(pFriend, SPELL_HEALING_WAVE);
} else
DoCast(me, SPELL_HEALING_WAVE);
uiHealingWaveTimer = 12000;
} else uiHealingWaveTimer -= uiDiff;
if (uiEartShieldTimer <= uiDiff)
{
DoCast(me, SPELL_EARTH_SHIELD);
uiEartShieldTimer = urand(30000, 35000);
} else uiEartShieldTimer -= uiDiff;
if (uiHexMendingTimer <= uiDiff)
{
DoCastVictim(SPELL_HEX_OF_MENDING, true);
uiHexMendingTimer = urand(20000, 25000);
} else uiHexMendingTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff)
{
if (me->IsVisible() && !_movementStarted)
{
_movementStarted = true;
_wpReached = true;
_events.ScheduleEvent(EVENT_CLOUD, urand(5, 10) *IN_MILLISECONDS);
_events.ScheduleEvent(EVENT_LEECH, urand(7, 12) *IN_MILLISECONDS);
_events.ScheduleEvent(EVENT_UNSTUCK, 3*IN_MILLISECONDS);
_events.ScheduleEvent(EVENT_SPAWN, 1*IN_MILLISECONDS);
}
if (_wpReached)
{
_wpReached = false;
if (me->isInCombat())
{
me->SetReactState(REACT_AGGRESSIVE);
_events.ScheduleEvent(EVENT_FORCEMOVE, urand(7, 10) *IN_MILLISECONDS);
}
else
me->GetMotionMaster()->MovePoint(_wpCount, HadronoxWaypoints[_wpCount]);
}
if (!UpdateVictim() && _engaged)
return;
_events.Update(diff);
if (me->HasUnitState(UNIT_STATE_CASTING))
return;
while (uint32 eventId = _events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_CLOUD:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 60, false))
DoCast(target, DUNGEON_MODE(SPELL_ACID_CLOUD, H_SPELL_ACID_CLOUD));
_events.ScheduleEvent(EVENT_CLOUD, urand(25, 35) *IN_MILLISECONDS);
break;
case EVENT_LEECH:
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 20, false))
DoCast(target, DUNGEON_MODE(SPELL_LEECH_POISON, H_SPELL_LEECH_POISON));
_events.ScheduleEvent(EVENT_LEECH, urand(10, 20) *IN_MILLISECONDS);
break;
case EVENT_PIECRE:
DoCastVictim(SPELL_PIERCE_ARMOR);
_events.ScheduleEvent(EVENT_PIECRE, urand(15, 20) *IN_MILLISECONDS);
break;
case EVENT_GRAB:
DoCast(me, DUNGEON_MODE(SPELL_WEB_GRAB, H_SPELL_WEB_GRAB));
DoCast(me, DUNGEON_MODE(SPELL_ACID_CLOUD, H_SPELL_ACID_CLOUD));
_events.ScheduleEvent(EVENT_GRAB, urand(17, 23) *IN_MILLISECONDS);
break;
case EVENT_SPAWN:
me->SummonCreature(RAND(NPC_ADD_CHAMPION, NPC_ADD_CRYPT_FIEND, NPC_ADD_NECROMANCER), AddWaypoints[0]);
_events.ScheduleEvent(EVENT_SPAWN, urand(1500, 3000));
break;
case EVENT_FORCEMOVE:
me->SetReactState(REACT_PASSIVE);
me->GetMotionMaster()->MovePoint(_wpCount, HadronoxWaypoints[_wpCount]);
break;
case EVENT_UNSTUCK:
if (me->getVictim())
if (me->IsWithinCombatRange(me->getVictim(), 10.0f) && !me->IsWithinLOSInMap(me->getVictim()))
me->GetMotionMaster()->MoveJump(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ() + 10.0f, 1.0f, 1.0f);
if (_engaged)
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 150.0f, true);
if (!target)
EnterEvadeMode();
}
_events.ScheduleEvent(EVENT_UNSTUCK, 3*IN_MILLISECONDS);
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!bHasAura)
{
switch (me->GetEntry())
{
case NPC_NORTH_MARSHAL:
DoCast(me, SPELL_NORTH_MARSHAL);
break;
case NPC_SOUTH_MARSHAL:
DoCast(me, SPELL_SOUTH_MARSHAL);
break;
case NPC_STONEHEARTH_MARSHAL:
DoCast(me, SPELL_STONEHEARTH_MARSHAL);
break;
case NPC_ICEWING_MARSHAL:
DoCast(me, SPELL_ICEWING_MARSHAL);
break;
case NPC_EAST_FROSTWOLF_WARMASTER:
DoCast(me, SPELL_EAST_FROSTWOLF_WARMASTER);
break;
case NPC_WEST_FROSTWOLF_WARMASTER:
DoCast(me, SPELL_WEST_FROSTWOLF_WARMASTER);
break;
case NPC_ICEBLOOD_WARMASTER:
DoCast(me, SPELL_ICEBLOOD_WARMASTER);
break;
case NPC_TOWER_POINT_WARMASTER:
DoCast(me, SPELL_TOWER_POINT_WARMASTER);
break;
}
bHasAura = true;
}
if (!UpdateVictim())
return;
if (uiChargeTimer <= diff)
{
DoCastVictim( SPELL_CHARGE);
uiChargeTimer = urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS);
}
else uiChargeTimer -= diff;
if (uiCleaveTimer <= diff)
{
DoCastVictim( SPELL_CLEAVE);
uiCleaveTimer = urand(10 * IN_MILLISECONDS, 16 * IN_MILLISECONDS);
}
else uiCleaveTimer -= diff;
if (uiDemoralizingShoutTimer <= diff)
{
DoCastVictim( SPELL_DEMORALIZING_SHOUT);
uiDemoralizingShoutTimer = urand(10 * IN_MILLISECONDS, 15 * IN_MILLISECONDS);
}
else uiDemoralizingShoutTimer -= diff;
if (uiWhirlwind1Timer <= diff)
{
DoCastVictim( SPELL_WHIRLWIND1);
uiWhirlwind1Timer = urand(6 * IN_MILLISECONDS, 20 * IN_MILLISECONDS);
}
else uiWhirlwind1Timer -= diff;
if (uiWhirlwind2Timer <= diff)
{
DoCastVictim( SPELL_WHIRLWIND2);
uiWhirlwind2Timer = urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS);
}
else uiWhirlwind2Timer -= diff;
if (uiEnrageTimer <= diff)
{
DoCastVictim( SPELL_ENRAGE);
uiEnrageTimer = urand(10 * IN_MILLISECONDS, 30 * IN_MILLISECONDS);
}
else uiEnrageTimer -= diff;
// check if creature is not outside of building
if (uiResetTimer <= diff)
{
if (me->GetDistance2d(me->GetHomePosition().GetPositionX(), me->GetHomePosition().GetPositionY()) > 50)
EnterEvadeMode();
uiResetTimer = 5 * IN_MILLISECONDS;
}
else uiResetTimer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && instance && instance->GetData(DATA_KARATHRESSEVENT))
{
Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_KARATHRESSEVENT_STARTER));
if (target)
{
AttackStart(target);
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (instance && !instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//WaterBoltVolley_Timer
if (WaterBoltVolley_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_WATER_BOLT_VOLLEY);
WaterBoltVolley_Timer = 30000;
} else WaterBoltVolley_Timer -= diff;
//TidalSurge_Timer
if (TidalSurge_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_TIDAL_SURGE);
// Hacky way to do it - won't trigger elseways
me->getVictim()->CastSpell(me->getVictim(), SPELL_TIDAL_SURGE_FREEZE, true);
TidalSurge_Timer = 15000+rand()%5000;
} else TidalSurge_Timer -= diff;
//Cyclone_Timer
if (Cyclone_Timer <= diff)
{
//DoCast(me, SPELL_SUMMON_CYCLONE); // Doesn't work
Cyclone_Timer = 30000+rand()%10000;
Creature* Cyclone = me->SummonCreature(CREATURE_CYCLONE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), float(rand()%5), TEMPSUMMON_TIMED_DESPAWN, 15000);
if (Cyclone)
{
CAST_CRE(Cyclone)->SetObjectScale(3.0f);
Cyclone->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
Cyclone->setFaction(me->getFaction());
Cyclone->CastSpell(Cyclone, SPELL_CYCLONE_CYCLONE, true);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (target)
{
Cyclone->AI()->AttackStart(target);
}
}
} else Cyclone_Timer -= diff;
//Heal_Timer
if (Heal_Timer <= diff)
{
// It can be cast on any of the mobs
Unit* unit = NULL;
while (unit == NULL || !unit->isAlive())
{
unit = selectAdvisorUnit();
}
if (unit && unit->isAlive())
DoCast(unit, SPELL_HEAL);
Heal_Timer = 60000;
} else Heal_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (m_checkTimer < diff)
{
if (me->IsWithinDistInMap(&wLoc, 100.0f))
DoZoneInCombat();
else
{
EnterEvadeMode();
return;
}
me->SetSpeed(MOVE_RUN, 2.0);
uint32 damage = 0;
SharedRule(damage);
m_checkTimer = 1000;
}
else
m_checkTimer -= diff;
if (m_blessingTimer < diff)
{
if (Unit *pUnit = SelectCouncil())
{
AddSpellToCast(pUnit, RAND(SPELL_BLESS_SPELLWARD, SPELL_BLESS_PROTECTION));
m_blessingTimer = RAND(urand(15000, 20000), urand(25000, 35000));
}
}
else
m_blessingTimer -= diff;
if (m_consecrationTimer < diff)
{
AddSpellToCast(me, SPELL_CONSECRATION);
m_consecrationTimer = urand(30000, 35000);
}
else
m_consecrationTimer -= diff;
if (m_hammerTimer < diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 40, true, 0, 10.0f))
{
AddSpellToCast(pTarget, SPELL_HAMMER_OF_JUSTICE);
m_hammerTimer = urand(10000, 20000);
}
}
else
m_hammerTimer -= diff;
if (m_sealTimer < diff)
{
AddSpellToCast(me, RAND(SPELL_SEAL_OF_COMMAND, SPELL_SEAL_OF_BLOOD));
m_sealTimer = urand(17000, 20000);
}
else
m_sealTimer -= diff;
if (m_judgementTimer < diff)
{
RegenMana();
ForceSpellCast(me->getVictim(), SPELL_GATHIOS_JUDGEMENT, INTERRUPT_AND_CAST);
m_judgementTimer = 15000;
}
else
m_judgementTimer -= diff;
if (m_auraTimer < diff)
{
AddSpellToCast(RAND(SPELL_DEVOTION_AURA, SPELL_CHROMATIC_AURA), CAST_SELF);
m_auraTimer = 60000;
}
else
m_auraTimer -= diff;
DoMeleeAttackIfReady();
CastNextSpellIfAnyAndReady();
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && instance && instance->GetData(DATA_KARATHRESSEVENT))
{
Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_KARATHRESSEVENT_STARTER));
if (target)
{
AttackStart(target);
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (instance && !instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//LeechingThrow_Timer
if (LeechingThrow_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_LEECHING_THROW);
LeechingThrow_Timer = 20000;
} else LeechingThrow_Timer -= diff;
//Multishot_Timer
if (Multishot_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_MULTISHOT);
Multishot_Timer = 20000;
} else Multishot_Timer -= diff;
//TheBeastWithin_Timer
if (TheBeastWithin_Timer <= diff)
{
DoCast(me, SPELL_THE_BEAST_WITHIN);
Creature* Pet = Unit::GetCreature(*me, SummonedPet);
if (Pet && Pet->isAlive())
{
Pet->CastSpell(Pet, SPELL_PET_ENRAGE, true);
}
TheBeastWithin_Timer = 30000;
} else TheBeastWithin_Timer -= diff;
//Pet_Timer
if (Pet_Timer < diff && pet == false)
{
pet = true;
//uint32 spell_id;
uint32 pet_id;
if (!urand(0, 1))
{
//spell_id = SPELL_SUMMON_FATHOM_LURKER;
pet_id = CREATURE_FATHOM_LURKER;
}
else
{
//spell_id = SPELL_SUMMON_FATHOM_SPOREBAT;
pet_id = CREATURE_FATHOM_SPOREBAT;
}
//DoCast(me, spell_id, true);
Creature* Pet = DoSpawnCreature(pet_id, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000);
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);
if (Pet && target)
{
Pet->AI()->AttackStart(target);
SummonedPet = Pet->GetGUID();
}
} else Pet_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && instance && instance->GetData(DATA_KARATHRESSEVENT))
{
Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_KARATHRESSEVENT_STARTER));
if (target)
{
AttackStart(target);
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (instance && !instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
if (!me->HasAura(SPELL_WINDFURY_WEAPON))
{
DoCast(me, SPELL_WINDFURY_WEAPON);
}
//FrostShock_Timer
if (FrostShock_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_FROST_SHOCK);
FrostShock_Timer = 25000+rand()%5000;
} else FrostShock_Timer -= diff;
//Spitfire_Timer
if (Spitfire_Timer <= diff)
{
DoCast(me, SPELL_SPITFIRE_TOTEM);
Unit* SpitfireTotem = Unit::GetUnit(*me, CREATURE_SPITFIRE_TOTEM);
if (SpitfireTotem)
{
CAST_CRE(SpitfireTotem)->AI()->AttackStart(me->getVictim());
}
Spitfire_Timer = 60000;
} else Spitfire_Timer -= diff;
//PoisonCleansing_Timer
if (PoisonCleansing_Timer <= diff)
{
DoCast(me, SPELL_POISON_CLEANSING_TOTEM);
PoisonCleansing_Timer = 30000;
} else PoisonCleansing_Timer -= diff;
//Earthbind_Timer
if (Earthbind_Timer <= diff)
{
DoCast(me, SPELL_EARTHBIND_TOTEM);
Earthbind_Timer = 45000;
} else Earthbind_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && instance && instance->GetData(DATA_KARATHRESSEVENT))
{
Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_KARATHRESSEVENT_STARTER));
if (target)
{
AttackStart(target);
GetAdvisors();
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (instance && !instance->GetData(DATA_KARATHRESSEVENT))
{
EnterEvadeMode();
return;
}
//CataclysmicBolt_Timer
if (CataclysmicBolt_Timer <= diff)
{
//select a random unit other than the main tank
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
//if there aren't other units, cast on the tank
if (!target)
target = me->getVictim();
if (target)
DoCast(target, SPELL_CATACLYSMIC_BOLT);
CataclysmicBolt_Timer = 10000;
} else CataclysmicBolt_Timer -= diff;
//SearNova_Timer
if (SearNova_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_SEAR_NOVA);
SearNova_Timer = 20000+rand()%40000;
} else SearNova_Timer -= diff;
//Enrage_Timer
if (Enrage_Timer <= diff)
{
DoCast(me, SPELL_ENRAGE);
Enrage_Timer = 90000;
} else Enrage_Timer -= diff;
//Blessing of Tides Trigger
if (!HealthAbovePct(75) && !BlessingOfTides)
{
BlessingOfTides = true;
bool continueTriggering = false;
Creature* Advisor;
for (uint8 i = 0; i < MAX_ADVISORS; ++i)
if (Advisors[i])
{
Advisor = (Unit::GetCreature(*me, Advisors[i]));
if (Advisor && Advisor->isAlive())
{
continueTriggering = true;
break;
}
}
if (continueTriggering)
{
DoCast(me, SPELL_BLESSING_OF_THE_TIDES);
me->MonsterYell(SAY_GAIN_BLESSING_OF_TIDES, LANG_UNIVERSAL, 0);
DoPlaySoundToSet(me, SOUND_GAIN_BLESSING_OF_TIDES);
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
if (instance && !instance->GetData(TYPE_MOROES))
{
EnterEvadeMode();
return;
}
if (!Enrage && HealthBelowPct(30))
{
DoCast(me, SPELL_FRENZY);
Enrage = true;
}
if (CheckAdds_Timer <= diff)
{
for (uint8 i = 0; i < 4; ++i)
{
if (AddGUID[i])
{
Creature* temp = Unit::GetCreature((*me), AddGUID[i]);
if (temp && temp->IsAlive())
if (!temp->GetVictim())
temp->AI()->AttackStart(me->GetVictim());
}
}
CheckAdds_Timer = 5000;
} else CheckAdds_Timer -= diff;
if (!Enrage)
{
//Cast Vanish, then Garrote random victim
if (Vanish_Timer <= diff)
{
DoCast(me, SPELL_VANISH);
InVanish = true;
Vanish_Timer = 30000;
Wait_Timer = 5000;
} else Vanish_Timer -= diff;
if (Gouge_Timer <= diff)
{
DoCastVictim(SPELL_GOUGE);
Gouge_Timer = 40000;
} else Gouge_Timer -= diff;
if (Blind_Timer <= diff)
{
std::list<Unit*> targets;
SelectTargetList(targets, 5, SELECT_TARGET_RANDOM, me->GetMeleeReach()*5, true);
for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)
if (!me->IsWithinMeleeRange(*i))
{
DoCast(*i, SPELL_BLIND);
break;
}
Blind_Timer = 40000;
} else Blind_Timer -= diff;
}
if (InVanish)
{
if (Wait_Timer <= diff)
{
Talk(SAY_SPECIAL);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
target->CastSpell(target, SPELL_GARROTE, true);
InVanish = false;
} else Wait_Timer -= diff;
}
if (!InVanish)
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (StormCount)
{
Unit *pTarget = Unit::GetUnit(*me, CloudGUID);
if (!pTarget || !pTarget->isAlive())
{
EnterEvadeMode();
return;
}
else if (Unit* Cyclone = Unit::GetUnit(*me, CycloneGUID))
Cyclone->CastSpell(pTarget, 25160, true); // keep casting or...
if (StormSequenceTimer <= diff)
HandleStormSequence(pTarget);
else
StormSequenceTimer -= diff;
return;
}
if (Enrage_Timer <= diff)
{
me->MonsterYell(SAY_ONENRAGE, LANG_UNIVERSAL, NULL);
DoPlaySoundToSet(me, SOUND_ONENRAGE);
DoCast(me, SPELL_BERSERK, true);
Enrage_Timer = 600000;
} else Enrage_Timer -= diff;
if (StaticDisruption_Timer <= diff)
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
if (!pTarget) pTarget = me->getVictim();
TargetGUID = pTarget->GetGUID();
DoCast(pTarget, SPELL_STATIC_DISRUPTION, false);
me->SetInFront(me->getVictim());
StaticDisruption_Timer = (10+rand()%8)*1000; // < 20s
/*if (float dist = me->IsWithinDist3d(pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 5.0f) dist = 5.0f;
SDisruptAOEVisual_Timer = 1000 + floor(dist / 30 * 1000.0f);*/
} else StaticDisruption_Timer -= diff;
if (GustOfWind_Timer <= diff)
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
if (!pTarget) pTarget = me->getVictim();
DoCast(pTarget, SPELL_GUST_OF_WIND);
GustOfWind_Timer = (20+rand()%10)*1000; //20 to 30 seconds(bosskillers)
} else GustOfWind_Timer -= diff;
if (CallLighting_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_CALL_LIGHTNING);
CallLighting_Timer = (12 + rand()%5)*1000; //totaly random timer. can't find any info on this
} else CallLighting_Timer -= diff;
if (!isRaining && ElectricalStorm_Timer < uint32(8000 + rand() % 5000))
{
SetWeather(WEATHER_STATE_HEAVY_RAIN, 0.9999f);
isRaining = true;
}
if (ElectricalStorm_Timer <= diff) {
Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true);
if (!pTarget)
{
EnterEvadeMode();
return;
}
pTarget->CastSpell(pTarget, 44007, true);//cloud visual
DoCast(pTarget, SPELL_ELECTRICAL_STORM, false);//storm cyclon + visual
float x,y,z;
pTarget->GetPosition(x,y,z);
if (pTarget)
{
pTarget->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING);
pTarget->SendMonsterMove(x,y,me->GetPositionZ()+15,0);
}
Unit *Cloud = me->SummonTrigger(x, y, me->GetPositionZ()+16, 0, 15000);
if (Cloud)
{
CloudGUID = Cloud->GetGUID();
Cloud->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING);
Cloud->StopMoving();
Cloud->SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
Cloud->setFaction(35);
Cloud->SetMaxHealth(9999999);
Cloud->SetHealth(9999999);
Cloud->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
ElectricalStorm_Timer = 60000; //60 seconds(bosskillers)
StormCount = 1;
StormSequenceTimer = 0;
} else ElectricalStorm_Timer -= diff;
if (SummonEagles_Timer <= diff)
{
me->MonsterYell(SAY_ONSUMMON, LANG_UNIVERSAL, NULL);
DoPlaySoundToSet(me, SOUND_ONSUMMON);
float x, y, z;
me->GetPosition(x, y, z);
for (uint8 i = 0; i < 8; ++i)
{
Unit* bird = Unit::GetUnit(*me,BirdGUIDs[i]);
if (!bird) //they despawned on die
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
{
x = pTarget->GetPositionX() + irand(-10,10);
y = pTarget->GetPositionY() + irand(-10,10);
z = pTarget->GetPositionZ() + urand(16,20);
if (z > 95)
z = 95.0f - urand(0,5);
}
Creature *pCreature = me->SummonCreature(MOB_SOARING_EAGLE, x, y, z, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
if (pCreature)
{
pCreature->AddThreat(me->getVictim(), 1.0f);
pCreature->AI()->AttackStart(me->getVictim());
BirdGUIDs[i] = pCreature->GetGUID();
}
}
}
SummonEagles_Timer = 999999;
} else SummonEagles_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && pInstance && pInstance->GetData(DATA_MAULGAREVENT))
{
Unit *pTarget = Unit::GetUnit((*me), pInstance->GetData64(DATA_MAULGAREVENT_TANK));
if (pTarget)
{
AttackStart(pTarget);
GetCouncil();
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (pInstance && !pInstance->GetData(DATA_MAULGAREVENT))
{
EnterEvadeMode();
return;
}
//ArcingSmash_Timer
if (ArcingSmash_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_ARCING_SMASH);
ArcingSmash_Timer = 10000;
} else ArcingSmash_Timer -= diff;
//Whirlwind_Timer
if (Whirlwind_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_WHIRLWIND);
Whirlwind_Timer = 55000;
} else Whirlwind_Timer -= diff;
//MightyBlow_Timer
if (MightyBlow_Timer <= diff)
{
DoCast(me->getVictim(), SPELL_MIGHTY_BLOW);
MightyBlow_Timer = 30000+rand()%10000;
} else MightyBlow_Timer -= diff;
//Entering Phase 2
if (!Phase2 && HealthBelowPct(50))
{
Phase2 = true;
DoScriptText(SAY_ENRAGE, me);
DoCast(me, SPELL_DUAL_WIELD, true);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, 0);
me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID+1, 0);
}
if (Phase2)
{
//Charging_Timer
if (Charging_Timer <= diff)
{
Unit *pTarget = NULL;
pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (pTarget)
{
AttackStart(pTarget);
DoCast(pTarget, SPELL_BERSERKER_C);
}
Charging_Timer = 20000;
} else Charging_Timer -= diff;
//Intimidating Roar
if (Roar_Timer <= diff)
{
DoCast(me, SPELL_ROAR);
Roar_Timer = 40000+(rand()%10000);
} else Roar_Timer -= diff;
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (m_checkTimer < diff)
{
if (me->IsWithinDistInMap(&wLoc, 100.0f))
DoZoneInCombat();
else
{
EnterEvadeMode();
return;
}
if (me->GetDistance2d(me->getVictim()) <= 40.0f)
me->GetMotionMaster()->MoveIdle();
else
me->GetMotionMaster()->MoveChase(me->getVictim(), 40);
// On front stairs, do not let boss to go into textures;
//CheckStairsPos();
uint32 damage = 0;
SharedRule(damage);
me->SetSpeed(MOVE_RUN, 2.0);
m_checkTimer = 1000;
}
else
m_checkTimer -= diff;
if (m_immunityTimer < diff)
{
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_INTERRUPT, false);
m_immunityTimer = 60000;
}
else
m_immunityTimer -= diff;
if (m_dampenTimer < diff)
{
ForceSpellCast(me, SPELL_DAMPEN_MAGIC);
m_dampenTimer = 67200; // almost 1,12 minutes (??)
}
else
m_dampenTimer -= diff;
if (m_blizzardTimer < diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 200, true))
{
AddSpellToCast(pTarget, SPELL_BLIZZARD, true);
m_blizzardTimer = urand(12000, 17000);
}
}
else
m_blizzardTimer -= diff;
if (m_flamestrikeTimer < diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 200, true))
{
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_INTERRUPT, true);
AddSpellToCast(pTarget, SPELL_FLAMESTRIKE);
m_flamestrikeTimer = 12000;
m_immunityTimer = 3000;
}
}
else
m_flamestrikeTimer -= diff;
if (m_aexpTimer < diff)
{
std::list<HostilReference*>& m_threatlist = me->getThreatManager().getThreatList();
for (std::list<HostilReference*>::iterator i = m_threatlist.begin(); i!= m_threatlist.end();++i)
{
if (Unit* pUnit = Unit::GetUnit((*me), (*i)->getUnitGuid()))
{
if (pUnit->IsWithinDistInMap(me, 5) && pUnit->GetTypeId() == TYPEID_PLAYER && pUnit->isAlive() && !pUnit->IsImmunedToDamage(SPELL_SCHOOL_MASK_ARCANE))
{
ForceSpellCast(SPELL_ARCANE_EXPLOSION, CAST_SELF);
m_aexpTimer = 3000;
break;
}
else
m_aexpTimer = 1000;
}
}
}
else
m_aexpTimer -= diff;
CastNextSpellIfAnyAndReady(diff);
}
void UpdateAI(const uint32 diff)
{
//Only if not incombat check if the event is started
if (!me->isInCombat() && pInstance && pInstance->GetData(DATA_MAULGAREVENT))
{
Unit *pTarget = Unit::GetUnit((*me), pInstance->GetData64(DATA_MAULGAREVENT_TANK));
if (pTarget)
{
AttackStart(pTarget);
}
}
//Return since we have no target
if (!UpdateVictim())
return;
//someone evaded!
if (pInstance && !pInstance->GetData(DATA_MAULGAREVENT))
{
EnterEvadeMode();
return;
}
//GreaterFireball_Timer
if (GreaterFireball_Timer < diff || me->IsWithinDist(me->getVictim(), 30))
{
DoCast(me->getVictim(), SPELL_GREATER_FIREBALL);
GreaterFireball_Timer = 2000;
} else GreaterFireball_Timer -= diff;
//SpellShield_Timer
if (SpellShield_Timer <= diff)
{
me->InterruptNonMeleeSpells(false);
DoCast(me->getVictim(), SPELL_SPELLSHIELD);
SpellShield_Timer = 30000;
} else SpellShield_Timer -= diff;
//BlastWave_Timer
if (BlastWave_Timer <= diff)
{
Unit *pTarget = NULL;
std::list<HostileReference *> t_list = me->getThreatManager().getThreatList();
std::vector<Unit *> target_list;
for (std::list<HostileReference *>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
pTarget = Unit::GetUnit(*me, (*itr)->getUnitGuid());
//15 yard radius minimum
if (pTarget && pTarget->IsWithinDist(me, 15, false))
target_list.push_back(pTarget);
pTarget = NULL;
}
if (target_list.size())
pTarget = *(target_list.begin()+rand()%target_list.size());
me->InterruptNonMeleeSpells(false);
DoCast(pTarget, SPELL_BLAST_WAVE);
BlastWave_Timer = 60000;
} else BlastWave_Timer -= diff;
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (m_checkTimer < diff)
{
if (me->IsWithinDistInMap(&wLoc, 100.0f))
DoZoneInCombat();
else
{
EnterEvadeMode();
return;
}
uint32 damage = 0;
SharedRule(damage);
me->SetSpeed(MOVE_RUN, 2.0);
m_checkTimer = 1000;
}
else
m_checkTimer -= diff;
if (m_smiteTimer < diff)
{
AddSpellToCast(me->getVictim(), SPELL_EMPOWERED_SMITE, false, true);
m_smiteTimer = urand(5000, 9000);
}
else
m_smiteTimer -= diff;
if (m_cohTimer < diff)
{
AddSpellToCast(me, SPELL_CIRCLE_OF_HEALING);
m_cohTimer = urand(19000, 23000);
}
else
m_cohTimer -= diff;
if (m_wrathTimer < diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 100, true))
{
AddSpellToCast(pTarget, SPELL_DIVINE_WRATH, false, true);
m_wrathTimer = urand(15000, 30000);
}
}
else
m_wrathTimer -= diff;
if (m_shieldTimer < diff)
{
AddSpellToCast(me, SPELL_REFLECTIVE_SHIELD);
m_shieldTimer = urand(40000, 55000);
}
else
m_shieldTimer -= diff;
CastNextSpellIfAnyAndReady();
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (ResetTimer <= diff)
{
if (me->IsWithinDist3d(119.223f, 1035.45f, 29.4481f, 10))
{
EnterEvadeMode();
return;
}
ResetTimer = 5000;
} else ResetTimer -= diff;
if (CheckAddState_Timer <= diff)
{
for (uint8 i = 0; i < 4; ++i)
if (Creature *pTemp = Unit::GetCreature(*me, AddGUID[i]))
if (pTemp->isAlive() && !pTemp->getVictim())
pTemp->AI()->AttackStart(me->getVictim());
CheckAddState_Timer = 5000;
} else CheckAddState_Timer -= diff;
if (DrainPower_Timer <= diff)
{
DoCast(me, SPELL_DRAIN_POWER, true);
me->MonsterYell(YELL_DRAIN_POWER, LANG_UNIVERSAL, NULL);
DoPlaySoundToSet(me, SOUND_YELL_DRAIN_POWER);
DrainPower_Timer = urand(40000, 55000); // must cast in 60 sec, or buff/debuff will disappear
} else DrainPower_Timer -= diff;
if (SpiritBolts_Timer <= diff)
{
if (DrainPower_Timer < 12000) // channel 10 sec
SpiritBolts_Timer = 13000; // cast drain power first
else
{
DoCast(me, SPELL_SPIRIT_BOLTS, false);
me->MonsterYell(YELL_SPIRIT_BOLTS, LANG_UNIVERSAL, NULL);
DoPlaySoundToSet(me, SOUND_YELL_SPIRIT_BOLTS);
SpiritBolts_Timer = 40000;
SiphonSoul_Timer = 10000; // ready to drain
PlayerAbility_Timer = 99999;
}
} else SpiritBolts_Timer -= diff;
if (SiphonSoul_Timer <= diff)
{
Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 70, true);
Unit *trigger = DoSpawnCreature(MOB_TEMP_TRIGGER, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN, 30000);
if (!pTarget || !trigger)
{
EnterEvadeMode();
return;
}
else
{
trigger->SetDisplayId(11686);
trigger->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
trigger->CastSpell(pTarget, SPELL_SIPHON_SOUL, true);
trigger->GetMotionMaster()->MoveChase(me);
//DoCast(pTarget, SPELL_SIPHON_SOUL, true);
//me->SetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT, pTarget->GetGUID());
//me->SetUInt32Value(UNIT_CHANNEL_SPELL, SPELL_SIPHON_SOUL);
PlayerGUID = pTarget->GetGUID();
PlayerAbility_Timer = urand(8000, 10000);
PlayerClass = pTarget->getClass() - 1;
if (PlayerClass == CLASS_DRUID-1)
PlayerClass = CLASS_DRUID;
else if (PlayerClass == CLASS_PRIEST-1 && pTarget->HasSpell(15473))
PlayerClass = CLASS_PRIEST; // shadow priest
SiphonSoul_Timer = 99999; // buff lasts 30 sec
}
} else SiphonSoul_Timer -= diff;
if (PlayerAbility_Timer <= diff)
{
//Unit *pTarget = Unit::GetUnit(*me, PlayerGUID);
//if (pTarget && pTarget->isAlive())
//{
UseAbility();
PlayerAbility_Timer = urand(8000, 10000);
//}
} else PlayerAbility_Timer -= diff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (m_checkTimer < diff)
{
if (me->IsWithinDistInMap(&wLoc, 100.0f))
DoZoneInCombat();
else
{
EnterEvadeMode();
return;
}
uint32 damage = 0;
SharedRule(damage);
me->SetSpeed(MOVE_RUN, 2.0);
// move always after stun recovery
if (!me->hasUnitState(UNIT_STAT_STUNNED) && !me->HasAura(SPELL_VANISH, 1))
DoStartMovement(me->getVictim());
m_checkTimer = 1000;
}
else
m_checkTimer -= diff;
if (m_vanishTimer < diff)
{
if (me->HasAuraType(SPELL_AURA_MOD_STUN)) // remove stun
me->RemoveSpellsCausingAura(SPELL_AURA_MOD_STUN);
if (me->HasAuraType(SPELL_AURA_MOD_STALKED)) // remove Hunter's Marks and similar trackers
me->RemoveSpellsCausingAura(SPELL_AURA_MOD_STALKED);
me->ApplySpellImmune(0, IMMUNITY_MECHANIC, MECHANIC_STUN, true);
ForceSpellCast(me, SPELL_VANISH, INTERRUPT_AND_CAST_INSTANTLY);
ForceSpellCast(me, SPELL_DEADLY_POISON, INTERRUPT_AND_CAST_INSTANTLY);
Position dest;
if (Unit *target = SelectUnit(SELECT_TARGET_RANDOM, 0, 35.0f, true))
target->GetValidPointInAngle(dest, 5.0f, frand(0.0f, 2*M_PI), true);
else
me->GetValidPointInAngle(dest, 30.0f, frand(0.0f, 2*M_PI), true);
DoTeleportTo(dest.x, dest.y, dest.z);
// drop movement :P
me->GetMotionMaster()->MoveIdle();
m_vanishTimer = 60000;
}
else
m_vanishTimer -= diff;
if (me->HasAura(SPELL_VANISH, 1))
return;
DoMeleeAttackIfReady();
CastNextSpellIfAnyAndReady();
}
void PassiveAI::UpdateAI(const uint32)
{
if (me->isInCombat() && me->getAttackers().empty())
EnterEvadeMode();
}
void UpdateAI(const uint32 diff)
{
if (!CanStartEvent)//boss is invisible, don't attack
{
if (CheckCanStart())
{
if (Submerged)
{
me->SetVisible(true);
Submerged = false;
WaitTimer2 = 500;
}
if (!Submerged && WaitTimer2 <= diff)//wait 500ms before emerge anim
{
me->RemoveAllAuras();
me->RemoveFlag(UNIT_NPC_EMOTESTATE,EMOTE_STATE_SUBMERGED);
DoCast(me, SPELL_EMERGE, false);
WaitTimer2 = 60000;//never reached
WaitTimer = 3000;
} else WaitTimer2 -= diff;
if (WaitTimer <= diff)//wait 3secs for emerge anim, then attack
{
WaitTimer = 3000;
CanStartEvent=true;//fresh fished from pool
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
} else WaitTimer -= diff;
}
return;
}
if (me->getThreatManager().getThreatList().empty())//check if should evade
{
if (me->isInCombat())
EnterEvadeMode();
return;
}
if (!Submerged)
{
if (PhaseTimer <= diff)
{
me->InterruptNonMeleeSpells(false);
DoCast(me, SPELL_SUBMERGE);
PhaseTimer = 60000;//60secs submerged
Submerged = true;
} else PhaseTimer-=diff;
if (SpoutTimer <= diff)
{
me->MonsterTextEmote(EMOTE_SPOUT,0,true);
me->SetReactState(REACT_PASSIVE);
me->GetMotionMaster()->MoveRotate(20000, rand()%2 ? ROTATE_DIRECTION_LEFT : ROTATE_DIRECTION_RIGHT);
SpoutTimer = 45000;
WhirlTimer = 20000;//whirl directly after spout
RotTimer = 20000;
return;
} else SpoutTimer -= diff;
//Whirl directly after a Spout and at random times
if (WhirlTimer <= diff)
{
WhirlTimer = 18000;
DoCast(me, SPELL_WHIRL);
} else WhirlTimer -= diff;
if (CheckTimer <= diff)//check if there are players in melee range
{
InRange = false;
Map* pMap = me->GetMap();
Map::PlayerList const &PlayerList = pMap->GetPlayers();
if (!PlayerList.isEmpty())
{
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
if (me->IsWithinMeleeRange(i->getSource()))
InRange = true;
}
}
CheckTimer = 2000;
} else CheckTimer -= diff;
if (RotTimer)
{
Map* pMap = me->GetMap();
if (pMap->IsDungeon())
{
Map::PlayerList const &PlayerList = pMap->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
{
if (i->getSource() && i->getSource()->isAlive() && me->HasInArc(float(diff/20000*M_PI*2),i->getSource()) && me->IsWithinDist(i->getSource(), SPOUT_DIST) && !i->getSource()->IsInWater())
DoCast(i->getSource(), SPELL_SPOUT, true);//only knock back palyers in arc, in 100yards, not in water
}
}
if (SpoutAnimTimer <= diff)
{
DoCast(me, SPELL_SPOUT_ANIM, true);
SpoutAnimTimer = 1000;
} else SpoutAnimTimer -= diff;
if (RotTimer <= diff)
{
RotTimer = 0;
} else RotTimer -= diff;
return;
}
if (GeyserTimer <= diff)
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,1);
if (!pTarget && me->getVictim())
pTarget = me->getVictim();
if (pTarget)
DoCast(pTarget, SPELL_GEYSER, true);
GeyserTimer = rand()%5000 + 15000;
} else GeyserTimer -= diff;
if (!InRange)//if on players in melee range cast Waterbolt
{
if (WaterboltTimer <= diff)
{
Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);
if (!pTarget && me->getVictim())
pTarget = me->getVictim();
if (pTarget)
DoCast(pTarget, SPELL_WATERBOLT, true);
WaterboltTimer = 3000;
} else WaterboltTimer -= diff;
}
if (!UpdateVictim())
return;
DoMeleeAttackIfReady();
}else//submerged
{
if (PhaseTimer <= diff)
{
Submerged = false;
me->InterruptNonMeleeSpells(false);//shouldn't be any
me->RemoveAllAuras();
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
me->RemoveFlag(UNIT_NPC_EMOTESTATE,EMOTE_STATE_SUBMERGED);
DoCast(me, SPELL_EMERGE, true);
Spawned = false;
SpoutTimer = 3000; // directly cast Spout after emerging!
PhaseTimer = 120000;
return;
} else PhaseTimer-=diff;
if (me->getThreatManager().getThreatList().empty())//check if should evade
{
EnterEvadeMode();
return;
}
if (!me->isInCombat())
DoZoneInCombat();
if (!Spawned)
{
me->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);
//spawn adds
for (uint8 i = 0; i < 9; ++i)
{
Creature* Summoned;
if (i < 6)
Summoned = me->SummonCreature(MOB_COILFANG_AMBUSHER,AddPos[i][0],AddPos[i][1],AddPos[i][2], 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
else Summoned = me->SummonCreature(MOB_COILFANG_GUARDIAN,AddPos[i][0],AddPos[i][1],AddPos[i][2], 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
if (Summoned)
Summons.Summon(Summoned);
}
Spawned = true;
}
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!bDone && GrandChampionsOutVehicle(me))
{
bDone = true;
if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_1))
me->SetHomePosition(739.678f, 662.541f, 412.393f, 4.49f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_2))
me->SetHomePosition(746.71f, 661.02f, 411.69f, 4.6f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_3))
me->SetHomePosition(754.34f, 660.70f, 412.39f, 4.79f);
if (pInstance)
pInstance->SetData(BOSS_GRAND_CHAMPIONS, IN_PROGRESS);
EnterEvadeMode();
bHome = true;
}
if (uiPhaseTimer <= uiDiff)
{
if (uiPhase == 1)
{
AggroAllPlayers(me);
uiPhase = 0;
}
}else uiPhaseTimer -= uiDiff;
if (uiFireBallTimer <= uiDiff)
{
if (me->getVictim())
DoCastVictim(SPELL_FIREBALL);
uiFireBallTimer = 5000;
} else uiFireBallTimer -= uiDiff;
if (!UpdateVictim() || me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT))
return;
if (uiFireBallTimer <= uiDiff)
{
DoCastVictim(SPELL_FIREBALL);
uiFireBallTimer = 5000;
} else uiFireBallTimer -= uiDiff;
if (uiPolymorphTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
DoCast(target, SPELL_POLYMORPH);
uiPolymorphTimer = 8000;
} else uiPolymorphTimer -= uiDiff;
if (uiBlastWaveTimer <= uiDiff)
{
DoCastAOE(SPELL_BLAST_WAVE, false);
uiBlastWaveTimer = 13000;
} else uiBlastWaveTimer -= uiDiff;
if (uiHasteTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(true);
DoCast(me, SPELL_HASTE);
uiHasteTimer = 22000;
} else uiHasteTimer -= uiDiff;
DoMeleeAttackIfReady();
}
bool CheckPlayerOnTransport()
{
Transport * pTransport = NULL;
if (!pInstance)
return false;
if (IsFriendlyCommander)
return false; // Le commandant ami ne doit pas check les joueurs sur le transport
pTransport = GetTransportByGUID(me, pInstance->GetData64(DATA_GUNSHIP_TRANSPORT_SECOND));
if (!pTransport)
return false;
std::set<Player*> pSet = pTransport->GetPassengers();
if(pSet.empty()) // Stop l'attaque si personne sur le transport
{
if (me->isInCombat())
EnterEvadeMode();
return false;
}
bool checkPassed = true;
if (!me->isInCombat()) // Débute l'attaque si un joueur arrive sur le transport
{
checkPassed = false;
}
else
{
if (Unit * victim = me->getVictim())
{
if (victim->GetTypeId() != TYPEID_PLAYER)
{
checkPassed = false;
}
else if (victim->GetTransport())
{
if (victim->GetTransport()->GetGUID() != pInstance->GetData64(DATA_GUNSHIP_TRANSPORT_SECOND))
checkPassed = false;
if (victim->GetVehicle())
checkPassed = false;
if (!victim->isAlive())
checkPassed = false;
}
else
checkPassed = false;
}
else
checkPassed = false;
}
if (!checkPassed)
{
Player * pPassenger = MistCore::Containers::SelectRandomContainerElement(pSet);
if (!pPassenger)
if (me->isInCombat())
EnterEvadeMode();
if(!pPassenger->IsHostileTo(me))
if (me->isInCombat())
EnterEvadeMode();
me->CombatStop();
AttackStart(pPassenger);
return false;
}
return true;
}
void UpdateAI(const uint32 uiDiff)
{
if (!bDone && GrandChampionsOutVehicle(me))
{
bDone = true;
if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_1))
me->SetHomePosition(739.678f, 662.541f, 412.393f, 4.49f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_2))
me->SetHomePosition(746.71f, 661.02f, 411.69f, 4.6f);
else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_3))
me->SetHomePosition(754.34f, 660.70f, 412.39f, 4.79f);
if (pInstance)
pInstance->SetData(BOSS_GRAND_CHAMPIONS, IN_PROGRESS);
EnterEvadeMode();
bHome = true;
}
if (uiPhaseTimer <= uiDiff)
{
if (uiPhase == 1)
{
AggroAllPlayers(me);
uiPhase = 0;
}
}else uiPhaseTimer -= uiDiff;
if (!UpdateVictim() || me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT))
return;
if (uiLightningArrowsTimer <= uiDiff)
{
DoCastAOE(SPELL_LIGHTNING_ARROWS, false);
uiLightningArrowsTimer = 7000;
} else uiLightningArrowsTimer -= uiDiff;
if (uiShootTimer <= uiDiff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_FARTHEST, 0, 30.0f))
{
uiTargetGUID = target->GetGUID();
DoCast(target, SPELL_SHOOT);
}
uiShootTimer = 12000;
uiMultiShotTimer = 3000;
bShoot = true;
} else uiShootTimer -= uiDiff;
if (bShoot && uiMultiShotTimer <= uiDiff)
{
me->InterruptNonMeleeSpells(true);
Unit* target = Unit::GetUnit(*me, uiTargetGUID);
if (target && me->IsInRange(target, 5.0f, 30.0f, false))
{
DoCast(target, SPELL_MULTI_SHOT);
} else
{
Map::PlayerList const& players = me->GetMap()->GetPlayers();
if (me->GetMap()->IsDungeon() && !players.isEmpty())
{
for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
{
Player* player = itr->getSource();
if (player && !player->isGameMaster() && me->IsInRange(player, 5.0f, 30.0f, false))
{
DoCast(target, SPELL_MULTI_SHOT);
break;
}
}
}
}
bShoot = false;
} else uiMultiShotTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (isFlameBreathing)
{
if (!me->IsNonMeleeSpellCasted(false))
{
isFlameBreathing = false;
} else return;
}
if (isBombing)
{
if (BombSequenceTimer <= diff)
{
HandleBombSequence();
} else BombSequenceTimer -= diff;
return;
}
if (!UpdateVictim())
return;
//enrage if under 25% hp before 5 min.
if (!enraged && me->GetHealth() * 4 < me->GetMaxHealth())
EnrageTimer = 0;
if (EnrageTimer <= diff)
{
if (!enraged)
{
me->CastSpell(me, SPELL_ENRAGE, true);
enraged = true;
EnrageTimer = 300000;
}
else
{
DoScriptText(SAY_BERSERK, me);
me->CastSpell(me, SPELL_BERSERK, true);
EnrageTimer = 300000;
}
} else EnrageTimer -= diff;
if (BombTimer <= diff)
{
DoScriptText(SAY_FIRE_BOMBS, me);
me->AttackStop();
me->GetMotionMaster()->Clear();
DoTeleportTo(JanalainPos[0][0],JanalainPos[0][1],JanalainPos[0][2]);
me->StopMoving();
me->CastSpell(me, SPELL_FIRE_BOMB_CHANNEL, false);
//DoTeleportPlayer(me, JanalainPos[0][0], JanalainPos[0][1],JanalainPos[0][2], 0);
//me->CastSpell(me, SPELL_TELE_TO_CENTER, true);
FireWall();
SpawnBombs();
isBombing = true;
BombSequenceTimer = 100;
//Teleport every Player into the middle
Map *map = me->GetMap();
if (!map->IsDungeon()) return;
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())
DoTeleportPlayer(i_pl, JanalainPos[0][0]-5+rand()%10, JanalainPos[0][1]-5+rand()%10, JanalainPos[0][2], 0);
}
//me->CastSpell(Temp, SPELL_SUMMON_PLAYERS, true); // core bug, spell does not work if too far
return;
} else BombTimer -= diff;
if (!noeggs)
{
if (100 * me->GetHealth() < 35 * me->GetMaxHealth())
{
DoScriptText(SAY_ALL_EGGS, me);
me->AttackStop();
me->GetMotionMaster()->Clear();
DoTeleportTo(JanalainPos[0][0],JanalainPos[0][1],JanalainPos[0][2]);
me->StopMoving();
me->CastSpell(me, SPELL_HATCH_ALL, false);
HatchAllEggs(2);
noeggs = true;
}
else if (HatcherTimer <= diff)
{
if (HatchAllEggs(0))
{
DoScriptText(SAY_SUMMON_HATCHER, me);
me->SummonCreature(MOB_AMANI_HATCHER,hatcherway[0][0][0],hatcherway[0][0][1],hatcherway[0][0][2],0,TEMPSUMMON_CORPSE_TIMED_DESPAWN,10000);
me->SummonCreature(MOB_AMANI_HATCHER,hatcherway[1][0][0],hatcherway[1][0][1],hatcherway[1][0][2],0,TEMPSUMMON_CORPSE_TIMED_DESPAWN,10000);
HatcherTimer = 90000;
}
else
noeggs = true;
} else HatcherTimer -= diff;
}
if (ResetTimer <= diff)
{
float x, y, z, o;
me->GetHomePosition(x, y, z, o);
if (me->GetPositionZ() <= z-7)
{
EnterEvadeMode();
return;
}
ResetTimer = 5000;
} else ResetTimer -= diff;
DoMeleeAttackIfReady();
if (FireBreathTimer <= diff)
{
if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))
{
me->AttackStop();
me->GetMotionMaster()->Clear();
me->SetInFront(pTarget);
me->CastSpell(pTarget, SPELL_FLAME_BREATH, false);
me->StopMoving();
isFlameBreathing = true;
}
FireBreathTimer = 8000;
} else FireBreathTimer -= diff;
}
void UpdateAI(const uint32 diff)
{
//Return since we have no target
if (!UpdateVictim())
return;
if (Assassins_Timer)
{
if (Assassins_Timer <= diff)
{
SpawnAssassin();
Assassins_Timer = 0;
}
else
Assassins_Timer -= diff;
}
if (InBlade)
{
if (Wait_Timer)
{
if (Wait_Timer <= diff)
{
if (target_num <= 0)
{
// stop bladedance
InBlade = false;
me->SetSpeed(MOVE_RUN,2);
me->GetMotionMaster()->MoveChase(me->getVictim());
Blade_Dance_Timer = 30000;
Wait_Timer = 0;
if (IsHeroic())
Charge_timer = 5000;
}
else
{
//move in bladedance
float x,y,randx,randy;
randx = 0.0f + rand()%40;
randy = 0.0f + rand()%40;
x = 210+ randx ;
y = -60- randy ;
me->GetMotionMaster()->MovePoint(1,x,y,me->GetPositionZ());
Wait_Timer = 0;
}
}
else
Wait_Timer -= diff;
}
}
else
{
if (Blade_Dance_Timer)
{
if (Blade_Dance_Timer <= diff)
{
target_num = TARGET_NUM;
Wait_Timer = 1;
InBlade = true;
Blade_Dance_Timer = 0;
me->SetSpeed(MOVE_RUN,4);
return;
}
else
Blade_Dance_Timer -= diff;
}
if (Charge_timer)
{
if (Charge_timer <= diff)
{
DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), H_SPELL_CHARGE);
Charge_timer = 0;
}
else
Charge_timer -= diff;
}
if (Summon_Assistant_Timer <= diff)
{
for (uint8 i = 0; i < summoned; ++i)
{
switch (urand(0,2))
{
case 0:
me->SummonCreature(MOB_HEARTHEN_GUARD,AddsEntrance[0],AddsEntrance[1], AddsEntrance[2], 0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,30000);
break;
case 1:
me->SummonCreature(MOB_SHARPSHOOTER_GUARD,AddsEntrance[0],AddsEntrance[1], AddsEntrance[2], 0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,30000);
break;
case 2:
me->SummonCreature(MOB_REAVER_GUARD,AddsEntrance[0],AddsEntrance[1], AddsEntrance[2], 0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,30000);
break;
}
}
if (urand(0,9) < 2)
++summoned;
Summon_Assistant_Timer = urand(25000,35000);
}
else
Summon_Assistant_Timer -= diff;
DoMeleeAttackIfReady();
}
if (resetcheck_timer <= diff)
{
uint32 tempx,tempy;
tempx = uint32(me->GetPositionX());
tempy = uint32(me->GetPositionY());
if (tempx > 255 || tempx < 205)
{
EnterEvadeMode();
return;
}
resetcheck_timer = 5000;
}
else
resetcheck_timer -= diff;
}
void UpdateAI(const uint32 diff)
{
switch (Phase)
{
case COMBAT:
//Return since we have no target
if (!UpdateVictim())
return;
if (!bYelled && HealthBelowPct(30))
{
Talk(SAY_30HEALTH);
bYelled = true;
}
if (!bYelled2 && HealthBelowPct(15))
{
Talk(SAY_15HEALTH);
bYelled2 = true;
}
if (HealthBelowPct(1))
{
//Handle Escape Event: Don't forget to add Player::RewardPlayerAndGroupAtEvent
me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);
uiOutroStep = 1;
Phase = OUTRO;
return;
}
if (Creature* pArthas = me->GetCreature(*me, instance ? instance->GetData64(DATA_ARTHAS) : 0))
if (pArthas->isDead())
{
EnterEvadeMode();
me->DisappearAndDie();
if (instance)
instance->SetData(DATA_MAL_GANIS_EVENT, FAIL);
}
if (uiCarrionSwarmTimer < diff)
{
DoCastVictim(SPELL_CARRION_SWARM);
uiCarrionSwarmTimer = 7000;
} else uiCarrionSwarmTimer -= diff;
if (uiMindBlastTimer < diff)
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_MIND_BLAST);
uiMindBlastTimer = 6000;
} else uiMindBlastTimer -= diff;
if (uiVampiricTouchTimer < diff)
{
DoCast(me, SPELL_VAMPIRIC_TOUCH);
uiVampiricTouchTimer = 32000;
} else uiVampiricTouchTimer -= diff;
if (uiSleepTimer < diff)
{
Talk(SAY_SLEEP);
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))
DoCast(target, SPELL_SLEEP);
uiSleepTimer = urand(15000, 20000);
} else uiSleepTimer -= diff;
DoMeleeAttackIfReady();
break;
case OUTRO:
if (uiOutroTimer < diff)
{
switch (uiOutroStep)
{
case 1:
Talk(SAY_ESCAPE_SPEECH_1);
me->GetMotionMaster()->MoveTargetedHome();
++uiOutroStep;
uiOutroTimer = 8000;
break;
case 2:
me->SetTarget(instance ? instance->GetData64(DATA_ARTHAS) : 0);
me->HandleEmoteCommand(29);
Talk(SAY_ESCAPE_SPEECH_2);
++uiOutroStep;
uiOutroTimer = 9000;
break;
case 3:
Talk(SAY_OUTRO);
++uiOutroStep;
uiOutroTimer = 16000;
break;
case 4:
me->HandleEmoteCommand(33);
++uiOutroStep;
uiOutroTimer = 500;
break;
case 5:
me->SetVisible(false);
me->Kill(me);
break;
}
} else uiOutroTimer -= diff;
break;
}
}
void UpdateAI(const uint32 diff)
{
if (!CanAttack && Intro)
{
if (AggroTimer <= diff)
{
CanAttack = true;
me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
AggroTimer=19000;
} else
{
AggroTimer-=diff;
return;
}
}
//to prevent abuses during phase 2
if (Phase == 2 && !me->getVictim() && me->isInCombat())
{
EnterEvadeMode();
return;
}
//Return since we have no target
if (!UpdateVictim())
return;
if (Phase == 1 || Phase == 3)
{
//ShockBlast_Timer
if (ShockBlast_Timer <= diff)
{
//Shock Burst
//Randomly used in Phases 1 and 3 on Vashj's target, it's a Shock spell doing 8325-9675 nature damage and stunning the target for 5 seconds, during which she will not attack her target but switch to the next person on the aggro list.
DoCast(me->getVictim(), SPELL_SHOCK_BLAST);
me->TauntApply(me->getVictim());
ShockBlast_Timer = 1000+rand()%14000; //random cooldown
} else ShockBlast_Timer -= diff;
//StaticCharge_Timer
if (StaticCharge_Timer <= diff)
{
//Static Charge
//Used on random people (only 1 person at any given time) in Phases 1 and 3, it's a debuff doing 2775 to 3225 Nature damage to the target and everybody in about 5 yards around it, every 1 seconds for 30 seconds. It can be removed by Cloak of Shadows, Iceblock, Divine Shield, etc, but not by Cleanse or Dispel Magic.
Unit *pTarget = NULL;
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 200, true);
if (pTarget && !pTarget->HasAura(SPELL_STATIC_CHARGE_TRIGGER, 0))
//cast Static Charge every 2 seconds for 20 seconds
DoCast(pTarget, SPELL_STATIC_CHARGE_TRIGGER);
StaticCharge_Timer = 10000+rand()%20000; //blizzlike
} else StaticCharge_Timer -= diff;
//Entangle_Timer
if (Entangle_Timer <= diff)
{
if (!Entangle)
{
//Entangle
//Used in Phases 1 and 3, it casts Entangling Roots on everybody in a 15 yard radius of Vashj, immobilzing them for 10 seconds and dealing 500 damage every 2 seconds. It's not a magic effect so it cannot be dispelled, but is removed by various buffs such as Cloak of Shadows or Blessing of Freedom.
DoCast(me->getVictim(), SPELL_ENTANGLE);
Entangle = true;
Entangle_Timer = 10000;
}
else
{
CastShootOrMultishot();
Entangle = false;
Entangle_Timer = 20000+rand()%5000;
}
} else Entangle_Timer -= diff;
//Phase 1
if (Phase == 1)
{
//Start phase 2
if ((me->GetHealth()*100 / me->GetMaxHealth()) < 70)
{
//Phase 2 begins when Vashj hits 70%. She will run to the middle of her platform and surround herself in a shield making her invulerable.
Phase = 2;
me->GetMotionMaster()->Clear();
DoTeleportTo(MIDDLE_X, MIDDLE_Y, MIDDLE_Z);
Creature* creature;
for (uint8 i = 0; i < 4; ++i)
{
creature = me->SummonCreature(SHIED_GENERATOR_CHANNEL, ShieldGeneratorChannelPos[i][0], ShieldGeneratorChannelPos[i][1], ShieldGeneratorChannelPos[i][2], ShieldGeneratorChannelPos[i][3], TEMPSUMMON_CORPSE_DESPAWN, 0);
if (creature)
ShieldGeneratorChannel[i] = creature->GetGUID();
}
DoScriptText(SAY_PHASE2, me);
}
}
//Phase 3
else
{
//SummonSporebat_Timer
if (SummonSporebat_Timer <= diff)
{
Creature *Sporebat = NULL;
Sporebat = me->SummonCreature(TOXIC_SPOREBAT, SPOREBAT_X, SPOREBAT_Y, SPOREBAT_Z, SPOREBAT_O, TEMPSUMMON_CORPSE_DESPAWN, 0);
if (Sporebat)
{
Unit *pTarget = NULL;
pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (pTarget)
Sporebat->AI()->AttackStart(pTarget);
}
//summon sporebats faster and faster
if (SummonSporebat_StaticTimer > 1000)
SummonSporebat_StaticTimer -= 1000;
SummonSporebat_Timer = SummonSporebat_StaticTimer;
if (SummonSporebat_Timer < 5000)
SummonSporebat_Timer = 5000;
} else SummonSporebat_Timer -= diff;
}
//Melee attack
DoMeleeAttackIfReady();
//Check_Timer - used to check if somebody is in melee range
if (Check_Timer <= diff)
{
bool InMeleeRange = false;
Unit *pTarget;
std::list<HostileReference *> t_list = me->getThreatManager().getThreatList();
for (std::list<HostileReference *>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
pTarget = Unit::GetUnit(*me, (*itr)->getUnitGuid());
//if in melee range
if (pTarget && pTarget->IsWithinDistInMap(me, 5))
{
InMeleeRange = true;
break;
}
}
//if nobody is in melee range
if (!InMeleeRange)
CastShootOrMultishot();
Check_Timer = 5000;
} else Check_Timer -= diff;
}
//Phase 2
else
{
//ForkedLightning_Timer
if (ForkedLightning_Timer <= diff)
{
//Forked Lightning
//Used constantly in Phase 2, it shoots out completely randomly targeted bolts of lightning which hit everybody in a roughtly 60 degree cone in front of Vashj for 2313-2687 nature damage.
Unit *pTarget = NULL;
pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (!pTarget)
pTarget = me->getVictim();
DoCast(pTarget, SPELL_FORKED_LIGHTNING);
ForkedLightning_Timer = 2000+rand()%6000; //blizzlike
} else ForkedLightning_Timer -= diff;
//EnchantedElemental_Timer
if (EnchantedElemental_Timer <= diff)
{
Creature *Elemental;
Elemental = me->SummonCreature(ENCHANTED_ELEMENTAL, ElementPos[EnchantedElemental_Pos][0], ElementPos[EnchantedElemental_Pos][1], ElementPos[EnchantedElemental_Pos][2], ElementPos[EnchantedElemental_Pos][3], TEMPSUMMON_CORPSE_DESPAWN, 0);
if (EnchantedElemental_Pos == 7)
EnchantedElemental_Pos = 0;
else
++EnchantedElemental_Pos;
EnchantedElemental_Timer = 10000+rand()%5000;
} else EnchantedElemental_Timer -= diff;
//TaintedElemental_Timer
if (TaintedElemental_Timer <= diff)
{
Creature *Tain_Elemental;
uint32 pos = rand()%8;
Tain_Elemental = me->SummonCreature(TAINTED_ELEMENTAL, ElementPos[pos][0], ElementPos[pos][1], ElementPos[pos][2], ElementPos[pos][3], TEMPSUMMON_DEAD_DESPAWN, 0);
TaintedElemental_Timer = 120000;
} else TaintedElemental_Timer -= diff;
//CoilfangElite_Timer
if (CoilfangElite_Timer <= diff)
{
uint32 pos = rand()%3;
Creature* CoilfangElite = NULL;
CoilfangElite = me->SummonCreature(COILFANG_ELITE, CoilfangElitePos[pos][0], CoilfangElitePos[pos][1], CoilfangElitePos[pos][2], CoilfangElitePos[pos][3], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
if (CoilfangElite)
{
Unit *pTarget = NULL;
pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (pTarget)
CoilfangElite->AI()->AttackStart(pTarget);
else if (me->getVictim())
CoilfangElite->AI()->AttackStart(me->getVictim());
}
CoilfangElite_Timer = 45000+rand()%5000;
} else CoilfangElite_Timer -= diff;
//CoilfangStrider_Timer
if (CoilfangStrider_Timer <= diff)
{
uint32 pos = rand()%3;
Creature* CoilfangStrider = NULL;
CoilfangStrider = me->SummonCreature(COILFANG_STRIDER, CoilfangStriderPos[pos][0], CoilfangStriderPos[pos][1], CoilfangStriderPos[pos][2], CoilfangStriderPos[pos][3], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 5000);
if (CoilfangStrider)
{
Unit *pTarget = NULL;
pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);
if (pTarget)
CoilfangStrider->AI()->AttackStart(pTarget);
else if (me->getVictim())
CoilfangStrider->AI()->AttackStart(me->getVictim());
}
CoilfangStrider_Timer = 60000+rand()%10000;
} else CoilfangStrider_Timer -= diff;
//Check_Timer
if (Check_Timer <= diff)
{
//Start Phase 3
if (instance && instance->GetData(DATA_CANSTARTPHASE3))
{
//set life 50%
me->SetHealth(me->GetMaxHealth()/2);
me->RemoveAurasDueToSpell(SPELL_MAGIC_BARRIER);
DoScriptText(SAY_PHASE3, me);
Phase = 3;
//return to the tank
me->GetMotionMaster()->MoveChase(me->getVictim());
}
Check_Timer = 1000;
} else Check_Timer -= diff;
}
}
npc_toxic_sporebatAI(Creature* creature) : ScriptedAI(creature)
{
Initialize();
instance = creature->GetInstanceScript();
EnterEvadeMode();
}