void UpdateAI(const uint32 diff) { //Inhibitmagic_Timer if (Inhibitmagic_Timer <= diff) { float dist; Map* pMap = me->GetMap(); Map::PlayerList const &PlayerList = pMap->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 *pTarget = SelectTarget(SELECT_TARGET_RANDOM,1); if (pTarget && pTarget->GetTypeId() == TYPEID_PLAYER && pTarget->isAlive()) { FocusedTargetGUID = pTarget->GetGUID(); me->SummonCreature(ENTRY_FOCUS_FIRE,pTarget->GetPositionX(),pTarget->GetPositionY(),pTarget->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,5500); // TODO: Find better way to handle emote // Emote std::string *emote = new std::string(EMOTE_FOCUSES_ON); emote->append(pTarget->GetName()); emote->append("!"); const char* text = emote->c_str(); me->MonsterTextEmote(text, 0, true); delete emote; } FocusFire_Timer = 15000+(rand()%5000); } else FocusFire_Timer -= diff; DoMeleeAttackIfReady(); }
void UpdateAI(uint32 diff) override { //Only if not incombat check if the event is started if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT)) { if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER))) AttackStart(target); } //Return since we have no target if (!UpdateVictim()) return; //someone evaded! if (!instance->GetData(DATA_KARATHRESSEVENT)) { EnterEvadeMode(); return; } //WaterBoltVolley_Timer if (WaterBoltVolley_Timer <= diff) { DoCastVictim(SPELL_WATER_BOLT_VOLLEY); WaterBoltVolley_Timer = 30000; } else WaterBoltVolley_Timer -= diff; //TidalSurge_Timer if (TidalSurge_Timer <= diff) { DoCastVictim(SPELL_TIDAL_SURGE); // Hacky way to do it - won't trigger elseways if (me->GetVictim()) me->EnsureVictim()->CastSpell(me->GetVictim(), SPELL_TIDAL_SURGE_FREEZE, true); TidalSurge_Timer = 15000 + rand32() % 5000; } else TidalSurge_Timer -= diff; //Cyclone_Timer if (Cyclone_Timer <= diff) { //DoCast(me, SPELL_SUMMON_CYCLONE); // Doesn't work Cyclone_Timer = 30000 + rand32() % 10000; if (Creature* Cyclone = me->SummonCreature(CREATURE_CYCLONE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), float(rand32() % 5), TEMPSUMMON_TIMED_DESPAWN, 15000)) { Cyclone->SetObjectScale(3.0f); Cyclone->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); Cyclone->setFaction(me->getFaction()); Cyclone->CastSpell(Cyclone, SPELL_CYCLONE_CYCLONE, true); if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) 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) { //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) { if (IsEvent) { //Must update npc_escortAI npc_escortAI::UpdateAI(diff); if (!pGo) { pGo = true; if (pInstance) { AddWaypoint(0, 4896.08, -1576.35, 1333.65); AddWaypoint(1, 4898.68, -1615.02, 1329.48); AddWaypoint(2, 4907.12, -1667.08, 1321.00); AddWaypoint(3, 4963.18, -1699.35, 1340.51); AddWaypoint(4, 4989.16, -1716.67, 1335.74); AddWaypoint(5, 5026.27, -1736.89, 1323.02); AddWaypoint(6, 5037.77, -1770.56, 1324.36); AddWaypoint(7, 5067.23, -1789.95, 1321.17); Start(false, true); SetDespawnAtEnd(false); } } } //Return since we have no target if (!UpdateVictim()) return; if (SwarmTimer < diff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM,0,100,true)) DoCast(target,SPELL_CARRION_SWARM); SwarmTimer = 45000+rand()%15000; switch(rand()%2) { case 0: DoPlaySoundToSet(m_creature, SOUND_SWARM1); m_creature->MonsterYell(SAY_SWARM1, LANG_UNIVERSAL, 0); break; case 1: DoPlaySoundToSet(m_creature, SOUND_SWARM2); m_creature->MonsterYell(SAY_SWARM2, LANG_UNIVERSAL, 0); break; } }else SwarmTimer -= diff; if (SleepTimer < diff) { for(uint8 i=0;i<3; ++i) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM,0,100,true)) target->CastSpell(target,SPELL_SLEEP,true); } SleepTimer = 60000; switch(rand()%2) { case 0: DoPlaySoundToSet(m_creature, SOUND_SLEEP1); m_creature->MonsterYell(SAY_SLEEP1, LANG_UNIVERSAL, 0); break; case 1: DoPlaySoundToSet(m_creature, SOUND_SLEEP2); m_creature->MonsterYell(SAY_SLEEP2, LANG_UNIVERSAL, 0); break; } }else SleepTimer -= diff; if (AuraTimer < diff) { DoCast(m_creature, SPELL_VAMPIRIC_AURA,true); AuraTimer = 10000+rand()%10000; }else AuraTimer -= diff; if (InfernoTimer < diff) { DoCast(SelectTarget(SELECT_TARGET_RANDOM,0,100,true), SPELL_INFERNO); InfernoTimer = 45000; switch(rand()%2) { case 0: DoPlaySoundToSet(m_creature, SOUND_INFERNO1); m_creature->MonsterYell(SAY_INFERNO1, LANG_UNIVERSAL, 0); break; case 1: DoPlaySoundToSet(m_creature, SOUND_INFERNO2); m_creature->MonsterYell(SAY_INFERNO2, LANG_UNIVERSAL, 0); break; } }else InfernoTimer -= diff; DoMeleeAttackIfReady(); }
void UpdateAI(uint32 diff) override { //Only if not incombat check if the event is started if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT)) { if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER))) { AttackStart(target); GetAdvisors(); } } //Return since we have no target if (!UpdateVictim()) return; //someone evaded! if (!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) { DoCastVictim(SPELL_SEAR_NOVA); SearNova_Timer = 20000 + rand32() % 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; for (uint8 i = 0; i < MAX_ADVISORS; ++i) { if (!Advisors[i].IsEmpty()) { Creature* advisor = ObjectAccessor::GetCreature(*me, Advisors[i]); if (advisor && advisor->IsAlive()) { continueTriggering = true; break; } } } if (continueTriggering) { DoCast(me, SPELL_BLESSING_OF_THE_TIDES); me->Yell(SAY_GAIN_BLESSING_OF_TIDES, LANG_UNIVERSAL); DoPlaySoundToSet(me, SOUND_GAIN_BLESSING_OF_TIDES); } } DoMeleeAttackIfReady(); }
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->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0); 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_IMMUNE_TO_PC); 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, urand(0, 1) ? 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* map = me->GetMap(); Map::PlayerList const &PlayerList = map->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* map = me->GetMap(); if (map->IsDungeon()) { Map::PlayerList const &PlayerList = map->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 players 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* target = SelectTarget(SELECT_TARGET_RANDOM, 1); if (!target && me->getVictim()) target = me->getVictim(); if (target) DoCast(target, SPELL_GEYSER, true); GeyserTimer = rand()%5000 + 15000; } else GeyserTimer -= diff; if (!InRange) // if on players in melee range cast Waterbolt { if (WaterboltTimer <= diff) { Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0); if (!target && me->getVictim()) target = me->getVictim(); if (target) DoCast(target, 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_IMMUNE_TO_PC); 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_IMMUNE_TO_PC); // spawn adds for (uint8 i = 0; i < 9; ++i) if (Creature* summoned = me->SummonCreature(i < 6 ? MOB_COILFANG_AMBUSHER : MOB_COILFANG_GUARDIAN, AddPos[i][0], AddPos[i][1], AddPos[i][2], 0, TEMPSUMMON_CORPSE_DESPAWN, 0)) Summons.Summon(summoned); Spawned = true; } } }
void UpdateAI(const uint32 uiDiff) { if (!UpdateVictim()) return; if (instanceScript && instanceScript->GetData(TYPE_NORTHREND_BEASTS) == SNAKES_SPECIAL && !enraged) { DoScriptText(SAY_EMERGE, me); me->RemoveAurasDueToSpell(SPELL_SUBMERGE_0); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE); DoCast(SPELL_ENRAGE); enraged = true; DoScriptText(SAY_BERSERK, me); switch (stage) { case 0: break; case 4: stage = 5; submergeTimer = 5*IN_MILLISECONDS; break; default: stage = 7; } } switch (stage) { case 0: // Mobile if (biteTimer <= uiDiff) { DoCastVictim(biteSpell); biteTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS); } else biteTimer -= uiDiff; if (spewTimer <= uiDiff) { DoCastAOE(spewSpell); spewTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS); } else spewTimer -= uiDiff; if (slimePoolTimer <= uiDiff) { /* Spell summon has only 30s duration */ DoCast(me, SUMMON_SLIME_POOL); slimePoolTimer = 30*IN_MILLISECONDS; } else slimePoolTimer -= uiDiff; if (submergeTimer <= uiDiff && !enraged) { stage = 1; submergeTimer = 5*IN_MILLISECONDS; } else submergeTimer -= uiDiff; DoMeleeAttackIfReady(); break; case 1: // Submerge me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE); DoCast(me, SPELL_SUBMERGE_0); DoScriptText(SAY_SUBMERGE, me); me->GetMotionMaster()->MovePoint(0, ToCCommonLoc[1].GetPositionX()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionY()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionZ()); stage = 2; case 2: // Wait til emerge if (submergeTimer <= uiDiff) { stage = 3; submergeTimer = 50*IN_MILLISECONDS; } else submergeTimer -= uiDiff; break; case 3: // Emerge me->SetDisplayId(modelStationary); DoScriptText(SAY_EMERGE, me); me->RemoveAurasDueToSpell(SPELL_SUBMERGE_0); DoCast(me, SPELL_EMERGE_0); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE); me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE); SetCombatMovement(false); me->GetMotionMaster()->MoveIdle(); stage = 4; break; case 4: // Stationary if (sprayTimer <= uiDiff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) DoCast(target, spraySpell); sprayTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS); } else sprayTimer -= uiDiff; if (sweepTimer <= uiDiff) { DoCastAOE(SPELL_SWEEP_0); sweepTimer = urand(15*IN_MILLISECONDS, 30*IN_MILLISECONDS); } else sweepTimer -= uiDiff; if (submergeTimer <= uiDiff) { stage = 5; submergeTimer = 10*IN_MILLISECONDS; } else submergeTimer -= uiDiff; DoSpellAttackIfReady(spitSpell); break; case 5: // Submerge me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE); DoCast(me, SPELL_SUBMERGE_0); DoScriptText(SAY_SUBMERGE, me); me->GetMotionMaster()->MovePoint(0, ToCCommonLoc[1].GetPositionX()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionY()+urand(0, 80)-40, ToCCommonLoc[1].GetPositionZ()); stage = 6; case 6: // Wait til emerge if (submergeTimer <= uiDiff) { stage = 7; submergeTimer = 45*IN_MILLISECONDS; } else submergeTimer -= uiDiff; break; case 7: // Emerge me->SetDisplayId(modelMobile); DoScriptText(SAY_EMERGE, me); me->RemoveAurasDueToSpell(SPELL_SUBMERGE_0); DoCast(me, SPELL_EMERGE_0); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_OOC_NOT_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE); SetCombatMovement(true); me->GetMotionMaster()->MoveChase(me->getVictim()); stage = 0; break; } }
void UpdateAI(const uint32 Diff) { if (!UpdateVictim()) return; //START NOT TRANSFORMED if (!_bTransformed) { //MindBlast if (MindBlast_Timer <= Diff) { DoCast(me->getVictim(), SPELL_MINDBLAST); MindBlast_Timer = urand(15000, 20000); } else MindBlast_Timer -= Diff; //CrusadersHammer if (CrusadersHammer_Timer <= Diff) { DoCast(me->getVictim(), SPELL_CRUSADERSHAMMER); CrusadersHammer_Timer = 12000; } else CrusadersHammer_Timer -= Diff; //CrusaderStrike if (CrusaderStrike_Timer <= Diff) { DoCast(me->getVictim(), SPELL_CRUSADERSTRIKE); CrusaderStrike_Timer = 15000; } else CrusaderStrike_Timer -= Diff; //HolyStrike if (HolyStrike_Timer <= Diff) { DoCast(me->getVictim(), SPELL_HOLYSTRIKE); HolyStrike_Timer = 15000; } else HolyStrike_Timer -= Diff; //BalnazzarTransform if (HealthBelowPct(40)) { if (me->IsNonMeleeSpellCasted(false)) me->InterruptNonMeleeSpells(false); //restore hp, mana and stun DoCast(me, SPELL_BALNAZZARTRANSFORM); me->UpdateEntry(NPC_BALNAZZAR); _bTransformed = true; } } else { //MindBlast if (MindBlast_Timer <= Diff) { DoCast(me->getVictim(), SPELL_MINDBLAST); MindBlast_Timer = urand(15000, 20000); } else MindBlast_Timer -= Diff; //ShadowShock if (ShadowShock_Timer <= Diff) { DoCast(me->getVictim(), SPELL_SHADOWSHOCK); ShadowShock_Timer = 11000; } else ShadowShock_Timer -= Diff; //PsychicScream if (PsychicScream_Timer <= Diff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) DoCast(target, SPELL_PSYCHICSCREAM); PsychicScream_Timer = 20000; } else PsychicScream_Timer -= Diff; //DeepSleep if (DeepSleep_Timer <= Diff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) DoCast(target, SPELL_SLEEP); DeepSleep_Timer = 15000; } else DeepSleep_Timer -= Diff; //MindControl if (MindControl_Timer <= Diff) { DoCast(me->getVictim(), SPELL_MINDCONTROL); MindControl_Timer = 15000; } else MindControl_Timer -= Diff; } DoMeleeAttackIfReady(); }
void UpdateAI(const uint32 diff) { if (!me->isInCombat()) { if (instance) { // Do not let the raid skip straight to Archimonde. Visible and hostile ONLY if Azagalor is finished. if ((instance->GetData(DATA_AZGALOREVENT) < DONE) && (me->IsVisible() || (me->getFaction() != 35))) { me->SetVisible(false); me->setFaction(35); } else if ((instance->GetData(DATA_AZGALOREVENT) >= DONE) && (!me->IsVisible() || (me->getFaction() == 35))) { me->setFaction(1720); me->SetVisible(true); } } if (DrainNordrassilTimer <= diff) { if (!IsChanneling) { Creature* temp = me->SummonCreature(CREATURE_CHANNEL_TARGET, NordrassilLoc, TEMPSUMMON_TIMED_DESPAWN, 1200000); if (temp) WorldTreeGUID = temp->GetGUID(); if (Unit* Nordrassil = Unit::GetUnit(*me, WorldTreeGUID)) { Nordrassil->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); Nordrassil->SetDisplayId(11686); DoCast(Nordrassil, SPELL_DRAIN_WORLD_TREE); IsChanneling = true; } } if (Unit* Nordrassil = Unit::GetUnit(*me, WorldTreeGUID)) { Nordrassil->CastSpell(me, SPELL_DRAIN_WORLD_TREE_2, true); DrainNordrassilTimer = 1000; } } else DrainNordrassilTimer -= diff; } if (!UpdateVictim()) return; if (me->HealthBelowPct(10) && !BelowTenPercent && !Enraged) // Evita que salgan add y que tire el dedo de la muerte para que se puedan sacar el logro. //BelowTenPercent = true; if (!Enraged) { if (EnrageTimer <= diff) { if (HealthAbovePct(10)) { me->GetMotionMaster()->Clear(false); me->GetMotionMaster()->MoveIdle(); Enraged = true; Talk(SAY_ENRAGE); } } else EnrageTimer -= diff; if (CheckDistanceTimer <= diff) { // To simplify the check, we simply summon a Creature in the location and then check how far we are from the creature Creature* Check = me->SummonCreature(CREATURE_CHANNEL_TARGET, NordrassilLoc, TEMPSUMMON_TIMED_DESPAWN, 2000); if (Check) { Check->SetVisible(false); if (me->IsWithinDistInMap(Check, 75)) { me->GetMotionMaster()->Clear(false); me->GetMotionMaster()->MoveIdle(); Enraged = true; Talk(SAY_ENRAGE); } } CheckDistanceTimer = 5000; } else CheckDistanceTimer -= diff; } if (BelowTenPercent) { if (!HasProtected) { me->GetMotionMaster()->Clear(false); me->GetMotionMaster()->MoveIdle(); //all members of raid must get this buff DoCastVictim(SPELL_PROTECTION_OF_ELUNE, true); HasProtected = true; Enraged = true; } if (SummonWispTimer <= diff) { DoSpawnCreature(CREATURE_ANCIENT_WISP, float(rand()%40), float(rand()%40), 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000); SummonWispTimer = 1500; ++WispCount; } else SummonWispTimer -= diff; if (WispCount >= 30) me->DealDamage(me, me->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false); } if (Enraged) { if (HandOfDeathTimer <= diff) { DoCast(me->getVictim(), SPELL_HAND_OF_DEATH); HandOfDeathTimer = 2000; } else HandOfDeathTimer -= diff; return; // Don't do anything after this point. } if (SoulChargeCount) { if (SoulChargeTimer <= diff) UnleashSoulCharge(); else SoulChargeTimer -= diff; } if (GripOfTheLegionTimer <= diff) { DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_GRIP_OF_THE_LEGION); GripOfTheLegionTimer = urand(5000, 25000); } else GripOfTheLegionTimer -= diff; if (AirBurstTimer <= diff) { Talk(SAY_AIR_BURST); DoCast(SelectTarget(SELECT_TARGET_RANDOM, 1), SPELL_AIR_BURST);//not on tank AirBurstTimer = urand(25000, 40000); } else AirBurstTimer -= diff; if (FearTimer <= diff) { DoCast(me->getVictim(), SPELL_FEAR); FearTimer = 42000; } else FearTimer -= diff; if (DoomfireTimer <= diff) { Talk(SAY_DOOMFIRE); Unit* temp = SelectTarget(SELECT_TARGET_RANDOM, 1); if (!temp) temp = me->getVictim(); //replace with spell cast 31903 once implicitTarget 73 implemented SummonDoomfire(temp); //supposedly three doomfire can be up at the same time DoomfireTimer = 20000; } else DoomfireTimer -= diff; if (MeleeRangeCheckTimer <= diff) { if (CanUseFingerOfDeath()) { DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_FINGER_OF_DEATH); MeleeRangeCheckTimer = 1000; } MeleeRangeCheckTimer = 5000; } else MeleeRangeCheckTimer -= diff; DoMeleeAttackIfReady(); }
void UpdateAI(uint32 const diff) { if(!UpdateVictim()) return; events.Update(diff); if(me->HasUnitState(UNIT_STAT_CASTING)) return; while(uint32 eventId = events.ExecuteEvent()) { switch(eventId) { case EVENT_BERSERK: DoScriptText(SAY_MOLGEIM_BERSERK, me); DoCast(SPELL_BERSERK); events.CancelEvent(EVENT_BERSERK); break; case EVENT_RUNE_OF_POWER: // Improve target selection; random alive friendly { Unit* target = NULL; switch(urand(0, 2)) { case 0: target = me; break; case 1: if(Creature* Steelbreaker = ObjectAccessor::GetCreature(*me, instance->GetData64(BOSS_STEELBREAKER))) if(Steelbreaker->isAlive()) target = Steelbreaker; break; case 2: if(Creature* Brundir = ObjectAccessor::GetCreature(*me, instance->GetData64(BOSS_STEELBREAKER))) if(Brundir->isAlive()) target = Brundir; break; } DoCast(target, SPELL_SUMMON_RUNE_OF_POWER); events.ScheduleEvent(EVENT_RUNE_OF_POWER, 60000); break; } case EVENT_SHIELD_OF_RUNES: DoCast(me, SPELL_SHIELD_OF_RUNES); events.ScheduleEvent(EVENT_SHIELD_OF_RUNES, urand(27000, 34000)); break; case EVENT_RUNE_OF_DEATH: DoScriptText(SAY_MOLGEIM_RUNE_DEATH, me); if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) DoCast(target, SPELL_RUNE_OF_DEATH); events.ScheduleEvent(EVENT_RUNE_OF_DEATH, urand(30000, 40000)); break; case EVENT_RUNE_OF_SUMMONING: DoScriptText(SAY_MOLGEIM_SUMMON, me); if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) DoCast(target, SPELL_RUNE_OF_SUMMONING); events.ScheduleEvent(EVENT_RUNE_OF_SUMMONING, urand(30000, 45000)); break; } } DoMeleeAttackIfReady(); }
void UpdateAI(uint32 const diff) { if(!UpdateVictim()) return; events.Update(diff); if(me->HasUnitState(UNIT_STAT_CASTING)) return; while(uint32 eventId = events.ExecuteEvent()) { switch(eventId) { case EVENT_BERSERK: DoScriptText(SAY_BRUNDIR_BERSERK, me); DoCast(SPELL_BERSERK); events.CancelEvent(EVENT_BERSERK); break; case EVENT_CHAIN_LIGHTNING: if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) DoCast(target, SPELL_CHAIN_LIGHTNING); events.ScheduleEvent(EVENT_CHAIN_LIGHTNING, urand(7000, 10000)); break; case EVENT_OVERLOAD: me->MonsterTextEmote(EMOTE_OVERLOAD, 0, true); DoScriptText(SAY_BRUNDIR_SPECIAL, me); DoCast(SPELL_OVERLOAD); events.ScheduleEvent(EVENT_OVERLOAD, urand(60000, 120000)); break; case EVENT_LIGHTNING_WHIRL: DoCast(SPELL_LIGHTNING_WHIRL); events.ScheduleEvent(EVENT_LIGHTNING_WHIRL, urand(15000, 20000)); break; case EVENT_LIGHTNING_TENDRILS: DoScriptText(SAY_BRUNDIR_FLIGHT, me); DoCast(SPELL_LIGHTNING_TENDRILS); me->AttackStop(); me->AddUnitMovementFlag(MOVEMENTFLAG_LEVITATING); DoCast(SPELL_LIGHTNING_TENDRILS_SELF_VISUAL); me->GetMotionMaster()->Initialize(); me->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), FINAL_FLIGHT_Z); events.DelayEvents(35000); events.ScheduleEvent(EVENT_FLIGHT, 2500); events.ScheduleEvent(EVENT_ENDFLIGHT, 32500); events.ScheduleEvent(EVENT_LIGHTNING_TENDRILS, 90000); break; case EVENT_FLIGHT: if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) me->GetMotionMaster()->MovePoint(0, target->GetPositionX(), target->GetPositionY(), FINAL_FLIGHT_Z); events.ScheduleEvent(EVENT_FLIGHT, 6000); break; case EVENT_ENDFLIGHT: me->GetMotionMaster()->Initialize(); me->GetMotionMaster()->MovePoint(0, 1586.920166f, 119.848984f, FINAL_FLIGHT_Z); events.CancelEvent(EVENT_FLIGHT); events.CancelEvent(EVENT_ENDFLIGHT); events.ScheduleEvent(EVENT_LAND, 4000); break; case EVENT_LAND: me->GetMotionMaster()->Initialize(); me->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), FLOOR_Z); events.CancelEvent(EVENT_LAND); events.ScheduleEvent(EVENT_GROUND, 2500); break; case EVENT_GROUND: me->RemoveUnitMovementFlag(MOVEMENTFLAG_LEVITATING); me->RemoveAurasDueToSpell(SPELL_LIGHTNING_TENDRILS); me->RemoveAurasDueToSpell(SPELL_LIGHTNING_TENDRILS_SELF_VISUAL); DoStartMovement(me->getVictim()); events.CancelEvent(EVENT_GROUND); break; case EVENT_MOVE_POSITION: if(me->IsWithinMeleeRange(me->getVictim())) { float x = (float)irand(-25, 25); float y = (float)irand(-25, 25); me->GetMotionMaster()->MovePoint(0, me->GetPositionX() + x, me->GetPositionY() + y, FLOOR_Z); // Prevention to go outside the room or into the walls if(Creature* trigger = me->FindNearestCreature(NPC_WORLD_TRIGGER, 100.0f, true)) if(me->GetDistance(trigger) >= 50.0f) me->GetMotionMaster()->MovePoint(0, trigger->GetPositionX(), trigger->GetPositionY(), FLOOR_Z); } events.ScheduleEvent(EVENT_MOVE_POSITION, urand(7500, 10000)); break; default: break; } } DoMeleeAttackIfReady(); }
void UpdateAI(uint32 diff) { //Return since we have no target or casting if (!UpdateVictim() || me->IsNonMeleeSpellCasted(false)) return; // Sonic Boom if (SonicBoom) { DoCast(me, SPELL_SONIC_BOOM_EFFECT, true); SonicBoomEffect(); SonicBoom = false; Resonance_Timer = 1500; } if (SonicBoom_Timer <= diff) { Talk(EMOTE_SONIC_BOOM); DoCast(me, SPELL_SONIC_BOOM_CAST); SonicBoom_Timer = 30000; SonicBoom = true; return; } else SonicBoom_Timer -= diff; // Murmur's Touch if (MurmursTouch_Timer <= diff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 80, true)) DoCast(target, SPELL_MURMURS_TOUCH); MurmursTouch_Timer = urand(25000, 35000); } else MurmursTouch_Timer -= diff; // Resonance if (!SonicBoom && !(me->IsWithinMeleeRange(me->GetVictim()))) { if (Resonance_Timer <= diff) { DoCast(me, SPELL_RESONANCE); Resonance_Timer = 5000; } else Resonance_Timer -= diff; } // Magnetic Pull if (MagneticPull_Timer <= diff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) if (target->GetTypeId() == TYPEID_PLAYER && target->IsAlive()) { DoCast(target, SPELL_MAGNETIC_PULL); MagneticPull_Timer = 15000+rand()%15000; return; } MagneticPull_Timer = 500; } else MagneticPull_Timer -= diff; if (IsHeroic()) { // Thundering Storm if (ThunderingStorm_Timer <= diff) { ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList(); for (ThreatContainer::StorageType::const_iterator i = threatlist.begin(); i != threatlist.end(); ++i) if (Unit* target = Unit::GetUnit(*me, (*i)->getUnitGuid())) if (target->IsAlive() && !me->IsWithinDist(target, 35, false)) DoCast(target, SPELL_THUNDERING_STORM, true); ThunderingStorm_Timer = 15000; } else ThunderingStorm_Timer -= diff; // Sonic Shock if (SonicShock_Timer <= diff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 20, false)) if (target->IsAlive()) DoCast(target, SPELL_SONIC_SHOCK); SonicShock_Timer = 10000+rand()%10000; } else SonicShock_Timer -= diff; } // Select nearest most aggro target if top aggro too far if (!me->isAttackReady()) return; if (!me->IsWithinMeleeRange(me->GetVictim())) { ThreatContainer::StorageType threatlist = me->getThreatManager().getThreatList(); for (ThreatContainer::StorageType::const_iterator i = threatlist.begin(); i != threatlist.end(); ++i) if (Unit* target = Unit::GetUnit(*me, (*i)->getUnitGuid())) if (target->IsAlive() && me->IsWithinMeleeRange(target)) { me->TauntApply(target); break; } } DoMeleeAttackIfReady(); }
void UpdateAI(uint32 diff) override { if (!UpdateVictim()) return; events.Update(diff); if (me->HasUnitState(UNIT_STATE_CASTING)) return; while (uint32 eventId = events.ExecuteEvent()) { switch (eventId) { case EVENT_FEL_EXPLOSION: DoCastAOE(SPELL_FEL_EXPLOSION); events.ScheduleEvent(EVENT_FEL_EXPLOSION, 2s, 0, PHASE_NORMAL); break; case EVENT_DRAIN_CRYSTAL: SelectNearestCrystal(); _scheduledEvents = false; break; case EVENT_DRAIN_MANA: if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 45.0f, true)) DoCast(target, SPELL_DRAIN_MANA); events.ScheduleEvent(EVENT_DRAIN_MANA, 10s, 0, PHASE_NORMAL); break; case EVENT_DRAIN_LIFE: if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 20.0f, true)) DoCast(target, SPELL_DRAIN_LIFE); events.ScheduleEvent(EVENT_DRAIN_LIFE, 10s, 0, PHASE_NORMAL); break; case EVENT_EMPOWER: { Talk(SAY_EMPOWERED); Creature* CrystalChosen = ObjectAccessor::GetCreature(*me, CrystalGUID); if (CrystalChosen && CrystalChosen->IsAlive()) CrystalChosen->KillSelf(); CrystalGUID.Clear(); me->GetMotionMaster()->Clear(); me->GetMotionMaster()->MoveChase(me->GetVictim()); break; } default: break; } if (me->HasUnitState(UNIT_STATE_CASTING)) return; } if (me->GetPower(POWER_MANA) * 100 / me->GetMaxPower(POWER_MANA) < 10) { if (events.IsInPhase(PHASE_NORMAL) && !_scheduledEvents) { _scheduledEvents = true; uint32 timer = urand(3000, 7000); events.ScheduleEvent(EVENT_DRAIN_LIFE, timer, 0, PHASE_NORMAL); if (IsHeroic()) { events.ScheduleEvent(EVENT_DRAIN_CRYSTAL, urand(10000, 15000), 0, PHASE_NORMAL); events.ScheduleEvent(EVENT_DRAIN_MANA, timer + 5000, 0, PHASE_NORMAL); } else events.ScheduleEvent(EVENT_DRAIN_CRYSTAL, urand(20000, 25000), 0, PHASE_NORMAL); } } DoMeleeAttackIfReady(); }
void UpdateAI(const uint32 diff) { if(!UpdateVictim()) return; // Void Zone if(VoidZoneTimer < diff) { DoCast(SelectTarget(SELECT_TARGET_RANDOM,1,45,true),SPELL_VOIDZONE,true); VoidZoneTimer = 15000; }else VoidZoneTimer -= diff; // NetherInfusion Berserk if(!Berserk && NetherInfusionTimer < diff) { m_creature->AddAura(SPELL_NETHER_INFUSION, m_creature); DoCast(m_creature, SPELL_NETHERSPITE_ROAR); Berserk = true; }else NetherInfusionTimer -= diff; if(PortalPhase) // PORTAL PHASE { // Distribute beams and buffs if(PortalTimer < diff) { UpdatePortals(); PortalTimer = 1000; }else PortalTimer -= diff; // Empowerment & Nether Burn if(EmpowermentTimer < diff) { DoCast(m_creature, SPELL_EMPOWERMENT); m_creature->AddAura(SPELL_NETHERBURN_AURA, m_creature); EmpowermentTimer = 90000; }else EmpowermentTimer -= diff; if(PhaseTimer < diff) { if(!m_creature->IsNonMeleeSpellCasted(false)) { SwitchToBanishPhase(); return; } }else PhaseTimer -= diff; } else // BANISH PHASE { // Netherbreath if(NetherbreathTimer < diff) { if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM,0,40,true)) DoCast(target,SPELL_NETHERBREATH); NetherbreathTimer = 5000+rand()%2000; }else NetherbreathTimer -= diff; if(PhaseTimer < diff) { if(!m_creature->IsNonMeleeSpellCasted(false)) { SwitchToPortalPhase(); return; } }else PhaseTimer -= diff; } DoMeleeAttackIfReady(); }
void UpdateAI(const uint32 diff) { if (questPhase == 1) { if (timer <= diff) { me->SetUInt32Value(UNIT_FIELD_BYTES_1, UNIT_STAND_STATE_STAND); me->setFaction(FACTION_HOSTILE); questPhase = 0; if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true)) { me->AddThreat(pTarget, 5000000.0f); AttackStart(pTarget); } } else timer -= diff; } if (!UpdateVictim()) return; // healer if (spellFlashLight) { if (me->GetHealth() * 100 / me->GetMaxHealth() < 70) { if (timerFlashLight <= diff) { DoCast(me, SPELL_FLASH_OF_LIGHT); timerFlashLight = TIMER_FLASH_OF_LIGHT + rand() % TIMER_FLASH_OF_LIGHT; } else timerFlashLight -= diff; } } if (spellJustice) { if (timerJustice <= diff) { DoCast(me, SPELL_SEAL_OF_JUSTICE); timerJustice = TIMER_SEAL_OF_JUSTICE + rand() % TIMER_SEAL_OF_JUSTICE; } else timerJustice -= diff; } if (spellJudLight) { if (timerJudLight <= diff) { DoCast(me, SPELL_JUDGEMENT_OF_LIGHT); timerJudLight = TIMER_JUDGEMENT_OF_LIGHT + rand() % TIMER_JUDGEMENT_OF_LIGHT; } else timerJudLight -= diff; } if (spellCommand) { if (timerCommand <= diff) { DoCast(me, TIMER_SEAL_OF_COMMAND); timerCommand = TIMER_SEAL_OF_COMMAND + rand() % TIMER_SEAL_OF_COMMAND; } else timerCommand -= diff; } DoMeleeAttackIfReady(); }
void UpdateAI(uint32 diff) { if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING)) return; events.Update(diff); while (uint32 eventId = events.ExecuteEvent()) { switch (eventId) { case EVENT_PYROBLAST: DoCastVictim(SPELL_PYROBLAST); events.ScheduleEvent(EVENT_PYROBLAST, urand(3500, 4500)); break; case EVENT_FLARECORE: if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100.0f, true)) DoCast(target, SPELL_FLARECORE_MISSILE); events.ScheduleEvent(EVENT_FLARECORE, urand(19000, 21000)); break; case EVENT_BLINK: Talk(SAY_BLINK); DoCast(me, SPELL_BLINK); if (Creature* blink = me->FindNearestCreature(NPC_BLINK_TARGT, 200.0f, true)) me->NearTeleportTo(blink->GetPositionX(), blink->GetPositionY(), blink->GetPositionZ(), blink->GetOrientation()); events.CancelEvent(EVENT_PYROBLAST); events.CancelEvent(EVENT_FLARECORE); events.ScheduleEvent(EVENT_FROST_BLADES, 1500); events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 2000); events.ScheduleEvent(EVENT_BLINK, 31500); break; case EVENT_FROSTBOLT_VOLLEY: if(VolleyCount < 3) { DoCast(me, SPELL_FROSTBOLT_VOLLEY); events.ScheduleEvent(EVENT_FROSTBOLT_VOLLEY, 2200); VolleyCount++; } else { Talk(SAY_FROSTBOLT_VOLLEY); DoCast(me, SPELL_FROSTBOLT_VOLLEY); events.CancelEvent(EVENT_FROSTBOLT_VOLLEY); VolleyCount = 0; events.ScheduleEvent(EVENT_PYROBLAST, urand(3000, 3500)); events.ScheduleEvent(EVENT_FLARECORE, urand (7500, 8500)); } break; case EVENT_FROST_BLADES: Talk(SAY_FROST_BLADES); me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation() - 0.1f, TEMPSUMMON_TIMED_DESPAWN, 10000); me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation(), TEMPSUMMON_TIMED_DESPAWN, 10000); me->SummonCreature(NPC_FROSTBLADES, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation() + 0.1f, TEMPSUMMON_TIMED_DESPAWN, 10000); break; } } }
void DoSplit(int atPercent /* 75 50 25 */) { DoScriptText(SAY_SPLIT, me); ov_mycoordinates *place1 = new ov_mycoordinates(-8340.782227,2083.814453,125.648788,0); ov_mycoordinates *place2 = new ov_mycoordinates(-8341.546875,2118.504639,133.058151,0); ov_mycoordinates *place3 = new ov_mycoordinates(-8318.822266,2058.231201,133.058151,0); ov_mycoordinates *bossc=place1, *i1=place2, *i2=place3; switch (urand(0,2)) { case 0: bossc=place1; i1=place2; i2=place3; break; case 1: bossc=place2; i1=place1; i2=place3; break; case 2: bossc=place3; i1=place1; i2=place2; break; } for (uint16 i = 0; i < 41; ++i) { if (Player *pTarget = CAST_PLR(SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))) { if (Group *pGrp = pTarget->GetGroup()) for (uint8 ico = 0; ico < TARGETICONCOUNT; ++ico) { //if (grp->m_targetIcons[ico] == me->GetGUID()) -- private member :( pGrp->SetTargetIcon(ico, 0, 0); } break; } } me->RemoveAllAuras(); me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); me->SetVisibility(VISIBILITY_OFF); me->GetMap()->CreatureRelocation(me, bossc->x, bossc->y, bossc->z, bossc->r); Invisible = true; delete place1; delete place2; delete place3; DoResetThreat(); DoStopAttack(); switch (atPercent) { case 75: Images75 = true; break; case 50: Images50 = true; break; case 25: Images25 = true; break; } Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0); Creature *Image1 = me->SummonCreature(15263, i1->x, i1->y, i1->z, i1->r, TEMPSUMMON_CORPSE_DESPAWN, 30000); if (Image1) { Image1->SetMaxHealth(me->GetMaxHealth() / 5); Image1->SetHealth(me->GetHealth() / 5); if (pTarget) Image1->AI()->AttackStart(pTarget); CAST_AI(boss_skeramAI, Image1->AI())->IsImage = true; } Creature *Image2 = me->SummonCreature(15263,i2->x, i2->y, i2->z, i2->r, TEMPSUMMON_CORPSE_DESPAWN, 30000); if (Image2) { Image2->SetMaxHealth(me->GetMaxHealth() / 5); Image2->SetHealth(me->GetHealth() / 5); if (pTarget) Image2->AI()->AttackStart(pTarget); CAST_AI(boss_skeramAI, Image2->AI())->IsImage = true; } Invisible = true; }
void UpdateAI(const uint32 uiDiff) { if (bDone && uiResetTimer <= uiDiff) { me->GetMotionMaster()->MovePoint(0, 746.87f, 665.87f, 411.75f); bDone = false; } else uiResetTimer -= uiDiff; if (!UpdateVictim()) return; if (uiHolyFireTimer <= uiDiff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 250, true)) { if (target && target->isAlive()) DoCast(target, SPELL_HOLY_FIRE); } if (me->HasAura(SPELL_SHIELD)) uiHolyFireTimer = 13000; else uiHolyFireTimer = urand(9000, 12000); } else uiHolyFireTimer -= uiDiff; if (uiHolySmiteTimer <= uiDiff) { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 250, true)) { if (target && target->isAlive()) DoCast(target, SPELL_SMITE); } if (me->HasAura(SPELL_SHIELD)) uiHolySmiteTimer = 9000; else uiHolySmiteTimer = urand(5000, 7000); } else uiHolySmiteTimer -= uiDiff; if (me->HasAura(SPELL_SHIELD)) { if (uiRenewTimer <= uiDiff) { me->InterruptNonMeleeSpells(true); uint8 uiTarget = urand(0, 1); switch (uiTarget) { case 0: DoCast(me, SPELL_RENEW); break; case 1: if (Creature* pMemory = Unit::GetCreature(*me, MemoryGUID)) if (pMemory->isAlive()) DoCast(pMemory, SPELL_RENEW); break; } uiRenewTimer = urand(15000, 17000); } else uiRenewTimer -= uiDiff; } if (!bHealth && !HealthAbovePct(25)) { me->InterruptNonMeleeSpells(true); DoCastAOE(SPELL_HOLY_NOVA, false); DoCast(me, SPELL_SHIELD); DoCastAOE(SPELL_SUMMON_MEMORY, false); DoCastAOE(SPELL_CONFESS, false); bHealth = true; } 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* target = NULL; target = SelectTarget(SELECT_TARGET_RANDOM, 0); if (target) { DoTeleportTo(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ()); DoCast(target, SPELL_AMBUSH); } Ambushed = true; Ambush_Timer = 3000; } else Ambush_Timer -= diff; } if (Ambushed) { if (Visible_Timer <= diff) { me->InterruptSpell(CURRENT_GENERIC_SPELL); me->SetDisplayId(15268); SetEquipmentSlots(false, EQUIP_ID_MAIN_HAND, EQUIP_NO_CHANGE, EQUIP_NO_CHANGE); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); Invisible = false; Visible_Timer = 4000; } else Visible_Timer -= diff; } //Resetting some aggro so he attacks other gamers if (!Invisible) { if (Aggro_Timer <= diff) { Unit* target = NULL; target = SelectTarget(SELECT_TARGET_RANDOM, 1); if (DoGetThreat(me->getVictim())) DoModifyThreatPercent(me->getVictim(), -50); if (target) AttackStart(target); 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(); }
void UpdateAI(const uint32 diff) { if (!UpdateVictim() || me->HasUnitState(UNIT_STAT_CASTING)) return; if(ShouldSummonAdds) { // Despawns the Stalker DespawnCreatures(NPC_SHADOW_GALE_STALKER); RemoveShadowGaleDebuffFromPlayers(); me->SetReactState(REACT_AGGRESSIVE); me->GetMotionMaster()->Clear(); me->GetMotionMaster()->MoveChase(me->getVictim()); if ((rand()%2)) me->MonsterYell(SAY_SUMMON, LANG_UNIVERSAL, NULL); //Adds a visual portal effect to the Stalker FacelessPortalStalker->GetAI()->DoCast(FacelessPortalStalker,SPELL_TWILIGHT_PORTAL_VISUAL,true); events.ScheduleEvent(EVENT_REMOVE_TWILIGHT_PORTAL, 7000); //Summons Faceless over the Spell FacelessPortalStalker->GetAI()->DoCast(FacelessPortalStalker,SPELL_SPAWN_FACELESS,true); ShouldSummonAdds = false; // DBM says that the Spell has 40s CD events.ScheduleEvent(EVENT_SHADOW_GALE, urand(40000,44000)); } events.Update(diff); while (uint32 eventId = events.ExecuteEvent()) { switch (eventId) { case EVENT_ENFEEBLING_BLOW: DoCastVictim(SPELL_ENFEEBLING_BLOW); events.ScheduleEvent(EVENT_ENFEEBLING_BLOW, urand(19000,24000)); break; case EVENT_SHADOW_GALE: ShadowGaleTrigger = me->SummonCreature(NPC_SHADOW_GALE_STALKER,-739.665f/*+(urand(0,20)-10)*/,-827.024f/*+(urand(0,20)-10)*/,232.412f,3.1f,TEMPSUMMON_CORPSE_DESPAWN); me->SetReactState(REACT_PASSIVE); me->GetMotionMaster()->MovePoint(POINT_ERUDAX_IS_AT_STALKER,ShadowGaleTrigger->GetPositionX(),ShadowGaleTrigger->GetPositionY(),ShadowGaleTrigger->GetPositionZ()); DoScriptText(SAY_GALE, me); break; case EVENT_REMOVE_TWILIGHT_PORTAL: //Removes Portal effect from Stalker FacelessPortalStalker->RemoveAllAuras(); break; case EVENT_BINDING_SHADOWS: if (Unit* tempTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 500.0f, true)) DoCast(tempTarget,SPELL_BINDING_SHADOWS); events.ScheduleEvent(EVENT_BINDING_SHADOWS, urand(12000,17000)); break; default: break; } } 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) { //Return since we have no target if (!UpdateVictim()) return; //Earthquake_Timer if (Earthquake_Timer <= diff) { if (!Earthquake) { DoCast(me->getVictim(), SPELL_EARTHQUAKE); Earthquake = true; Earthquake_Timer = 10000; } else { DoScriptText(RAND(SAY_SUMMON1, SAY_SUMMON2), me); for (uint8 i = 0; i < 10; ++i) { Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0); Creature* Murloc = me->SummonCreature(NPC_TIDEWALKER_LURKER, MurlocCords[i][0], MurlocCords[i][1], MurlocCords[i][2], MurlocCords[i][3], TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 10000); if (pTarget && Murloc) Murloc->AI()->AttackStart(pTarget); } DoScriptText(EMOTE_EARTHQUAKE, me); Earthquake = false; Earthquake_Timer = 40000+rand()%5000; } } else Earthquake_Timer -= diff; //TidalWave_Timer if (TidalWave_Timer <= diff) { DoCast(me->getVictim(), SPELL_TIDAL_WAVE); TidalWave_Timer = 20000; } else TidalWave_Timer -= diff; if (!Phase2) { //WateryGrave_Timer if (WateryGrave_Timer <= diff) { //Teleport 4 players under the waterfalls Unit *pTarget; std::set<uint64> list; std::set<uint64>::const_iterator itr; for (uint8 i = 0; i < 4; ++i) { counter = 0; do { pTarget = SelectTarget(SELECT_TARGET_RANDOM, 1, 50, true); //target players only if (counter < Playercount) break; if (pTarget) itr = list.find(pTarget->GetGUID()); ++counter; } while (itr != list.end()); if (pTarget) { list.insert(pTarget->GetGUID()); ApplyWateryGrave(pTarget, i); } } DoScriptText(RAND(SAY_SUMMON_BUBL1, SAY_SUMMON_BUBL2), me); DoScriptText(EMOTE_WATERY_GRAVE, me); WateryGrave_Timer = 30000; } else WateryGrave_Timer -= diff; //Start Phase2 if (HealthBelowPct(25)) Phase2 = true; } else { //WateryGlobules_Timer if (WateryGlobules_Timer <= diff) { Unit* pGlobuleTarget; std::set<uint64> globulelist; std::set<uint64>::const_iterator itr; for (uint8 g = 0; g < 4; g++) //one unit can't cast more than one spell per update, so some players have to cast for us XD { counter = 0; do { pGlobuleTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true); if (pGlobuleTarget) itr = globulelist.find(pGlobuleTarget->GetGUID()); if (counter > Playercount) break; ++counter; } while (itr != globulelist.end()); if (pGlobuleTarget) { globulelist.insert(pGlobuleTarget->GetGUID()); pGlobuleTarget->CastSpell(pGlobuleTarget, globulespell[g], true); } } DoScriptText(EMOTE_WATERY_GLOBULES, me); WateryGlobules_Timer = 25000; } else WateryGlobules_Timer -= diff; } DoMeleeAttackIfReady(); }
void UpdateAI(const uint32 diff) { if (!UpdateVictim()) return; if (pInstance && !pInstance->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) { Creature* Temp = NULL; if (AddGUID[i]) { 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*> pTargets; SelectTargetList(pTargets, 5, SELECT_TARGET_RANDOM, me->GetMeleeReach()*5, true); for (std::list<Unit*>::const_iterator i = pTargets.begin(); i != pTargets.end(); ++i) if (!me->IsWithinMeleeRange(*i)) { DoCast(*i, SPELL_BLIND); break; } Blind_Timer = 40000; } else Blind_Timer -= diff; } if (InVanish) { if (Wait_Timer <= diff) { DoScriptText(RAND(SAY_SPECIAL_1,SAY_SPECIAL_2), me); if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true)) pTarget->CastSpell(pTarget, SPELL_GARROTE,true); InVanish = false; } else Wait_Timer -= diff; } if (!InVanish) DoMeleeAttackIfReady(); }
void UpdateAI(uint32 diff) override { if (!UpdateVictim()) return; if (!HasVanished) { if (DeadlyPoisonTimer <= diff) { DoCastVictim(SPELL_DEADLY_POISON); DeadlyPoisonTimer = urand(15, 46) * 1000; } else DeadlyPoisonTimer -= diff; if (AppearEnvenomTimer <= diff) // Cast Envenom. This is cast 4 seconds after Vanish is over { DoCastVictim(SPELL_ENVENOM); AppearEnvenomTimer = 90000; } else AppearEnvenomTimer -= diff; if (VanishTimer <= diff) // Disappear and stop attacking, but follow a random unit { if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) { VanishTimer = 30000; AppearEnvenomTimer= 28000; HasVanished = true; me->SetVisible(false); me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); DoResetThreat(); // Chase a unit. Check before DoMeleeAttackIfReady prevents from attacking me->AddThreat(target, 500000.0f); me->GetMotionMaster()->MoveChase(target); } } else VanishTimer -= diff; DoMeleeAttackIfReady(); } else { if (VanishTimer <= diff) // Become attackable and poison current target { Unit* target = me->GetVictim(); DoCast(target, SPELL_DEADLY_POISON); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE); DoResetThreat(); me->AddThreat(target, 3000.0f); // Make Veras attack his target for a while, he will cast Envenom 4 seconds after. DeadlyPoisonTimer += 6000; VanishTimer = 90000; AppearEnvenomTimer = 4000; HasVanished = false; } else VanishTimer -= diff; if (AppearEnvenomTimer <= diff) // Appear 2 seconds before becoming attackable (Shifting out of vanish) { me->GetMotionMaster()->Clear(); me->GetMotionMaster()->MoveChase(me->GetVictim()); me->SetVisible(true); AppearEnvenomTimer = 6000; } else AppearEnvenomTimer -= diff; } }
void UpdateAI(uint32 diff) override { //Only if not incombat check if the event is started if (!me->IsInCombat() && instance->GetData(DATA_KARATHRESSEVENT)) { if (Unit* target = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_KARATHRESSEVENT_STARTER))) AttackStart(target); } //Return since we have no target if (!UpdateVictim()) return; //someone evaded! if (!instance->GetData(DATA_KARATHRESSEVENT)) { EnterEvadeMode(); return; } //LeechingThrow_Timer if (LeechingThrow_Timer <= diff) { DoCastVictim(SPELL_LEECHING_THROW); LeechingThrow_Timer = 20000; } else LeechingThrow_Timer -= diff; //Multishot_Timer if (Multishot_Timer <= diff) { DoCastVictim(SPELL_MULTISHOT); Multishot_Timer = 20000; } else Multishot_Timer -= diff; //TheBeastWithin_Timer if (TheBeastWithin_Timer <= diff) { DoCast(me, SPELL_THE_BEAST_WITHIN); Creature* Pet = ObjectAccessor::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); if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) { if (Creature* Pet = DoSpawnCreature(pet_id, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 15000)) { Pet->AI()->AttackStart(target); SummonedPet = Pet->GetGUID(); } } } else Pet_Timer -= diff; DoMeleeAttackIfReady(); }
void UpdateAI(const uint32 diff) { if (!UpdateVictim()) return; // Evade if too far if (check_Timer <= diff) { float x,y,z,o; me->GetHomePosition(x,y,z,o); if (me->GetDistance(x,y,z) > 60) { EnterEvadeMode(); return; } check_Timer = 1000; } else check_Timer -= diff; // Spore Striders if (HeroicMode && SporeStriders_Timer <= diff) { DoCast(me,SPELL_SUMMON_SPORE_STRIDER); SporeStriders_Timer = 10000+rand()%5000; } else SporeStriders_Timer -= diff; // Levitate if (LevitatedTarget) { if (LevitatedTarget_Timer <= diff) { if (Unit *pTarget = (Unit*)Unit::GetUnit(*me, LevitatedTarget)) { if (!pTarget->HasAura(SPELL_LEVITATE,0)) { LevitatedTarget = 0; return; } if (InAir) { pTarget->AddAura(SPELL_SUSPENSION, pTarget); LevitatedTarget = 0; } else { pTarget->CastSpell(pTarget, SPELL_MAGNETIC_PULL, true); InAir = true; LevitatedTarget_Timer = 1500; } } else LevitatedTarget = 0; } else LevitatedTarget_Timer -= diff; } if (Levitate_Timer <= diff) { if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,1)) { DoCast(pTarget, SPELL_LEVITATE); LevitatedTarget = pTarget->GetGUID(); LevitatedTarget_Timer = 2000; InAir = false; } Levitate_Timer = 12000+rand()%3000; } else Levitate_Timer -= diff; // Chain Lightning if (ChainLightning_Timer <= diff) { if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0)) DoCast(pTarget, SPELL_CHAIN_LIGHTNING); ChainLightning_Timer = 7000; } else ChainLightning_Timer -= diff; // Static Charge if (StaticCharge_Timer <= diff) { if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM,0,30,true)) DoCast(pTarget, SPELL_STATIC_CHARGE); StaticCharge_Timer = 10000; } else StaticCharge_Timer -= diff; DoMeleeAttackIfReady(); }
void hyjalAI::UpdateAI(uint32 diff) { if (IsDummy) { if (MassTeleportTimer < diff && DoMassTeleport) { DoCast(me, SPELL_MASS_TELEPORT, false); DoMassTeleport = false; } else MassTeleportTimer -= diff; return; } if (DoHide) { DoHide = false; switch (me->GetEntry()) { case JAINA: if (instance && instance->GetData(DATA_ALLIANCE_RETREAT)) { me->SetVisible(false); HideNearPos(me->GetPositionX(), me->GetPositionY()); HideNearPos(5037.76f, -1889.71f); for (uint8 i = 0; i < 92; ++i)//summon fires me->SummonGameObject(FLAMEOBJECT, AllianceFirePos[i][0], AllianceFirePos[i][1], AllianceFirePos[i][2], AllianceFirePos[i][3], AllianceFirePos[i][4], AllianceFirePos[i][5], AllianceFirePos[i][6], AllianceFirePos[i][7], 0); } else me->SetVisible(true); break; case THRALL: //thrall if (instance && instance->GetData(DATA_HORDE_RETREAT)) { me->SetVisible(false); HideNearPos(me->GetPositionX(), me->GetPositionY()); HideNearPos(5563, -2763.19f); HideNearPos(5542.2f, -2629.36f); for (uint8 i = 0; i < 65; ++i)//summon fires me->SummonGameObject(FLAMEOBJECT, HordeFirePos[i][0], HordeFirePos[i][1], HordeFirePos[i][2], HordeFirePos[i][3], HordeFirePos[i][4], HordeFirePos[i][5], HordeFirePos[i][6], HordeFirePos[i][7], 0); } else me->SetVisible(true); break; } } if (DoRespawn) { if (RespawnTimer <= diff) { DoRespawn = false; RespawnNearPos(me->GetPositionX(), me->GetPositionY()); if (Faction == 0) { RespawnNearPos(5037.76f, -1889.71f); } else if (Faction == 1) { RespawnNearPos(5563, -2763.19f); RespawnNearPos(5542.2f, -2629.36f); } me->SetVisible(true); }else{ RespawnTimer -= diff; me->SetVisible(false); } return; } if (Overrun) DoOverrun(Faction, diff); if (bRetreat) { if (RetreatTimer <= diff) { IsDummy = true; bRetreat = false; HideNearPos(me->GetPositionX(), me->GetPositionY()); switch (me->GetEntry()) { case JAINA://jaina HideNearPos(5037.76f, -1889.71f); break; case THRALL://thrall HideNearPos(5563, -2763.19f); HideNearPos(5542.2f, -2629.36f); HideNearPos(5603.75f, -2853.12f); break; } me->SetVisible(false); } else RetreatTimer -= diff; } if (!EventBegun) return; if (Summon) { if (instance && EnemyCount) { EnemyCount = instance->GetData(DATA_TRASH); if (!EnemyCount) NextWaveTimer = 5000; } if (NextWaveTimer <= diff) { if (Faction == 0) SummonNextWave(AllianceWaves, WaveCount, AllianceBase); else if (Faction == 1) SummonNextWave(HordeWaves, WaveCount, HordeBase); ++WaveCount; } else NextWaveTimer -= diff; } if (CheckTimer <= diff) { for (uint8 i = 0; i < 2; ++i) { if (BossGUID[i]) { Unit* unit = Unit::GetUnit(*me, BossGUID[i]); if (unit && (!unit->isAlive())) { if (BossGUID[i] == BossGUID[0]) { Talk(INCOMING); FirstBossDead = true; } else if (BossGUID[i] == BossGUID[1]) { Talk(SUCCESS); SecondBossDead = true; } EventBegun = false; CheckTimer = 0; me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP); BossGUID[i] = 0; if (instance) instance->DoUpdateWorldState(WORLD_STATE_ENEMY, 0); // Reset world state for enemies to disable it } } } CheckTimer = 5000; } else CheckTimer -= diff; if (!UpdateVictim()) return; for (uint8 i = 0; i < HYJAL_AI_MAX_SPELLS; ++i) { if (Spells[i].SpellId) { if (SpellTimer[i] <= diff) { if (me->IsNonMeleeSpellCasted(false)) me->InterruptNonMeleeSpells(false); Unit* target = NULL; switch (Spells[i].TargetType) { case TARGETTYPE_SELF: target = me; break; case TARGETTYPE_RANDOM: target = SelectTarget(SELECT_TARGET_RANDOM, 0); break; case TARGETTYPE_VICTIM: target = me->getVictim(); break; } if (target && target->isAlive()) { DoCast(target, Spells[i].SpellId); SpellTimer[i] = Spells[i].Cooldown; } } else SpellTimer[i] -= diff; } } DoMeleeAttackIfReady(); }
void UpdateAI(const uint32 diff) { if (!UpdateVictim()) return; if (HealthBelowPct(10) && !Enraged) { Enraged = true; DoCast(me, SPELL_ENRAGE, true); DoScriptText(SAY_ENRAGE, me); } //Randomly cast one beam. if (BeamTimer <= diff) { Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0); if (!pTarget || !pTarget->isAlive()) return; BeamTimer = 9000; switch(CurrentBeam) { case 0: DoCast(pTarget, SPELL_BEAM_SINISTER); break; case 1: DoCast(pTarget, SPELL_BEAM_VILE); break; case 2: DoCast(pTarget, SPELL_BEAM_WICKED); break; case 3: DoCast(pTarget, SPELL_BEAM_SINFUL); break; } ++BeamCount; uint32 Beam = CurrentBeam; if (BeamCount > 3) while (CurrentBeam == Beam) CurrentBeam = rand()%3; } else BeamTimer -= diff; // Random Prismatic Shield every 15 seconds. if (PrismaticShieldTimer <= diff) { uint32 random = rand()%6; if (PrismaticAuras[random]) DoCast(me, PrismaticAuras[random]); PrismaticShieldTimer = 15000; } else PrismaticShieldTimer -= diff; // Select 3 random targets (can select same target more than once), teleport to a random location then make them cast explosions until they get away from each other. if (FatalAttractionTimer <= diff) { ExplosionCount = 0; TeleportPlayers(); DoScriptText(RAND(SAY_SPELL2, SAY_SPELL3), me); FatalAttractionExplodeTimer = 2000; FatalAttractionTimer = 40000 + rand()%31 * 1000; } else FatalAttractionTimer -= diff; if (FatalAttractionExplodeTimer <= diff) { // Just make them explode three times... they're supposed to keep exploding while they are in range, but it'll take too much code. I'll try to think of an efficient way for it later. if (ExplosionCount < 3) { for (uint8 i = 0; i < 3; ++i) { Unit* pUnit = NULL; if (TargetGUID[i]) { pUnit = Unit::GetUnit((*me), TargetGUID[i]); if (pUnit) pUnit->CastSpell(pUnit, SPELL_ATTRACTION, true); TargetGUID[i] = 0; } } ++ExplosionCount; FatalAttractionExplodeTimer = 1000; } else { FatalAttractionExplodeTimer = FatalAttractionTimer + 2000; ExplosionCount = 0; } } else FatalAttractionExplodeTimer -= diff; if (ShriekTimer <= diff) { DoCast(me->getVictim(), SPELL_SILENCING_SHRIEK); ShriekTimer = 25000+rand()%10 * 1000; } else ShriekTimer -= diff; if (SaberTimer <= diff) { DoCast(me->getVictim(), SPELL_SABER_LASH); SaberTimer = 25000+rand()%10 * 1000; } else SaberTimer -= diff; //Enrage if (!me->HasAura(SPELL_BERSERK)) { if (EnrageTimer <= diff) { DoCast(me, SPELL_BERSERK); DoScriptText(SAY_ENRAGE, me); } else EnrageTimer -= diff; } //Random taunts if (RandomYellTimer <= diff) { DoScriptText(RAND(SAY_TAUNT1, SAY_TAUNT2, SAY_TAUNT3), me); RandomYellTimer = 60000 + rand()%91 * 1000; } else RandomYellTimer -= diff; DoMeleeAttackIfReady(); }
void UpdateAI(const uint32 diff) { //Only if not incombat check if the event is started if (!me->isInCombat() && instance && instance->GetData(DATA_MAULGAREVENT)) { Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_MAULGAREVENT_TANK)); if (target) { AttackStart(target); GetCouncil(); } } //Return since we have no target if (!UpdateVictim()) return; //someone evaded! if (instance && !instance->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; Talk(SAY_ENRAGE); 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* target = NULL; target = SelectTarget(SELECT_TARGET_RANDOM, 0); if (target) { AttackStart(target); DoCast(target, 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 (DelayTimer && DelayTimer > 5000) DelayEventStart(); else DelayTimer+=diff; switch (Phase) { case PHASE_UNDERGROUND: if (ImpaleTimer <= diff) { switch (ImpalePhase) { case IMPALE_PHASE_TARGET: if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true)) { if (Creature* impaleTarget = DoSummonImpaleTarget(target)) impaleTarget->CastSpell(impaleTarget, SPELL_IMPALE_SHAKEGROUND, true); ImpaleTimer = 3*IN_MILLISECONDS; ImpalePhase = IMPALE_PHASE_ATTACK; } break; case IMPALE_PHASE_ATTACK: if (Creature* impaleTarget = Unit::GetCreature(*me, ImpaleTarget)) { impaleTarget->CastSpell(impaleTarget, SPELL_IMPALE_SPIKE, false); impaleTarget->RemoveAurasDueToSpell(SPELL_IMPALE_SHAKEGROUND); } ImpalePhase = IMPALE_PHASE_DMG; ImpaleTimer = 1*IN_MILLISECONDS; break; case IMPALE_PHASE_DMG: if (Creature* impaleTarget = Unit::GetCreature(*me, ImpaleTarget)) me->CastSpell(impaleTarget, DUNGEON_MODE(SPELL_IMPALE_DMG, SPELL_IMPALE_DMG_H), true); ImpalePhase = IMPALE_PHASE_TARGET; ImpaleTimer = 9*IN_MILLISECONDS; break; } } else ImpaleTimer -= diff; if (!GuardianSummoned) { for (uint8 i = 0; i < 2; ++i) { if (Creature* Guardian = me->SummonCreature(CREATURE_GUARDIAN, SpawnPointGuardian[i], TEMPSUMMON_CORPSE_DESPAWN, 0)) { Guardian->AddThreat(me->getVictim(), 0.0f); DoZoneInCombat(Guardian); } } GuardianSummoned = true; } if (!VenomancerSummoned) { if (VenomancerTimer <= diff) { if (UndergroundPhase > 1) { for (uint8 i = 0; i < 2; ++i) { if (Creature* Venomancer = me->SummonCreature(CREATURE_VENOMANCER, SpawnPoint[i], TEMPSUMMON_CORPSE_DESPAWN, 0)) { Venomancer->AddThreat(me->getVictim(), 0.0f); DoZoneInCombat(Venomancer); } } VenomancerSummoned = true; } } else VenomancerTimer -= diff; } if (!DatterSummoned) { if (DatterTimer <= diff) { if (UndergroundPhase > 2) { for (uint8 i = 0; i < 2; ++i) { if (Creature* Datter = me->SummonCreature(CREATURE_DATTER, SpawnPoint[i], TEMPSUMMON_CORPSE_DESPAWN, 0)) { Datter->AddThreat(me->getVictim(), 0.0f); DoZoneInCombat(Datter); } } DatterSummoned = true; } } else DatterTimer -= diff; if (me->HasAura(SPELL_LEECHING_SWARM)) me->RemoveAurasDueToSpell(SPELL_LEECHING_SWARM); } if (UndergroundTimer <= diff) { me->RemoveAura(SPELL_SUBMERGE); me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE); Phase = PHASE_MELEE; } else UndergroundTimer -= diff; break; case PHASE_MELEE: if (((UndergroundPhase == 0 && HealthBelowPct(75)) || (UndergroundPhase == 1 && HealthBelowPct(50)) || (UndergroundPhase == 2 && HealthBelowPct(25))) && !me->HasUnitState(UNIT_STATE_CASTING)) { GuardianSummoned = false; VenomancerSummoned = false; DatterSummoned = false; UndergroundTimer = 40*IN_MILLISECONDS; VenomancerTimer = 25*IN_MILLISECONDS; DatterTimer = 32*IN_MILLISECONDS; ImpalePhase = 0; ImpaleTimer = 9*IN_MILLISECONDS; DoCast(me, SPELL_SUBMERGE, false); me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE); Phase = PHASE_UNDERGROUND; ++UndergroundPhase; } if (Channeling == true) { for (uint8 i = 0; i < 8; ++i) DoCast(me->getVictim(), SPELL_SUMMON_CARRION_BEETLES, true); Channeling = false; } else if (CarrionBeetlesTimer <= diff) { Channeling = true; DoCastVictim(SPELL_CARRION_BEETLES); CarrionBeetlesTimer = 25*IN_MILLISECONDS; } else CarrionBeetlesTimer -= diff; if (LeechingSwarmTimer <= diff) { DoCast(me, SPELL_LEECHING_SWARM, true); LeechingSwarmTimer = 19*IN_MILLISECONDS; } else LeechingSwarmTimer -= diff; if (PoundTimer <= diff) { if (Unit* target = me->getVictim()) { if (Creature* pImpaleTarget = DoSummonImpaleTarget(target)) me->CastSpell(pImpaleTarget, DUNGEON_MODE(SPELL_POUND, SPELL_POUND_H), false); } PoundTimer = 16500; } else PoundTimer -= diff; DoMeleeAttackIfReady(); break; } }