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

    void UpdateAI(const uint32 uiDiff) override    {        // so many things are based in this script on instance data        // so if we don't have access to it better do nothing        if (!m_pInstance)            return;        // OOC Intro part triggered by Altar activation        if (m_pInstance->GetData(TYPE_ARCHAEDAS) == SPECIAL)        {            if (m_uiAwakeningTimer <= uiDiff)            {                switch (m_uiSubevent)                {                    case 0:                        DoCastSpellIfCan(m_creature, SPELL_ARCHAEDAS_AWAKEN_VISUAL);                        m_uiAwakeningTimer = 2000;                        break;                    case 1:                        DoScriptText(EMOTE_BREAKS_FREE, m_creature);                        m_uiAwakeningTimer = 3000;                        break;                    case 2:                        DoScriptText(SAY_AGGRO, m_creature);                        m_creature->RemoveAurasDueToSpell(SPELL_FREEZE_ANIM);                        m_creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);                        // Attack player                        if (Player* pPlayer = m_creature->GetMap()->GetPlayer(m_pInstance->GetGuid(DATA_EVENT_STARTER)))                            AttackStart(pPlayer);                        else                            EnterEvadeMode();                        break;                    default:                        break;                }                ++m_uiSubevent;            }            else                m_uiAwakeningTimer -= uiDiff;        }        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        // Phase switch        if (m_creature->GetHealthPercent() < 100.0f - 33.4f * (float)m_uiHpPhaseCheck)        {            if (DoCastSpellIfCan(m_creature, m_uiHpPhaseCheck == 1 ? SPELL_AWAKEN_EARTHEN_GUARDIAN : SPELL_AWAKEN_VAULT_WARDER) == CAST_OK)            {                DoScriptText(m_uiHpPhaseCheck == 1 ? SAY_AWAKE_GUARDIANS : SAY_AWAKE_WARDERS, m_creature);                ++m_uiHpPhaseCheck;            }        }        // Awake random Dwarf        if (!m_bDwarvesAwaken && m_creature->GetHealthPercent() >= 33.0f)        {            if (m_uiAwakeDwarfTimer < uiDiff)            {                if (Creature* pEarthen = m_pInstance->GetClosestDwarfNotInCombat(m_creature))                {                    if (DoCastSpellIfCan(pEarthen, SPELL_AWAKEN_EARTHEN_DWARF) == CAST_OK)                        m_uiAwakeDwarfTimer = urand(9000, 12000);                }                else                    m_bDwarvesAwaken = true;            }            else                m_uiAwakeDwarfTimer -= uiDiff;        }        if (m_uiTremorTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_GROUND_TREMOR) == CAST_OK)                m_uiTremorTimer = urand(8000, 17000);        }        else            m_uiTremorTimer -= uiDiff;        DoMeleeAttackIfReady();    }

        void UpdateAI(const uint32 uiDiff)        {            if (!bDone && GrandChampionsOutVehicle(me))            {                bDone = true;                if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_1))                    me->SetHomePosition(739.678f, 662.541f, 412.393f, 4.49f);                else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_2))                    me->SetHomePosition(746.71f, 661.02f, 411.69f, 4.6f);                else if (pInstance && me->GetGUID() == pInstance->GetData64(DATA_GRAND_CHAMPION_3))                    me->SetHomePosition(754.34f, 660.70f, 412.39f, 4.79f);                EnterEvadeMode();                bHome = true;            }            if (uiPhaseTimer <= uiDiff)            {                if (uiPhase == 1)                {                    AggroAllPlayers(me);                    uiPhase = 0;                }            }else uiPhaseTimer -= uiDiff;            if (!UpdateVictim() || me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT))                return;            if (uiInterceptTimer <= uiDiff)            {                Map::PlayerList const& players = me->GetMap()->GetPlayers();                if (me->GetMap()->IsDungeon() && !players.isEmpty())                {                    for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)                    {                        Player* player = itr->getSource();                        if (player && !player->isGameMaster() && me->IsInRange(player, 8.0f, 25.0f, false))                        {                            DoResetThreat();                            me->AddThreat(player, 5.0f);                            DoCast(player, SPELL_INTERCEPT);                            break;                        }                    }                }                uiInterceptTimer = 7000;            } else uiInterceptTimer -= uiDiff;            if (uiBladeStormTimer <= uiDiff)            {                DoCastVictim(SPELL_BLADESTORM);                uiBladeStormTimer = urand(15000, 20000);            } else uiBladeStormTimer -= uiDiff;            if (uiMortalStrikeTimer <= uiDiff)            {                DoCastVictim(SPELL_MORTAL_STRIKE);                uiMortalStrikeTimer = urand(8000, 12000);            } else uiMortalStrikeTimer -= uiDiff;            DoMeleeAttackIfReady();        }

    void UpdateAI(const uint32 diff)    {        if (!bHasAura)        {            switch (me->GetEntry())            {            case NPC_NORTH_MARSHAL:                DoCast(me, SPELL_NORTH_MARSHAL);                break;            case NPC_SOUTH_MARSHAL:                DoCast(me, SPELL_SOUTH_MARSHAL);                break;            case NPC_STONEHEARTH_MARSHAL:                DoCast(me, SPELL_STONEHEARTH_MARSHAL);                break;            case NPC_ICEWING_MARSHAL:                DoCast(me, SPELL_ICEWING_MARSHAL);                break;            case NPC_EAST_FROSTWOLF_WARMASTER:                DoCast(me, SPELL_EAST_FROSTWOLF_WARMASTER);                break;            case NPC_WEST_FROSTWOLF_WARMASTER:                DoCast(me, SPELL_WEST_FROSTWOLF_WARMASTER);                break;            case NPC_ICEBLOOD_WARMASTER:                DoCast(me, SPELL_ICEBLOOD_WARMASTER);                break;            case NPC_TOWER_POINT_WARMASTER:                DoCast(me, SPELL_TOWER_POINT_WARMASTER);                break;            }            bHasAura = true;        }        if (!UpdateVictim())            return;        if (uiChargeTimer <= diff)        {            DoCastVictim( SPELL_CHARGE);            uiChargeTimer = urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS);        }        else uiChargeTimer -= diff;        if (uiCleaveTimer <= diff)        {            DoCastVictim( SPELL_CLEAVE);            uiCleaveTimer =  urand(10 * IN_MILLISECONDS, 16 * IN_MILLISECONDS);        }        else uiCleaveTimer -= diff;        if (uiDemoralizingShoutTimer <= diff)        {            DoCastVictim( SPELL_DEMORALIZING_SHOUT);            uiDemoralizingShoutTimer = urand(10 * IN_MILLISECONDS, 15 * IN_MILLISECONDS);        }        else uiDemoralizingShoutTimer -= diff;        if (uiWhirlwind1Timer <= diff)        {            DoCastVictim( SPELL_WHIRLWIND1);            uiWhirlwind1Timer = urand(6 * IN_MILLISECONDS, 20 * IN_MILLISECONDS);        }        else uiWhirlwind1Timer -= diff;        if (uiWhirlwind2Timer <= diff)        {            DoCastVictim( SPELL_WHIRLWIND2);            uiWhirlwind2Timer = urand(10 * IN_MILLISECONDS, 25 * IN_MILLISECONDS);        }        else uiWhirlwind2Timer -= diff;        if (uiEnrageTimer <= diff)        {            DoCastVictim( SPELL_ENRAGE);            uiEnrageTimer = urand(10 * IN_MILLISECONDS, 30 * IN_MILLISECONDS);        }        else uiEnrageTimer -= diff;        // check if creature is not outside of building        if (uiResetTimer <= diff)        {            if (me->GetDistance2d(me->GetHomePosition().GetPositionX(), me->GetHomePosition().GetPositionY()) > 50)                EnterEvadeMode();            uiResetTimer = 5 * IN_MILLISECONDS;        }        else uiResetTimer -= diff;        DoMeleeAttackIfReady();    }

        void UpdateAI(const uint32 diff)        {            //Only if not incombat check if the event is started            if (!me->isInCombat() && instance && instance->GetData(DATA_KARATHRESSEVENT))            {                Unit* target = Unit::GetUnit(*me, instance->GetData64(DATA_KARATHRESSEVENT_STARTER));                if (target)                {                    AttackStart(target);                }            }            //Return since we have no target            if (!UpdateVictim())                return;            //someone evaded!            if (instance && !instance->GetData(DATA_KARATHRESSEVENT))            {                EnterEvadeMode();                return;            }            //WaterBoltVolley_Timer            if (WaterBoltVolley_Timer <= diff)            {                DoCast(me->getVictim(), SPELL_WATER_BOLT_VOLLEY);                WaterBoltVolley_Timer = 30000;            } else WaterBoltVolley_Timer -= diff;            //TidalSurge_Timer            if (TidalSurge_Timer <= diff)            {                DoCast(me->getVictim(), SPELL_TIDAL_SURGE);                // Hacky way to do it - won't trigger elseways                me->getVictim()->CastSpell(me->getVictim(), SPELL_TIDAL_SURGE_FREEZE, true);                TidalSurge_Timer = 15000+rand()%5000;            } else TidalSurge_Timer -= diff;            //Cyclone_Timer            if (Cyclone_Timer <= diff)            {                //DoCast(me, SPELL_SUMMON_CYCLONE); // Doesn't work                Cyclone_Timer = 30000+rand()%10000;                Creature* Cyclone = me->SummonCreature(CREATURE_CYCLONE, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ(), float(rand()%5), TEMPSUMMON_TIMED_DESPAWN, 15000);                if (Cyclone)                {                    CAST_CRE(Cyclone)->SetObjectScale(3.0f);                    Cyclone->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);                    Cyclone->setFaction(me->getFaction());                    Cyclone->CastSpell(Cyclone, SPELL_CYCLONE_CYCLONE, true);                    Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0);                    if (target)                    {                        Cyclone->AI()->AttackStart(target);                    }                }            } else Cyclone_Timer -= diff;            //Heal_Timer            if (Heal_Timer <= diff)            {                // It can be cast on any of the mobs                Unit* unit = NULL;                while (unit == NULL || !unit->isAlive())                {                    unit = selectAdvisorUnit();                }                if (unit && unit->isAlive())                    DoCast(unit, SPELL_HEAL);                Heal_Timer = 60000;            } else Heal_Timer -= diff;            DoMeleeAttackIfReady();        }

    void UpdateAI(const uint32 diff)    {        if (!UpdateVictim())            return;        if (m_checkTimer < diff)        {            if (me->IsWithinDistInMap(&wLoc, 100.0f))                DoZoneInCombat();            else            {                EnterEvadeMode();                return;            }            me->SetSpeed(MOVE_RUN, 2.0);            uint32 damage = 0;            SharedRule(damage);            m_checkTimer = 1000;        }        else            m_checkTimer -= diff;        if (m_blessingTimer < diff)        {            if (Unit *pUnit = SelectCouncil())            {                AddSpellToCast(pUnit, RAND(SPELL_BLESS_SPELLWARD, SPELL_BLESS_PROTECTION));                m_blessingTimer = RAND(urand(15000, 20000), urand(25000, 35000));            }        }        else            m_blessingTimer -= diff;        if (m_consecrationTimer < diff)        {            AddSpellToCast(me, SPELL_CONSECRATION);            m_consecrationTimer = urand(30000, 35000);        }        else            m_consecrationTimer -= diff;        if (m_hammerTimer < diff)        {            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0, 40, true, 0, 10.0f))            {                AddSpellToCast(pTarget, SPELL_HAMMER_OF_JUSTICE);                m_hammerTimer = urand(10000, 20000);            }        }        else            m_hammerTimer -= diff;        if (m_sealTimer < diff)        {            AddSpellToCast(me, RAND(SPELL_SEAL_OF_COMMAND, SPELL_SEAL_OF_BLOOD));            m_sealTimer = urand(17000, 20000);        }        else            m_sealTimer -= diff;        if (m_judgementTimer < diff)        {            RegenMana();            ForceSpellCast(me->getVictim(), SPELL_GATHIOS_JUDGEMENT, INTERRUPT_AND_CAST);            m_judgementTimer = 15000;        }        else            m_judgementTimer -= diff;        if (m_auraTimer < diff)        {            AddSpellToCast(RAND(SPELL_DEVOTION_AURA, SPELL_CHROMATIC_AURA), CAST_SELF);            m_auraTimer = 60000;        }        else            m_auraTimer -= diff;        DoMeleeAttackIfReady();        CastNextSpellIfAnyAndReady();    }

        void UpdateAI(uint32 diff) override        {            if (!UpdateVictim())                return;            if (instance && !instance->GetData(TYPE_MOROES))            {                EnterEvadeMode();                return;            }            if (!Enrage && HealthBelowPct(30))            {                DoCast(me, SPELL_FRENZY);                Enrage = true;            }            if (CheckAdds_Timer <= diff)            {                for (uint8 i = 0; i < 4; ++i)                {                    if (AddGUID[i])                    {                        Creature* temp = Unit::GetCreature((*me), AddGUID[i]);                        if (temp && temp->IsAlive())                            if (!temp->GetVictim())                                temp->AI()->AttackStart(me->GetVictim());                    }                }                CheckAdds_Timer = 5000;            } else CheckAdds_Timer -= diff;            if (!Enrage)            {                //Cast Vanish, then Garrote random victim                if (Vanish_Timer <= diff)                {                    DoCast(me, SPELL_VANISH);                    InVanish = true;                    Vanish_Timer = 30000;                    Wait_Timer = 5000;                } else Vanish_Timer -= diff;                if (Gouge_Timer <= diff)                {                    DoCastVictim(SPELL_GOUGE);                    Gouge_Timer = 40000;                } else Gouge_Timer -= diff;                if (Blind_Timer <= diff)                {                    std::list<Unit*> targets;                    SelectTargetList(targets, 5, SELECT_TARGET_RANDOM, me->GetMeleeReach()*5, true);                    for (std::list<Unit*>::const_iterator i = targets.begin(); i != targets.end(); ++i)                        if (!me->IsWithinMeleeRange(*i))                        {                            DoCast(*i, SPELL_BLIND);                            break;                        }                    Blind_Timer = 40000;                } else Blind_Timer -= diff;            }            if (InVanish)            {                if (Wait_Timer <= diff)                {                    Talk(SAY_SPECIAL);                    if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))                        target->CastSpell(target, SPELL_GARROTE, true);                    InVanish = false;                } else Wait_Timer -= diff;            }            if (!InVanish)                DoMeleeAttackIfReady();        }

            void UpdateAI(const uint32 diff)            {                if (!UpdateVictim())                    return;                if (StormCount)                {                    Unit *pTarget = Unit::GetUnit(*me, CloudGUID);                    if (!pTarget || !pTarget->isAlive())                    {                        EnterEvadeMode();                        return;                    }                    else if (Unit* Cyclone = Unit::GetUnit(*me, CycloneGUID))                        Cyclone->CastSpell(pTarget, 25160, true); // keep casting or...                    if (StormSequenceTimer <= diff)                        HandleStormSequence(pTarget);                    else                        StormSequenceTimer -= diff;                    return;                }                if (Enrage_Timer <= diff)                {                    me->MonsterYell(SAY_ONENRAGE, LANG_UNIVERSAL, NULL);                    DoPlaySoundToSet(me, SOUND_ONENRAGE);                    DoCast(me, SPELL_BERSERK, true);                    Enrage_Timer = 600000;                } else Enrage_Timer -= diff;                if (StaticDisruption_Timer <= diff)                {                    Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);                    if (!pTarget) pTarget = me->getVictim();                    TargetGUID = pTarget->GetGUID();                    DoCast(pTarget, SPELL_STATIC_DISRUPTION, false);                    me->SetInFront(me->getVictim());                    StaticDisruption_Timer = (10+rand()%8)*1000; // < 20s                    /*if (float dist = me->IsWithinDist3d(pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 5.0f) dist = 5.0f;                    SDisruptAOEVisual_Timer = 1000 + floor(dist / 30 * 1000.0f);*/                } else StaticDisruption_Timer -= diff;                if (GustOfWind_Timer <= diff)                {                    Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);                    if (!pTarget) pTarget = me->getVictim();                    DoCast(pTarget, SPELL_GUST_OF_WIND);                    GustOfWind_Timer = (20+rand()%10)*1000; //20 to 30 seconds(bosskillers)                } else GustOfWind_Timer -= diff;                if (CallLighting_Timer <= diff)                {                    DoCast(me->getVictim(), SPELL_CALL_LIGHTNING);                    CallLighting_Timer = (12 + rand()%5)*1000; //totaly random timer. can't find any info on this                } else CallLighting_Timer -= diff;                if (!isRaining && ElectricalStorm_Timer < uint32(8000 + rand() % 5000))                {                    SetWeather(WEATHER_STATE_HEAVY_RAIN, 0.9999f);                    isRaining = true;                }                if (ElectricalStorm_Timer <= diff) {                    Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true);                    if (!pTarget)                    {                        EnterEvadeMode();                        return;                    }                    pTarget->CastSpell(pTarget, 44007, true);//cloud visual                    DoCast(pTarget, SPELL_ELECTRICAL_STORM, false);//storm cyclon + visual                    float x,y,z;                    pTarget->GetPosition(x,y,z);                    if (pTarget)                    {                        pTarget->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING);                        pTarget->SendMonsterMove(x,y,me->GetPositionZ()+15,0);                    }                    Unit *Cloud = me->SummonTrigger(x, y, me->GetPositionZ()+16, 0, 15000);                    if (Cloud)                    {                        CloudGUID = Cloud->GetGUID();                        Cloud->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING);                        Cloud->StopMoving();                        Cloud->SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);                        Cloud->setFaction(35);                        Cloud->SetMaxHealth(9999999);                        Cloud->SetHealth(9999999);                        Cloud->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);                    }                    ElectricalStorm_Timer = 60000; //60 seconds(bosskillers)                    StormCount = 1;                    StormSequenceTimer = 0;                } else ElectricalStorm_Timer -= diff;                if (SummonEagles_Timer <= diff)                {//.........这里部分代码省略.........

        void UpdateAI(const uint32 diff)        {            //Only if not incombat check if the event is started            if (!me->isInCombat() && pInstance && pInstance->GetData(DATA_MAULGAREVENT))            {                Unit *pTarget = Unit::GetUnit((*me), pInstance->GetData64(DATA_MAULGAREVENT_TANK));                if (pTarget)                {                    AttackStart(pTarget);                    GetCouncil();                }            }            //Return since we have no target            if (!UpdateVictim())                return;            //someone evaded!            if (pInstance && !pInstance->GetData(DATA_MAULGAREVENT))            {                EnterEvadeMode();                return;            }            //ArcingSmash_Timer            if (ArcingSmash_Timer <= diff)            {                DoCast(me->getVictim(), SPELL_ARCING_SMASH);                ArcingSmash_Timer = 10000;            } else ArcingSmash_Timer -= diff;            //Whirlwind_Timer                   if (Whirlwind_Timer <= diff)                   {                        DoCast(me->getVictim(), SPELL_WHIRLWIND);                        Whirlwind_Timer = 55000;                   } else Whirlwind_Timer -= diff;            //MightyBlow_Timer            if (MightyBlow_Timer <= diff)            {                DoCast(me->getVictim(), SPELL_MIGHTY_BLOW);                MightyBlow_Timer = 30000+rand()%10000;            } else MightyBlow_Timer -= diff;            //Entering Phase 2            if (!Phase2 && HealthBelowPct(50))            {                Phase2 = true;                DoScriptText(SAY_ENRAGE, me);                DoCast(me, SPELL_DUAL_WIELD, true);                me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, 0);                me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID+1, 0);            }            if (Phase2)            {                //Charging_Timer                if (Charging_Timer <= diff)                {                    Unit *pTarget = NULL;                    pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0);                    if (pTarget)                    {                        AttackStart(pTarget);                        DoCast(pTarget, SPELL_BERSERKER_C);                    }                    Charging_Timer = 20000;                } else Charging_Timer -= diff;                //Intimidating Roar                if (Roar_Timer <= diff)                {                    DoCast(me, SPELL_ROAR);                    Roar_Timer = 40000+(rand()%10000);                } else Roar_Timer -= diff;            }            DoMeleeAttackIfReady();        }

            void UpdateAI(const uint32 diff)            {                if (!UpdateVictim())                    return;                if (ResetTimer <= diff)                {                    if (me->IsWithinDist3d(119.223f, 1035.45f, 29.4481f, 10))                    {                        EnterEvadeMode();                        return;                    }                    ResetTimer = 5000;                } else ResetTimer -= diff;                if (CheckAddState_Timer <= diff)                {                    for (uint8 i = 0; i < 4; ++i)                        if (Creature *pTemp = Unit::GetCreature(*me, AddGUID[i]))                            if (pTemp->isAlive() && !pTemp->getVictim())                                pTemp->AI()->AttackStart(me->getVictim());                    CheckAddState_Timer = 5000;                } else CheckAddState_Timer -= diff;                if (DrainPower_Timer <= diff)                {                    DoCast(me, SPELL_DRAIN_POWER, true);                    me->MonsterYell(YELL_DRAIN_POWER, LANG_UNIVERSAL, NULL);                    DoPlaySoundToSet(me, SOUND_YELL_DRAIN_POWER);                    DrainPower_Timer = urand(40000, 55000);    // must cast in 60 sec, or buff/debuff will disappear                } else DrainPower_Timer -= diff;                if (SpiritBolts_Timer <= diff)                {                    if (DrainPower_Timer < 12000)    // channel 10 sec                        SpiritBolts_Timer = 13000;   // cast drain power first                    else                    {                        DoCast(me, SPELL_SPIRIT_BOLTS, false);                        me->MonsterYell(YELL_SPIRIT_BOLTS, LANG_UNIVERSAL, NULL);                        DoPlaySoundToSet(me, SOUND_YELL_SPIRIT_BOLTS);                        SpiritBolts_Timer = 40000;                        SiphonSoul_Timer = 10000;    // ready to drain                        PlayerAbility_Timer = 99999;                    }                } else SpiritBolts_Timer -= diff;                if (SiphonSoul_Timer <= diff)                {                    Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 70, true);                    Unit *trigger = DoSpawnCreature(MOB_TEMP_TRIGGER, 0, 0, 0, 0, TEMPSUMMON_TIMED_DESPAWN, 30000);                    if (!pTarget || !trigger)                    {                        EnterEvadeMode();                        return;                    }                    else                    {                        trigger->SetDisplayId(11686);                        trigger->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);                        trigger->CastSpell(pTarget, SPELL_SIPHON_SOUL, true);                        trigger->GetMotionMaster()->MoveChase(me);                        //DoCast(pTarget, SPELL_SIPHON_SOUL, true);                        //me->SetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT, pTarget->GetGUID());                        //me->SetUInt32Value(UNIT_CHANNEL_SPELL, SPELL_SIPHON_SOUL);                        PlayerGUID = pTarget->GetGUID();                        PlayerAbility_Timer = urand(8000, 10000);                        PlayerClass = pTarget->getClass() - 1;                        if (PlayerClass == CLASS_DRUID-1)                            PlayerClass = CLASS_DRUID;                        else if (PlayerClass == CLASS_PRIEST-1 && pTarget->HasSpell(15473))                            PlayerClass = CLASS_PRIEST; // shadow priest                        SiphonSoul_Timer = 99999;   // buff lasts 30 sec                    }                } else SiphonSoul_Timer -= diff;                if (PlayerAbility_Timer <= diff)                {                    //Unit *pTarget = Unit::GetUnit(*me, PlayerGUID);                    //if (pTarget && pTarget->isAlive())                    //{                        UseAbility();                        PlayerAbility_Timer = urand(8000, 10000);                    //}                } else PlayerAbility_Timer -= diff;                DoMeleeAttackIfReady();            }

void PassiveAI::UpdateAI(const uint32){    if (me->isInCombat() && me->getAttackers().empty())        EnterEvadeMode();}

        void UpdateAI(const uint32 diff)        {            if (!CanStartEvent)//boss is invisible, don't attack            {                if (CheckCanStart())                {                    if (Submerged)                    {                        me->SetVisible(true);                        Submerged = false;                        WaitTimer2 = 500;                    }                    if (!Submerged && WaitTimer2 <= diff)//wait 500ms before emerge anim                    {                        me->RemoveAllAuras();                        me->RemoveFlag(UNIT_NPC_EMOTESTATE,EMOTE_STATE_SUBMERGED);                        DoCast(me, SPELL_EMERGE, false);                        WaitTimer2 = 60000;//never reached                        WaitTimer = 3000;                    } else WaitTimer2 -= diff;                    if (WaitTimer <= diff)//wait 3secs for emerge anim, then attack                    {                        WaitTimer = 3000;                        CanStartEvent=true;//fresh fished from pool                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_OOC_NOT_ATTACKABLE);                        me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);                    } else WaitTimer -= diff;                }                return;            }            if (me->getThreatManager().getThreatList().empty())//check if should evade            {                if (me->isInCombat())                    EnterEvadeMode();                return;            }            if (!Submerged)            {                if (PhaseTimer <= diff)                {                    me->InterruptNonMeleeSpells(false);                    DoCast(me, SPELL_SUBMERGE);                    PhaseTimer = 60000;//60secs submerged                    Submerged = true;                } else PhaseTimer-=diff;                if (SpoutTimer <= diff)                {                    me->MonsterTextEmote(EMOTE_SPOUT,0,true);                    me->SetReactState(REACT_PASSIVE);                    me->GetMotionMaster()->MoveRotate(20000, rand()%2 ? ROTATE_DIRECTION_LEFT : ROTATE_DIRECTION_RIGHT);                    SpoutTimer = 45000;                    WhirlTimer = 20000;//whirl directly after spout                    RotTimer = 20000;                    return;                } else SpoutTimer -= diff;                //Whirl directly after a Spout and at random times                if (WhirlTimer <= diff)                {                    WhirlTimer = 18000;                    DoCast(me, SPELL_WHIRL);                } else WhirlTimer -= diff;                if (CheckTimer <= diff)//check if there are players in melee range                {                    InRange = false;                    Map* pMap = me->GetMap();                    Map::PlayerList const &PlayerList = pMap->GetPlayers();                    if (!PlayerList.isEmpty())                    {                        for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)                        {                            if (me->IsWithinMeleeRange(i->getSource()))                                InRange = true;                        }                    }                    CheckTimer = 2000;                } else CheckTimer -= diff;                if (RotTimer)                {                    Map* pMap = me->GetMap();                    if (pMap->IsDungeon())                    {                        Map::PlayerList const &PlayerList = pMap->GetPlayers();                        for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)                        {                            if (i->getSource() && i->getSource()->isAlive() && me->HasInArc(float(diff/20000*M_PI*2),i->getSource()) && me->IsWithinDist(i->getSource(), SPOUT_DIST) && !i->getSource()->IsInWater())                                DoCast(i->getSource(), SPELL_SPOUT, true);//only knock back palyers in arc, in 100yards, not in water                        }                    }                    if (SpoutAnimTimer <= diff)                    {                        DoCast(me, SPELL_SPOUT_ANIM, true);                        SpoutAnimTimer = 1000;                    } else SpoutAnimTimer -= diff;//.........这里部分代码省略.........

        bool CheckPlayerOnTransport()        {            Transport * pTransport = NULL;            if (!pInstance)                return false;            if (IsFriendlyCommander)                return false; // Le commandant ami ne doit pas check les joueurs sur le transport            pTransport = GetTransportByGUID(me, pInstance->GetData64(DATA_GUNSHIP_TRANSPORT_SECOND));            if (!pTransport)                return false;            std::set<Player*> pSet = pTransport->GetPassengers();            if(pSet.empty()) // Stop l'attaque si personne sur le transport            {                if (me->isInCombat())                    EnterEvadeMode();                return false;            }            bool checkPassed = true;            if (!me->isInCombat()) // Débute l'attaque si un joueur arrive sur le transport            {                checkPassed = false;            }            else            {                if (Unit * victim = me->getVictim())                {                    if (victim->GetTypeId() != TYPEID_PLAYER)                    {                        checkPassed = false;                    }                    else if (victim->GetTransport())                    {                        if (victim->GetTransport()->GetGUID() != pInstance->GetData64(DATA_GUNSHIP_TRANSPORT_SECOND))                            checkPassed = false;                        if (victim->GetVehicle())                            checkPassed = false;                        if (!victim->isAlive())                            checkPassed = false;                    }                    else                        checkPassed = false;                }                else                    checkPassed = false;            }            if (!checkPassed)            {                Player * pPassenger = MistCore::Containers::SelectRandomContainerElement(pSet);                if (!pPassenger)                    if (me->isInCombat())                        EnterEvadeMode();                if(!pPassenger->IsHostileTo(me))                    if (me->isInCombat())                        EnterEvadeMode();                me->CombatStop();                AttackStart(pPassenger);                return false;            }            return true;        }

//.........这里部分代码省略.........            {                me->CastSpell(me, SPELL_ENRAGE, true);                enraged = true;                EnrageTimer = 300000;            }            else            {                DoScriptText(SAY_BERSERK, me);                me->CastSpell(me, SPELL_BERSERK, true);                EnrageTimer = 300000;            }        } else EnrageTimer -= diff;        if (BombTimer <= diff)        {            DoScriptText(SAY_FIRE_BOMBS, me);            me->AttackStop();            me->GetMotionMaster()->Clear();            DoTeleportTo(JanalainPos[0][0],JanalainPos[0][1],JanalainPos[0][2]);            me->StopMoving();            me->CastSpell(me, SPELL_FIRE_BOMB_CHANNEL, false);            //DoTeleportPlayer(me, JanalainPos[0][0], JanalainPos[0][1],JanalainPos[0][2], 0);            //me->CastSpell(me, SPELL_TELE_TO_CENTER, true);            FireWall();            SpawnBombs();            isBombing = true;            BombSequenceTimer = 100;            //Teleport every Player into the middle            Map *map = me->GetMap();            if (!map->IsDungeon()) return;            Map::PlayerList const &PlayerList = map->GetPlayers();            for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)            {                if (Player* i_pl = i->getSource())                    if (i_pl->isAlive())                        DoTeleportPlayer(i_pl, JanalainPos[0][0]-5+rand()%10, JanalainPos[0][1]-5+rand()%10, JanalainPos[0][2], 0);            }            //me->CastSpell(Temp, SPELL_SUMMON_PLAYERS, true); // core bug, spell does not work if too far            return;        } else BombTimer -= diff;        if (!noeggs)        {            if (100 * me->GetHealth() < 35 * me->GetMaxHealth())            {                DoScriptText(SAY_ALL_EGGS, me);                me->AttackStop();                me->GetMotionMaster()->Clear();                DoTeleportTo(JanalainPos[0][0],JanalainPos[0][1],JanalainPos[0][2]);                me->StopMoving();                me->CastSpell(me, SPELL_HATCH_ALL, false);                HatchAllEggs(2);                noeggs = true;            }            else if (HatcherTimer <= diff)            {                if (HatchAllEggs(0))                {                    DoScriptText(SAY_SUMMON_HATCHER, me);                    me->SummonCreature(MOB_AMANI_HATCHER,hatcherway[0][0][0],hatcherway[0][0][1],hatcherway[0][0][2],0,TEMPSUMMON_CORPSE_TIMED_DESPAWN,10000);                    me->SummonCreature(MOB_AMANI_HATCHER,hatcherway[1][0][0],hatcherway[1][0][1],hatcherway[1][0][2],0,TEMPSUMMON_CORPSE_TIMED_DESPAWN,10000);                    HatcherTimer = 90000;                }                else                    noeggs = true;            } else HatcherTimer -= diff;        }        if (ResetTimer <= diff)        {            float x, y, z, o;            me->GetHomePosition(x, y, z, o);            if (me->GetPositionZ() <= z-7)            {                EnterEvadeMode();                return;            }            ResetTimer = 5000;        } else ResetTimer -= diff;        DoMeleeAttackIfReady();        if (FireBreathTimer <= diff)        {            if (Unit *pTarget = SelectUnit(SELECT_TARGET_RANDOM,0))            {                me->AttackStop();                me->GetMotionMaster()->Clear();                me->SetInFront(pTarget);                me->CastSpell(pTarget, SPELL_FLAME_BREATH, false);                me->StopMoving();                isFlameBreathing = true;            }            FireBreathTimer = 8000;        } else FireBreathTimer -= diff;    }

//.........这里部分代码省略.........                    {                        if (Wait_Timer <= diff)                        {                            if (target_num <= 0)                            {                                // stop bladedance                                InBlade = false;                                me->SetSpeed(MOVE_RUN,2);                                me->GetMotionMaster()->MoveChase(me->getVictim());                                Blade_Dance_Timer = 30000;                                Wait_Timer = 0;                                if (IsHeroic())                                    Charge_timer = 5000;                            }                            else                            {                                //move in bladedance                                float x,y,randx,randy;                                randx = 0.0f + rand()%40;                                randy = 0.0f + rand()%40;                                x = 210+ randx ;                                y = -60- randy ;                                me->GetMotionMaster()->MovePoint(1,x,y,me->GetPositionZ());                                Wait_Timer = 0;                            }                        }                        else                            Wait_Timer -= diff;                    }                }                else                {                    if (Blade_Dance_Timer)                    {                        if (Blade_Dance_Timer <= diff)                        {                            target_num = TARGET_NUM;                            Wait_Timer = 1;                            InBlade = true;                            Blade_Dance_Timer = 0;                            me->SetSpeed(MOVE_RUN,4);                            return;                        }                        else                            Blade_Dance_Timer -= diff;                    }                    if (Charge_timer)                    {                        if (Charge_timer <= diff)                        {                            DoCast(SelectTarget(SELECT_TARGET_RANDOM, 0), H_SPELL_CHARGE);                            Charge_timer = 0;                        }                        else                            Charge_timer -= diff;                    }                    if (Summon_Assistant_Timer <= diff)                    {                        for (uint8 i = 0; i < summoned; ++i)                        {                            switch (urand(0,2))                            {                                case 0:                                    me->SummonCreature(MOB_HEARTHEN_GUARD,AddsEntrance[0],AddsEntrance[1], AddsEntrance[2], 0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,30000);                                    break;                                case 1:                                    me->SummonCreature(MOB_SHARPSHOOTER_GUARD,AddsEntrance[0],AddsEntrance[1], AddsEntrance[2], 0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,30000);                                    break;                                case 2:                                    me->SummonCreature(MOB_REAVER_GUARD,AddsEntrance[0],AddsEntrance[1], AddsEntrance[2], 0,TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT,30000);                                    break;                            }                        }                        if (urand(0,9) < 2)                            ++summoned;                        Summon_Assistant_Timer = urand(25000,35000);                    }                    else                        Summon_Assistant_Timer -= diff;                    DoMeleeAttackIfReady();                }                if (resetcheck_timer <= diff)                {                    uint32 tempx,tempy;                    tempx = uint32(me->GetPositionX());                    tempy = uint32(me->GetPositionY());                    if (tempx > 255 || tempx < 205)                    {                        EnterEvadeMode();                        return;                    }                    resetcheck_timer = 5000;                }                else                    resetcheck_timer -= diff;            }

        void UpdateAI(const uint32 diff)        {            switch (Phase)            {                case COMBAT:                    //Return since we have no target                    if (!UpdateVictim())                        return;                    if (!bYelled && HealthBelowPct(30))                    {                        Talk(SAY_30HEALTH);                        bYelled = true;                    }                    if (!bYelled2 && HealthBelowPct(15))                    {                        Talk(SAY_15HEALTH);                        bYelled2 = true;                    }                    if (HealthBelowPct(1))                    {                        //Handle Escape Event: Don't forget to add Player::RewardPlayerAndGroupAtEvent                        me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE);                        uiOutroStep = 1;                        Phase = OUTRO;                        return;                    }                    if (Creature* pArthas = me->GetCreature(*me, instance ? instance->GetData64(DATA_ARTHAS) : 0))                        if (pArthas->isDead())                        {                            EnterEvadeMode();                            me->DisappearAndDie();                            if (instance)                                instance->SetData(DATA_MAL_GANIS_EVENT, FAIL);                        }                    if (uiCarrionSwarmTimer < diff)                    {                        DoCastVictim(SPELL_CARRION_SWARM);                        uiCarrionSwarmTimer = 7000;                    } else uiCarrionSwarmTimer -= diff;                    if (uiMindBlastTimer < diff)                    {                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))                            DoCast(target, SPELL_MIND_BLAST);                        uiMindBlastTimer = 6000;                    } else uiMindBlastTimer -= diff;                    if (uiVampiricTouchTimer < diff)                    {                        DoCast(me, SPELL_VAMPIRIC_TOUCH);                        uiVampiricTouchTimer = 32000;                    } else uiVampiricTouchTimer -= diff;                    if (uiSleepTimer < diff)                    {                        Talk(SAY_SLEEP);                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))                            DoCast(target, SPELL_SLEEP);                        uiSleepTimer = urand(15000, 20000);                    } else uiSleepTimer -= diff;                    DoMeleeAttackIfReady();                    break;                case OUTRO:                    if (uiOutroTimer < diff)                    {                        switch (uiOutroStep)                        {                            case 1:                                Talk(SAY_ESCAPE_SPEECH_1);                                me->GetMotionMaster()->MoveTargetedHome();                                ++uiOutroStep;                                uiOutroTimer = 8000;                                break;                            case 2:                                me->SetTarget(instance ? instance->GetData64(DATA_ARTHAS) : 0);                                me->HandleEmoteCommand(29);                                Talk(SAY_ESCAPE_SPEECH_2);                                ++uiOutroStep;                                uiOutroTimer = 9000;                                break;                            case 3:                                Talk(SAY_OUTRO);                                ++uiOutroStep;                                uiOutroTimer = 16000;                                break;                            case 4:                                me->HandleEmoteCommand(33);                                ++uiOutroStep;                                uiOutroTimer = 500;                                break;                            case 5:                                me->SetVisible(false);                                me->Kill(me);                                break;//.........这里部分代码省略.........

    void UpdateAI(const uint32 diff)    {        if (!CanAttack && Intro)        {            if (AggroTimer <= diff)            {                CanAttack = true;                me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);                AggroTimer=19000;            } else            {                AggroTimer-=diff;                return;            }        }        //to prevent abuses during phase 2        if (Phase == 2 && !me->getVictim() && me->isInCombat())        {            EnterEvadeMode();            return;        }        //Return since we have no target        if (!UpdateVictim())            return;        if (Phase == 1 || Phase == 3)        {            //ShockBlast_Timer            if (ShockBlast_Timer <= diff)            {                //Shock Burst                //Randomly used in Phases 1 and 3 on Vashj's target, it's a Shock spell doing 8325-9675 nature damage and stunning the target for 5 seconds, during which she will not attack her target but switch to the next person on the aggro list.                DoCast(me->getVictim(), SPELL_SHOCK_BLAST);                me->TauntApply(me->getVictim());                ShockBlast_Timer = 1000+rand()%14000;       //random cooldown            } else ShockBlast_Timer -= diff;            //StaticCharge_Timer            if (StaticCharge_Timer <= diff)            {                //Static Charge                //Used on random people (only 1 person at any given time) in Phases 1 and 3, it's a debuff doing 2775 to 3225 Nature damage to the target and everybody in about 5 yards around it, every 1 seconds for 30 seconds. It can be removed by Cloak of Shadows, Iceblock, Divine Shield, etc, but not by Cleanse or Dispel Magic.                Unit *pTarget = NULL;                pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 200, true);                if (pTarget && !pTarget->HasAura(SPELL_STATIC_CHARGE_TRIGGER, 0))                                                            //cast Static Charge every 2 seconds for 20 seconds                        DoCast(pTarget, SPELL_STATIC_CHARGE_TRIGGER);                StaticCharge_Timer = 10000+rand()%20000;    //blizzlike            } else StaticCharge_Timer -= diff;            //Entangle_Timer            if (Entangle_Timer <= diff)            {                if (!Entangle)                {                    //Entangle                    //Used in Phases 1 and 3, it casts Entangling Roots on everybody in a 15 yard radius of Vashj, immobilzing them for 10 seconds and dealing 500 damage every 2 seconds. It's not a magic effect so it cannot be dispelled, but is removed by various buffs such as Cloak of Shadows or Blessing of Freedom.                    DoCast(me->getVictim(), SPELL_ENTANGLE);                    Entangle = true;                    Entangle_Timer = 10000;                }                else                {                    CastShootOrMultishot();                    Entangle = false;                    Entangle_Timer = 20000+rand()%5000;                }            } else Entangle_Timer -= diff;            //Phase 1            if (Phase == 1)            {                //Start phase 2                if ((me->GetHealth()*100 / me->GetMaxHealth()) < 70)                {                    //Phase 2 begins when Vashj hits 70%. She will run to the middle of her platform and surround herself in a shield making her invulerable.                    Phase = 2;                    me->GetMotionMaster()->Clear();                    DoTeleportTo(MIDDLE_X, MIDDLE_Y, MIDDLE_Z);                    Creature* creature;                    for (uint8 i = 0; i < 4; ++i)                    {                        creature = me->SummonCreature(SHIED_GENERATOR_CHANNEL, ShieldGeneratorChannelPos[i][0], ShieldGeneratorChannelPos[i][1], ShieldGeneratorChannelPos[i][2], ShieldGeneratorChannelPos[i][3], TEMPSUMMON_CORPSE_DESPAWN, 0);                        if (creature)                            ShieldGeneratorChannel[i] = creature->GetGUID();                    }                    DoScriptText(SAY_PHASE2, me);                }            }            //Phase 3            else            {                //SummonSporebat_Timer                if (SummonSporebat_Timer <= diff)                {//.........这里部分代码省略.........

 npc_toxic_sporebatAI(Creature* creature) : ScriptedAI(creature) {     Initialize();     instance = creature->GetInstanceScript();     EnterEvadeMode(); }