Example #1
0
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim())
                return;

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

            switch (events.GetEvent())
            {
                case EVENT_SPELL_NECROTIC_AURA:
                    me->CastSpell(me, SPELL_NECROTIC_AURA, true);
                    events.RepeatEvent(20000);
                    break;
                case EVENT_SPELL_DEATHBLOOM:
                    me->CastSpell(me, SPELL_SUMMON_SPORE, true);
                    me->CastSpell(me, RAID_MODE(SPELL_DEATHBLOOM_10, SPELL_DEATHBLOOM_25), false);
                    events.RepeatEvent(30000);
                    break;
                case EVENT_SPELL_INEVITABLE_DOOM:
                    me->CastSpell(me, RAID_MODE(SPELL_INEVITABLE_DOOM_10, SPELL_INEVITABLE_DOOM_25), false);
                    events.RepeatEvent(events.GetTimer() < 5*MINUTE*IN_MILLISECONDS ? 30000 : 15000);
                    break;
                case EVENT_SPELL_BERSERK:
                    me->CastSpell(me, SPELL_BERSERK, true);
                    events.PopEvent();
                    break;
            }

            DoMeleeAttackIfReady();
        }
        void UpdateAI(uint32 diff)
        {
            //Return since we have no target or if we are frozen
            if (!UpdateVictim() || me->GetEntry() == NPC_BRITTLE_GOLEM)
                return;

            events.Update(diff);

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

            switch (events.GetEvent())
            {
                case EVENT_BLAST:
                    me->CastSpell(me, SPELL_BLAST_WAVE, false);
                    events.RepeatEvent(14000);
                    break;
                case EVENT_IMMOLATION:
                    me->CastSpell(me->GetVictim(), me->GetMap()->IsHeroic() ? SPELL_IMMOLATION_STRIKE_H : SPELL_IMMOLATION_STRIKE_N, false);
                    events.RepeatEvent(5000);
                    break;
            }

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

            events.Update(diff);

            // Special events which needs to be fired immidiately
            switch(events.GetEvent())
            {
                case EVENT_SARTHARION_SUMMON_LAVA:
                    if (!urand(0,3))
                        Talk(SAY_SARTHARION_SPECIAL);

                    SummonLavaWaves();
                    events.RepeatEvent(25000);
                    return;
                case EVENT_SARTHARION_START_LAVA:
                    SendLavaWaves(true);
                    events.PopEvent();
                    return;
                case EVENT_SARTHARION_FINISH_LAVA:
                    SendLavaWaves(false);
                    events.PopEvent();
                    return;
            }

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

            HandleSartharionAbilities();
            HandleDrakeAbilities();

            DoMeleeAttackIfReady();
        }
Example #4
0
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);

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

            switch(events.GetEvent())
            {
                case 0:
                    break;
                case EVENT_SPELL_GUSHING_WOUND:
                    me->CastSpell(me->GetVictim(), SPELL_GUSHING_WOUND, false);
                    events.RepeatEvent(urand(7000,12000));
                    break;
                case EVENT_SPELL_HOWLING_SCREECH:
                    me->CastSpell(me->GetVictim(), SPELL_HOWLING_SCREECH, false);
                    events.RepeatEvent(urand(8000,13000));
                    break;
                case EVENT_SPELL_STRIKE:
                    me->CastSpell(me->GetVictim(), SPELL_STRIKE, false);
                    events.RepeatEvent(urand(4000,8000));
                    break;
            }

            DoMeleeAttackIfReady();
        }
        void UpdateAI(uint32 diff)
        {
            if (beamTimer)
            {
                beamTimer += diff;
                if (beamTimer >= 2000)
                {
                    me->CastSpell(me, SPELL_CORRUPTION_OF_TIME_CHANNEL, true);
                    beamTimer = 0;
                }
            }

            if (!UpdateVictim())
                return;

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

            switch (events.GetEvent())
            {
                case EVENT_SPELL_VOID_STRIKE:
                    me->CastSpell(me->GetVictim(), SPELL_VOID_STRIKE, false);
                    events.RepeatEvent(8000);
                    break;
                case EVENT_SPELL_CORRUPTING_BLIGHT:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true))
                        me->CastSpell(target, SPELL_CORRUPTING_BLIGHT, false);
                    events.RepeatEvent(12000);
                    break;
            }

            DoMeleeAttackIfReady();
        }
Example #6
0
            void UpdateAI(uint32 diff)
            {
                if (!UpdateVictim())
                    return;

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

                switch (events.GetEvent())
                {
                    case EVENT_SPELL_ACID:
                        me->CastSpell(me->GetVictim(), SPELL_ACID_SPRAY, false);
                        events.RepeatEvent(urand(15000, 23000));
                        break;
                    case EVENT_SPELL_EXPLODING:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            me->CastSpell(target, SPELL_EXPLODING_BREAKER, false);
                        events.RepeatEvent(urand(7000, 11000));
                        break;
                    case EVENT_SPELL_DOMINATION:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            me->CastSpell(target, SPELL_DOMINATION, false);
                        events.RepeatEvent(120000);
                        break;
                    case EVENT_SPELL_KNOCKDOWN:
                        me->CastSpell(me->GetVictim(), SPELL_KNOCKDOWN, false);
                        events.RepeatEvent(urand(4000, 12000));
                        break;
                }

                DoMeleeAttackIfReady();
            }
Example #7
0
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);

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

            switch(events.GetEvent())
            {
                case 0:
                    break;
                case EVENT_SPELL_FIREBOLT:
                    me->CastSpell(me->GetVictim(), SPELL_FIREBOLT, false);
                    events.RepeatEvent(urand(5000,13000));
                    break;
                case EVENT_SPELL_FLAME_BREATH:
                    me->CastSpell(me->GetVictim(), SPELL_FLAME_BREATH, false);
                    events.RepeatEvent(urand(10000,15000));
                    break;
                case EVENT_SPELL_LAVA_BURN:
                    me->CastSpell(me->GetVictim(), SPELL_LAVA_BURN, false);
                    events.RepeatEvent(urand(14000,20000));
                    break;
                case EVENT_SPELL_CAUTERIZING_FLAMES:
                    me->CastSpell((Unit*)NULL, SPELL_FLAME_BREATH, false);
                    events.RepeatEvent(urand(10000,16000));
                    break;
            }

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

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

            switch (events.GetEvent())
            {
                case EVENT_WORGEN_MORTAL:
                {
                    me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_MORTAL_WOUND_H : SPELL_MORTAL_WOUND_H, false);
                    events.RepeatEvent(4000 + rand()%3000);
                    break;
                }
                case EVENT_WORGEN_ENRAGE1:
                {
                    me->CastSpell(me, SPELL_ENRAGE_1, false);
                    events.RepeatEvent(15000);
                    break;
                }
                case EVENT_WORGEN_ENRAGE2:
                {
                    me->CastSpell(me, SPELL_ENRAGE_2, false);
                    events.RepeatEvent(10000);
                    break;
                }
            }

            DoMeleeAttackIfReady();
        }
		void UpdateAI(uint32 diff)
		{
			if( TargetGUID )
			{
				Unit* target = ObjectAccessor::GetPlayer(*me, TargetGUID);
				if( !target || !target->HasAura(SPELL_MARK) || !me->IsValidAttackTarget(target) || me->GetMotionMaster()->GetCurrentMovementGeneratorType() != CHASE_MOTION_TYPE || !me->HasUnitState(UNIT_STATE_CHASE_MOVE) )
				{
					SelectNewTarget(true);
					return;
				}
			}

			events.Update(diff);

			switch( events.GetEvent() )
			{
				case 0:
					break;
				case 1:
					me->CastSpell(me, SPELL_SPIKE_SPEED2, true);
					events.PopEvent();
					events.RescheduleEvent(2, 7000);
					break;
				case 2:
					me->CastSpell(me, SPELL_SPIKE_SPEED3, true);
					events.PopEvent();
					break;
				case 3:
					Reset();
					break;
			}
		}
Example #10
0
		void UpdateAI(uint32 diff)
		{
			if( !UpdateVictim() )
				return;

			events.Update(diff);

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

			switch( events.GetEvent() )
			{
				case 0:
					break;
				case 1: // leap
					if (Unit* target = me->GetVictim())
						if (me->GetDistance(target) > 5.0f && me->GetDistance(target) < 30.0f)
						{
							me->CastSpell(target, SPELL_LEAP, false);
							events.PopEvent();
							break;
						}
					events.RepeatEvent(1000);
					break;
				case 2: // claw
					if (Unit* target = me->GetVictim())
						me->CastSpell(target, SPELL_CLAW_N, false);
					events.RepeatEvent(urand(6000,8000));
					break;
			}

			DoMeleeAttackIfReady();
		}
Example #11
0
            void UpdateAI(uint32 diff)
            {
                if (!UpdateVictim() || !canAttack)
                    return;

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

                switch (events.GetEvent())
                {
                    case EVENT_SPELL_SLIME:
                        me->CastSpell(me->GetVictim(), SPELL_SLIME_SPRAY, false);
                        events.RepeatEvent(urand(7000, 12000));
                        break;
                    case EVENT_SPELL_BOLT:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            me->CastSpell(target, SPELL_POISON_BOLT, false);
                        events.RepeatEvent(urand(6000, 11000));
                        break;
                    case EVENT_SPELL_POISON:
                        me->CastSpell(me, SPELL_POISON_CLOUD, false);
                        events.RepeatEvent(20000);
                        break;

                }

                DoMeleeAttackIfReady();
            }
Example #12
0
		void UpdateAI(uint32 diff)
		{
			if (!UpdateVictim())
				return;

			events.Update(diff);

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

			switch (events.GetEvent())
			{
				case EVENT_SPELL_DISEASE_EXPULSION:
					me->CastSpell(me, DUNGEON_MODE(SPELL_DISEASE_EXPULSION_N, SPELL_DISEASE_EXPULSION_H), false);
					events.RepeatEvent(6000);
					break;
				case EVENT_SPELL_FRENZY:
					me->CastSpell(me, SPELL_FRENZY, false);
					events.RepeatEvent(20000);
					break;
				case EVENT_SPELL_CONSTRICTING_CHAINS:
					if (Unit *pTarget = SelectTarget(SELECT_TARGET_BOTTOMAGGRO, 0, 50.0f, true))
						me->CastSpell(pTarget, DUNGEON_MODE(SPELL_CONSTRICTING_CHAINS_N, SPELL_CONSTRICTING_CHAINS_H), false);
					events.RepeatEvent(14000);
					break;
			}

			DoMeleeAttackIfReady();
		}
 void UpdateAI(uint32 diff)
 {
     events.Update(diff);
     switch (events.GetEvent())
     {
         case EVENT_CHECK_PLAYER:
         {
             Player* player = ObjectAccessor::GetPlayer(*me, _playerGUID);
             if (!player || me->GetDistance2d(player) > 100.0f)
             {
                 EnterEvadeMode();
                 return;
             }
             events.RepeatEvent(2000);
             break;
         }
         case EVENT_SUMMON_ARCHERS:
             SummonArchers();
             events.PopEvent();
             break;
         case EVENT_SUMMON_PEASANTS:
             _spoken = false;
             SummonPeasants();
             _spoken = false;
             events.RepeatEvent(60*IN_MILLISECONDS);
             break;
     }
 }
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim() || me->HasUnitState(UNIT_STATE_CASTING))
                return;

            events.Update(diff);

            while (uint32 eventId = events.GetEvent())
            {
                switch (eventId)
                {
                    case EVENT_VALIONAS_FLAME:
                        if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0))
                            DoCast(pTarget, SPELL_VALIONAS_FLAME);
                        events.RepeatEvent(urand(15000,25000));
                        break;
                    case EVENT_SHREDDING_SWIPE:
                        if(me->getVictim())
                            DoCastVictim(SPELL_SHREDDING_SWIPE);
                        events.RepeatEvent(urand(21000,30000));
                        break;
                    case EVENT_DEVOURING_FLAMES:
                        DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), SPELL_DEVOURING_FLAMES_H);
                        events.RepeatEvent(urand(30000,35000));
                        break;
                    default:
                        events.PopEvent();
                        break;
                }
            }

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

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

            switch (events.GetEvent())
            {
                case EVENT_FURBOLG_CHAIN:
                {
                    me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_CHAIN_LIGHTING_H : SPELL_CHAIN_LIGHTING_N, false);
                    events.RepeatEvent(4000 + rand()%3000);
                    break;
                }
                case EVENT_FURBOLG_CRAZED:
                {
                    me->CastSpell(me, SPELL_CRAZED, false);
                    events.RepeatEvent(8000 + rand()%4000);
                    break;
                }
                case EVENT_FURBOLG_ROAR:
                {
                    me->CastSpell(me, SPELL_TERRIFYING_ROAR, false);
                    events.RepeatEvent(10000 + rand()%5000);
                    break;
                }
            }

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

			events.Update(diff);
			switch (events.GetEvent())
			{
				case EVENT_SPELL_LIGHTNING:
					for (uint8 i = 0; i < DUNGEON_MODE(1, 2); ++i)
						if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
							me->CastSpell(target, SPELL_LIGHTNING_CLOUD, false);
					events.RepeatEvent(urand(15000, 25000));
					break;
				case EVENT_SPELL_LUNG:
					if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_LUNG_BURST);
					events.RepeatEvent(urand(7000, 12000));
					break;
				case EVENT_SPELL_ENVELOPING:
					for (uint8 i = 0; i < DUNGEON_MODE(1, 2); ++i)
						if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
							me->CastSpell(target, SPELL_ENVELOPING_WINDS, false);
					events.RepeatEvent(urand(10000, 15000));
					break;
			}

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

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

            switch (events.GetEvent())
            {
                case EVENT_RHINO_STOMP:
                {
                    me->CastSpell(me->GetVictim(), SPELL_STOMP, false);
                    events.RepeatEvent(8000 + rand()%4000);
                    break;
                }
                case EVENT_RHINO_GORE:
                {
                    me->CastSpell(me->GetVictim(), IsHeroic() ? SPELL_GORE_H : SPELL_GORE_N, false);
                    events.RepeatEvent(13000 + rand()%4000);
                    break;
                }
                case EVENT_RHINO_WOUND:
                {
                    if (Unit *tgt = SelectTarget(SELECT_TARGET_RANDOM, 0))
                        me->CastSpell(tgt, IsHeroic() ? SPELL_GRIEVOUS_WOUND_H : SPELL_GRIEVOUS_WOUND_N, false);

                    events.RepeatEvent(18000 + rand()%4000);
                    break;
                }
            }

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

            events.Update(diff);

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

            switch( events.GetEvent() )
            {
                case 0:
                    break;
                case EVENT_SPELL_RADIANCE:
                    me->CastSpell((Unit*)NULL, SPELL_RADIANCE, false);
                    me->MonsterTextEmote(TEXT_RADIATE, 0, true);
                    events.RepeatEvent(16000);
                    break;
                case EVENT_SPELL_HAMMER_RIGHTEOUS:
                    if( Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 55.0f, true) )
                    {
                        char buffer[100];
                        sprintf(buffer, "Eadric the Pure targets %s with the Hammer of the Righteous!", target->GetName().c_str());
                        me->MonsterTextEmote(buffer, 0, true);
                        Talk(TEXT_EADRIC_HAMMER);
                        me->CastSpell(target, SPELL_HAMMER_JUSTICE, true);
                        me->CastSpell(target, SPELL_HAMMER_RIGHTEOUS, false);
                    }
                    events.RepeatEvent(25000);
                    break;
            }

            DoMeleeAttackIfReady();
        }
Example #19
0
		void UpdateAI(uint32 diff)
		{
			if (!UpdateVictim())
				return;

			events.Update(diff);

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

			switch (events.GetEvent())
			{
				case EVENT_BOULDER:
				{
					if (Unit *target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true, 0)) 
						me->CastSpell(target, DUNGEON_MODE(BOULDER_TOSS, BOULDER_TOSS_H), false);

					events.RepeatEvent(5000 + rand()%2000);
					break;
				}
				case EVENT_GROUND_SPIKE:
				{
					me->CastSpell(me->GetVictim(), GROUND_SPIKE_H, false); // current enemy target
					events.RepeatEvent(8000 + rand()%3000);
					break;
				}
				case EVENT_STOMP:
				{
					me->CastSpell(me, DUNGEON_MODE(STOMP, STOMP_H), false);
					events.RepeatEvent(13000 + rand()% 5000);
					break;
				}
				case EVENT_GROUND_SLAM:
				{
					events.RepeatEvent(10000 + rand()%3000);
					me->CastSpell(me->GetVictim(), GROUND_SLAM, true);
					events.DelayEvents(10000);
					events.RescheduleEvent(EVENT_SHATTER, 8000);
					break;
				}
				case EVENT_SHATTER:
				{
					me->CastSpell((Unit*)NULL, DUNGEON_MODE(SHATTER, SHATTER_H), false);
					Talk(SAY_SHATTER);
					events.RescheduleEvent(EVENT_REMOVE_STONED, 1500);
					events.PopEvent();
					break;
				}
				case EVENT_REMOVE_STONED:
				{
					RemoveStonedEffect();
					events.PopEvent();
					break;
				}
			}

			DoMeleeAttackIfReady();
		}
Example #20
0
		void UpdateAI(uint32 diff)
		{
			if( !UpdateVictim() )
				return;

			events.Update(diff);

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

			switch( events.GetEvent() )
			{
				case 0:
					break;
				case EVENT_ANNOUNCER_SAY_ZOMBIE:
					if( pInstance && !summons.empty() )
						if( Creature* ghoul = pInstance->instance->GetCreature(*summons.begin()) )
							ghoul->MonsterYell("[Zombie] .... . Brains ....", LANG_UNIVERSAL, 0);
					events.PopEvent();
					break;
				case EVENT_SPELL_PLAGUE_STRIKE:
					if( me->GetVictim() )
						me->CastSpell(me->GetVictim(), SPELL_PLAGUE_STRIKE, false);
					events.RepeatEvent(urand(10000,12000));
					break;
				case EVENT_SPELL_ICY_TOUCH:
					if( me->GetVictim() )
						me->CastSpell(me->GetVictim(), SPELL_ICY_TOUCH, false);
					events.RepeatEvent(urand(5000,6000));
					break;
				case EVENT_SPELL_DEATH_RESPITE:
					if( Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true) )
						me->CastSpell(target, SPELL_DEATH_RESPITE, false);
					events.RepeatEvent(urand(13000,15000));
					break;
				case EVENT_SPELL_OBLITERATE:
					if( me->GetVictim() )
						me->CastSpell(me->GetVictim(), SPELL_OBLITERATE, false);
					events.RepeatEvent(urand(15000,17000));
					break;
				case EVENT_SPELL_DESECRATION:
					if( Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true) )
						me->CastSpell(target, SPELL_DESECRATION, false);
					events.RepeatEvent(urand(14000,17000));
					break;
				case EVENT_SPELL_DEATH_BITE:
					me->CastSpell((Unit*)NULL, SPELL_DEATH_BITE, false);
					events.RepeatEvent(urand(2000,4000));
					break;
				case EVENT_SPELL_MARKED_DEATH:
					if( Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.000000f, true) )
						me->CastSpell(target, SPELL_MARKED_DEATH, false);
					events.RepeatEvent(9000);
					break;
			}

			DoMeleeAttackIfReady();
		}
Example #21
0
		void UpdateAI(uint32 diff)
		{
			if (!UpdateVictim())
				return;

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

			switch (events.GetEvent())
			{
				case EVENT_SUMMON_FERAL_DEFENDER:
					me->MonsterTextEmote("Auriaya begins to activate Feral Defender.", 0, true);
					me->CastSpell(me, SPELL_ACTIVATE_FERAL_DEFENDER, true);
					events.PopEvent();
					me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_INTERRUPT_CAST, true);
					events.ScheduleEvent(EVENT_REMOVE_IMMUNE, 3000);
					break;
				case EVENT_REMOVE_IMMUNE:
					events.PopEvent();
					me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_INTERRUPT_CAST, false);
					break;
				case EVENT_TERRIFYING_SCREECH:
					me->MonsterTextEmote("Auriaya begins to cast Terrifying Screech.", 0, true);
					me->CastSpell(me, SPELL_TERRIFYING_SCREECH, false);
					events.RepeatEvent(35000);
					break;
				case EVENT_SONIC_SCREECH:
					me->CastSpell(me, SPELL_SONIC_SCREECH, false);
					events.RepeatEvent(50000);
					break;
				case EVENT_GUARDIAN_SWARM:
					me->CastSpell(me->GetVictim(), SPELL_GUARDIAN_SWARM, false);
					events.RepeatEvent(40000);
					break;
				case EVENT_SENTINEL_BLAST:
					me->CastSpell(me, SPELL_SENTINEL_BLAST, false);
					events.RepeatEvent(35000);
					events.DelayEvents(5000, 0);
					break;
				case EVENT_RESPAWN_FERAL_DEFENDER:
				{
					EntryCheckPredicate pred(NPC_FERAL_DEFENDER);
					summons.DoAction(ACTION_FERAL_RESPAWN, pred);
					events.PopEvent();
					break;
				}
				case EVENT_ENRAGE:
					me->MonsterTextEmote("You waste my time!", 0);
					me->PlayDirectSound(SOUND_BERSERK);
					me->CastSpell(me, SPELL_ENRAGE, true);
					events.PopEvent();
					break;
			}

			DoMeleeAttackIfReady();
		}
        void UpdateAI(uint32 diff)
        {
            events.Update(diff);
            switch (events.GetEvent())
            {
                case EVENT_GRAUF_CHECK:
                {
                    CheckPlayers();
                    events.RepeatEvent(2000);
                    break;
                }
                case EVENT_GRAUF_START:
                {
                    me->GetMotionMaster()->Clear(true);
                    me->GetMotionMaster()->MoveTakeoff(10, SkadiPosition[0].GetPositionX(), SkadiPosition[0].GetPositionY(), SkadiPosition[0].GetPositionZ(), 3.0f);

                    SpawnHelpers(0);
                    SpawnHelpers(0);
                    events.ScheduleEvent(EVENT_GRAUF_MOVE, 15000);
                    events.ScheduleEvent(EVENT_GRAUF_SUMMON_HELPERS, 20000);
                    events.PopEvent();
                    break;
                }
                case EVENT_GRAUF_MOVE:
                {
                    AchievementHitCount = 0;
                    uint8 targetPoint = SelectNextPos(currentPos);
                    me->GetMotionMaster()->MovePoint(targetPoint, SkadiPosition[targetPoint].GetPositionX(), SkadiPosition[targetPoint].GetPositionY(), SkadiPosition[targetPoint].GetPositionZ());
                    if (targetPoint <= 1)
                    {
                        SpawnFlameTriggers(targetPoint);
                        me->CastSpell(me, SPELL_FLAME_VISUAL, false);
                    }

                    if (m_pInstance) 
                        m_pInstance->SetData(SKADI_IN_RANGE, 0);

                    currentPos = targetPoint;
                    events.RepeatEvent(25000);
                    break;
                }
                case EVENT_GRAUF_SUMMON_HELPERS:
                {
                    SpawnHelpers(1);
                    events.RepeatEvent(15000);
                    break;
                }
                case EVENT_GRAUF_REMOVE_SKADI:
                {
                    RemoveSkadi(false);
                    me->DespawnOrUnsummon();
                    events.PopEvent();
                    break;
                }
            }
        }
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);
            if (events.GetEvent() == EVENT_STOLEN_SOUL_SPELL)
            {
                switch (myClass)
                {
                    case CLASS_WARRIOR:
                        me->CastSpell(me->GetVictim(), SPELL_MORTAL_STRIKE, false);
                        events.RepeatEvent(6000);
                        break;
                    case CLASS_PALADIN:
                        me->CastSpell(me->GetVictim(), SPELL_HAMMER_OF_JUSTICE, false);
                        events.RepeatEvent(6000);
                        break;
                    case CLASS_HUNTER:
                        me->CastSpell(me->GetVictim(), SPELL_FREEZING_TRAP, false);
                        events.RepeatEvent(20000);
                        break;
                    case CLASS_ROGUE:
                        me->CastSpell(me->GetVictim(), SPELL_HEMORRHAGE, false);
                        events.RepeatEvent(10000);
                        break;
                    case CLASS_PRIEST:
                        me->CastSpell(me->GetVictim(), SPELL_MIND_FLAY, false);
                        events.RepeatEvent(5000);
                        break;
                    case CLASS_SHAMAN:
                        me->CastSpell(me->GetVictim(), SPELL_FROSTSHOCK, false);
                        events.RepeatEvent(8000);
                        break;
                    case CLASS_MAGE:
                        me->CastSpell(me->GetVictim(), SPELL_FIREBALL, false);
                        events.RepeatEvent(5000);
                        break;
                    case CLASS_WARLOCK:
                        me->CastSpell(me->GetVictim(), SPELL_CURSE_OF_AGONY, false);
                        events.RepeatEvent(20000);
                        break;
                    case CLASS_DRUID:
                        me->CastSpell(me->GetVictim(), SPELL_MOONFIRE, false);
                        events.RepeatEvent(10000);
                        break;
                    case CLASS_DEATH_KNIGHT:
                        me->CastSpell(me->GetVictim(), SPELL_PLAGUE_STRIKE, false);
                        events.RepeatEvent(6000);
                        break;
                }
            }

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

            events.Update(diff);

            if( !summoned && HealthBelowPct(25) )
            {
                me->InterruptNonMeleeSpells(true);
                Talk(TEXT_PALETRESS_MEMORY_SUMMON);
                me->CastSpell((Unit*)NULL, SPELL_HOLY_NOVA, false);
                me->CastSpell(me, SPELL_SHIELD, false);
                me->CastSpell((Unit*)NULL, SPELL_SUMMON_MEMORY, false);
                SummonMemory();
                me->CastSpell((Unit*)NULL, SPELL_CONFESS, false);
                events.ScheduleEvent(EVENT_SPELL_RENEW, urand(6000,8000));
                summoned = true;
                return;
            }

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

            switch( events.GetEvent() )
            {
                case 0:
                    break;
                case EVENT_SPELL_SMITE:
                    if( Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f, true) )
                        me->CastSpell(target, SPELL_SMITE, false);
                    events.RepeatEvent(urand(3000,4000));
                    break;
                case EVENT_SPELL_HOLY_FIRE:
                    if( Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30.0f, true) )
                        me->CastSpell(target, SPELL_HOLY_FIRE, false);
                    events.RepeatEvent(urand(9000,12000));
                    break;
                case EVENT_SPELL_RENEW:
                    if( !MemoryGUID )
                    {
                        events.PopEvent();
                        break;
                    }
                    if( urand(0,1) )
                        me->CastSpell(me, SPELL_RENEW, false);
                    else if( Creature* memory = ObjectAccessor::GetCreature(*me, MemoryGUID) )
                        if( memory->IsAlive() )
                            me->CastSpell(memory, SPELL_RENEW, false);
                    events.RepeatEvent(urand(15000,17000));
                    break;
            }

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

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

			switch (events.GetEvent())
			{
				case EVENT_SPELL_ARCANE_VOLLEY:
					me->CastSpell(me, SPELL_ARCANE_VOLLEY_N, false);
					events.RepeatEvent(urand(7000, 12000));
					break;
				case EVENT_SPELL_POLYMORPH:
					if (Unit* target = (IsHeroic() ? SelectTarget(SELECT_TARGET_RANDOM, 0) : SelectTarget(SELECT_TARGET_TOPAGGRO, 1)))
						me->CastSpell(target, SPELL_POLYMORPH_N, false);
					events.RepeatEvent(urand(15000, 17500));
					break;
				case EVENT_SPELL_SLOW:
					me->CastSpell(me, SPELL_SLOW, false);
                    events.RepeatEvent(urand(15000, 30000));
					break;
				case EVENT_HEALTH_CHECK:
					if (me->HealthBelowPct(20))
					{
						me->CastSpell(me, SPELL_MANA_SHIELD, false);
						events.PopEvent();
						return;
					}
					events.RepeatEvent(1000);
					break;
				case EVENT_SPELL_BLINK:
					Talk(EMOTE_ARCANE_EXP);
					if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
					{
						me->CastSpell(target, SPELL_BLINK, false);
						me->NearTeleportTo(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), target->GetOrientation());

						DoCast(target, SPELL_BLINK_TELEPORT);
					}
					events.RepeatEvent(urand(35000, 40000));
					events.DelayEvents(500);
					events.ScheduleEvent(EVENT_SPELL_BLINK_2, 0);
					return;
				case EVENT_SPELL_BLINK_2:
					me->CastSpell(me, SPELL_ARCANE_EXPLOSION_N, false);
					me->CastSpell(me, SPELL_ARCANE_BUBBLE, true);
					events.PopEvent();
					break;
            }

            DoMeleeAttackIfReady();
        }
Example #26
0
		void UpdateAI(uint32 diff)
		{
			if( !UpdateVictim() )
				return;

			events.Update(diff);

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

			DoMeleeAttackIfReady();

			switch( events.GetEvent() )
			{
				case 0:
					break;
				case EVENT_MAGIC_PULL:
					{
						Talk(SAY_PULL);
						//me->MonsterTextEmote(TEXT_MAGIC_PULL, 0, true);

						me->CastSpell(me, SPELL_MAGIC_PULL, false);
						events.RepeatEvent(urand(15000,25000));
						events.ScheduleEvent(EVENT_SUMMON_x4, 1500);
					}
					break;
				case EVENT_THUNDERING_STOMP:
					{
						Talk(SAY_STOMP);

						me->CastSpell(me, SPELL_THUNDERING_STOMP, false);
						events.RepeatEvent(urand(10000,20000));
					}
					break;
				case EVENT_SUMMON:
					{
						for( uint8 i=0; i<2; ++i )
						{
							float angle = rand_norm()*2*M_PI;
							me->SummonCreature(NPC_UNSTABLE_SPHERE, me->GetPositionX() + 5.0f*cos(angle), me->GetPositionY() + 5.0f*sin(angle), me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN, 18000);
						}
						events.RepeatEvent(2000);
					}
					break;
				case EVENT_SUMMON_x4:
					for( uint8 i=0; i<4; ++i )
					{
						float angle = rand_norm()*2*M_PI;
						me->SummonCreature(NPC_UNSTABLE_SPHERE, me->GetPositionX() + 5.0f*cos(angle), me->GetPositionY() + 5.0f*sin(angle), me->GetPositionZ(), 0.0f, TEMPSUMMON_TIMED_DESPAWN, 18000);
					}
					events.PopEvent();
					break;
			}
		}
        void UpdateAI(uint32 diff)
        {
            events.Update(diff);
            uint32 eventId = events.GetEvent();
            if (eventId == EVENT_CHECK_PLAYER)
            {
                Player* player = ObjectAccessor::GetPlayer(*me, playerGUID);
                if (!player || !player->IsWithinDist2d(me, 60.0f))
                    EnterEvadeMode();
                else
                    events.RepeatEvent(5000);
                return;
            }

            if (!UpdateVictim())
                return;

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

            switch (eventId)
            {
                case EVENT_SPELL_CHAIN_LIGHTNING:
                    me->CastSpell(me->GetVictim(), eventId, false);
                    events.RepeatEvent(7000);
                    break;
                case EVENT_SPELL_TEMPTRESS_KISS:
                    me->CastSpell(me->GetVictim(), eventId, false);
                    events.RepeatEvent(45000);
                    break;
                case EVENT_SPELL_DEMONIC_ENRAGE:
                    me->CastSpell(me, eventId, false);
                    events.RepeatEvent(20000);
                    break;
                case EVENT_SPELL_ENTROPIC_STING:
                    me->CastSpell(me->GetVictim(), eventId, false);
                    events.RepeatEvent(20000);
                    break;
                case EVENT_SPELL_DEMONIC_DOOM:
                    me->CastSpell(me->GetVictim(), eventId, false);
                    events.RepeatEvent(50000);
                    break;
                case EVENT_SPELL_STINGING_TRAUMA:
                    me->CastSpell(me->GetVictim(), eventId, false);
                    events.RepeatEvent(20000);
                    break;
                case EVENT_SPELL_DREADFUL_FRIGHT:
                    me->CastSpell(me->GetVictim(), eventId, false);
                    events.RepeatEvent(15000);
                    break;
            }

            DoMeleeAttackIfReady();
        }
            void UpdateAI(uint32 diff)
            {
                if (!UpdateVictim())
                {
					checkTimer += diff;
                    if (checkTimer >= 5000)
                    {
						checkTimer = 0;
                        CheckChannelers();
						if (!me->HasUnitState(UNIT_STATE_CASTING))
                            me->CastSpell(me, SPELL_EVOCATION, false);
                        
                    }
                    return;
                }

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

				switch (events.GetEvent())
				{
					case EVENT_SPELL_VOLLEY:
						me->CastSpell(me, SPELL_SHADOW_BOLT_VOLLEY, false);
						events.RepeatEvent(urand(8000, 13000));
						break;
					case EVENT_SPELL_CORRUPTION:
						me->CastSpell(me, SPELL_CORRUPTION, false);
						events.RepeatEvent(urand(30000, 50000));
						break;
					case EVENT_SPELL_BURNING_NOVA:
						Talk(SAY_NOVA);
						
						ApplyImmunities(false);
						me->AddAura(SPELL_BURNING_NOVA, me);
						ApplyImmunities(true);

						if (IsHeroic())
							DoTeleportAll(me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), me->GetOrientation());

						events.DelayEvents(6000, 0);
						events.RepeatEvent(urand(25000, 32000));
						events.ScheduleEvent(EVENT_SPELL_FIRE_NOVA, 5000);
						break;
					case EVENT_SPELL_FIRE_NOVA:
						me->CastSpell(me, SPELL_FIRE_NOVA, true);
						events.PopEvent();
						break;
				}

                DoMeleeAttackIfReady();
            }
        void UpdateAI(uint32 diff)
        {
            if( pInstance && pInstance->GetData(DATA_KELESETH) != IN_PROGRESS )
            {
                if( me->IsAlive() )
                    Unit::Kill(me, me);
                return;
            }

            if (!UpdateVictim())
                return;

            events.Update(diff);

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

            switch( events.GetEvent() )
            {
                case 0:
                    break;
                case EVENT_SPELL_DECREPIFY:
                    if( !me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE) )
                        me->CastSpell(me->GetVictim(), SPELL_DECREPIFY, false);
                    events.RepeatEvent(urand(15000,25000));
                    break;
                case EVENT_SPELL_BONE_ARMOR:
                    if( !me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE) )
                        me->CastSpell((Unit*)NULL, SPELL_BONE_ARMOR, false);
                    events.RepeatEvent(urand(40000,120000));
                    break;
                case EVENT_RESURRECT:
                    events.PopEvent();
                    events.DelayEvents(3500);
                    DoCast(me, SPELL_SCOURGE_RESURRECTION, true);
                    me->SetStandState(UNIT_STAND_STATE_STAND);
                    me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNK_29);
                    me->RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FEIGN_DEATH);
                    me->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_DEAD);
                    events.RescheduleEvent(EVENT_RESURRECT_2, 3000);
                    break;
                case EVENT_RESURRECT_2:
                    me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                    me->SetControlled(false, UNIT_STATE_ROOT);
                    me->GetMotionMaster()->MoveChase(me->GetVictim());
                    events.PopEvent();
                    break;
            }

            if( !me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE) )
                DoMeleeAttackIfReady();
        }
Example #30
0
        void UpdateAI(uint32 diff)
        {
            if (!UpdateVictim())
                return;

            events.Update(diff);

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

            switch (events.GetEvent())
            {
                case EVENT_BALL_LIGHTNING:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
                        me->CastSpell(target, me->GetMap()->IsHeroic() ? SPELL_BALL_LIGHTNING_H : SPELL_BALL_LIGHTNING_N, false);
                    
                    events.RepeatEvent(10000 + rand()%1000);
                    break;
                case EVENT_STATIC_OVERLOAD:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))
                        me->CastSpell(target, me->GetMap()->IsHeroic() ? SPELL_STATIC_OVERLOAD_H : SPELL_STATIC_OVERLOAD_N, false);

                    events.RepeatEvent(5000 + rand()%1000);
                    break;
                case EVENT_CHECK_HEALTH:
                    if (HealthBelowPct(HealthCheck))
                        me->CastSpell(me, SPELL_DISPERSE, false);

                    events.RepeatEvent(1000);
                    return;
                case EVENT_CALL_SPARKS:
                {
                    EntryCheckPredicate pred(NPC_SPARK_OF_IONAR);
                    summons.DoAction(ACTION_CALLBACK, pred);
                    events.PopEvent();
                    events.ScheduleEvent(EVENT_RESTORE, 2000, 0, 2);
                    return;
                }
                case EVENT_RESTORE:
                    EntryCheckPredicate pred(NPC_SPARK_OF_IONAR);
                    summons.DoAction(ACTION_SPARK_DESPAWN, pred);
                    events.PopEvent();

                    me->SetVisible(true);
                    me->SetControlled(false, UNIT_STATE_STUNNED);
                    ScheduleEvents(true);
                    return;
            }

            DoMeleeAttackIfReady();
        }