Пример #1
0
            void Reset()
            {
                events.Reset();

                events.ScheduleEvent(EVENT_SUMMON_ZEPHYR, 4000);
            }
Пример #2
0
 void Reset()
 {
     m_instance->SetData(ENC_IMMOLTHAR, NOT_STARTED);
     m_events.Reset();
     m_phase = 0;
 }
Пример #3
0
		void UpdateAI(uint32 diff)
		{
			if (!UpdateVictim() && !me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE))
				return;

			events.Update(diff);

			if (me->HasUnitState(UNIT_STATE_CASTING))
				return;

			switch(events.GetEvent())
			{
				case 0:
					break;
				case EVENT_EMERGE:
					me->SetVisible(true);
					me->CastSpell(me, SPELL_EMERGE_0, false);
					events.PopEvent();
					events.RescheduleEvent(EVENT_ATTACK, 2000);
					break;
				case EVENT_SUMMON_TOTEMS:
					for (uint8 i=0; i<3; ++i)
						DoSummon(NPC_TOTEM, TotemPos[i], 10*60*1000, TEMPSUMMON_TIMED_DESPAWN);
					events.PopEvent();
					break;
				case EVENT_INVOKER_SAY_1:
					if (Player* plr = ObjectAccessor::GetPlayer(*me, InvokerGUID))
					{
						plr->MonsterSay("The Ice Stone has melted!", LANG_UNIVERSAL, 0);
						plr->CastSpell(plr, SPELL_MAKE_BONFIRE, true);
					}
					events.PopEvent();
					events.RescheduleEvent(EVENT_INVOKER_SAY_2, 2000);
					break;
				case EVENT_INVOKER_SAY_2:
					if (Player* plr = ObjectAccessor::GetPlayer(*me, InvokerGUID))
						plr->MonsterSay("Ahune, your strength grows no more!", LANG_UNIVERSAL, 0);
					events.PopEvent();
					events.RescheduleEvent(EVENT_INVOKER_SAY_3, 2000);
					break;
				case EVENT_INVOKER_SAY_3:
					if (Player* plr = ObjectAccessor::GetPlayer(*me, InvokerGUID))
						plr->MonsterSay("Your frozen reign will not come to pass!", LANG_UNIVERSAL, 0);
					events.PopEvent();
					break;
				case EVENT_ATTACK:
					events.Reset();
					if (Player* plr = ObjectAccessor::GetPlayer(*me, InvokerGUID))
						AttackStart(plr);
					me->SetInCombatWithZone();
					if (!me->IsInCombat())
					{
						EnterEvadeMode();
						return;
					}
					else
						me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
					break;
				case EVENT_TOTEMS_ATTACK:
					for (uint8 i=0; i<3; ++i)
						if (Creature* bunny = me->FindNearestCreature(NPC_TOTEM_BUNNY_1+i, 150.0f, true))
							bunny->CastSpell(me, SPELL_TOTEM_BEAM, false);
					events.PopEvent();
					events.RescheduleEvent(EVENT_SUBMERGE, 10000);
					break;
				case EVENT_SUBMERGE:
					me->MonsterTextEmote(TEXT_RETREAT, 0, true);
					me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
					me->CastSpell(me, SPELL_SUBMERGE_0, true);
					me->CastSpell(me, SPELL_SELF_STUN, true);
					if (Creature* c = DoSummon(NPC_FROZEN_CORE, *me, 24000, TEMPSUMMON_TIMED_DESPAWN))
					{
						c->SetHealth(me->GetHealth());
					}
					events.Reset();
					events.RescheduleEvent(EVENT_COMBAT_EMERGE, 25000);
					events.RescheduleEvent(EVENT_EMERGE_WARNING, 20000);
					break;
				case EVENT_EMERGE_WARNING:
					me->MonsterTextEmote(TEXT_RESURFACE, 0, true);
					events.PopEvent();
					break;
				case EVENT_COMBAT_EMERGE:
					me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
					me->RemoveAura(SPELL_SELF_STUN);
					me->CastSpell(me, SPELL_EMERGE_0, false);
					// me->CastSpell(me, SPELL_AHUNE_RESURFACES, true); // done in SummonedCreatureDespawn
					me->RemoveAura(SPELL_SUBMERGE_0);
					events.PopEvent();
					StartPhase1();
					break;

				case EVENT_SPELL_COLD_SLAP:
					if (Unit* target = SelectTarget(SELECT_TARGET_NEAREST, 0, 5.0f, true))
						if (target->GetPositionZ() < me->GetPositionZ()+6.0f)
						{
							int32 dmg = urand(5500,6000);
							me->CastCustomSpell(target, SPELL_COLD_SLAP, &dmg, NULL, NULL, false);
							float x, y, z;
							target->GetNearPoint(target, x, y, z, target->GetObjectSize(), 30.0f, target->GetAngle(me->GetPositionX(), me->GetPositionY()) + M_PI);
							target->GetMotionMaster()->MoveJump(x, y, z+20.0f, 10.0f, 20.0f);
						}
					events.RepeatEvent(1500);
					break;
				case EVENT_SPELL_SUMMON_HAILSTONE:
					{
						float dist = (float)urand(3,10);
						float angle = rand_norm()*2*M_PI;
						me->CastSpell(MinionSummonPos.GetPositionX()+cos(angle)*dist, MinionSummonPos.GetPositionY()+sin(angle)*dist, MinionSummonPos.GetPositionZ(), SPELL_SUMMON_HAILSTONE, false);
						events.RepeatEvent(30000);
					}
					break;
				case EVENT_SPELL_SUMMON_COLDWAVE:
					for (uint8 i=0; i<2; ++i)
					{
						float dist = (float)urand(3,10);
						float angle = rand_norm()*2*M_PI;
						me->CastSpell(MinionSummonPos.GetPositionX()+cos(angle)*dist, MinionSummonPos.GetPositionY()+sin(angle)*dist, MinionSummonPos.GetPositionZ(), SPELL_SUMMON_COLDWAVE, false);
					}
					{
						float dist = (float)urand(3,10);
						float angle = rand_norm()*2*M_PI;
						me->CastSpell(MinionSummonPos.GetPositionX()+cos(angle)*dist, MinionSummonPos.GetPositionY()+sin(angle)*dist, MinionSummonPos.GetPositionZ(), SPELL_SUMMON_FROSTWIND, false);
					}
					events.RepeatEvent(6000);
					break;

				default:
					events.PopEvent();
					break;
			}

			DoMeleeAttackIfReady();
		}
Пример #4
0
 void Reset()
 {
     events.Reset();
     Summons.DespawnAll();
     isEnraged = false;
 }
Пример #5
0
 void EnterCombat(Unit* /*attacker*/)
 {
     events.Reset();
     events.ScheduleEvent(EVENT_CAST_CLEAVE, urand(3000, 5000));
     events.ScheduleEvent(EVENT_CAST_STARFALL, urand(8000, 10000));
 }
            void Reset()
            {
                events.Reset();

                events.ScheduleEvent(EVENT_THROW,      7000);
            }
Пример #7
0
 void Reset()
 {
     summons.DespawnAll();
     events.Reset();
     stage = 0;
 }
		void Reset()
		{
			events.Reset();

			events.ScheduleEvent(EVENT_AGGRO, 5500);
		}
Пример #9
0
		void Reset()
            {
                me->SetReactState(REACT_DEFENSIVE);
                events.Reset();
            }
		void UpdateAI(uint32 diff)
		{
			if (me->HasUnitState(UNIT_STATE_CASTING) || (!me->isInCombat()))
				return;

			if((me->GetHealthPct() < 25 || Ignacious->GetHealthPct() < 25 ) && phase == 1)
			{ // Switch to Arion and Terrestra Phase (2)

				phase++;
				events.Reset();
				me->RemoveAllAuras();
				Ignacious->RemoveAllAuras();

				me->SetVisible(false);
				Ignacious->SetVisible(false);

				me->SetReactState(REACT_PASSIVE);
				Ignacious->SetReactState(REACT_PASSIVE);

				me->SetFlag(UNIT_FIELD_FLAGS,UNIT_FLAG_NON_ATTACKABLE);
				Ignacious->SetFlag(UNIT_FIELD_FLAGS,UNIT_FLAG_NON_ATTACKABLE);

				Ascendants[3] = Terrestra = me->SummonCreature(BOSS_TERRASTRA,position[1],TEMPSUMMON_MANUAL_DESPAWN);
				Ascendants[2] = Arion = me->SummonCreature(BOSS_ARION,position[0],TEMPSUMMON_MANUAL_DESPAWN);

			}else if(Arion && Terrestra)
			{
				if((Arion->GetHealthPct() < 25 || Terrestra->GetHealthPct() < 25 ) && phase == 2)
				{ // Switch to Monstrosity Phase (3)

					phase++;

					for(uint8 i = 0; i<=3;i++)
					{
						Ascendants[i]->RemoveAllAuras();
						Ascendants[i]->SetVisible(true);
						Ascendants[i]->SetReactState(REACT_PASSIVE);
						Ascendants[i]->AttackStop();
						Ascendants[i]->SetFlag(UNIT_FIELD_FLAGS,UNIT_FLAG_NON_ATTACKABLE);

						Ascendants[i]->NearTeleportTo(position[i+1].GetPositionX(),position[i+1].GetPositionY(),position[i+1].GetPositionZ(),position[i+1].GetOrientation());
					}

					AscentInTheMiddle = 0;
					events.ScheduleEvent(EVENT_EVENT_GO_IN_DELAY, 2200);

				}else if(phase == 3)
				{ // Phase 3 for Event

					events.Update(diff);

					while (uint32 eventId = events.ExecuteEvent())
					{
						switch (eventId)
						{
						case EVENT_EVENT_GO_IN_DELAY:			

							Ascendants[AscentInTheMiddle]->GetMotionMaster()->MovePoint(0,position[6]);

							AscentInTheMiddle++;

							if(AscentInTheMiddle != 4)
								events.ScheduleEvent(EVENT_EVENT_GO_IN_DELAY, 2200);
							break;
						}
					}
				}
			}

			if(phase > 1 || !UpdateVictim())
				return;

			events.Update(diff);

			while (uint32 eventId = events.ExecuteEvent())
			{
				switch (eventId)
				{

				case EVENT_HYDROLANCE:

					if(Unit * Victim = SelectTarget(SELECT_TARGET_RANDOM,0 ,500.0f,true))
						me->CastSpell(Victim,SPELL_HYDROLANCE,false);

					events.ScheduleEvent(EVENT_HYDROLANCE, urand(10000,12000));
					break;

				case EVENT_WATER_BOMB:
					DoCast(SPELL_WATERBOMB);

					events.ScheduleEvent(EVENT_WATER_BOMB, urand(16000,19000));
					break;

				case EVENT_HEART_OF_ICE:

					if(Unit * Victim = SelectTarget(SELECT_TARGET_RANDOM,0 ,500.0f,true))
						me->CastSpell(Victim,SPELL_HEART_OF_ICE,false);

					events.ScheduleEvent(EVENT_HEART_OF_ICE, urand(10000,12000));
					break;

				case EVENT_GLACIATE:
					DoCastAOE(SPELL_GLACIATE);

					events.ScheduleEvent(EVENT_GLACIATE, urand(32000,34000));
					break;

				default:
					break;
				}
			}		

			DoMeleeAttackIfReady();
		}
Пример #11
0
 void Reset()
 {
     m_instance->SetData(ENC_LETHTENDRIS, NOT_STARTED);
     m_events.Reset();
     m_phase = 0;
 }
Пример #12
0
            void Reset()
            {
                events.Reset();

                events.ScheduleEvent(EVENT_BURST, 4000);
            }
Пример #13
0
            void Reset()
            {
                events.Reset();

                events.ScheduleEvent(EVENT_UNDERWHELMING_ASSAULT, 4000);
            }
Пример #14
0
            void Reset()
            {
                events.Reset();

                events.ScheduleEvent(EVENT_SWIFT_STEP, 4000);
            }
Пример #15
0
        void UpdateAI(uint32 diff) override
        {
            if (HealthBelowPct(75))
            {
                if (PotTimer <= diff)
                {
                    DoCast(me, SPELL_HEALING_POTION, true);
                    PotTimer = 10000;
                } else PotTimer -= diff;
            }

            if (GetAttack() && UpdateVictim())
                DoMeleeAttackIfReady();

            npc_escortAI::UpdateAI(diff);

            if (me->IsInCombat())
                return;

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                    case EVENT_EMOTE_BEG:
                        me->HandleEmoteCommand(EMOTE_ONESHOT_BEG);
                        events.ScheduleEvent(EVENT_EMOTE_BEG, Seconds(25));
                        break;
                    case EVENT_BEGIN:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_0, player);
                        break;
                    case EVENT_START_ESCORT:
                        events.Reset();
                        me->setFaction(FACTION_ESCORTEE_H);
                        me->SetReactState(REACT_AGGRESSIVE);
                        ENSURE_AI(npc_escortAI, (me->AI()))->Start(true, true, _player);
                        break;
                    case EVENT_TALK_1:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_1, player);
                        break;
                    case EVENT_KNEEL:
                        me->HandleEmoteCommand(EMOTE_ONESHOT_KNEEL);
                        break;
                    case EVENT_TALK_2:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_2, player);
                        me->LoadEquipment(EQUIP_TORCH);
                        me->SetSheath(SHEATH_STATE_MELEE);
                        break;
                    case EVENT_BURN_CRATES:
                        DoCastAOE(SPELL_BURN, true);
                        break;
                    case EVENT_TALK_3:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_3, player);
                        break;
                    case EVENT_TALK_4:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_4, player);
                        break;
                    case EVENT_LAUGH:
                        me->HandleEmoteCommand(EMOTE_ONESHOT_LAUGH);
                        break;
                    case EVENT_TALK_5:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_5, player);
                        me->HandleEmoteCommand(EMOTE_ONESHOT_RUDE);
                        break;
                    case EVENT_TALK_6:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_6, player);
                        break;
                    case EVENT_TALK_8:
                        if (Player* player = ObjectAccessor::GetPlayer(*me, _player))
                            Talk(TALK_8, player);
                        break;
                }
            }
        }
Пример #16
0
 void Reset()
 {
     events.Reset();
     me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
     me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC);
 }
Пример #17
0
 void Reset() 
 {
     events.Reset();
     m_uiHealthAmountModifier = 1;
 }
Пример #18
0
 void Reset()
 {
     m_instance->SetData(ENC_TENDRIS_WARPWOOD, NOT_STARTED);
     m_events.Reset();
     m_phase = 0;
 }
Пример #19
0
            void UpdateAI(uint32 diff)
            {
                events2.Update(diff);
                switch (events2.ExecuteEvent())
                {
                    case INTRO_1:
                        me->GetMotionMaster()->MovePath(KIRTONOS_PATH, false);
                        break;
                    case INTRO_2:
                        me->GetMotionMaster()->MovePoint(0, PosMove[0]);
                        break;
                    case INTRO_3:
                        if (GameObject* gate = me->GetMap()->GetGameObject(instance->GetData64(GO_GATE_KIRTONOS)))
                            gate->SetGoState(GO_STATE_READY);
                        me->SetFacingTo(0.01745329f);
                        break;
                    case INTRO_4:
                        me->SetWalk(true);
                        me->SetDisableGravity(false);
                        me->CastSpell(me, SPELL_KIRTONOS_TRANSFORM, true);
                        me->SetCanFly(false);
                        break;
                    case INTRO_5:
                        me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
                        me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(WEAPON_KIRTONOS_STAFF));
                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE|UNIT_FLAG_NOT_SELECTABLE);
                        me->SetReactState(REACT_AGGRESSIVE);
                        break;
                    case INTRO_6:
                        me->GetMotionMaster()->MovePoint(0, PosMove[1]);
                        break;
                }

                if (!UpdateVictim())
                    return;

                events.Update(diff);
                if (me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                switch (events.ExecuteEvent())
                {
                    case EVENT_SWOOP:
                        me->CastSpell(me->GetVictim(), SPELL_SWOOP, false);
                        events.ScheduleEvent(EVENT_SWOOP, 15000);
                        break;
                    case EVENT_WING_FLAP:
                        me->CastSpell(me, SPELL_WING_FLAP, false);
                        events.ScheduleEvent(EVENT_WING_FLAP, 13000);
                        break;
                    case EVENT_PIERCE_ARMOR:
                        me->CastSpell(me->GetVictim(), SPELL_PIERCE_ARMOR, false);
                        events.ScheduleEvent(EVENT_PIERCE_ARMOR, 12000);
                        break;
                    case EVENT_DISARM:
                        me->CastSpell(me->GetVictim(), SPELL_DISARM, false);
                        events.ScheduleEvent(EVENT_DISARM, 11000);
                        break;
                    case EVENT_SHADOW_BOLT_VOLLEY:
                        me->CastSpell(me, SPELL_SHADOW_BOLT_VOLLEY, false);
                        events.ScheduleEvent(EVENT_SHADOW_BOLT_VOLLEY, 10000);
                        break;
                    case EVENT_CURSE_OF_TONGUES:
                        me->CastSpell(me, SPELL_CURSE_OF_TONGUES, false);
                        events.ScheduleEvent(EVENT_CURSE_OF_TONGUES, 20000);
                        break;
                    case EVENT_DOMINATE_MIND:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 20.0f, true))
                            me->CastSpell(target, SPELL_DOMINATE_MIND, false);
                        events.ScheduleEvent(EVENT_DOMINATE_MIND, urand(44000, 48000));
                        break;
                    case EVENT_KIRTONOS_TRANSFORM:
                        if (me->HealthBelowPct(50))
                        {
                            events.Reset();
                            events.ScheduleEvent(EVENT_SWOOP, 4000);
                            events.ScheduleEvent(EVENT_WING_FLAP, 7000);
                            events.ScheduleEvent(EVENT_PIERCE_ARMOR, 11000);
                            events.ScheduleEvent(EVENT_DISARM, 15000);
                            me->RemoveAura(SPELL_KIRTONOS_TRANSFORM);
                            me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, uint32(0));
                            break;
                        }

                        events.ScheduleEvent(EVENT_KIRTONOS_TRANSFORM, 2000);
                        break;
                }

                DoMeleeAttackIfReady();
            }
Пример #20
0
        void Reset()
        {
            events.Reset();
			_ragecasted = false;
        }
Пример #21
0
 void Reset()
 {
     events.Reset();
     phase = PHASE_NORMAL;
 }
Пример #22
0
			void Reset()
			{
				events.Reset();
				events.ScheduleEvent(EVENT_MOJO_MOJO_PUDDLE, 13000);
				events.ScheduleEvent(EVENT_MOJO_MOJO_WAVE, 15000);
			}
Пример #23
0
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
                return;

            if(phase == PHASE_CASTER_PHASE && !HealthAbovePct(30))
            {
                phase = PHASE_DRAGON_PHASE;

                me->SetSpeed(MOVE_RUN, 1.5f);
                me->SetReactState(REACT_PASSIVE);
                me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                me->RemoveAllAuras();

                DoCast(me, SPELL_TWILIGHT_PROTECTION, true);

                events.Reset();

                me->GetMotionMaster()->MovePoint(POINT_DRAHGA_GO_TO_THE_LAVA, position[0]);
                pValiona = me->SummonCreature(NPC_VALIONA,-375.33f,-667.291f,270.0f,3.29545f, TEMPSUMMON_CORPSE_DESPAWN);
            }

            if(phase == PHASE_DRAGON_PHASE && !HealthAbovePct(10))
            {
                phase = PHASE_FINAL_PHASE;

                me->SetReactState(REACT_AGGRESSIVE);
                me->GetMotionMaster()->Clear();
                me->GetMotionMaster()->MoveChase(me->getVictim());

                if(pValiona)
                    pValiona->GetAI()->DoAction(ACTION_VALIONA_SHOULD_FLY_AWAY);
            }

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                    case EVENT_BURNING_SHADOWBOLT:
                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(pTarget, RAID_MODE(SPELL_BURNING_SHADOWBOLT,SPELL_BURNING_SHADOWBOLT_H));
                        events.ScheduleEvent(EVENT_BURNING_SHADOWBOLT,4000);
                        break;
                    case EVENT_SUMMON_INVOKED_FLAME_SPIRIT:
                        Talk(SAY_SUMMON_1);
                        me->CastSpell(me->getVictim(), SPELL_INVOCATION_OF_FLAME, true);
                        events.ScheduleEvent(EVENT_SUMMON_INVOKED_FLAME_SPIRIT,20000);
                        break;
                    case EVENT_DRAGAH_ENTER_VEHICLE:
                        me->GetMotionMaster()->Clear();
                        me->EnterVehicle(pValiona);
                        break;
                    default:
                        break;
                }
            }

            DoMeleeAttackIfReady();
        }
            void UpdateAI(uint32 diff)
            {
                events2.Update(diff);
                switch (events2.ExecuteEvent())
                {
                    case EVENT_RANDOM_TAUNT:
                        Talk(SAY_TAUNT);
                        events2.ScheduleEvent(EVENT_RANDOM_TAUNT, 90000);
                        break;
                    case EVENT_CHECK_GRASP:
                        if (me->GetAuraCount(SPELL_SHADOW_GRASP_VISUAL) == 5)
                        {
                            Talk(SAY_BANISH);
                            me->InterruptNonMeleeSpells(true);
                            break;
                        }
                        events2.ScheduleEvent(EVENT_CHECK_GRASP, 0);
                        break;
                }


                if (!UpdateVictim() || !CheckInRoom())
                    return;

                events.Update(diff);
                if (me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                switch (events.ExecuteEvent())
                {
                    case EVENT_EMOTE1:
                        Talk(SAY_EMOTE_BEGIN);
                        break;
                    case EVENT_EMOTE2:
                        Talk(SAY_EMOTE_NEARLY);
                        break;
                    case EVENT_EMOTE3:
                        Talk(SAY_EMOTE_FREE);
                        Talk(SAY_FREE);
                        break;
                    case EVENT_ENTER_COMBAT:
                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_IMMUNE_TO_PC);
                        me->SetReactState(REACT_AGGRESSIVE);
                        events.ScheduleEvent(EVENT_CLEAVE, 9000);
                        events.ScheduleEvent(EVENT_BLAST_NOVA, 60000);
                        events.ScheduleEvent(EVENT_BLAZE, 10000);
                        events.ScheduleEvent(EVENT_QUAKE, 40000);
                        events.ScheduleEvent(EVENT_CHECK_HEALTH, 500);
                        events.ScheduleEvent(EVENT_ENRAGE, 22*MINUTE*IN_MILLISECONDS);

                        instance->SetData(DATA_ACTIVATE_CUBES, 1);
                        me->RemoveAurasDueToSpell(SPELL_SHADOW_CAGE);
                        break;
                    case EVENT_CLEAVE:
                        me->CastSpell(me->GetVictim(), SPELL_CLEAVE, false);
                        events.ScheduleEvent(EVENT_CLEAVE, 10000);
                        break;
                    case EVENT_BLAST_NOVA:
                        me->CastSpell(me, SPELL_BLAST_NOVA, false);
                        events.ScheduleEvent(EVENT_BLAST_NOVA, 60000);
                        events.ScheduleEvent(EVENT_CANCEL_GRASP_CHECK, 12000);
                        events2.ScheduleEvent(EVENT_CHECK_GRASP, 0);
                        break;
                    case EVENT_BLAZE:
                        me->CastCustomSpell(SPELL_BLAZE, SPELLVALUE_MAX_TARGETS, 1);
                        events.ScheduleEvent(EVENT_BLAZE, 30000);
                        break;
                    case EVENT_ENRAGE:
                        me->CastSpell(me, SPELL_BERSERK, true);
                        break;
                    case EVENT_CANCEL_GRASP_CHECK:
                        events2.Reset();
                        break;
                    case EVENT_QUAKE:
                        me->CastSpell(me, SPELL_QUAKE, false);
                        events.ScheduleEvent(EVENT_QUAKE, 50000);
                        break;
                    case EVENT_CHECK_HEALTH:
                        if (me->HealthBelowPct(30))
                        {
                            Talk(SAY_PHASE3);
                            events.SetPhase(1);
                            events.DelayEvents(18000);
                            events.ScheduleEvent(EVENT_COLLAPSE_CEIL, 8000);
                            events.ScheduleEvent(EVENT_COLLAPSE_DAMAGE, 15000);
                            break;
                        }
                        events.ScheduleEvent(EVENT_CHECK_HEALTH, 500);
                        break;
                    case EVENT_COLLAPSE_CEIL:
                        me->CastSpell(me, SPELL_CAMERA_SHAKE, true);
                        instance->SetData(DATA_COLLAPSE, GO_STATE_ACTIVE);
                        break;
                    case EVENT_COLLAPSE_DAMAGE:
                        me->CastSpell(me, SPELL_COLLAPSE_DAMAGE, true);
                        me->resetAttackTimer();
                        events.SetPhase(0);
                        events.ScheduleEvent(EVENT_DEBRIS, 20000);
                        break;
                    case EVENT_DEBRIS:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
                        {
                            target->CastSpell(target, SPELL_DEBRIS_VISUAL, true, NULL, NULL, me->GetGUID());
                            me->m_Events.AddEvent(new DealDebrisDamage(*me, target->GetGUID()), me->m_Events.CalculateTime(5000));
                        }
                        events.ScheduleEvent(EVENT_DEBRIS, 20000);
                        break;
                }

                if (!events.IsInPhase(1))
                    DoMeleeAttackIfReady();
            }
Пример #25
0
 void Reset()
 {
     events.Reset();
     events.ScheduleEvent(EVENT_DESPAWN, 5*MINUTE*IN_MILLISECONDS);
 }
Пример #26
0
 void Reset()
 {
     _events.Reset();
     summons.DespawnAll();
 }
Пример #27
0
		void EnterCombat(Unit* /*who*/)
		{
			DoZoneInCombat();
			events.Reset();
			StartPhase1();
		}
Пример #28
0
        void Reset()
        {
            me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
            events.Reset();

        }
Пример #29
0
 void Reset()
 {
     events.Reset();
 }
Пример #30
0
            void Reset()
            {
                events.Reset();

                events.ScheduleEvent(EVENT_WIND_SLASH, 7000);
            }