示例#1
0
		void Split()
		{
			Talk(SAY_SPLIT);

			Creature* spark;
			for (uint8 i = 0; i < 5; ++i)
			{
				if (spark = me->SummonCreature(NPC_SPARK_OF_IONAR, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 20000))
				{
					summons.Summon(spark);
					spark->CastSpell(spark, me->GetMap()->IsHeroic() ? SPELL_SPARK_VISUAL_TRIGGER_H : SPELL_SPARK_VISUAL_TRIGGER_N, true);
					spark->CastSpell(spark, SPELL_RANDOM_LIGHTNING, true);
					spark->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED|UNIT_FLAG_NOT_SELECTABLE|UNIT_FLAG_NON_ATTACKABLE);
					spark->SetHomePosition(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), 0);

					if (Player* tgt = SelectTargetFromPlayerList(100))
						spark->GetMotionMaster()->MoveFollow(tgt, 0.0f, 0.0f, MOTION_SLOT_CONTROLLED);
				}
			}
			
			me->SetVisible(false);
			me->SetControlled(true, UNIT_STATE_STUNNED);

			events.SetPhase(2);
			events.ScheduleEvent(EVENT_CALL_SPARKS, 15000, 0, 2);
		}
示例#2
0
 void ChangePhase()
 {
     if (!phase || phase == PHASE_CHASE)
     {
         phase = PHASE_STRIKE;
         summons.DoAction(EVENT_VOLCANO, 0);
         events.ScheduleEvent(EVENT_HATEFUL_STRIKE, 5000, GCD_CAST, PHASE_STRIKE);
         me->SetSpeed(MOVE_RUN, 1.2f);
         me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, false);
         me->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, false);
     }
     else
     {
         phase = PHASE_CHASE;
         events.ScheduleEvent(EVENT_VOLCANO, 5000, GCD_CAST, PHASE_CHASE);
         events.ScheduleEvent(EVENT_SWITCH_TARGET, 10000, 0, PHASE_CHASE);
         me->SetSpeed(MOVE_RUN, 0.9f);
         me->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TAUNT, true);
         me->ApplySpellImmune(0, IMMUNITY_EFFECT,SPELL_EFFECT_ATTACK_ME, true);
     }
     DoResetThreat();
     DoZoneInCombat();
     events.SetPhase(phase);
     events.ScheduleEvent(EVENT_SWITCH_PHASE, 60000, GCD_CAST);
 }
 void ScheduleEvents(bool anvil)
 {
     events.SetPhase(1);
     events.RescheduleEvent(EVENT_HEAT, 8000, 0, 1);
     events.RescheduleEvent(EVENT_SHATTER, 10000, 0, 1);
     events.RescheduleEvent(EVENT_CHECK_HEALTH, anvil ? 1000 : 6000, 0, 1);
     events.RescheduleEvent(EVENT_POSITION, 4000, 0, 1);
 }
示例#4
0
        void ScheduleEvents(bool spark)
        {
            events.SetPhase(1);
            if (!spark)
                events.RescheduleEvent(EVENT_CHECK_HEALTH, 1000, 0, 1);

            events.RescheduleEvent(EVENT_BALL_LIGHTNING, 10000, 0, 1);
            events.RescheduleEvent(EVENT_STATIC_OVERLOAD, 5000, 0, 1);
        }
示例#5
0
 void UpdatePhase()
 {
     ++phase;
     events.SetPhase(phase);
     events.RescheduleEvent(EVENT_FUSION_PUNCH, 15000);
     if(phase >= 2)
         events.RescheduleEvent(EVENT_STATIC_DISRUPTION, 30000);
     if(phase >= 3)
         events.RescheduleEvent(EVENT_OVERWHELMING_POWER, rand()%5000);
 }
		void Reset()
		{
			events.Reset();
			evade = false;

			me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
			me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED);
			me->SetReactState(REACT_PASSIVE);

			events.SetPhase(PHASE_BOSS_WAITING);
		}
		void EnterCombat(Unit* /*who*/)
		{
			if (Creature* mushiba = me->GetCreature(*me, instance->GetData64(DATA_MUSHIBA)))
			{
				mushiba->SetReactState(REACT_AGGRESSIVE);
				mushiba->SetInCombatWithZone();
			}

			events.SetPhase(PHASE_BOSS_ATTACK);
			events.ScheduleEvent(EVENT_SHOCKWAVE, 17*IN_MILLISECONDS, 0);
		}
 void EnterCombat(Unit* who)
 {
     DoScriptText(SAY_STEELBREAKER_AGGRO, me);
     DoZoneInCombat();
     CallBosses(pInstance, DATA_STEELBREAKER, who);
     DoCast(me, SPELL_HIGH_VOLTAGE);
     phase = 1;
     events.SetPhase(phase);
     events.ScheduleEvent(EVENT_ENRAGE, 900000);
     events.ScheduleEvent(EVENT_FUSION_PUNCH, 15000);
 }
 void DamageTaken(Unit* /*done_by*/, uint32 & /*damage*/)
 {
     if (!Repentance && me->GetHealthPct() <= 50.0f)
     {
         Repentance = true;
         events.Reset();
         events.SetPhase(PHASE_REPENTANCE);
         me->SetReactState(REACT_PASSIVE);
         me->AttackStop();
         me->GetMotionMaster()->MoveTargetedHome();
     }
 }
示例#10
0
 void DoAction(int32 action)
 {
     if (action == ACTION_SERVANT_DEATH)
     {
         Talk(SAY_WAILING_WINDS);
         me->RemoveAura(SPELL_DEFLECTING_WINDS);
         me->CastSpell(me, SPELL_WAILING_WINDS_AURA, false);
         events.SetPhase(PHASE_WAILING_WINDS);
         events.ScheduleEvent(EVENT_WAILING_WINDS, 1000, 0, PHASE_WAILING_WINDS);
         events.ScheduleEvent(EVENT_STORM_BOLT_S, urand(10000, 25000), 0, PHASE_SIAMAT);
     }
 }
示例#11
0
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim())
                return;

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

			switch (events.ExecuteEvent())
			{
				case EVENT_SPELL_DRAIN_LIFE:
					if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
						me->CastSpell(target, DUNGEON_MODE(SPELL_DRAIN_LIFE_N, SPELL_DRAIN_LIFE_H), false);
					events.ScheduleEvent(EVENT_SPELL_DRAIN_LIFE, 10000, 1);
					return;
				case EVENT_SPELL_DRAIN_MANA:
					if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, PowerUsersSelector(me, POWER_MANA, 40.0f, false)))
						me->CastSpell(target, SPELL_DRAIN_MANA, false);
					events.ScheduleEvent(EVENT_SPELL_DRAIN_MANA, 10000, 1);
					return;
				case EVENT_SPELL_FEL_EXPLOSION:
					me->RemoveAuraFromStack(SPELL_MANA_RAGE_TRIGGER);
					me->CastSpell(me, SPELL_FEL_EXPLOSION, false);
					events.ScheduleEvent(EVENT_SPELL_FEL_EXPLOSION, 2000);
					break;
				case EVENT_DRAIN_CRYSTAL:
					events.DelayEvents(10001);
					events.ScheduleEvent(EVENT_EMPOWER, 10000);
					events.ScheduleEvent(EVENT_DRAIN_CRYSTAL, 30000);
					SelectNearestCrystal();
					break;
				case EVENT_EMPOWER:
					if (me->GetPower(POWER_MANA) == me->GetMaxPower(POWER_MANA))
					{
						Talk(SAY_EMPOWERED);
						if (Unit* crystal = ObjectAccessor::GetUnit(*me, CrystalGUID))
							Unit::Kill(crystal, crystal);
						events.DelayEvents(10000, 1);
						events.ScheduleEvent(EVENT_RESTORE_COMBAT, 0);
					}
					else
						events.ScheduleEvent(EVENT_EMPOWER, 0, 0, 1);
					break;
				case EVENT_RESTORE_COMBAT:
					events.SetPhase(0);
					me->GetMotionMaster()->MoveChase(me->GetVictim());
					break;
			}

            DoMeleeAttackIfReady();
        }
示例#12
0
            void EnterCombat(Unit* who)
            {
                DoZoneInCombat();

                events.Reset();
                events.SetPhase(PHASE_ONE);
                events.ScheduleEvent(EVENT_SWITCH_PHASE, 90000); 
                events.ScheduleEvent(EVENT_COLD_SLAP, 500, 0, PHASE_ONE); 
                events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, 1000, 0, PHASE_ONE); 
                events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 8000, 0, PHASE_ONE); 
                events.ScheduleEvent(EVENT_ICE_SPEAR, 9500, 0, PHASE_ONE); 
                events.ScheduleEvent(EVENT_EARTHEN_RING_ATTACK, 10000, 0, PHASE_ONE); 
            }
示例#13
0
            void EnterCombat(Unit* who)
            {
                DoZoneInCombat();

                events.Reset();
                events.SetPhase(PHASE_ONE);
                events.ScheduleEvent(EVENT_SWITCH_PHASE, 90000); // phase 2 after 90 seconds
                events.ScheduleEvent(EVENT_COLD_SLAP, 500, 0, PHASE_ONE); // every 500ms in melee range in phase 1
                events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, 1000, 0, PHASE_ONE); // once in every phase 1
                events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 8000, 0, PHASE_ONE); // every 7 seconds in phase 1
                events.ScheduleEvent(EVENT_ICE_SPEAR, 9500, 0, PHASE_ONE); // every 7 seconds in phase 1, first after 9.5 seconds
                events.ScheduleEvent(EVENT_EARTHEN_RING_ATTACK, 10000, 0, PHASE_ONE); // every 10 seconds in phase 1 totem attack visual
            }
示例#14
0
        void MoveInLineOfSight(Unit* who) override
        {
            if (!_introDone && (instance->GetData(BOSS_GRAND_CHAMPIONS) != DONE && instance->GetData(BOSS_GRAND_CHAMPIONS) != FAIL) && me->IsWithinDistInMap(who, 75.0f))
            {
                _introDone = true;
                me->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
                
                events.SetPhase(PHASE_INTRO);
                events.ScheduleEvent(EVENT_INTRO_1, 10000, 0, PHASE_INTRO);

                SummonNpcs();
            }
        }
        void HealReceived(Unit* /*healer*/, uint32& heal)
        {
            if (me->GetHealth() + heal >= me->GetMaxHealth())
                if (events.GetPhaseMask() & PHASE_EGG_MASK)
                {
                    Birth = true;
                    uiBirthTimer = 2500;
                    me->RemoveAura(SPELL_BLAZE_OF_THE_HEAVENS_TRANSFORM);

                    events.SetPhase(PHASE_BLAZE);

                }
        }
示例#16
0
        void EnterCombat(Unit* /*who*/)
        {
            Talk(SAY_AGGRO);
            UpdateDistanceVisibility();

            events.ScheduleEvent(EVENT_DISTANCE, 2*IN_MILLISECONDS);
            events.ScheduleEvent(EVENT_ENDLESS_RAGE, 20*IN_MILLISECONDS);
            events.ScheduleEvent(EVENT_GROWING_ANGER, urand(30*IN_MILLISECONDS, 35*IN_MILLISECONDS), 0, PHASE_GROWING_ANGER);
            events.ScheduleEvent(EVENT_UNLEASHED_WRATH, 50*IN_MILLISECONDS);
            events.ScheduleEvent(EVENT_BERSERK, 900*IN_MILLISECONDS);

            events.SetPhase(PHASE_GROWING_ANGER);
        }
示例#17
0
		void EnterCombat(Unit* /*who*/)
		{
			if (instance)
				instance->SetBossState(DATA_BOSS_GU_CLOUDSTRIKE, IN_PROGRESS);

			me->SetInCombatWithZone();

			events.SetPhase(PHASE_COMBAT);
			events.ScheduleEvent(EVENT_AGGRO_PART_1, 2*IN_MILLISECONDS, 0, PHASE_COMBAT); 
			events.ScheduleEvent(EVENT_AGGRO_PART_2, 6*IN_MILLISECONDS, 0, PHASE_COMBAT);
			events.ScheduleEvent(EVENT_AGGRO_PART_3, 9*IN_MILLISECONDS, 0, PHASE_COMBAT);

		}
		void Reset()
		{
			events.Reset();
			intro = false;
			xinTrigger = false;

			if (instance)
				instance->SetData(DATA_NPC_XIN_THE_WEAPONMASTER, NOT_STARTED);

			me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);

			events.SetPhase(PHASE_NULL);
		}
示例#19
0
        void EnterCombat(Unit* /*who*/)
        {
            Talk(SAY_START);
            events.SetPhase(PHASE_DEFLECTING_WINDS);
            events.ScheduleEvent(EVENT_STATIC_SHOCK, 2000, 0, PHASE_DEFLECTING_WINDS);
            events.ScheduleEvent(EVENT_DEFLECTING_WINDS, 5000, 0, PHASE_DEFLECTING_WINDS);
            events.ScheduleEvent(EVENT_CALL_OF_SKY, 15000);
            events.ScheduleEvent(EVENT_CLOUD_BURST, 7000, 0, PHASE_DEFLECTING_WINDS);
            events.ScheduleEvent(EVENT_STORM_BOLT_DW, 500, 0, PHASE_DEFLECTING_WINDS);

            if (instance)
                instance->SetData(DATA_SIAMAT, IN_PROGRESS);
        }
 void DoAction(uint32 action)
 {
     switch (action)
     {
         case EVENT_UPDATEPHASE:
             events.SetPhase(++phase);
             events.RescheduleEvent(EVENT_FUSION_PUNCH, 15000);
             if (phase >= 2)
                 events.RescheduleEvent(EVENT_STATIC_DISRUPTION, 30000);
             if (phase >= 3)
                 events.RescheduleEvent(EVENT_OVERWHELMING_POWER, rand()%5000);
         break;
     }
 }
        void GoToAnvil()
        {
            events.SetPhase(2);
            HealthCheck -= 20;
            me->SetSpeed(MOVE_RUN, 4.0f,true);
            me->SetReactState(REACT_PASSIVE);

            Talk(SAY_FORGE);

            if (me->GetMotionMaster()->GetCurrentMovementGeneratorType() == CHASE_MOTION_TYPE)
                me->GetMotionMaster()->MovementExpired();

            events.ScheduleEvent(EVENT_MOVE_TO_ANVIL, 0, 0, 2);
        }
		void Reset()
		{
			events.Reset();

			if (instance)
				instance->SetBossState(DATA_BOSS_LOREWALKER_STONESTEP, NOT_STARTED);

			emote = false;
			intro = false;
			end = false;

			events.SetPhase(PHASE_ATTACK_SCROLL);
			events.ScheduleEvent(EVENT_SPINNING_CRANE_KICK, 0, 0, PHASE_ATTACK_SCROLL);
		}
        void EnterCombat(Unit* /*who*/)
        {
            if (instance)
                instance->SetData(DATA_HIGH_PROPHET_BARIM, IN_PROGRESS);

            if (IsHeroic())
                events.ScheduleEvent(EVENT_SUMMON_BLAZE_OF_THE_HEAVENS, 3000);

            Talk(SAY_AGGRO);
            events.SetPhase(PHASE_BARIM);
            events.ScheduleEvent(EVENT_FIFTY_LASHINGS, 5000, 0, PHASE_BARIM);
            events.ScheduleEvent(EVENT_HEAVENS_FURY, 5000, 0, PHASE_BARIM);
            events.ScheduleEvent(EVENT_PLAGUE_OF_AGES, 6000, 0, PHASE_BARIM);
        }
 void DoAction(uint32 action)
 {
     switch (action)
     {
         case EVENT_UPDATEPHASE:
             events.SetPhase(++phase);
             events.RescheduleEvent(EVENT_SHIELD_OF_RUNES, 27000);
             events.RescheduleEvent(EVENT_RUNE_OF_POWER, 60000);
             if (phase >= 2)
                 events.RescheduleEvent(EVENT_RUNE_OF_DEATH, 30000);
             if (phase >= 3)
                 events.RescheduleEvent(EVENT_RUNE_OF_SUMMONING, urand(20000,30000));
         break;
     }
 }
		void EnterCombat(Unit* /*who*/) 
		{
			if (instance)
			{
				instance->SetBossState(DATA_BOSS_WISE_MARI, IN_PROGRESS);
				me->SetInCombatWithZone();
				me->HandleEmoteCommand(EMOTE_ONESHOT_CUSTOM_SPELL_01);
				DoCast(SPELL_WATER_BUBBLE);
				Talk(SAY_AGGRO);

				events.SetPhase(PHASE_CORRUPT_LIVING_WATERS);
				events.ScheduleEvent(EVENT_HYDROLANCE, 0, 0, PHASE_CORRUPT_LIVING_WATERS);
				events.ScheduleEvent(EVENT_CALL_FIRST_WATER, 8*IN_MILLISECONDS, 0, PHASE_CORRUPT_LIVING_WATERS);
			}
		}
示例#26
0
 void DoAction(int32 const action)
 {
     switch (action)
     {
         case EVENT_UPDATEPHASE:
             events.SetPhase(++phase);
             if (phase == 2)
                 events.ScheduleEvent(EVENT_STATIC_DISRUPTION, 30000);
             if (phase == 3)
             {
                 me->ResetLootMode();
                 events.ScheduleEvent(EVENT_OVERWHELMING_POWER, rand()%5000);
             }
         break;
     }
 }
示例#27
0
 void DoAction(int32 const action)
 {
     switch (action)
     {
         case EVENT_UPDATEPHASE:
             events.SetPhase(++phase);
             if (phase == 2)
                 events.ScheduleEvent(EVENT_RUNE_OF_DEATH, 30000);
             if (phase == 3)
             {
                 me->ResetLootMode();
                 events.ScheduleEvent(EVENT_RUNE_OF_SUMMONING, urand(20000, 30000));
             }
         break;
     }
 }
示例#28
0
            void Reset()
            {
                summons.DespawnAll();

                events.Reset();
                events.SetPhase(PHASE_ONE);

                intro = false;

                me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK, true);
                me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK_DEST, true);

                me->CastSpell(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), SPELL_SUMMONING_VISUAL1, true);
                me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);

                me->AddAura(SPELL_AHUNES_SHIELD, me);
            }
示例#29
0
        void MovementInform(uint32 type, uint32 id)
        {
            if (type == POINT_MOTION_TYPE && id == 2)
            {
                if (Unit* crystal = ObjectAccessor::GetUnit(*me, CrystalGUID))
                {
					Talk(EMOTE_CRYSTAL);
                    crystal->SetUInt32Value(UNIT_FIELD_FLAGS, 0);
                    crystal->CastSpell(me, SPELL_MANA_RAGE, true);
                    me->CastSpell(crystal, SPELL_FEL_CRYSTAL_COSMETIC, true);
					events.SetPhase(1);
					events.ScheduleEvent(EVENT_EMPOWER, 0, 0, 1);
                }
				else
					events.ScheduleEvent(EVENT_RESTORE_COMBAT, 0);
            }
        }
示例#30
0
        void EnterCombat(Unit* /*who*/)
        {
            DoCast(me, SPELL_AHUNES_SHIELD );
            me->SetVisible(true);
            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_IMMUNE_TO_PC);
            me->SetUInt32Value(UNIT_NPC_EMOTESTATE, 0);
            me->HandleEmoteCommand(EMOTE_ONESHOT_EMERGE);
            me->SetReactState(REACT_AGGRESSIVE);
            DoZoneInCombat();

            events.Reset();            
            events.SetPhase(PHASE_ONE);
            events.ScheduleEvent(EVENT_SUBMERGE, 90000, 0, PHASE_ONE);
            events.ScheduleEvent(EVENT_SPIKE, 5000, 0, PHASE_ONE);
            events.ScheduleEvent(EVENT_SUMMON_HAILSTONE, 1000, 0, PHASE_ONE);
            events.ScheduleEvent(EVENT_SUMMON_COLDWEAVE, 1000, 0, PHASE_ONE);
        }