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

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

                switch (events.ExecuteEvent())
                {
                    case EVENT_SUMMON_IMAGE1:
                        if (HealthBelowPct(67))
                        {
                            Talk(SAY_IMAGE);
                            me->CastSpell(me, SPELL_66_ILLUSION, false);
                            break;
                        }
                        events.ScheduleEvent(EVENT_SUMMON_IMAGE1, 1000);
                        break;
                    case EVENT_SUMMON_IMAGE2:
                        if (HealthBelowPct(34))
                        {
                            Talk(SAY_IMAGE);
                            me->CastSpell(me, SPELL_33_ILLUSION, false);
                            break;
                        }
                        events.ScheduleEvent(EVENT_SUMMON_IMAGE2, 1000);
                        break;
                    case EVENT_SPELL_MIND_REND:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50.0f))
                            me->CastSpell(target, SPELL_MIND_REND, false);
                        events.ScheduleEvent(EVENT_SPELL_MIND_REND, 10000);
                        break;
                    case EVENT_SPELL_FEAR:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 20.0f))
                        {
                            Talk(SAY_FEAR);
                            me->CastSpell(target, SPELL_FEAR, false);
                        }
                        events.ScheduleEvent(EVENT_SPELL_FEAR, 25000);
                        break;
                    case EVENT_SPELL_DOMINATION:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 30.0f))
                        {
                            Talk(SAY_MIND);
                            me->CastSpell(target, SPELL_DOMINATION, false);
                        }
                        events.ScheduleEvent(EVENT_SPELL_DOMINATION, 30000);
                        break;
                    case EVENT_SPELL_MANA_BURN:
                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, PowerUsersSelector(me, POWER_MANA, 40.0f, false)))
                            me->CastSpell(target, SPELL_MANA_BURN, false);
                        events.ScheduleEvent(EVENT_SPELL_MANA_BURN, 30000);
                        break;
                }

                DoMeleeAttackIfReady();
            }
        void UpdateAI(uint32 diff)
        {
            // Return since we have no target
            if (!UpdateVictim())
                return;

            _events.Update(diff);

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

            while (uint32 eventId = _events.ExecuteEvent())
            {
                switch (eventId)
                {
                case EVENT_SHADOW_VOLLEY:
                    DoCastVictim(SPELL_SHADOW_VOLLEY);
                    _events.ScheduleEvent(EVENT_SHADOW_VOLLEY, urand(4000, 6000));
                    break;
                case EVENT_CLEAVE:
                    DoCastVictim(SPELL_CLEAVE);
                    _events.ScheduleEvent(EVENT_CLEAVE, urand(8000, 12000));
                    break;
                case EVENT_THUNDERCLAP:
                    DoCastVictim(SPELL_THUNDERCLAP);
                    _events.ScheduleEvent(EVENT_THUNDERCLAP, urand(10000, 14000));
                    break;
                case EVENT_VOID_BOLT:
                    DoCastVictim(SPELL_VOID_BOLT);
                    _events.ScheduleEvent(EVENT_VOID_BOLT, urand(15000, 18000));
                    break;
                case EVENT_MARK_OF_KAZZAK:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, PowerUsersSelector(me, POWER_MANA, 100.0f, true)))
                        DoCast(target, SPELL_MARK_OF_KAZZAK);
                    _events.ScheduleEvent(EVENT_MARK_OF_KAZZAK, 20000);
                    break;
                case EVENT_ENRAGE:
                    Talk(EMOTE_FRENZY);
                    DoCast(me, SPELL_ENRAGE);
                    _events.ScheduleEvent(EVENT_ENRAGE, 30000);
                    break;
                case EVENT_TWISTED_REFLECTION:
                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true))
                        DoCast(target, SPELL_TWISTED_REFLECTION);
                    _events.ScheduleEvent(EVENT_TWISTED_REFLECTION, 15000);
                    break;
                case EVENT_BERSERK:
                    DoCast(me, SPELL_BERSERK);
                    break;
                default:
                    break;
                }
            }

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

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

                switch (events.ExecuteEvent())
                {
                    case EVENT_ARCANE_EXPLOSION:
						me->CastSpell(me, SPELL_ARCANE_EXPLOSION, false);
                        events.ScheduleEvent(EVENT_ARCANE_EXPLOSION, 12000);
                        break;
                    case EVENT_ARCANE_TORRENT:
						me->RemoveAurasDueToSpell(SPELL_MANA_TAP);
						me->ModifyPower(POWER_MANA, 5000);
                        me->CastSpell(me, SPELL_ARCANE_TORRENT, false);
                        events.ScheduleEvent(EVENT_ARCANE_TORRENT, 15000);
                        break;
                    case EVENT_MANA_TAP:
						if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, PowerUsersSelector(me, POWER_MANA, 40.0f, false)))
							me->CastSpell(target, SPELL_MANA_TAP, false);
                        events.ScheduleEvent(EVENT_MANA_TAP, 18000);
                        break;
                    case EVENT_DOMINATION:
                        Talk(SAY_DOMINATION);
						if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 50.0f))
							me->CastSpell(target, SPELL_DOMINATION, false);
                        events.ScheduleEvent(EVENT_DOMINATION, 30000);
                        break;
					case EVENT_FRENZY:
						if (me->HealthBelowPct(20))
						{
							summons.DespawnAll();
							me->CastSpell(me, SPELL_DISGRUNTLED_ANGER, true);
							Talk(SAY_ENRAGE);
							break;
						}
						events.ScheduleEvent(EVENT_FRENZY, 1000);
						break;
                    case EVENT_SUMMON:
                        for (uint8 i = 0; i < DUNGEON_MODE(3, 4); ++i)
							me->CastSpell(me, SPELL_SUMMON_NETHER_WRAITH_1+i, true);

                        Talk(SAY_SUMMON);
                        events.ScheduleEvent(EVENT_SUMMON, urand(30000, 45000));
                        break;
                }

                DoMeleeAttackIfReady();
            }
        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();
        }
			void UpdateAI(uint32 diff)
			{
				if (!UpdateVictim())
					return;

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

				switch (events.ExecuteEvent())
				{
					case EVENT_SPELL_ENRAGE:
						me->CastSpell(me, SPELL_ENRAGE, true);
						break;
					case EVENT_SPELL_CATACLYSMIC_BOLT:
						if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, PowerUsersSelector(me, POWER_MANA, 50.0f, true)))
							me->CastSpell(target, SPELL_CATACLYSMIC_BOLT, false);
						events.ScheduleEvent(EVENT_SPELL_CATACLYSMIC_BOLT, 6000);
						break;
					case EVENT_SPELL_SEAR_NOVA:
						me->CastSpell(me, SPELL_SEAR_NOVA, false);
						events.ScheduleEvent(EVENT_SPELL_SEAR_NOVA, 20000+urand(0, 20000));
						break;
					case EVENT_HEALTH_CHECK:
						if (me->HealthBelowPct(76))
						{
							for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)
								if (Creature* summon = ObjectAccessor::GetCreature(*me, *itr))
									if (summon->GetMaxHealth() > 500000)
										summon->CastSpell(me, SPELL_BLESSING_OF_THE_TIDES, true);

							if (me->HasAura(SPELL_BLESSING_OF_THE_TIDES))
								Talk(SAY_GAIN_BLESSING);
							break;
						}
						events.ScheduleEvent(EVENT_HEALTH_CHECK, 1000);
						break;
				}

				DoMeleeAttackIfReady();
			}