Exemple #1
0
		void UpdateAI(uint32 diff)
		{
			if (!pInstance)
				return;

			events.Update(diff);

			switch (events.ExecuteEvent())
			{
			case EVENT_CHECK_WIPE:
				if (pInstance->IsWipe())
					Reset();
				else
					events.ScheduleEvent(EVENT_CHECK_WIPE, 1000);
				break;
			case EVENT_RAIGONN_CHARGE:
				DoEventCharge();
				break;
			case EVENT_SUMMON_PROTECTORAT:
			{
				for (uint8 i = 0; i < 8; ++i)
					if (Creature* summon = me->SummonCreature(NPC_KRIKTHIK_PROTECTORAT, frand(941.0f, 974.0f), 2374.85f, 296.67f, 4.73f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000))
						if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
							if (summon->IsAIEnabled)
								summon->AI()->AttackStart(target);

				events.ScheduleEvent(EVENT_SUMMON_PROTECTORAT, urand(30000, 45000), PHASE_WEAK_SPOT);
				break;
			}
			case EVENT_SUMMON_ENGULFER:
			{
				for (uint8 i = 0; i < 3; ++i)
					me->SummonCreature(NPC_KRIKTHIK_ENGULFER, frand(941.0f, 974.0f), me->GetPositionY(), me->GetPositionZ() + 30.0f, 4.73f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000);

				events.ScheduleEvent(EVENT_SUMMON_ENGULFER, urand(95000, 105000), PHASE_WEAK_SPOT);
				break;
			}
			case EVENT_SUMMON_SWARM_BRINGER:
			{
				if (Creature* summon = me->SummonCreature(NPC_KRIKTHIK_SWARM_BRINGER, frand(941.0f, 974.0f), 2374.85f, 296.67f, 4.73f, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 5000))
					if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
						if (summon->AI())
							summon->AI()->AttackStart(target);

				events.ScheduleEvent(EVENT_SUMMON_ENGULFER, urand(35000, 50000), PHASE_WEAK_SPOT);
				break;
			}
			case EVENT_FIXATE:
			{
				if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1))
				{
					me->CastSpell(target, SPELL_FIXATE, true);

					me->SetReactState(REACT_PASSIVE);
					me->GetMotionMaster()->MoveChase(target);

				}
				events.ScheduleEvent(EVENT_FIXATE_STOP, 15000, PHASE_VULNERABILITY);
				break;
			}
			case EVENT_FIXATE_STOP:
			{
				me->SetReactState(REACT_AGGRESSIVE);
				me->GetMotionMaster()->Clear();

				if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
					AttackStart(target);

				events.ScheduleEvent(EVENT_FIXATE, 30000, PHASE_VULNERABILITY);
				break;
			}
			case EVENT_STOMP:
			{
				me->CastSpell(me, SPELL_STOMP, false);
				events.ScheduleEvent(EVENT_STOMP, 30000, PHASE_VULNERABILITY);
				break;
			}
			default:
				break;
			}

			if (Phase == PHASE_VULNERABILITY)
				DoMeleeAttackIfReady();
		}
Exemple #2
0
            void UpdateAI(uint32 const diff)
            {
                if (!UpdateVictim() || !CheckInRoom() || me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                if (instance && instance->IsWipe())
                {
                    EnterEvadeMode();
                    return;
                }

                if (me->GetPower(POWER_ENERGY) == 100 && !breathScheduled)
                {
				    events.ScheduleEvent(EVENT_FURIOUS_STONE_BREATH, TIMER_FURIOUS_STONE_BREATH);
				    events.ScheduleEvent(EVENT_RESET_CAST, TIMER_RESET_CAST);
					breathScheduled = true;
                }

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
                {
                    switch (eventId)
                    {
                        case EVENT_CALL_OF_TORTOS:
                            Talk(ANN_TURTLES);
				            DoCast(me, SPELL_CALL_OF_TORTOS);
				            events.ScheduleEvent(EVENT_CALL_OF_TORTOS, TIMER_CALL_OF_TORTOS_S);
                            break;

                        case EVENT_FURIOUS_STONE_BREATH:
                            Talk(ANN_FURIOUS_BREATH);
				            DoCast(me, SPELL_FURIOUS_STONE_BREATH);
                            break;

                        case EVENT_RESET_CAST:
				            breathScheduled = false;
                            break;

                        case EVENT_SNAPPING_BITE:
				            DoCast(me->getVictim(), SPELL_SNAPPING_BITE);
				            events.ScheduleEvent(EVENT_SNAPPING_BITE, IsHeroic() ? TIMER_SNAPPING_BITE_H : TIMER_SNAPPING_BITE_N);
                            break;

                        case EVENT_QUAKE_STOMP:
				            DoCast(me, SPELL_QUAKE_STOMP);
				            events.ScheduleEvent(EVENT_QUAKE_STOMP, TIMER_QUAKE_STOMP_S);
                            break;

                        case EVENT_SUMMON_BATS:
                            if (Unit* target = SelectTarget(SELECT_TARGET_FARTHEST, 0, 100.0f, true))
				                me->CastSpell(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ() + 12.0f, SPELL_SUMMON_BATS, true);
				            events.ScheduleEvent(EVENT_SUMMON_BATS, TIMER_CALL_BATS_S);
                            break;

                        case EVENT_GROWING_FURY:
                            if (!me->IsWithinDistInMap(me->getVictim(), me->GetAttackDistance(me->getVictim())))
				                DoCast(me, SPELL_GROWING_FURY);
                            events.ScheduleEvent(EVENT_GROWING_FURY, TIMER_GROWING_FURY);
                            break;

                        case EVENT_REGEN_FURY_POWER:
                            me->SetPower(POWER_ENERGY, me->GetPower(POWER_ENERGY) + 2);
                            events.ScheduleEvent(EVENT_REGEN_FURY_POWER, TIMER_REGEN_FURY_POWER);
                            break;

                        case EVENT_BERSERK:
				            DoCast(me, SPELL_BERSERK);
                            break;

                        default: break;
                    }
                }

                DoMeleeAttackIfReady();
            }
            void UpdateAI(const uint32 diff)
            {
                events.Update(diff);

                switch(uint32 eventId = events.ExecuteEvent())
                {
                    // Event Script
                    case EVENT_FIRST_EVENT:
                        DoEvent();
                        break;
                    case EVENT_CHECK_WIPE:
                        if (pInstance->IsWipe())
                            Reset();
                        events.ScheduleEvent(EVENT_CHECK_WIPE, defaultrand);
                        break;
                    // Combat Script
                    /// Phase 1
                    case EVENT_TORNADO_KICK:
                        me->CastSpell(me, SPELL_TORNADO_KICK, false);
                        events.ScheduleEvent(EVENT_TORNADO_KICK, urand(7500, 12500));
                        break;
                    case EVENT_FIST_OF_FURY:
                        if (Unit* target = SelectTarget(SELECT_TARGET_TOPAGGRO))
                            me->CastSpell(target, SPELL_FIST_OF_FURY, false);

                        events.ScheduleEvent(EVENT_FIST_OF_FURY, urand(5000, 10000));
                        break;
                    case EVENT_CHASE_DOWN:
                        // Todo
                        events.ScheduleEvent(eventId, defaultrand);
                        break;
                    /// Phase 2
                    case EVENT_DISAPPEAR:
                    {
                        std::vector<uint8> randomIndex;
                        for (int i = 0; i < 3; ++i) randomIndex.push_back(i); // 0 1 2
                        std::random_shuffle(randomIndex.begin(), randomIndex.end());

                        bool isBoss = true;

                        for (auto index : randomIndex)
                        {
                            // The first random pos is for the boss, the two others are for his clones
                            if (isBoss)
                            {
                                me->NearTeleportTo(ClonePos[index].GetPositionX(), ClonePos[index].GetPositionY(), ClonePos[index].GetPositionZ(), ClonePos[index].GetOrientation());
                                me->SetVisible(true);
                                me->CastSpell(me, SPELL_SMOKE_BOMB, true);
                                isBoss = false;
                            }
                            else
                                if (Creature* clone = me->SummonCreature(NPC_SNOWDRIFT_CLONE, ClonePos[index].GetPositionX(), ClonePos[index].GetPositionY(), ClonePos[index].GetPositionZ(), ClonePos[index].GetOrientation()))
                                    clone->CastSpell(clone, SPELL_SMOKE_BOMB, true);
                        }

                        initDefaultEventsForPhase();
                        break;
                    }
                    case EVENT_FIREBALL:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
                            me->CastSpell(target, SPELL_BALL_OF_FIRE, false);

                        events.ScheduleEvent(EVENT_FIREBALL, urand(2500, 5000));
                        break;
                    /// Phase 3
                    case EVENT_PHASE_3:
                        me->SetReactState(REACT_AGGRESSIVE);
                        phase = PHASE_FIGHT_3;
                        initDefaultEventsForPhase();
                        break;
                    case EVENT_PARRY_STANCE:
                        me->CastSpell(me, SPELL_PARRY_STANCE, false);
                        events.ScheduleEvent(EVENT_PARRY_STANCE, urand(10000, 15000));
                        break;
                    case EVENT_QUIVERING_PALM:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
                            me->CastSpell(target, SPELL_QUIVERING_PALM, false);

                        events.ScheduleEvent(EVENT_QUIVERING_PALM, urand(5000, 10000));
                        break;
                    default:
                        break;
                }

                if (phase == PHASE_FIGHT_1 || phase == PHASE_FIGHT_3)
                    DoMeleeAttackIfReady();
            }