void DamageTaken(Unit* pDoneBy, uint32 &uiDamage)
        {
            if (me->HealthBelowPctDamaged(5, uiDamage))
            {
                if (lifei)
                {
                    lifei->UnSummon();
                    lifei = NULL;
                }

                uiDamage = 0;
                me->MonsterSay("I can't meditate!", LANG_UNIVERSAL, 0);
                me->SetFullHealth();
                me->SetReactState(REACT_DEFENSIVE);

                std::list<Creature*> unitlist;
                GetCreatureListWithEntryInGrid(unitlist, me, 59637, 50.0f);
                for (auto creature: unitlist)
                    me->Kill(creature);

                events.ScheduleEvent(EVENT_START, 20000);
                events.CancelEvent(EVENT_SPAWN_MOBS);
                events.CancelEvent(EVENT_PROGRESS);
                events.CancelEvent(EVENT_END);
            }
        }
Esempio n. 2
0
 void DoAction(const int32 action)
 {
     switch (action)
     {
         case ACTION_EYE_DRAIN_LIFE:
             events.ScheduleEvent(EVENT_DRAIN_LIFE, 12000);
             break;
         case ACTION_MAZE_START:
             events.CancelEvent(EVENT_LINGERING_GAZE);
             events.CancelEvent(EVENT_FORCE_OF_WILL);
             break;
         case ACTION_MAZE_END:
             switch (me->GetEntry())
             {
                case MIND_EYE:
                   events.ScheduleEvent(EVENT_FORCE_OF_WILL, 25000);
                    break;
                case APPRAYISYING_EYE:
                   events.ScheduleEvent(EVENT_LINGERING_GAZE, 19000);
                    break;
                default:
                   break;
             }
             break;
         default:
             break;
     }
 }
        void DamageTaken(Unit* attacker, uint32& damage)
        {
            if (me->HealthBelowPctDamaged(30, damage) && !isInFalcon)
            {
                isInFalcon = true;
                me->SetDisplayId(39796); //falcon
                events.ScheduleEvent(EVENT_FALCON, 1000);
                events.CancelEvent(EVENT_JAOMIN_JUMP);
                events.CancelEvent(EVENT_HIT_CIRCLE);
            }

            if (me->HealthBelowPctDamaged(5, damage))
            {
                me->SetDisplayId(39755);

                std::list<Player*> playerList;
                GetPlayerListInGrid(playerList, me, 15.0f);
                for (auto player: playerList)
                    player->KilledMonsterCredit(me->GetEntry(), 0);

                me->CombatStop();
                me->setFaction(35);
                me->SetFullHealth();
                me->HandleEmoteCommand(EMOTE_ONESHOT_SALUTE);
                events.Reset();
                events.ScheduleEvent(EVENT_RESET, 5000);
                damage = 0;
            }

            if (damage > me->GetHealth())
                damage = 0;
        }
		void UpdateAI(const uint32 diff)
		{
			events.Update(diff);

			if (!xinTrigger)
				if (Creature* trigger = me->FindNearestCreature(NPC_XIN_TRIGGER, 1.0f))
				{
					me->Relocate(trigger->GetHomePosition());
					me->SetFacingTo(0.0f);
					xinTrigger = true;
				}

			while(uint32 eventId = events.ExecuteEvent())
			{
				switch(eventId)
				{
					if (instance)
					{
						case EVENT_INTRO_1:
							Talk(SAY_INTRO_1);
							me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);

							events.ScheduleEvent(EVENT_INTRO_2, 12*IN_MILLISECONDS);
							events.CancelEvent(EVENT_INTRO_1);
							break;

						case EVENT_INTRO_2:
							Talk(SAY_INTRO_2);

							events.ScheduleEvent(EVENT_JUMP_BACK, 12*IN_MILLISECONDS);
							events.CancelEvent(EVENT_INTRO_2);
							break;

						case EVENT_JUMP_BACK:
							me->GetMotionMaster()->MoveJump(XinJumpPosition, 10.0f, 10.0f);

							events.ScheduleEvent(EVENT_CHOOSE_BOSS, 3*IN_MILLISECONDS);
							events.CancelEvent(EVENT_JUMP_BACK);
							break;

						case EVENT_CHOOSE_BOSS:
							if (Creature* boss = /*RAND(*/me->GetCreature(*me, instance->GetData64(DATA_KUAI_THE_BRUTE)))/*,
							                          me->GetCreature(*me, instance->GetData64(DATA_MING_THE_CUNNING)),
													  me->GetCreature(*me, instance->GetData64(DATA_HAIYAN_THE_UNSTOPPABLE)))*/
													  boss->AI()->DoAction(ACTION_BOSS_ENTER_COMBAT);

							events.CancelEvent(EVENT_CHOOSE_BOSS);
							break;

						default:
							break;
					}
				}
			}
		}
        void SpellHit(Unit* caster, const SpellInfo* spell)
        {
            if (!caster || !pInstance)
                return;

            switch (spell->Id)
            {
                case SPELL_LAUNCH_CHAIN:
                    {
                        uint32 spell = 0;
                        if( caster->GetGUID() == pInstance->GetData64(DATA_HARPOON_FIRE_STATE_1) )
                            spell = SPELL_CHAIN_1;
                        else if( caster->GetGUID() == pInstance->GetData64(DATA_HARPOON_FIRE_STATE_2) )
                            spell = SPELL_CHAIN_2;
                        else if( caster->GetGUID() == pInstance->GetData64(DATA_HARPOON_FIRE_STATE_3) )
                            spell = SPELL_CHAIN_3;
                        else
                            spell = SPELL_CHAIN_4;
                        caster->CastSpell(me, spell, true);
                    }
                    break;
                case SPELL_CHAIN_1:
                case SPELL_CHAIN_2:
                case SPELL_CHAIN_3:
                case SPELL_CHAIN_4:
                    {
                        uint8 count = 0;
                        if( me->HasAura(SPELL_CHAIN_1) )
                            count++;
                        if( me->HasAura(SPELL_CHAIN_3) )
                            count++;
                        if (RAID_MODE(0,1))
                        {
                            if( me->HasAura(SPELL_CHAIN_2) )
                                count++;
                            if( me->HasAura(SPELL_CHAIN_4) )
                                count++;
                        }
                        if( count >= REQ_CHAIN_COUNT )
                        {
                            if (Creature* commander = ObjectAccessor::GetCreature(*me, CommanderGUID))
                                commander->AI()->Talk(SAY_COMMANDER_GROUND);

                            me->InterruptNonMeleeSpells(true);
                            events.CancelEvent(EVENT_SPELL_FIREBALL);
                            events.CancelEvent(EVENT_SPELL_DEVOURING_FLAME);
                            events.CancelEvent(EVENT_SUMMON_MOLE_MACHINES);
                            me->SetTarget(0);
                            me->SendMeleeAttackStop(me->GetVictim());
                            me->GetMotionMaster()->MoveLand(0, CORDS_GROUND, 25.0f);
                        }
                    }
                    break;
            }
        }
 void PassengerBoarded(Unit* who, int8 seatId, bool apply)
 {
     if (apply)
         events.ScheduleEvent(EVENT_TENTACLE_TOSS, urand(6000, 18000));
     else
     {
         events.ScheduleEvent(EVENT_TENTACLE_TOSS_V, urand(5000, 15000));
         events.CancelEvent(EVENT_TENTACLE_TOSS); // If Logout player
         events.CancelEvent(EVENT_TENTACLE_TOSS_J); // If Logout player
     }
 }
Esempio n. 7
0
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch(eventId)
                {
                    case EVENT_SAY_AGGRO_2:
                        me->MonsterSay(SAY_AGGRO_2, 0, 0);
                        events.CancelEvent(EVENT_SAY_AGGRO_2);
                        break;
                    case EVENT_SAY_AGGRO_3:
                        me->MonsterSay(SAY_AGGRO_3, 0, 0);
                        me->SetReactState(REACT_AGGRESSIVE);
                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                        events.CancelEvent(EVENT_SAY_AGGRO_3);
                        break;
                    case EVENT_CALL_BAXTER:
                        me->MonsterSay(SAY_BAXTER, 0, 0);
                        if (Creature* Baxter = me->GetCreature(*me, pInstance->GetData64(DATA_BAXTER)))
                            Baxter->AI()->DoAction(ACTION_START);
                        events.CancelEvent(EVENT_CALL_BAXTER);
                        break;
                    case EVENT_CALL_FRYE:
                        me->MonsterSay(SAY_FRYE, 0, 0);
                        if (Creature* Frye = me->GetCreature(*me, pInstance->GetData64(DATA_FRYE)))
                            Frye->AI()->DoAction(ACTION_START);
                        events.CancelEvent(EVENT_CALL_FRYE);
                        break;
                    case EVENT_PERFUME_SPRAY:
                        DoCastVictim(SPELL_PERFUME_SPRAY);
                        events.RescheduleEvent(EVENT_PERFUME_SPRAY, urand(4000, 6000));
                        break;
                    case EVENT_CHAIN_REACTION:
                        DoCast(SPELL_CHAIN_REACTION);
                        events.RescheduleEvent(EVENT_PERFUME_SPRAY, 6000);
                        events.RescheduleEvent(EVENT_CHAIN_REACTION, 40000);
                        break;
                    default:
                        break;
                }
            }

            DoMeleeAttackIfReady();
        }
        void UpdateAI(uint32 const diff)
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);

            if (me->HasAura(SPELL_CONDENSE) && !form_1)
            {
                events.ScheduleEvent(EVENT_CONDENSING_VAPOR, 2000);
                form_1 = true;
            } else if (me->HasAura(SPELL_CONDENSE_2) && !form_2)
            {
                me->SetDisplayId(25654);
                events.CancelEvent(EVENT_CONDENSING_VAPOR);
                events.ScheduleEvent(EVENT_SWIRLING_VAPOR, 2000);
                form_2 = true;
            } else if (me->HasAura(SPELL_CONDENSE_3) && !form_3)
            {
                me->SetDisplayId(36455);
                events.CancelEvent(EVENT_SWIRLING_VAPOR);
                events.ScheduleEvent(EVENT_FREEZING_VAPOR, 2000);
                form_3 = true;
            }

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                    case EVENT_CONDENSING_VAPOR:
                        DoCastVictim(SPELL_CONDENSING_VAPOR);
                        events.ScheduleEvent(EVENT_SWIRLING_VAPOR, 3500);
                        break;
                    case EVENT_SWIRLING_VAPOR:
                        DoCastVictim(SPELL_SWIRLING_VAPOR);
                        events.ScheduleEvent(EVENT_SWIRLING_VAPOR, 3500);
                        break;
                    case EVENT_FREEZING_VAPOR:
                        DoCastVictim(SPELL_FREEZING_VAPOR);
                        events.ScheduleEvent(EVENT_COALESCE, 5000);
                        break;
                    case EVENT_COALESCE:
                        DoCastVictim(SPELL_COALESCE);
                        break;
                }
            }
            DoMeleeAttackIfReady();
        }
Esempio n. 9
0
        void DoAction(int32 action)
        {
            switch(action)
            {
                case ACTION_GET_IMPALED:
                    Talk(ANN_IMPALED);
                    me->RemoveAura(SPELL_CUSTOM_STATE_05);
                    DoCast(me, SPELL_CUSTOM_STATE_04); // Pinned

                    // Make head visible and attackable.
                    if (Unit* head = vehicle->GetPassenger(0))
                    {
                        head->SetHealth(me->GetHealth());
                        head->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);

                        me->CastSpell(head, SPELL_POINT_OF_VULNERABILITY, true);
                        head->CastSpell(head, SPELL_POINT_OF_VULNERABILITY2, true);
                    }

                    events.ScheduleEvent(EVENT_LEAVE_GROUND_PHASE, 33000);
                    events.ScheduleEvent(EVENT_EJECT_PINCERS, 1000);
                    events.CancelEvent(EVENT_KILL_TANK);
                    break;

                case ACTION_BREAK_LOOSE:
                    events.ScheduleEvent(EVENT_BREAK_FREE, 6000);
                    break;

                default:
                    break;
            }
        }
		void DamageTaken(Unit*, uint32& /*damage*/, DamageEffectType /*damagetype*/, SpellSchoolMask /*damageSchoolMask*/)
		{
			if (phase == 0 && !HealthAbovePct(66) && !me->HasUnitState(UNIT_STATE_ROOT))
			{
				phase = 1;
				me->SetReactState(REACT_PASSIVE);
				me->SetTarget(0);
				me->SendMeleeAttackStop(me->GetVictim());
				events.DelayEvents(8000);
				me->CastSpell(me, SPELL_THUNDERING_STOMP, false);
				events.RescheduleEvent(EVENT_JUMP, 1250);
				return;
			}

			if (phase == 1 && !HealthAbovePct(33) && !me->HasUnitState(UNIT_STATE_ROOT))
			{
				events.CancelEvent(EVENT_SPELL_CHILLING_WAVE);
				phase = 2;
				me->SetReactState(REACT_PASSIVE);
				me->SetTarget(0);
				me->SendMeleeAttackStop(me->GetVictim());
				events.DelayEvents(8000);
				me->CastSpell(me, SPELL_THUNDERING_STOMP, false);
				events.RescheduleEvent(EVENT_JUMP, 1250);
				return;
			}
		}
        void DamageTaken(Unit* /*pDoneBy*/, uint32& /*uiDamage*/)
        {
            if (HealthBelowPct(66) && !phase2)
            {
                phase2 = true;
                DoCast(me, SPELL_THUNDERING_STOMP);
                // TODO: should go to a forge
                DoCast(me, SPELL_FORGE_BLADE);
                // TODO: should equip when spell completes
                SetEquipmentSlots(false, EQUIP_ID_SWORD, -1, -1);
                me->SetByteValue(UNIT_FIELD_BYTES_2, 0, SHEATH_STATE_MELEE);
                events.ScheduleEvent(EVENT_CHILLINGWAVE, 10000);
            }

            if (HealthBelowPct(33) && !phase3)
            {
                phase3 = true;
                DoCast(me, SPELL_THUNDERING_STOMP);
                // TODO: should go to a forge
                DoCast(me, SPELL_FORGE_MACE);
                // TODO: should equip when spell completes
                SetEquipmentSlots(false, EQUIP_ID_MACE, -1, -1);
                me->SetByteValue(UNIT_FIELD_BYTES_2, 0, SHEATH_STATE_MELEE);
                events.CancelEvent(EVENT_CHILLINGWAVE); // cast only in phase 2.
                events.ScheduleEvent(EVENT_DEEPFREEZE, 10000);
            }
        }
Esempio n. 12
0
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);

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

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch (eventId)
                {
                case EVENT_TWILIGHT_SHIFT:
                    DoCast(me, SPELL_TWILIGHT_SHIFT);
                    events.ScheduleEvent(EVENT_TWILIGHT_SHIFT, urand(30000, 35000));
                    events.ScheduleEvent(EVENT_NEXT_TARGET_ON, 3000);
                    break;
                case EVENT_NEXT_TARGET_ON:
                    DoResetThreat();
                    events.ScheduleEvent(EVENT_NEXT_TARGET_ON, 3000);
                    break;
                case EVENT_NEXT_TARGET_OFF:
                    events.CancelEvent(EVENT_NEXT_TARGET_ON);
                    break;
                }
            }
            DoMeleeAttackIfReady();
        }
Esempio n. 13
0
        void UpdateAI(const uint32 diff)
        {
            //Return since we have no target
            if (!UpdateVictim())
                return;

            events.Update(diff);

            if (me->hasUnitState(UNIT_STAT_CASTING))
                return;

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch(eventId)
                {
                    case EVENT_GLACIAL_STRIKE:
                        DoCast(me->getVictim(), SPELL_GLACIAL_STRIKE);
                        events.RescheduleEvent(EVENT_GLACIAL_STRIKE, 8000);
                        return;
                    case EVENT_FROSTBLADE:
                        DoCast(me, SPELL_FROSTBLADE);
                        events.CancelEvent(EVENT_FROSTBLADE);
                        return;
                }
            }

            DoMeleeAttackIfReady();
        }
Esempio n. 14
0
 void SummonedCreatureDies(Creature* creature, Unit* /*pKiller*/)
 {
     summons.Despawn(creature);
     if (creature->GetEntry() == NPC_VICIOUS_MINDLASHER)
     {
         uiMindLasherCount++;
         if (uiMindLasherCount > 2)
         {
             Talk(SAY_PHASE_2_2);
             events.CancelEvent(EVENT_SUMMON_MURLOC);
             events.ScheduleEvent(EVENT_PHASE_2_2, 10000);
             events.ScheduleEvent(EVENT_SUMMON_SAPPER, 8000);
             events.ScheduleEvent(EVENT_SUMMON_BEAST, 14000);
             events.ScheduleEvent(EVENT_BLIGHT_OF_OZUMAT, urand(9000, 11000));
         }
         else
             events.ScheduleEvent(EVENT_SUMMON_MINDLASHER, urand(10000, 15000));
     }
     else if (creature->GetEntry() == NPC_FACELESS_SAPPER)
     {
         uiSapperCount++;
         if (uiSapperCount > 2)
         {
             bActive = false;
             Talk(SAY_PHASE_3_1);
             CompleteEncounter();
         }
     }
 }
Esempio n. 15
0
        void UpdateAI(const uint32 diff)
        {
            //Return since we have no target
            if (!UpdateVictim())
                return;

            events.Update(diff);

            if (me->hasUnitState(UNIT_STAT_CASTING))
                return;

            while (uint32 eventId = events.ExecuteEvent())
            {
                switch(eventId)
                {
                    //Should only be used on NPCs
                    case EVENT_LEAPING_FACE_MAUL:
                        if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                            DoCast(pTarget, SPELL_LEAPING_FACE_MAUL);
                        events.CancelEvent(EVENT_LEAPING_FACE_MAUL);
                        return;
                }
            }

            DoMeleeAttackIfReady();
        }
Esempio n. 16
0
        void UpdateAI(uint32 diff) override
        {
            m_events.Update(diff);

            while (uint32 eventId = m_events.ExecuteEvent())
            {
                switch (eventId)
                {
                    case EVENT_CHECK_PLAYER:
                    {
                        Vehicle* catapult = me->GetVehicleKit();
                        Unit* unit = catapult->GetPassenger(0);
                        if (catapult)
                            if (unit)
                            {
                                if (Creature* forsaken = unit->ToCreature())
                                {
                                    if (forsaken->IsInCombat())
                                    {
                                        forsaken->ExitVehicle();
                                        forsaken->SetUInt32Value(UNIT_FIELD_BYTES_1, 0);
                                        m_events.ScheduleEvent(EVENT_MASTER_RESET, 10000);
                                    }
                                }
                            }
                            else
                            {
                                if (me->getFaction() != 35)
                                {
                                    m_events.CancelEvent(EVENT_CAST_BOULDER_PREPARE);
                                    me->setFaction(35);
                                    me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE | UNIT_FLAG_NOT_SELECTABLE);
                                    me->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_DISABLE_TURN);
                                }
                                break;
                            }

                        m_events.ScheduleEvent(EVENT_CHECK_PLAYER, 1000);
                        break;
                    }
                    case EVENT_CAST_BOULDER_PREPARE:
                    {
                        me->CastSpell(me, SPELL_FIERY_BOULDER, true);
                        m_events.ScheduleEvent(EVENT_CAST_BOULDER_PREPARE, urand(8000,15000));
                        break;
                    }
                    case EVENT_MASTER_RESET:
                    {
                        me->DespawnOrUnsummon(1);
                        break;
                    }
                }
            }

            if (!UpdateVictim())
                return;
            else
                DoMeleeAttackIfReady();
        }
		void UpdateAI(uint32 diff)
		{
			events.Update(diff);

			while(uint32 eventId = events.ExecuteEvent())
			{
				switch(eventId)
				{
					if (instance)
					{
						case EVENT_AGGRO:
							Talk(SAY_OSONG_AGGRO);

							events.ScheduleEvent(EVENT_ATTACK_STRIFE, 2*IN_MILLISECONDS);
							break;

						case EVENT_ATTACK_STRIFE:
							if (Creature* strife = me->FindNearestCreature(NPC_STRIFE, 99999.0f))
							{
								me->AI()->AttackStart(strife);
								me->AddThreat(strife, 99999.0f);
							}

							events.ScheduleEvent(EVENT_ATTACK_PERIL, 8*IN_MILLISECONDS);
							events.CancelEvent(EVENT_ATTACK_STRIFE);
							break;

						case EVENT_ATTACK_PERIL:
							if (Creature* peril = me->FindNearestCreature(NPC_PERIL, 99999.0f))
							{
								me->AI()->AttackStart(peril);
								me->AddThreat(peril, 99999.0f);
							}

							events.ScheduleEvent(EVENT_ATTACK_STRIFE, 8*IN_MILLISECONDS);
							events.CancelEvent(EVENT_ATTACK_PERIL);
							break;
						
						default:
							break;
					}
				}
			}

			DoMeleeAttackIfReady();
		}
Esempio n. 18
0
 void SetGUID(uint64 playerGUID, int32 faction)
 {
     _playerGUID = playerGUID;
     _faction = faction;
     SetEscortPaused(false);
     if (Creature* active = !headNorth ? me : ObjectAccessor::GetCreature(*me, summons[0]))
         active->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_QUESTGIVER);
     events.CancelEvent(EVENT_WAIT_FOR_ASSIST);
 }
        void UpdateAI(const uint32 diff)
        {
            if(!UpdateVictim())
                return;

            events.Update(diff);

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

            if (me->HealthBelowPct(50) && scorchedearth)
            {
                events.ScheduleEvent(EVENT_SCORCHED_EARTH, 1*IN_MILLISECONDS);
                scorchedearth = false;
            }

            while(uint32 eventId = events.ExecuteEvent())
            {
                switch(eventId)
                {
                    if (instance)
                    {
                        case EVENT_JUMP_FIRESTORM:
                            if (Unit* target = SelectTarget(SELECT_TARGET_FARTHEST))
                            {
                                me->GetMotionMaster()->MoveJump(target->GetPositionX()+3, target->GetPositionY()+3, target->GetPositionZ(), 20, 20, EVENT_JUMP);
                            }
                            break;

                        case EVENT_FIRESTORM_KICK:
                            me->StopMoving();
                            DoCastAOE(SPELL_FIRESTORM_KICK);

                            events.ScheduleEvent(EVENT_JUMP_FIRESTORM, 28*IN_MILLISECONDS);
                            break;

                        case EVENT_SCORCHED_EARTH:
                            DoCast(SPELL_SCORCHED_EARTH);

                            events.CancelEvent(EVENT_SCORCHED_EARTH);
                            break;

                        case EVENT_BLAZING_FISTS:
                            me->StopMoving();
                            DoCastAOE(SPELL_BLAZING_FISTS);

                            events.ScheduleEvent(EVENT_BLAZING_FISTS, 30*IN_MILLISECONDS);
                            break;

                        default:
                            break;
                    }
                }
            }
            DoMeleeAttackIfReady();
        }
		void UpdateAI(const uint32 diff)
		{
			if(!UpdateVictim())
				return;

			events.Update(diff);

			while(uint32 eventId = events.ExecuteEvent())
			{
				switch(eventId)
				{
					if (instance)
					{
						case EVENT_LEAP:
						{
							ravageVictim = SelectTarget(SELECT_TARGET_RANDOM);//1, 500, true);

							if (ravageVictim)
								me->CastSpell(ravageVictim, SPELL_LEAP);

							events.ScheduleEvent(EVENT_RAVAGE, 1*IN_MILLISECONDS);
							events.CancelEvent(EVENT_LEAP);
							break;
						}

						case EVENT_RAVAGE:
							if (ravageVictim && ravageVictim->isAlive())
								me->CastSpell(ravageVictim, SPELL_RAVAGE);

							events.ScheduleEvent(EVENT_LEAP, 30*IN_MILLISECONDS);
							events.CancelEvent(EVENT_RAVAGE);
							break;

						default:
							break;
					}
				}
			}

			DoMeleeAttackIfReady();
		}
Esempio n. 21
0
            void UpdateAI(const uint32 diff)
            {
                _events.Update(diff);

                switch (_events.ExecuteEvent())
                {
                    case EVENT_SIMON_PERIODIC_PLAYER_CHECK:
                        if (!CheckPlayer())
                            ResetNode();
                        else
                            _events.ScheduleEvent(EVENT_SIMON_PERIODIC_PLAYER_CHECK, 2000);
                        break;
                    case EVENT_SIMON_SETUP_PRE_GAME:
                        SetUpPreGame();
                        _events.CancelEvent(EVENT_SIMON_GAME_TICK);
                        _events.ScheduleEvent(EVENT_SIMON_PLAY_SEQUENCE, 1000);
                        break;
                    case EVENT_SIMON_PLAY_SEQUENCE:
                        if (!playableSequence.empty())
                        {
                            PlayNextColor();
                            _events.ScheduleEvent(EVENT_SIMON_PLAY_SEQUENCE, 1500);
                        }
                        else
                        {
                            listening = true;
                            DoCast(SPELL_VISUAL_START_PLAYER_LEVEL);
                            playerSequence.clear();
                            PrepareClusters();
                            gameTicks = 0;
                            _events.ScheduleEvent(EVENT_SIMON_GAME_TICK, 3000);
                        }
                        break;
                    case EVENT_SIMON_GAME_TICK:
                        DoCast(SPELL_AUDIBLE_GAME_TICK);

                        if (gameTicks > gameLevel)
                            _events.ScheduleEvent(EVENT_SIMON_TOO_LONG_TIME, 500);
                        else
                            _events.ScheduleEvent(EVENT_SIMON_GAME_TICK, 3000);
                        gameTicks++;
                        break;
                    case EVENT_SIMON_RESET_CLUSTERS:
                        PrepareClusters(true);
                        break;
                    case EVENT_SIMON_TOO_LONG_TIME:
                        DoAction(ACTION_SIMON_WRONG_SEQUENCE);
                        break;
                    case EVENT_SIMON_ROUND_FINISHED:
                        DoAction(ACTION_SIMON_ROUND_FINISHED);
                        break;
                }
            }
Esempio n. 22
0
 void SpellHit(Unit* caster, const SpellInfo* Spell) override
 {
     if (!m_playerGUID)
         if (Spell->Id == 28880 || (Spell->Id >= 59542 && Spell->Id <= 59548) || Spell->Id == 57901)
         {
             m_playerGUID = caster->GetGUID();
             m_events.CancelEvent(EVENT_CHECK_PLAYER_NEAR);
             m_events.ScheduleEvent(EVENT_SAY_THANKS, 6000);
             Talk(SAY_HEAL);
             me->SetStandState(UNIT_STAND_STATE_STAND);
         }
 }
Esempio n. 23
0
		void DamageTaken(Unit*, uint32& damage, DamageEffectType, SpellSchoolMask)
		{
			if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE) && me->HealthBelowPctDamaged(35, damage))
			{
				me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE);
				me->GetMotionMaster()->Clear();
				me->GetMotionMaster()->MoveIdle();
				me->CastSpell(me, SPELL_TELEPORT, false);
				events.CancelEvent(EVENT_SPELL_CORRUPT_SOUL);
				events.DelayEvents(6000);
				events.RescheduleEvent(EVENT_SPELL_FEAR, urand(8000, 14000));
			}
		}
Esempio n. 24
0
        void DoAction(int32 param)
        {
            if (param == ACTION_ENRAGE || param == ACTION_ENRAGE_OTHER)
			{
				me->CastSpell(me, SPELL_CRAZED_RAGE, true);
				events.CancelEvent(EVENT_CHECK_HEALTH);
			}
            else if (param == ACTION_BANISH)
			{
				me->CastSpell(me, SPELL_BANISH, true);
				events.Reset();
			}
        }
Esempio n. 25
0
            void Maze(bool start)
            {
                me->SetReactState(start ? REACT_PASSIVE : REACT_AGGRESSIVE);
                start ? events.CancelEvent(EVENT_HARD_STARE) : events.ScheduleEvent(EVENT_HARD_STARE, 2000);
                start ? events.CancelEvent(EVENT_GAZE) : events.ScheduleEvent(EVENT_GAZE, 2000);

                if (!start)
                {
                    DespawnCreature(YELLOW_EYE_MOVER);

                    events.CancelEvent(EVENT_MIND_DAGGERS);
                    events.CancelEvent(EVENT_MAZE_ORIENTATION);

                    me->RemoveAurasDueToSpell(SPELL_DESINTEGRATION_BEAM);
                }
                else
                {
                    me->SetOrientation(6.272f);
                    if (Creature * tarMover = me->SummonCreature(YELLOW_EYE_MOVER,YellowEyePositions[0]))
                        me->CastSpell(tarMover,SPELL_DESINTEGRATION_BEAM,true);
                }
            }
		void UpdateAI(const uint32 diff) 
		{
			if(!UpdateVictim())
				return;

			if (me->GetHealth() == 1 && droplets == 0)
			{
				events.ScheduleEvent(EVENT_SUMMON_CORRUPT_DROPLETS, 0);
			}

			if (me->GetHealth() == 1 && droplets == 1)
			{
				events.ScheduleEvent(EVENT_SUMMON_CORRUPT_DROPLETS, 0);
			}

			if (me->GetHealth() == 1 && droplets == 2)
			{
				events.ScheduleEvent(EVENT_SUMMON_CORRUPT_DROPLETS, 0);
			}

			if (droplets >= 3)
				me->Kill(me);

			while (uint32 eventId = events.ExecuteEvent())
			{
				switch (eventId)
				{
					if (instance)
					{
						case EVENT_SUMMON_CORRUPT_DROPLETS:
							if (droplets < 3)
								me->CastSpell(me, SPELL_CORRUPTED_DROPLET);

							droplets++;
							events.CancelEvent(EVENT_SUMMON_CORRUPT_DROPLETS);
							break;

						default:
							break;
					}
				}
			}

			DoMeleeAttackIfReady();
		}
Esempio n. 27
0
			void UpdateAI(uint32 const diff)
            {
                if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
				{
                    switch (eventId)
                    {
					case EVENT_SUMMON:
						events.ScheduleEvent(EVENT_SUMMON, 5000);
						if(me->GetHealthPct() < 50)
						{
							events.CancelEvent(EVENT_SUMMON);
							me->SummonCreature(NPC_MYTATED_CORRUPTION, -12060.653f, 12235.851f, -6.255f, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 120000);
						}
						break;
					}
				}
			}
		void UpdateAI(uint32 diff) 
		{
			events.Update(diff);

			if (!corruptedScroll)
			{
				me->CastSpell(me, SPELL_FLOOR_SCROLL);
				corruptedScroll = true;
			}

			while(uint32 eventId = events.ExecuteEvent())
			{
				switch(eventId)
				{
					if (instance)
					{
						case EVENT_SUMMON_BOSSES:
							me->SummonCreature(NPC_OSONG, 848.020325f, -2449.538818f, 174.961197f, 4.385465f, TEMPSUMMON_MANUAL_DESPAWN);
							me->SummonCreature(NPC_PERIL, 835.478394f, -2466.505859f, 174.961578f, 0.935758f, TEMPSUMMON_MANUAL_DESPAWN);
							me->SummonCreature(NPC_STRIFE, 848.223511f, -2470.850586f, 174.961578f, 1.537897f, TEMPSUMMON_MANUAL_DESPAWN);
							
							if (Creature* lorewalker = me->FindNearestCreature(NPC_LOREWALKER_STONESTEP, 99999.0f))
							{
								lorewalker->GetMotionMaster()->MovePoint(0, 824.674438f, -2453.281738f, 176.302979f);
								lorewalker->RemoveAurasDueToSpell(SPELL_SPINNING_CRANE_KICK, lorewalker->GetGUID());
								lorewalker->Say(SAY_OSONG_INTRO_1, 0, 0);
							}

							me->DespawnOrUnsummon();
							events.CancelEvent(EVENT_SUMMON_BOSSES);
							break;

						default:
							break;
					}
				}
			}
		}
Esempio n. 29
0
				void DoAction(const int32 action)
				 {
				switch (action)
					{
					case ACTION_JULES_HOVER:
						me->AddAura(SPELL_JULES_GOES_PRONE, me);
						me->AddAura(SPELL_JULES_THREATENS_AURA, me);
						
							me->SetCanFly(true);
							me->SetSpeed(MOVE_RUN, 0.2f);
						
							me->SetFacingTo(3.207566f);
						                    //MovePoint moechte er nicht, warum auch immer...
							                    //me->GetMotionMaster()->MovePoint(11, exorcismPos[2]);
							me->GetMotionMaster()->MoveJump(exorcismPos[2], 2.0f, 2.0f);
						
							events.ScheduleEvent(EVENT_SUMMON_SKULL, 10000);
						break;
						case ACTION_JULES_FLIGH:
							circleRounds++;
							
								me->RemoveAura(SPELL_JULES_GOES_PRONE);
							
								me->AddAura(SPELL_JULES_GOES_UPRIGHT, me);
								me->AddAura(SPELL_JULES_VOMITS_AURA, me);
							
								wpreached = true;
							me->GetMotionMaster()->MovePoint(point, exorcismPos[point]);
							break;
							case ACTION_JULES_MOVE_HOME:
								wpreached = false;
								me->SetSpeed(MOVE_RUN, 1.0f);
								me->GetMotionMaster()->MovePoint(11, exorcismPos[2]);
								
									events.CancelEvent(EVENT_SUMMON_SKULL);
								break;
								}
				}
Esempio n. 30
0
			void UpdateAI(uint32 const diff)
            {
                if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
                    return;

                events.Update(diff);

                while (uint32 eventId = events.ExecuteEvent())
				{
                    switch (eventId)
                    {
					case EVENT_SUMMON:
						events.ScheduleEvent(EVENT_SUMMON, 5000);
						if(me->GetHealthPct() < 50)
						{
							events.CancelEvent(EVENT_SUMMON);
							if(Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
							me->SummonCreature(NPC_MYTATED_CORRUPTION, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 120000);
						}
						break;
					}
				}
			}