自学教程：C++ DoSummon函数代码示例

        void UpdateAI(const uint32 diff)        {            if (!UpdateVictim() || !CheckInRoom())                return;            events.Update(diff);            while (uint32 eventId = events.ExecuteEvent())            {                switch(eventId)                {                    case EVENT_IMPALE:                        //Cast Impale on a random target                        //Do NOT cast it when we are afflicted by locust swarm                        if (!me->HasAura(RAID_MODE(SPELL_LOCUST_SWARM_10,SPELL_LOCUST_SWARM_25)))                            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))                                DoCast(pTarget, RAID_MODE(SPELL_IMPALE_10,SPELL_IMPALE_25));                        events.ScheduleEvent(EVENT_IMPALE, urand(10000,20000));                        break;                    case EVENT_LOCUST:                        // TODO : Add Text                        DoCast(me, RAID_MODE(SPELL_LOCUST_SWARM_10,SPELL_LOCUST_SWARM_25));                        DoSummon(MOB_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);                        events.ScheduleEvent(EVENT_LOCUST, 90000);                        break;                    case EVENT_SPAWN_GUARDIAN_NORMAL:                        // TODO : Add Text                        DoSummon(MOB_CRYPT_GUARD, GuardSummonPos, 0, TEMPSUMMON_CORPSE_DESPAWN);                        break;                    case EVENT_BERSERK:                        DoCast(me, SPELL_BERSERK, true);                        events.ScheduleEvent(EVENT_BERSERK, 600000);                        break;                }            }            DoMeleeAttackIfReady();        }

            void UpdateAI(const uint32 diff)            {                if (!UpdateVictim() || !CheckInRoom())                    return;                events.Update(diff);                if (me->HasUnitState(UNIT_STAT_CASTING))                    return;                while (uint32 eventId = events.ExecuteEvent())                {                    switch (eventId)                    {                        case EVENT_SLIME_SPRAY:                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))                            {                                DoSummon(NPC_OOZE_SPRAY_STALKER, *target, 8000, TEMPSUMMON_TIMED_DESPAWN);                                Talk(EMOTE_SLIME_SPRAY);                                DoCast(me, SPELL_SLIME_SPRAY);                            }                            events.ScheduleEvent(EVENT_SLIME_SPRAY, 20000);                            break;                        case EVENT_HASTEN_INFECTIONS:                            if (infectionStage++ < 4)                            {                                infectionCooldown -= 2000;                                events.ScheduleEvent(EVENT_HASTEN_INFECTIONS, 90000);                            }                            break;                        case EVENT_MUTATED_INFECTION:                        {                            Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true, -MUTATED_INFECTION);                            if (!target)                                target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true, -MUTATED_INFECTION);                            if (target)                            {                                me->CastCustomSpell(SPELL_MUTATED_INFECTION, SPELLVALUE_MAX_TARGETS, 1, target, false);                                Talk(EMOTE_MUTATED_INFECTION, target->GetGUID());                            }                            events.ScheduleEvent(EVENT_MUTATED_INFECTION, infectionCooldown);                            break;                        }                        default:                            break;                    }                }                DoMeleeAttackIfReady();            }

            void EnterCombat(Unit* /*who*/) override            {                for (uint32 i = 0; i < POS_LIVE; ++i)                    if (Creature* trigger = DoSummon(WORLD_TRIGGER, PosSummonLive[i]))                        LiveTriggerGUID.push_back(trigger->GetGUID());                for (uint32 i = 0; i < POS_DEAD; ++i)                    if (Creature* trigger = DoSummon(WORLD_TRIGGER, PosSummonDead[i]))                        DeadTriggerGUID.push_back(trigger->GetGUID());                if (LiveTriggerGUID.size() < POS_LIVE || DeadTriggerGUID.size() < POS_DEAD)                {                    TC_LOG_ERROR("scripts", "Script Gothik: cannot summon triggers!");                    EnterEvadeMode();                    return;                }                _EnterCombat();                waveCount = 0;                events.ScheduleEvent(EVENT_SUMMON, 30000);                DoTeleportTo(PosPlatform);                Talk(SAY_SPEECH);                instance->SetData(DATA_GOTHIK_GATE, GO_STATE_READY);            }

    void UpdateAI(const uint32 diff)    {        if (pInstance && pInstance->GetData(DATA_REMOVE_NPC) == 1)        {            me->ForcedDespawn();            pInstance->SetData(DATA_REMOVE_NPC, 0);        }        if (uiSpawnTimer <= diff)        {            if (bPortalGuardianOrKeeperSpawn)            {                uint8 k = pInstance && pInstance->GetData(DATA_WAVE_COUNT) < 12 ? 2 : 3;                for (uint8 i = 0; i < k; ++i)                {                    uint32 entry = RAND(CREATURE_AZURE_CAPTAIN,CREATURE_AZURE_RAIDER,CREATURE_AZURE_STALKER,CREATURE_AZURE_SORCEROR);                    if (Creature* pSummon = DoSummon(entry, me, 2.0f, 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT))                        pSummon->GetMotionMaster()->MovePoint(0, DoorPosition);                }            }            else            {                bPortalGuardianOrKeeperSpawn = true;                uint32 entry = RAND(CREATURE_PORTAL_GUARDIAN, CREATURE_PORTAL_KEEPER);                if (Creature *pPortalKeeper = DoSummon(entry, me, 2.0f, 0, TEMPSUMMON_DEAD_DESPAWN))                    me->CastSpell(pPortalKeeper, SPELL_PORTAL_CHANNEL, false);            }            uiSpawnTimer = SPAWN_TIME;        } else uiSpawnTimer -= diff;        if (bPortalGuardianOrKeeperSpawn && !me->IsNonMeleeSpellCasted(false))        {            me->Kill(me, false);            me->RemoveCorpse();            return;        }    }

    void UpdateAI(const uint32 uiDiff) override    {        if (m_uiTimer < uiDiff)        {            switch (m_uiWave)            {            case 0:                DoSummon(0);                m_uiTimer = 15000;                ++m_uiWave;                break;            case 1:                DoSummon(1);                DoSummon(2);                m_uiTimer = 15000;                ++m_uiWave;                break;            case 2:                {                    DoSummon(3);                    m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_PACIFIED | UNIT_FLAG_PASSIVE);                    m_creature->SetVisibility(VISIBILITY_ON);                    if (auto pPlayer = m_creature->GetMap()->GetPlayer(m_PlayerGuid))                    {                        if (pPlayer->isAlive())                            m_creature->AI()->AttackStart(pPlayer);                    }                    ++m_uiWave;                }                break;            }        }        else            m_uiTimer -= uiDiff;        ScriptedAI::UpdateAI(uiDiff);    }

        void UpdateAI(const uint32 diff)        {            //Return since we have no target            if (!UpdateVictim())                return;            if (uiSpawnTimer <= diff)            {                uint32 spawnNumber = urand(2, DUNGEON_MODE(3, 5));                for (uint8 i = 0; i < spawnNumber; ++i)                    DoSummon(RAND(NPC_DRAKKARI_INVADER_1, NPC_DRAKKARI_INVADER_2), AddSpawnPoint, 0, TEMPSUMMON_DEAD_DESPAWN);                uiSpawnTimer = urand(30*IN_MILLISECONDS, 40*IN_MILLISECONDS);            } else uiSpawnTimer -= diff;            if (uiConsumeTimer <= diff)            {                DoScriptText(SAY_CONSUME, me);                DoCast(SPELL_CONSUME);                uiConsumeTimer = 15*IN_MILLISECONDS;            } else uiConsumeTimer -= diff;            if (consumptionJunction)            {                Aura* ConsumeAura = me->GetAura(DUNGEON_MODE(SPELL_CONSUME_AURA, H_SPELL_CONSUME_AURA));                if (ConsumeAura && ConsumeAura->GetStackAmount() > 9)                    consumptionJunction = false;            }            if (uiCrushTimer <= diff)            {                DoCastVictim(SPELL_CRUSH);                uiCrushTimer = urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS);            } else uiCrushTimer -= diff;            if (uiInfectedWoundTimer <= diff)            {                DoCastVictim(SPELL_INFECTED_WOUND);                uiInfectedWoundTimer = urand(25*IN_MILLISECONDS, 35*IN_MILLISECONDS);            } else uiInfectedWoundTimer -= diff;            if (uiExplodeCorpseTimer <= diff)            {                DoCast(SPELL_CORPSE_EXPLODE);                DoScriptText(SAY_EXPLODE, me);                uiExplodeCorpseTimer = urand(15*IN_MILLISECONDS, 19*IN_MILLISECONDS);            } else uiExplodeCorpseTimer -= diff;            DoMeleeAttackIfReady();        }

        void UpdateAI(const uint32 diff)        {            if (!UpdateVictimWithGaze() || !CheckInRoom())                return;            events.Update(diff);            while (uint32 eventId = events.ExecuteEvent())            {                switch (eventId)                {                    case EVENT_WOUND:                        DoCast(me->getVictim(), SPELL_MORTAL_WOUND);                        events.ScheduleEvent(EVENT_WOUND, 10000);                        break;                    case EVENT_ENRAGE:                        // TODO : Add missing text                        DoCast(me, SPELL_ENRAGE);                        events.ScheduleEvent(EVENT_ENRAGE, 15000);                        break;                    case EVENT_DECIMATE:                        // TODO : Add missing text                        DoCastAOE(SPELL_DECIMATE);                        events.ScheduleEvent(EVENT_DECIMATE, 105000);                        break;                    case EVENT_BERSERK:                        DoCast(me, SPELL_BERSERK);                        events.ScheduleEvent(EVENT_BERSERK, 5*60000);                        break;                    case EVENT_SUMMON:                        for (int32 i = 0; i < RAID_MODE(1, 2); ++i)                            DoSummon(MOB_ZOMBIE, PosSummon[rand() % RAID_MODE(1, 3)]);                        events.ScheduleEvent(EVENT_SUMMON, 10000);                        break;                }            }            if (me->getVictim() && me->getVictim()->GetEntry() == MOB_ZOMBIE)            {                if (me->IsWithinMeleeRange(me->getVictim()))                {                    me->Kill(me->getVictim());                    me->ModifyHealth(int32(me->CountPctFromMaxHealth(5)));                }            }            else                DoMeleeAttackIfReady();        }

        boss_flame_leviathanAI(Creature *pCreature) : BossAI(pCreature, BOSS_LEVIATHAN), vehicle(me->GetVehicleKit())        {            assert(vehicle);            pInstance = pCreature->GetInstanceScript();            ColossusCount = 0;            me->ApplySpellImmune(0, IMMUNITY_EFFECT, SPELL_EFFECT_KNOCK_BACK, true);            me->ApplySpellImmune(0, IMMUNITY_ID, 49560, true);  // Death Grip                    me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE | UNIT_FLAG_STUNNED);            me->SetReactState(REACT_PASSIVE);        // Summon Ulduar Colossus        if (me->isAlive())            for(uint32 i = 0; i < 2; ++i)                DoSummon(MOB_COLOSSUS, PosColossus[i], 7000, TEMPSUMMON_CORPSE_TIMED_DESPAWN);    	}

        void UpdateAI(uint32 diff) override        {            if (!UpdateVictim())                return;            events.Update(diff);            if (me->HasUnitState(UNIT_STATE_CASTING))                return;            while (uint32 eventId = events.ExecuteEvent())            {                switch (eventId)                {                case EVENT_SLIME_SPRAY:                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1, 0.0f, true))                    {                        DoSummon(NPC_OOZE_SPRAY_STALKER, *target, 8000, TEMPSUMMON_TIMED_DESPAWN);                        Talk(EMOTE_SLIME_SPRAY);                        DoCast(me, SPELL_SLIME_SPRAY);                    }                    events.ScheduleEvent(EVENT_SLIME_SPRAY, 20000);                    break;                case EVENT_HASTEN_INFECTIONS:                    if (infectionStage++ < 4)                    {                        infectionCooldown -= 2000;                        events.ScheduleEvent(EVENT_HASTEN_INFECTIONS, 90000);                    }                    break;                case EVENT_MUTATED_INFECTION:                    DoCastAOE(SPELL_MUTATED_INFECTION);                    events.ScheduleEvent(EVENT_MUTATED_INFECTION, infectionCooldown);                    break;                case EVENT_VILE_GAS:                    DoCastAOE(SPELL_VILE_GAS_TRIGGER);                    events.ScheduleEvent(EVENT_VILE_GAS, urand(30000, 35000));                    break;                default:                    break;                }            }            DoMeleeAttackIfReady();        }

    void UpdateAI(const uint32 diff)    {        if (!UpdateVictimWithGaze() || !CheckInRoom())            return;        events.Update(diff);        while(uint32 eventId = events.ExecuteEvent())        {            switch(eventId)            {                case EVENT_WOUND:                    DoCast(me->getVictim(), SPELL_MORTAL_WOUND);                    events.ScheduleEvent(EVENT_WOUND, 10000);                    return;                case EVENT_ENRAGE:                    DoCast(me, SPELL_ENRAGE);                    events.ScheduleEvent(EVENT_ENRAGE, 30000);                    return;                case EVENT_DECIMATE:                    DoCastAOE(SPELL_DECIMATE);                    events.ScheduleEvent(EVENT_DECIMATE, 105000);                    return;                case EVENT_BERSERK:                    DoCast(me, SPELL_BERSERK);                    return;                case EVENT_SUMMON:                    for(uint32 i = 0; i < HEROIC(1,2); ++i)                        DoSummon(MOB_ZOMBIE, triggers[rand()%3]);                    events.ScheduleEvent(EVENT_SUMMON, 10000);                    return;            }        }        if (me->getVictim()->GetEntry() == MOB_ZOMBIE)        {            if (me->IsWithinMeleeRange(me->getVictim()))            {                me->Kill(me->getVictim());                me->ModifyHealth(me->GetMaxHealth() * 0.05f);            }        }        else            DoMeleeAttackIfReady();    }

        void UpdateAI(uint32 diff) override        {            if (!UpdateVictimWithGaze() || !CheckInRoom())                return;            events.Update(diff);            while (uint32 eventId = events.ExecuteEvent())            {                switch (eventId)                {                    case EVENT_WOUND:                        DoCastVictim(SPELL_MORTAL_WOUND);                        events.ScheduleEvent(EVENT_WOUND, 10000);                        break;                    case EVENT_ENRAGE:                        Talk(EMOTE_ENRAGE);                        DoCast(me, SPELL_ENRAGE);                        events.ScheduleEvent(EVENT_ENRAGE, 15000);                        break;                    case EVENT_DECIMATE:                        Talk(EMOTE_DECIMATE);                        DoCastAOE(SPELL_DECIMATE);                        events.ScheduleEvent(EVENT_DECIMATE, 105000);                        break;                    case EVENT_BERSERK:                        DoCast(me, SPELL_BERSERK);                        events.ScheduleEvent(EVENT_BERSERK, 5*60000);                        break;                    case EVENT_SUMMON:                        for (int32 i = 0; i < RAID_MODE(1, 2); ++i)                            DoSummon(NPC_ZOMBIE, PosSummon[rand32() % RAID_MODE(1, 3)]);                        // There's probably a better way to handle this                        for (SummonList::iterator itr = summons.begin(); itr != summons.end(); ++itr)                            if(Unit* unit = ObjectAccessor::GetUnit(*me, *itr))                                if (unit->GetEntry() == NPC_ZOMBIE)                                    unit->ToCreature()->AI()->AttackStart(me);                        events.ScheduleEvent(EVENT_SUMMON, 10000);                        break;                }            }                DoMeleeAttackIfReady();        }

    void EnterCombat(Unit *who)    {        for(uint32 i = 0; i < 3; ++i)            if (Creature *trigger = DoSummon(WORLD_TRIGGER, PosSummon[i]))                triggers.push_back(trigger);        if (triggers.size() < 3)        {            error_log("Script Gluth: cannot summon triggers!");            EnterEvadeMode();            return;        }        _EnterCombat();        events.ScheduleEvent(EVENT_WOUND, 10000);        events.ScheduleEvent(EVENT_ENRAGE, 30000);        events.ScheduleEvent(EVENT_DECIMATE, 105000);        events.ScheduleEvent(EVENT_BERSERK, 8*60000);        events.ScheduleEvent(EVENT_SUMMON, 10000);    }

        void MovementInform(uint32 type, uint32 id) override        {            if (type != POINT_MOTION_TYPE)                return;            if (id < 10)                wpreached = true;            if (id == 8)            {                for (uint8 i = 0; i < 2; i++)                    DoSummon(NPC_FOUL_PURGE, exorcismPos[8]);            }            if (id == 10)            {                wpreached = true;                point = 3;            }        }

        void DoSummonAtRift(uint32 creature_entry)        {            if (!creature_entry)                return;            if (instance->GetData(TYPE_MEDIVH) != IN_PROGRESS)            {                me->InterruptNonMeleeSpells(true);                me->RemoveAllAuras();                return;            }            Position pos = me->GetRandomNearPosition(10.0f);            //normalize Z-level if we can, if rift is not at ground level.            pos.m_positionZ = std::max(me->GetMap()->GetHeight(pos.m_positionX, pos.m_positionY, MAX_HEIGHT), me->GetMap()->GetWaterLevel(pos.m_positionX, pos.m_positionY));            if (Unit* Summon = DoSummon(creature_entry, pos, 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT))                if (Unit* temp = ObjectAccessor::GetUnit(*me, instance->GetGuidData(DATA_MEDIVH)))                    AddThreat(temp, 0.0f, Summon);        }

	void SummonPlanarAnomaly()	{		std::list<HostileReference*>& m_threatlist = me->getThreatManager().getThreatList();		std::list<HostileReference*>::const_iterator i = m_threatlist.begin();		for (i = m_threatlist.begin(); i!= m_threatlist.end(); ++i)		{			Unit* pUnit = Unit::GetUnit((*me), (*i)->getUnitGuid());			if (pUnit )			{				Creature* summon = DoSummon(PLANAR_ANOMALY, me, 3.0f, 30000, TEMPSUMMON_DEAD_DESPAWN);				if(summon)				{					summon->Attack(pUnit,true);					printf("PLANAR_ANOMALY attack uinit %s /n",pUnit->GetName());					summon->SetVisibility(VISIBILITY_ON);					summon->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);					summon->SetUnitMovementFlags(MOVEMENTFLAG_FLYING);				}			}		}	}

 void WaypointStart(uint32 pointId) override {     switch (pointId)     {         case 27:             for (uint8 i = 0; i < 3; ++i)             {                 const Position src = {147.927444f, -3851.513428f, 130.893f, 0};                 Position dst = me->GetRandomPoint(src, 7.0f);                 DoSummon(NPC_MARAUDING_OWL, dst, 25000, TEMPSUMMON_CORPSE_TIMED_DESPAWN);             }             break;         case 44:             for (uint8 i = 0; i < 3; ++i)             {                 const Position src = {-141.151581f, -4291.213867f, 120.130f, 0};                 Position dst = me->GetRandomPoint(src, 7.0f);                 me->SummonCreature(NPC_VILE_AMBUSHER, dst, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 25000);             }             break;     } }

        void UpdateAI(const uint32 diff)        {            if (LamentEvent)            {                if (LamentEvent_Timer <= diff)                {                    DoSummon(ENTRY_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);                    LamentEvent_Timer = 2000;                    if (!me->HasAura(SPELL_SYLVANAS_CAST))                    {                        DoScriptText(SAY_LAMENT_END, me);                        DoScriptText(EMOTE_LAMENT_END, me);                        LamentEvent = false;                    }                } else LamentEvent_Timer -= diff;            }            if (!UpdateVictim())                return;            DoMeleeAttackIfReady();        }

 void RandomSpawn() {     switch(m_uiStage)     {         case 1:             DoSummon(CREATURE_FANATIC, SpawnLoc[0]);             DoSummon(CREATURE_ADHERENT, SpawnLoc[1]);             DoSummon(CREATURE_FANATIC, SpawnLoc[2]);             ++m_uiStage;             break;         case 2:             DoSummon(CREATURE_ADHERENT, SpawnLoc[3]);             DoSummon(CREATURE_FANATIC, SpawnLoc[4]);             DoSummon(CREATURE_ADHERENT, SpawnLoc[5]);             --m_uiStage;             break;     } }

		void OozesMeetCheck()		{			if (summons.empty() || summons.size()==1)				return;			for (SummonList::const_iterator itr = summons.begin(); itr != summons.end(); ++itr)			{				Creature* ooze = ObjectAccessor::GetCreatureOrPetOrVehicle((*me), (*itr));				if (!ooze || !ooze->isAlive())					continue;				if (ooze->GetEntry() != CREATURE_LITTLE_OOZE && ooze->GetEntry() != CREATURE_OOZE_BIG)					continue;				bool little = (ooze->GetEntry() == CREATURE_LITTLE_OOZE);				for(SummonList::const_iterator itr2 = summons.begin(); itr2 != summons.end(); ++itr2)				{					Creature* ooze2 = ObjectAccessor::GetCreatureOrPetOrVehicle((*me), (*itr2));					if (!ooze2 || !ooze2->isAlive())						continue;					if (ooze2->GetEntry() != CREATURE_LITTLE_OOZE && ooze2->GetEntry() != CREATURE_OOZE_BIG)						continue;					if (ooze2 == ooze)						continue;					if (ooze->GetDistance2d(ooze2) > 5.0f)						continue;					bool little2 = (ooze2->GetEntry() == CREATURE_LITTLE_OOZE);					//if first ooze is big ooze					if (!little)					{						//and if second ooze is little						if (little2)						{							ooze->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);							if (ooze->GetAura(SPELL_UNSTABLE_OOZE) && ooze->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)								ooze->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);							continue;						}						else //big ooze meet another big ooze, check wich one have more buff stack and despawn second one						{							uint8 stack1, stack2 = 0;							if (Aura* aura = ooze->GetAura(SPELL_UNSTABLE_OOZE))								stack1 = aura->GetStackAmount();							if (Aura* aura = ooze2->GetAura(SPELL_UNSTABLE_OOZE))								stack2 = aura->GetStackAmount();							if (stack1 < stack2)							{								ooze2->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);								ooze->ForcedDespawn();								if (ooze2->GetAura(SPELL_UNSTABLE_OOZE) && ooze2->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)								{									ooze2->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);									ooze2->ForcedDespawn();								}								break;							}							else							{								ooze->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);								ooze2->ForcedDespawn();								if (ooze->GetAura(SPELL_UNSTABLE_OOZE) && ooze->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)								{									ooze->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);									ooze->ForcedDespawn();								}								continue;							}						}					}					else  //if first ooze is little					{						if (little2) //and second ooze is little, despawn both and summon big ooze						{							DoSummon(CREATURE_OOZE_BIG, (*ooze));							ooze->ForcedDespawn();							ooze2->ForcedDespawn();							break;						}						else						{							ooze2->CastSpell(ooze, SPELL_UNSTABLE_OOZE, false);							ooze->ForcedDespawn();							if (ooze2->GetAura(SPELL_UNSTABLE_OOZE) && ooze2->GetAura(SPELL_UNSTABLE_OOZE)->GetStackAmount() >= 5)							{								ooze2->CastSpell(ooze2->getVictim(), SPELL_UNSTABLE_EXPLOSION, true);								ooze2->ForcedDespawn();							}							break;						}					}				}			}		}

        void UpdateAI(const uint32 diff)        {            if (!phase)                return;            events.Update(diff);            if ((phase != PHASE_BIRTH && !UpdateVictim()) || !CheckInRoom())                return;            if (CanTheHundredClub)            {                if (CheckFrostResistTimer <= diff)                {                    CheckPlayersFrostResist();                    CheckFrostResistTimer = (rand() % 5 + 5) * 1000;                } else CheckFrostResistTimer -= diff;            }            if (phase == PHASE_GROUND)            {                while (uint32 eventId = events.ExecuteEvent())                {                    switch (eventId)                    {                        case EVENT_BERSERK:                            DoScriptText(EMOTE_ENRAGE, me);                            DoCast(me, SPELL_BERSERK);                            return;                        case EVENT_CLEAVE:                            DoCast(me->getVictim(), SPELL_CLEAVE);                            events.ScheduleEvent(EVENT_CLEAVE, 5000+rand()%10000, 0, PHASE_GROUND);                            return;                        case EVENT_TAIL:                            DoCastAOE(SPELL_TAIL_SWEEP);                            events.ScheduleEvent(EVENT_TAIL, 5000+rand()%10000, 0, PHASE_GROUND);                            return;                        case EVENT_DRAIN:                            DoCastAOE(SPELL_LIFE_DRAIN);                            events.ScheduleEvent(EVENT_DRAIN, 24000, 0, PHASE_GROUND);                            return;                        case EVENT_BLIZZARD:                        {                            //DoCastAOE(SPELL_SUMMON_BLIZZARD);                            if (Creature* summon = DoSummon(MOB_BLIZZARD, me, 0.0f, urand(25000, 30000), TEMPSUMMON_TIMED_DESPAWN))                                summon->GetMotionMaster()->MoveRandom(40);                            events.ScheduleEvent(EVENT_BLIZZARD, RAID_MODE(20000, 7000), 0, PHASE_GROUND);                            break;                        }                        case EVENT_FLIGHT:                            if (HealthAbovePct(10))                            {                                phase = PHASE_FLIGHT;                                events.SetPhase(PHASE_FLIGHT);                                me->SetReactState(REACT_PASSIVE);                                me->AttackStop();                                float x, y, z, o;                                me->GetHomePosition(x, y, z, o);                                me->GetMotionMaster()->MovePoint(1, x, y, z);                                return;                            }                            break;                    }                }                DoMeleeAttackIfReady();            }            else            {                if (uint32 eventId = events.ExecuteEvent())                {                    switch (eventId)                    {                        case EVENT_LIFTOFF:                            me->HandleEmoteCommand(EMOTE_ONESHOT_LIFTOFF);                            me->SetLevitate(true);                            me->SendMovementFlagUpdate();                            events.ScheduleEvent(EVENT_ICEBOLT, 1500);                            iceboltCount = RAID_MODE(2, 3);                            return;                        case EVENT_ICEBOLT:                        {                            std::vector<Unit*> targets;                            std::list<HostileReference*>::const_iterator i = me->getThreatManager().getThreatList().begin();                            for (; i != me->getThreatManager().getThreatList().end(); ++i)                                if ((*i)->getTarget()->GetTypeId() == TYPEID_PLAYER && !(*i)->getTarget()->HasAura(SPELL_ICEBOLT))                                    targets.push_back((*i)->getTarget());                            if (targets.empty())                                iceboltCount = 0;                            else                            {                                std::vector<Unit*>::const_iterator itr = targets.begin();                                advance(itr, rand()%targets.size());                                iceblocks.insert(std::make_pair((*itr)->GetGUID(), 0));                                DoCast(*itr, SPELL_ICEBOLT);                                --iceboltCount;                            }                            if (iceboltCount)//.........这里部分代码省略.........

        void UpdateAI(uint32 uiDiff)        {            if (!UpdateVictim())                return;            if (!bIsFrenzy && !bIsExploded && HealthBelowPct(25))            {                Talk(SAY_ENRAGE);                me->CastSpell(me, SPELL_FRENZY, true);                bIsFrenzy = true;            }            if (!bIsFrenzy)            {                if (!bIsExploded)                {                    if (!me->HasAura(SPELL_PROTECTIVE_BUBBLE))                    {                        me->InterruptNonMeleeSpells(false);                        Talk(SAY_SHATTER);                        DoZoneInCombat();                        IchoronDoCastToAllHostilePlayers(SPELL_WATER_BLAST, true);                        me->CastSpell(me, SPELL_DRAINED, true);                        bIsExploded = true;                        uiDrainedTimer = 15000;                        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);                        me->SetDisplayId(11686);                        for (uint8 i=0; i<MAX_SPAWN_LOC; ++i)                        {                            float angle = rand_norm()*2*M_PI;                            Position p1(SpawnLoc[i]), p2(SpawnLoc[i]);                            p1.m_positionX += 2.5f*cos(angle);                            p1.m_positionY += 2.5f*sin(angle);                            p2.m_positionX -= 2.5f*cos(angle);                            p2.m_positionY -= 2.5f*sin(angle);                            DoSummon(NPC_ICHOR_GLOBULE, p1, 60000, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN);                            DoSummon(NPC_ICHOR_GLOBULE, p2, 60000, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN);                        }                    }                }                else                {                    if (uiDrainedTimer <= uiDiff)                        DoExplodeCompleted();                    else                    {                        uiDrainedTimer -= uiDiff;                        bool bIsWaterElementsAlive = false;                        if (!globules.empty())                        {                            for (std::list<uint64>::const_iterator itr = globules.begin(); itr != globules.end(); ++itr)                                if (Creature* pTemp = ObjectAccessor::GetCreature(*me, *itr))                                    if (pTemp->IsAlive())                                    {                                        bIsWaterElementsAlive = true;                                        break;                                    }                        }                        if (!bIsWaterElementsAlive)                            DoExplodeCompleted();                    }                }            }            if (!bIsExploded)            {                if (uiWaterBoltVolleyTimer <= uiDiff)                {                    me->CastSpell((Unit*)NULL, SPELL_WATER_BOLT_VOLLEY, false);                    uiWaterBoltVolleyTimer = urand(10000, 15000);                }                else uiWaterBoltVolleyTimer -= uiDiff;            }            DoMeleeAttackIfReady();        }

        void UpdateAI(const uint32 diff)        {            if (!UpdateVictim())                return;            events.Update(diff);            if (me->HasUnitState(UNIT_STAT_CASTING))                return;            EncounterTime += diff;            ConstructTimer += diff;            while(uint32 eventId = events.ExecuteEvent())            {                switch(eventId)                {                    case EVENT_JET:                        me->MonsterTextEmote(EMOTE_JETS, 0, true);                        DoCastAOE(SPELL_FLAME_JETS);                        events.RescheduleEvent(EVENT_JET,urand(35000,40000));                        break;                    case EVENT_SLAG_POT:                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))                        {                            DoScriptText(SAY_SLAG_POT, me);                            SlagPotGUID = pTarget->GetGUID();                            DoCast(pTarget, SPELL_GRAB);                            events.DelayEvents(3000);                            events.ScheduleEvent(EVENT_GRAB_POT, 500);                        }                        events.RescheduleEvent(EVENT_SLAG_POT,RAID_MODE(30000, 15000));                        break;                    case EVENT_GRAB_POT:                        if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))                        {                            SlagPotTarget->EnterVehicle(me, 0);                            events.CancelEvent(EVENT_GRAB_POT);                            events.ScheduleEvent(EVENT_CHANGE_POT, 1000);                        }                        break;                    case EVENT_CHANGE_POT:                        if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))                        {                            SlagPotTarget->AddAura(SPELL_SLAG_POT, SlagPotTarget);                            SlagPotTarget->EnterVehicle(me, 1);                            events.CancelEvent(EVENT_CHANGE_POT);                            events.ScheduleEvent(EVENT_END_POT, 10000);                        }                        break;                    case EVENT_END_POT:                        if (Unit* SlagPotTarget = Unit::GetUnit(*me, SlagPotGUID))                        {                            SlagPotTarget->ExitVehicle();                            SlagPotTarget = NULL;                            SlagPotGUID = NULL;                            events.CancelEvent(EVENT_END_POT);                        }                        break;                    case EVENT_SCORCH:                        DoScriptText(RAND(SAY_SCORCH_1, SAY_SCORCH_2), me);                        if (Unit *pTarget = me->getVictim())                            me->SummonCreature(NPC_GROUND_SCORCH, pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 45000);                        DoCast(SPELL_SCORCH);                        events.RescheduleEvent(EVENT_SCORCH,25000);                        break;                    case EVENT_CONSTRUCT:                        DoScriptText(SAY_SUMMON, me);                        DoSummon(NPC_IRON_CONSTRUCT, Pos[rand()%20], 30000, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT);                        DoCast(SPELL_STRENGHT);                        DoCast(me, SPELL_ACTIVATE_CONSTRUCT);                        events.RescheduleEvent(EVENT_CONSTRUCT,RAID_MODE(40000, 30000));                        break;                    case EVENT_BERSERK:                        DoCast(me, SPELL_BERSERK, true);                        DoScriptText(SAY_BERSERK, me);                        break;                }            }            DoMeleeAttackIfReady();        }

        void UpdateAI(const uint32 diff)        {            if (LamentEvent)            {                if (LamentEvent_Timer <= diff)                {                    DoSummon(ENTRY_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);                    LamentEvent_Timer = 2000;                    if (!me->HasAura(SPELL_SYLVANAS_CAST))                    {                        DoScriptText(SAY_LAMENT_END, me);                        DoScriptText(EMOTE_LAMENT_END, me);                        LamentEvent = false;                    }                }                 else                     LamentEvent_Timer -= diff;            }            if (!UpdateVictim())                return;            if (_fadeTimer <= diff)            {                DoCast(SPELL_FADE);                _fadeTimer = 10 *IN_MILLISECONDS;            }            else                _fadeTimer -= diff;            if (_blackarrowTimer <= diff)            {                Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);                if (target)                {                    DoCast(target, SPELL_BLACK_ARROW);                    _blackarrowTimer = urand(12, 15) *IN_MILLISECONDS;                }            }            else                _blackarrowTimer -= diff;            if (_multishotTimer <= diff)            {                Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);                if (target)                {                    DoCast(target, SPELL_MULTI_SHOT);                    _multishotTimer = urand(8, 10) *IN_MILLISECONDS;                }            }            else                _multishotTimer -= diff;            if (_shootTimer <= diff)            {                Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);                if (target)                {                    DoCast(target, SPELL_SHOOT);                    _shootTimer = urand(2, 4) *IN_MILLISECONDS;                }            }            else                _shootTimer -= diff;            if (_summonskeletonTimer <= diff)            {                DoCast(SPELL_SUMMON_SKELETON);                _summonskeletonTimer = 10 *IN_MILLISECONDS;            }            else                _summonskeletonTimer -= diff;            DoMeleeAttackIfReady();        }

        void UpdateAI(uint32 diff) override        {            if (LamentEvent)            {                if (LamentEventTimer <= diff)                {                    DoSummon(ENTRY_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);                    LamentEventTimer = 2000;                    if (!me->HasAura(SPELL_SYLVANAS_CAST))                    {                        Talk(SAY_LAMENT_END);                        Talk(EMOTE_LAMENT_END);                        LamentEvent = false;                    }                } else LamentEventTimer -= diff;            }            if (!UpdateVictim())                return;            // Combat spells            if (FadeTimer <= diff)            {                DoCast(me, SPELL_FADE);                // add a blink to simulate a stealthed movement and reappearing elsewhere                DoCast(me, SPELL_FADE_BLINK);                FadeTimer = 30000 + rand32() % 5000;                // if the victim is out of melee range she cast multi shot                if (Unit* victim = me->GetVictim())                    if (me->GetDistance(victim) > 10.0f)                        DoCast(victim, SPELL_MULTI_SHOT);            } else FadeTimer -= diff;            if (SummonSkeletonTimer <= diff)            {                DoCast(me, SPELL_SUMMON_SKELETON);                SummonSkeletonTimer = 20000 + rand32() % 10000;            } else SummonSkeletonTimer -= diff;            if (BlackArrowTimer <= diff)            {                if (Unit* victim = me->GetVictim())                {                    DoCast(victim, SPELL_BLACK_ARROW);                    BlackArrowTimer = 15000 + rand32() % 5000;                }            } else BlackArrowTimer -= diff;            if (ShotTimer <= diff)            {                if (Unit* victim = me->GetVictim())                {                    DoCast(victim, SPELL_SHOT);                    ShotTimer = 8000 + rand32() % 2000;                }            } else ShotTimer -= diff;            if (MultiShotTimer <= diff)            {                if (Unit* victim = me->GetVictim())                {                    DoCast(victim, SPELL_MULTI_SHOT);                    MultiShotTimer = 10000 + rand32() % 3000;                }            } else MultiShotTimer -= diff;            DoMeleeAttackIfReady();        }

        void UpdateAI(uint32 diff) override        {            if (!UpdateVictim() && !LamentEvent)                return;            _events.Update(diff);            if (me->HasUnitState(UNIT_STATE_CASTING))                return;            while (uint32 eventId = _events.ExecuteEvent())            {                switch (eventId)                {                    case EVENT_FADE:                        DoCast(me, SPELL_FADE);                        // add a blink to simulate a stealthed movement and reappearing elsewhere                        DoCast(me, SPELL_FADE_BLINK);                        // if the victim is out of melee range she cast multi shot                        if (Unit* victim = me->GetVictim())                            if (me->GetDistance(victim) > 10.0f)                                DoCast(victim, SPELL_MULTI_SHOT);                        _events.ScheduleEvent(EVENT_FADE, urand(30000, 35000));                        break;                    case EVENT_SUMMON_SKELETON:                        DoCast(me, SPELL_SUMMON_SKELETON);                        _events.ScheduleEvent(EVENT_SUMMON_SKELETON, urand(20000, 30000));                        break;                    case EVENT_BLACK_ARROW:                        if (Unit* victim = me->GetVictim())                            DoCast(victim, SPELL_BLACK_ARROW);                        _events.ScheduleEvent(EVENT_BLACK_ARROW, urand(15000, 20000));                        break;                    case EVENT_SHOOT:                        if (Unit* victim = me->GetVictim())                            DoCast(victim, SPELL_SHOT);                        _events.ScheduleEvent(EVENT_SHOOT, urand(8000, 10000));                        break;                    case EVENT_MULTI_SHOT:                        if (Unit* victim = me->GetVictim())                            DoCast(victim, SPELL_MULTI_SHOT);                        _events.ScheduleEvent(EVENT_MULTI_SHOT, urand(10000, 13000));                        break;                    case EVENT_LAMENT_OF_THE_HIGHBORN:                        if (!me->HasAura(SPELL_SYLVANAS_CAST))                        {                            Talk(SAY_LAMENT_END);                            Talk(EMOTE_LAMENT_END);                            LamentEvent = false;                            me->HandleEmoteCommand(EMOTE_ONESHOT_KNEEL);                            Reset();                        }                        else                        {                            DoSummon(NPC_HIGHBORNE_BUNNY, me, 10.0f, 3000, TEMPSUMMON_TIMED_DESPAWN);                            _events.ScheduleEvent(EVENT_LAMENT_OF_THE_HIGHBORN, 2000);                        }                        break;                    case EVENT_SUNSORROW_WHISPER:                        if (Creature* ambassador = me->FindNearestCreature(NPC_AMBASSADOR_SUNSORROW, 20.0f))                            if (Player* player = ObjectAccessor::GetPlayer(*me, playerGUID))                                ambassador->AI()->Talk(SAY_SUNSORROW_WHISPER, player);                        break;                    default:                        break;                }            }            DoMeleeAttackIfReady();        }

        void UpdateAI(const uint32 diff)        {            if (!UpdateVictim())                return;            events.Update(diff);            if (Phase == 1)            {                while (uint32 eventId = events.GetEvent())                {                    switch (eventId)                    {                        case EVENT_WASTE:                            DoSummon(NPC_WASTE, Pos[RAND(0, 3, 6, 9)]);                            events.RepeatEvent(urand(2000, 5000));                            break;                        case EVENT_ABOMIN:                            if (nAbomination < 8)                            {                                DoSummon(NPC_ABOMINATION, Pos[RAND(1, 4, 7, 10)]);                                nAbomination++;                                events.RepeatEvent(20000);                            }                            else                                events.PopEvent();                            break;                        case EVENT_WEAVER:                            if (nWeaver < 8)                            {                                DoSummon(NPC_WEAVER, Pos[RAND(0, 3, 6, 9)]);                                nWeaver++;                                events.RepeatEvent(25000);                            }                            else                                events.PopEvent();                            break;                        case EVENT_TRIGGER:                            if (GameObject* pKTTrigger = me->GetMap()->GetGameObject(KTTriggerGUID))                                pKTTrigger->SetPhaseMask(2, true);                            events.PopEvent();                            break;                        case EVENT_PHASE:                            events.Reset();                            DoScriptText(RAND(SAY_AGGRO_1, SAY_AGGRO_2, SAY_AGGRO_3), me);                            spawns.DespawnAll();                            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_DISABLE_MOVE | UNIT_FLAG_NOT_SELECTABLE);                            me->CastStop();                            DoStartMovement(me->getVictim());                            events.ScheduleEvent(EVENT_BOLT, urand(5000, 10000));                            events.ScheduleEvent(EVENT_NOVA, 15000);                            events.ScheduleEvent(EVENT_DETONATE, urand(30000, 40000));                            events.ScheduleEvent(EVENT_FISSURE, urand(10000, 30000));                            events.ScheduleEvent(EVENT_BLAST, urand(60000, 120000));                            if (GetDifficulty() == RAID_DIFFICULTY_25MAN_NORMAL)                                events.ScheduleEvent(EVENT_CHAIN, urand(30000, 60000));                            Phase = 2;                            break;                        default:                            events.PopEvent();                            break;                    }                }            }            else            {                //start phase 3 when we are 45% health                if (Phase != 3)                {                    if (HealthBelowPct(45))                    {                        Phase = 3;                        DoScriptText(SAY_REQUEST_AID, me);                        //here Lich King should respond to KelThuzad but I don't know which Creature to make talk                        //so for now just make Kelthuzad says it.                        DoScriptText(SAY_ANSWER_REQUEST, me);                        for (uint8 i = 0; i <= 3; ++i)                        {                            if (GameObject* pPortal = me->GetMap()->GetGameObject(PortalsGUID[i]))                            {                                if (pPortal->getLootState() == GO_READY)                                    pPortal->UseDoorOrButton();                            }                        }                    }                }                else if (nGuardiansOfIcecrownCount < RAID_MODE(2, 4))                {                    if (uiGuardiansOfIcecrownTimer <= diff)                    {                        // TODO : Add missing text                        if (Creature* pGuardian = DoSummon(NPC_ICECROWN, Pos[RAND(2, 5, 8, 11)]))                            pGuardian->SetFloatValue(UNIT_FIELD_COMBATREACH, 2);                        ++nGuardiansOfIcecrownCount;                        uiGuardiansOfIcecrownTimer = 5000;                    }                    else uiGuardiansOfIcecrownTimer -= diff;                }//.........这里部分代码省略.........