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

        void UpdateAI(const uint32 diff)        {            if (!UpdateVictim())                return;            events.Update(diff);            if (me->HasUnitState(UNIT_STATE_CASTING))                return;            while (uint32 eventId = events.ExecuteEvent())            {                switch (eventId)                {                    case EVENT_SHADOW_WORD_PAIN:                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))                            DoCast(target, SPELL_SHADOW_WORD_PAIN);                        events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, 8000);                        return;                    case EVENT_CIRCLE_OF_DESTRUCTION:                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))                            DoCast(target, SPELL_CIRCLE_OF_DESTRUCTION);                        events.ScheduleEvent(EVENT_CIRCLE_OF_DESTRUCTION, 12000);                        return;                    case EVENT_COWER_IN_FEAR:                        if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM))                            DoCast(target, SPELL_COWER_IN_FEAR);                        events.ScheduleEvent(EVENT_COWER_IN_FEAR, 10000);                        return;                    case EVENT_DARK_MENDING:                        // find an ally with missing HP                        if (Unit* target = DoSelectLowestHpFriendly(40, DUNGEON_MODE(30000, 50000)))                        {                            DoCast(target, SPELL_DARK_MENDING);                            events.ScheduleEvent(EVENT_DARK_MENDING, 20000);                        }                        else                        {                            // no friendly unit with missing hp. re-check in just 5 sec.                            events.ScheduleEvent(EVENT_DARK_MENDING, 5000);                        }                        return;                }            }            DoMeleeAttackIfReady();        }

    void UpdateAI(const uint32 diff)    {        if (!UpdateVictim())            return;        if (uiShieldTimer <= diff)        {            me->AddAura(RAND(SPELL_MAGIC_REFLECTION, SPELL_DAMAGE_REFLECTION), me);       //     DoCast(m_creature, RAND(SPELL_MAGIC_REFLECTION, SPELL_DAMAGE_REFLECTION));            uiShieldTimer = urand(20000, 30000);        } else uiShieldTimer -= diff;        switch (me->GetEntry())        {        case NPC_FLAMEWAKER_ELITE:            if (Blastwave_Timer <= diff)            {                DoCast(SPELL_BLAST_WAVE);                Blastwave_Timer = 10000;            } else Blastwave_Timer -= diff;            if (uiFireBlastTimer <= diff)            {                DoCast(SPELL_FIRE_BLAST);                uiFireBlastTimer = 15000;            } else uiFireBlastTimer -= diff;            break;        case NPC_FLAMEWAKER_HEALER:            if (uiShadowShockTimer <= diff)            {                if (Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 100, true))                    DoCast(pTarget, SPELL_SHADOW_SHOCK);                uiShadowShockTimer = 2000;            } else uiShadowShockTimer -= diff;            if (uiHealTimer <= diff)            {                if (Unit* pTarget = DoSelectLowestHpFriendly(200))                    DoCast(pTarget, SPELL_HEAL_BRETHREN);                uiHealTimer = urand(15000, 20000);            } else uiHealTimer -= diff;            break;        }        DoMeleeAttackIfReady();    }

        void UpdateAI(const uint32 diff)        {            if (!UpdateVictim())                return;            events.Update(diff);            while (uint32 eventId = events.ExecuteEvent())            {                switch(eventId)                {                    case EVENT_ENRAGE:                        DoScriptText(SAY_MOLGEIM_BERSERK, me);                        DoCast(SPELL_BERSERK);                        break;                    case EVENT_RUNE_OF_POWER: // Improve target selection; random alive friendly                    {                        Unit *pTarget = DoSelectLowestHpFriendly(60);                        if (!pTarget || !pTarget->isAlive())                            pTarget = me;                        DoCast(pTarget, SPELL_SUMMON_RUNE_OF_POWER);                        events.ScheduleEvent(EVENT_RUNE_OF_POWER, 60000);                        break;                    }                    case EVENT_SHIELD_OF_RUNES:                        DoCast(me, RAID_MODE(SPELL_SHIELD_OF_RUNES, SPELL_SHIELD_OF_RUNES_H));                        events.ScheduleEvent(EVENT_SHIELD_OF_RUNES, urand(27000,34000));                        break;                    case EVENT_RUNE_OF_DEATH:                        DoScriptText(SAY_MOLGEIM_RUNE_DEATH, me);                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM))                            DoCast(pTarget, SPELL_RUNE_OF_DEATH);                        events.ScheduleEvent(EVENT_RUNE_OF_DEATH, urand(30000,40000));                        break;                    case EVENT_RUNE_OF_SUMMONING:                        DoScriptText(SAY_MOLGEIM_SUMMON, me);                        if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM))                            DoCast(pTarget, SPELL_RUNE_OF_SUMMONING);                        events.ScheduleEvent(EVENT_RUNE_OF_SUMMONING, urand(20000,30000));                        break;                }            }            DoMeleeAttackIfReady();        }

            void UpdateAI(const uint32 uiDiff)            {                if (!UpdateVictim())                    return;					                if (me->HasUnitState(UNIT_STAT_CASTING))                    return;				                //Chain heal Timer                if (m_uiHealTimer <= uiDiff)                {                    if (Unit *pAlly = DoSelectLowestHpFriendly(INTERACTION_DISTANCE*100))                        DoCast(pAlly, SPELL_HEAL);                    m_uiHealTimer = urand(15000, 20000);                }                else                    m_uiHealTimer -= uiDiff;                //Fel Fireball Timer                if (m_uiFFireballTimer <= uiDiff)                {                    if (Unit *pTarget = SelectTarget(SELECT_TARGET_RANDOM))                        DoCast(pTarget, SPELL_FEL_FIREBALL);                    m_uiFFireballTimer = urand(10000, 15000);                }                else                    m_uiFFireballTimer -= uiDiff;                //Fire Nova timer                if (m_uiFireNovaTimer <= uiDiff)                {                    DoCast(me, SPELL_FIRE_NOVA);                    m_uiFireNovaTimer = urand(8000,  15000);                }                else                    m_uiFireNovaTimer -= uiDiff;                DoMeleeAttackIfReady();            }

    void UpdateAI(const uint32 uiDiff) override    {        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        // Casting Heal to Sulfuron or other Guards.        if (m_uiHealTimer < uiDiff)        {            if (Unit* pUnit = DoSelectLowestHpFriendly(60.0f, 1))            {                if (DoCastSpellIfCan(pUnit, SPELL_HEAL) == CAST_OK)                    m_uiHealTimer = urand(15000, 20000);            }        }        else            m_uiHealTimer -= uiDiff;        // ShadowWord Pain Timer        if (m_uiShadowWordPainTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))            {                if (DoCastSpellIfCan(pTarget, SPELL_SHADOWWORD_PAIN) == CAST_OK)                    m_uiShadowWordPainTimer = urand(18000, 26000);            }        }        else            m_uiShadowWordPainTimer -= uiDiff;        // Immolate Timer        if (m_uiImmolateTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))            {                if (DoCastSpellIfCan(pTarget, SPELL_IMMOLATE) == CAST_OK)                    m_uiImmolateTimer = urand(15000, 25000);            }        }        else            m_uiImmolateTimer -= uiDiff;        DoMeleeAttackIfReady();    }

    bool UpdateChampionAI(const uint32 uiDiff)    {        if (m_uiLightningTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_CHAIN_LIGHTNING) == CAST_OK)                m_uiLightningTimer = urand(1000, 3000);        }        else            m_uiLightningTimer -= uiDiff;        if (m_uiHealingWaveTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(40.0f))            {                if (DoCastSpellIfCan(pTarget, SPELL_HEALING_WAVE) == CAST_OK)                    m_uiHealingWaveTimer = urand(8000, 13000);            }        }        else            m_uiHealingWaveTimer -= uiDiff;        if (m_uiEarthShieldTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_EARTH_SHIELD, CAST_AURA_NOT_PRESENT) == CAST_OK)                m_uiEarthShieldTimer = 30000;            else                m_uiEarthShieldTimer = 5000;        }        else            m_uiEarthShieldTimer -= uiDiff;        if (m_uiHexTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_HEX_OF_MENDING) == CAST_OK)                m_uiHexTimer = urand(17000, 25000);        }        else            m_uiHexTimer -= uiDiff;        return true;    }

    void UpdateEscortAI(const uint32 uiDiff) override    {        DialogueUpdate(uiDiff);        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        if (m_uiExorcismTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature->getVictim(), m_bIsRegularMode ? SPELL_EXORCISM : SPELL_EXORCISM_H) == CAST_OK)                m_uiExorcismTimer = urand(9000, 13000);        }        else            m_uiExorcismTimer -= uiDiff;        if (m_uiHolyLightTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(40.0f))            {                if (DoCastSpellIfCan(pTarget, SPELL_HOLY_LIGHT) == CAST_OK)                    m_uiHolyLightTimer = urand(18000, 25000);            }        }        else            m_uiHolyLightTimer -= uiDiff;        if (!m_bYell50Pct && m_creature->GetHealthPercent() < 50.0f)        {            DoScriptText(SAY_ARTHAS_HALF_HP, m_creature);            m_bYell50Pct = true;        }        if (!m_bYell20Pct && m_creature->GetHealthPercent() < 20.0f)        {            DoScriptText(SAY_ARTHAS_LOW_HP, m_creature);            m_bYell20Pct = true;        }        DoMeleeAttackIfReady();    }

    void UpdateAI(const uint32 diff)    {        if (!UpdateVictim())            return;        //Casting Heal to Sulfuron or other Guards.        if (Heal_Timer <= diff)        {            Unit* pUnit = DoSelectLowestHpFriendly(60.0f, 1);            if (!pUnit)                return;            DoCast(pUnit, SPELL_HEAL);            Heal_Timer = 15000+rand()%5000;        } else Heal_Timer -= diff;        //ShadowWordPain_Timer        if (ShadowWordPain_Timer <= diff)        {            Unit *pTarget = NULL;            pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);            if (pTarget) DoCast(pTarget, SPELL_SHADOWWORDPAIN);            ShadowWordPain_Timer = 18000+rand()%8000;        } else ShadowWordPain_Timer -= diff;        //Immolate_Timer        if (Immolate_Timer <= diff)        {            Unit *pTarget = NULL;            pTarget = SelectUnit(SELECT_TARGET_RANDOM,0);            if (pTarget) DoCast(pTarget, SPELL_IMMOLATE);            Immolate_Timer = 15000+rand()%10000;        } else Immolate_Timer -= diff;        DoMeleeAttackIfReady();    }

void PlayerbotPaladinAI::DoNonCombatActions(){    PlayerbotAI *ai = GetAI();    Player *m_bot = GetPlayerBot();    if (!m_bot || !ai || m_bot->isDead()) { return; }    //If Casting or Eating/Drinking return    if (m_bot->HasUnitState(UNIT_STATE_CASTING)) { return; }    if (m_bot->getStandState() == UNIT_STAND_STATE_SIT) { return; }    //buff and heal raid    if (DoSupportRaid(m_bot)) { return; }    //heal pets and bots    Unit *target = DoSelectLowestHpFriendly(40, 1000);    if (target && target->isAlive() && HealTarget(target, target->GetHealth()*100 / target->GetMaxHealth())) { return; }    //mana/hp check    //Don't bother with eating, if low on hp, just let it heal themself    if (m_bot->getRace() == (uint8) RACE_UNDEAD_PLAYER && ai->GetHealthPercent() < 75 && CastSpell(R_CANNIBALIZE,m_bot)) { return; }    if (m_bot->GetHealth() < m_bot->GetMaxHealth() && CastSpell(FLASH_OF_LIGHT,m_bot)) { return; }    if (ai->GetManaPercent() < 70) { ai->Feast(); }} //end DoNonCombatActions

bool PlayerbotShamanAI::HealGroup (Unit *target, uint8 hp, uint8 &countNeedHeal){    Player *m_bot = GetPlayerBot();    if (countNeedHeal < 2) {        return false;    }    Unit *rTarget = DoSelectLowestHpFriendly(30,500);    if (!rTarget || rTarget->isDead() || rTarget->GetHealth() * 100 / rTarget->GetMaxHealth() > 80 ) {        return false;    }    if (hp < 65 && RIPTIDE && rTarget->HasAura(RIPTIDE,m_bot->GetGUID()) && CastSpell(CHAIN_HEAL, rTarget)) {        return true;    }    if (hp < 85 && CastSpell(RIPTIDE, rTarget)) {        return true;    }    if (hp < 75 && CastSpell(CHAIN_HEAL, rTarget,true,true)) {        return true;    }    return false;}

    void UpdateAI(const uint32 diff)    {        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim()) return;        //cast bubble at 20% hp        if (m_creature->GetHealthPercent() < 20.0f)             timedCast(SPELL_BUBBLE, diff);            if (Unit *target = DoSelectLowestHpFriendly(40.0f))                if (target->GetHealthPercent() < 15.0f)                    timedCast(SPELL_HAND_OF_PROTECTION, diff);            timedCast(SPELL_HOLY_SHOCK, diff);            if (Unit *target = SelectRandomFriendlyMissingBuff(SPELL_HAND_OF_FREEDOM))                timedCast(SPELL_HAND_OF_FREEDOM, diff, target);            timedCast(SPELL_HAMMER_OF_JUSTICE, diff);        if (timedQuery(SPELL_FLASH_OF_LIGHT, diff))        {            switch (urand(0,4))            {                case 0: case 1:                        doCast(SPELL_FLASH_OF_LIGHT);                    break;                case 2: case 3:                        doCast(SPELL_HOLY_LIGHT);                    break;                case 4:                        doCast(SPELL_CLEANSE);                    break;            }        }        boss_faction_championsAI::UpdateAI(diff);    }

    void UpdateAI(const uint32 uiDiff) override    {        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        if (m_uiHealTimer <= uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(50.0f))            {                if (DoCastSpellIfCan(pTarget, SPELL_SOLARIUM_GREAT_HEAL) == CAST_OK)                    m_uiHealTimer = 9000;            }        }        else            m_uiHealTimer -= uiDiff;        if (m_uiHolySmiteTimer <= uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0, nullptr, SELECT_FLAG_PLAYER))            {                if (DoCastSpellIfCan(pTarget, SPELL_SOLARIUM_HOLY_SMITE) == CAST_OK)                    m_uiHolySmiteTimer = 4000;            }        }        else            m_uiHolySmiteTimer -= uiDiff;        if (m_uiAoESilenceTimer <= uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_SOLARIUM_ARCANE_TORRENT) == CAST_OK)                m_uiAoESilenceTimer = 13000;        }        else            m_uiAoESilenceTimer -= uiDiff;        DoMeleeAttackIfReady();    }

            void UpdateAI(const uint32 diff)            {                if (!UpdateVictim())                    return;                events.Update(diff);                if (me->HasUnitState(UNIT_STAT_CASTING))                    return;                while (uint32 eventId = events.ExecuteEvent())                {                    switch (eventId)                    {                        case EVENT_HEAL:                            if (Unit* target = DoSelectLowestHpFriendly(60.0f, 1))                                DoCast(target, SPELL_HEAL);                            events.ScheduleEvent(EVENT_HEAL, urand(15000, 20000));                            break;                        case EVENT_SHADOW_WORD_PAIN:                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true, -SPELL_SHADOWWORDPAIN))                                DoCast(target, SPELL_SHADOWWORDPAIN);                            events.ScheduleEvent(EVENT_SHADOW_WORD_PAIN, urand(18000, 26000));                            break;                        case EVENT_IMMOLATE:                            if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 0.0f, true, -SPELL_IMMOLATE))                                DoCast(target, SPELL_IMMOLATE);                            events.ScheduleEvent(EVENT_IMMOLATE, urand(15000, 25000));                            break;                        default:                            break;                    }                }                DoMeleeAttackIfReady();            }

//.........这里部分代码省略.........            // Do support stuff            if (!m_bot->isMoving() && ChangeTotems(m_role)) { return; }            if (ai->GetManaPercent() > 70 && DoSupportRaid(m_bot)) { return; }            break;        #pragma endregion        #pragma region BOT_ROLE_DPS_MELEE        case BOT_ROLE_DPS_MELEE:            TakePosition(pTarget);            // Do support stuff            if (!m_bot->isMoving() && ChangeTotems(m_role)) { return; }            if (ai->GetManaPercent() > 40 && DoSupportRaid(m_bot)) { return; }            break;        #pragma endregion        #pragma region BOT_ROLE_DPS_RANGED        case BOT_ROLE_DPS_RANGED:            TakePosition(pTarget);            // Do support stuff            if (!m_bot->isMoving() && ChangeTotems(m_role)) { return; }            if (ai->GetManaPercent() > 40 && DoSupportRaid(m_bot)) { return; }            break;        #pragma endregion        #pragma region BOT_ROLE_SUPPORT        case BOT_ROLE_SUPPORT:            TakePosition(pTarget);            // Do support stuff            if (!m_bot->isMoving() && ChangeTotems(m_role)) { return; }            if (DoSupportRaid(m_bot)) { return; }            //heal pets and bots            Unit *target = DoSelectLowestHpFriendly(40, 1000);            if(target && target->isAlive() && HealTarget(target, target->GetHealth()*100 / target->GetMaxHealth()) ) { return; }            break;        #pragma endregion    }    #pragma region ShamanCommon    //Defensive Stuff    if (m_tank->GetGUID() != m_bot->GetGUID() && pVictim && pVictim->GetGUID() == m_bot->GetGUID() )    {        if (pDist > 5 && CastSpell(FROST_SHOCK, pTarget)) { return; }        if ((pTarget->GetCreatureType() == (uint32) CREATURE_TYPE_BEAST || pTarget->GetCreatureType() == (uint32) CREATURE_TYPE_HUMANOID) && CastSpell(HEX, pTarget)) { return; } // no gcd        if (CastSpell(WIND_SHEAR, pTarget)) { } // no gcd    }    if (m_bot->getRace() == (uint8) RACE_BLOODELF && pDist < 8 && pTarget->IsNonMeleeSpellCasted(true) && CastSpell(R_ARCANE_TORRENT, pTarget)) { } //no gcd    if (pTarget->IsNonMeleeSpellCasted(true) && CastSpell(WIND_SHEAR, pTarget)) { } //no gcd    if (m_bot->getRace() == (uint8) RACE_TAUREN && pVictim && pVictim->GetGUID() == m_bot->GetGUID() && pDist < 8 && CastSpell(R_WAR_STOMP, pTarget)) { return; }    //Catch    if (pTarget->HasUnitMovementFlag(UNIT_FLAG_FLEEING))    {        if (CastSpell(FROST_SHOCK,pTarget)) return;    }    //Buff and restores    if ( ( (ai->GetHealthPercent() < 60 && isUnderAttack()) ||        (ai->GetManaPercent() < 30) ) && CastSpell(SHAMANISTIC_RAGE, m_bot)) { return; }    if (m_bot->getRace() == (uint8) RACE_TROLL && CastSpell(R_BERSERKING,m_bot)) {} // no GCD    if (m_bot->getRace() == (uint8) RACE_ORC && CastSpell(R_BLOOD_FURY,m_bot)) {} // no GCD    if (!m_bot->HasAura(HEROISM) && !m_bot->HasAura(EXHAUSTION) && !m_bot->HasAura(SATED) && CastSpell(HEROISM,m_bot)) { return; }

//.........这里部分代码省略.........            case SUMMON_INSTANT:                   pSummon = _doSummon(m_uiSpellIdx, TEMPSUMMON_MANUAL_DESPAWN,0);                   if(pSummon) result = CAST_OK;                       else result = CAST_FAIL_OTHER;                   break;            case CAST_ON_ALLPLAYERS:                   {                       Map* pMap = m_creature->GetMap();                       Map::PlayerList const& pPlayers = pMap->GetPlayers();                       if (!pPlayers.isEmpty())                       {                           for (Map::PlayerList::const_iterator itr = pPlayers.begin(); itr != pPlayers.end(); ++itr)                           {                               pTarget = itr->getSource();                               if (pTarget && pTarget->isAlive() && pTarget->IsWithinDistInMap(m_creature, pSpell->LocData.x))                               {                                   if (!pSpell->m_IsBugged)                                   {                                       m_creature->CastSpell(pTarget, pSpell->m_uiSpellEntry[currentDifficulty], false);                                   }                                   else                                   {                                       _BSWDoCast(m_uiSpellIdx, pTarget);                                   };                               result = CAST_OK;                               };                           }                       } else result = CAST_FAIL_OTHER;                   }                   break;            case CAST_ON_FRENDLY:                   pTarget = DoSelectLowestHpFriendly(pSpell->LocData.x,0);                   result = _BSWCastOnTarget(pTarget, m_uiSpellIdx);                   break;            case CAST_ON_FRENDLY_LOWHP:                   pTarget = DoSelectLowestHpFriendly(pSpell->LocData.x,1);                   result = _BSWCastOnTarget(pTarget, m_uiSpellIdx);                   break;            case CAST_ON_RANDOM_POINT:                   if (!pTarget) pTarget = m_creature;                   if (pSpell->LocData.z <= 1.0f)                   {                         float fPosX, fPosY, fPosZ;                         if (!pTarget->IsPositionValid() || !pTarget->IsInMap(m_creature))                         {                             if (pTarget->GetTypeId() == TYPEID_PLAYER)                                 error_log("BSW: CAST_ON_RANDOM_POINT FAILED: player has invalid position. SpellID is %u",pSpell->m_uiSpellEntry[currentDifficulty]);                             else error_log("BSW: CAST_ON_RANDOM_POINT FAILED: creature has invalid position. SpellID is %u",pSpell->m_uiSpellEntry[currentDifficulty]);                             result = CAST_FAIL_OTHER;                             break;                         }                         pTarget->GetPosition(fPosX, fPosY, fPosZ);                         pTarget->GetRandomPoint(fPosX, fPosY, fPosZ, urand((uint32)pSpell->LocData.x, (uint32)pSpell->LocData.y), fPosX, fPosY, fPosZ);                         if ((int)fPosZ == 0)                         {                             error_log("BSW: CAST_ON_RANDOM_POINT FAILED: Positon Z is NULL. Strange bug");                             result = CAST_FAIL_OTHER;                             break;                         }                         if (SpellEntry const *spell = (SpellEntry *)GetSpellStore()->LookupEntry(pSpell->m_uiSpellEntry[currentDifficulty]))

    void UpdateAI(const uint32 uiDiff) override    {        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        if (m_uiBlessingTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(80.0f))            {                if (DoCastSpellIfCan(pTarget, urand(0, 1) ? SPELL_BLESS_SPELLWARD : SPELL_BLESS_PROTECTION) == CAST_OK)                    m_uiBlessingTimer = 60000;            }        }        else            m_uiBlessingTimer -= uiDiff;        if (m_uiConsecrationTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_CONSECRATION) == CAST_OK)                m_uiConsecrationTimer = urand(10000, 15000);        }        else            m_uiConsecrationTimer -= uiDiff;        if (m_uiHammerOfJusticeTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0, SPELL_HAMMER_OF_JUSTICE, SELECT_FLAG_PLAYER | SELECT_FLAG_NOT_IN_MELEE_RANGE))            {                if (DoCastSpellIfCan(pTarget, SPELL_HAMMER_OF_JUSTICE) == CAST_OK)                    m_uiHammerOfJusticeTimer = 20000;            }        }        else            m_uiHammerOfJusticeTimer -= uiDiff;        if (m_uiSealTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, urand(0, 1) ? SPELL_SEAL_OF_COMMAND : SPELL_SEAL_OF_BLOOD) == CAST_OK)            {                m_uiSealTimer = 40000;                if (urand(0, 1))                    m_uiJudgmentTimer = urand(4000, 7000);            }        }        else            m_uiSealTimer -= uiDiff;        if (m_uiAuraTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, urand(0, 1) ? SPELL_DEVOTION_AURA : SPELL_CHROMATIC_AURA) == CAST_OK)                m_uiAuraTimer = 90000;        }        else            m_uiAuraTimer -= uiDiff;        if (m_uiJudgmentTimer)        {            if (m_uiJudgmentTimer <= uiDiff)            {                if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_JUDGMENT) == CAST_OK)                    m_uiJudgmentTimer = 0;            }            else                m_uiJudgmentTimer -= uiDiff;        }        DoMeleeAttackIfReady();    }

    void UpdateAI(const uint32 uiDiff) override    {        // spawn Romulo on timer after fake death        if (m_uiSummonRomuloTimer)        {            if (m_uiSummonRomuloTimer <= uiDiff)            {                m_creature->SummonCreature(NPC_ROMULO, afRomuloSpawnLoc[0], afRomuloSpawnLoc[1], afRomuloSpawnLoc[2], afRomuloSpawnLoc[3], TEMPSUMMON_DEAD_DESPAWN, 0);                m_uiSummonRomuloTimer = 0;            }            else                m_uiSummonRomuloTimer -= uiDiff;        }        if (m_uiResurrectSelfTimer)        {            if (m_uiResurrectSelfTimer <= uiDiff)            {                if (m_pInstance)                {                    if (Creature* pRomulo = m_pInstance->GetSingleCreatureFromStorage(NPC_ROMULO))                    {                        // if Romulos is dead, then self kill                        if (pRomulo->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE))                        {                            m_creature->DealDamage(m_creature, m_creature->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NONE, NULL, false);                            pRomulo->DealDamage(pRomulo, pRomulo->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NONE, NULL, false);                        }                        else                        {                            DoRemoveFakeDeath();                            DoCastSpellIfCan(m_creature, SPELL_FULL_HEALTH, CAST_TRIGGERED);                        }                    }                }                m_uiResurrectSelfTimer = 0;            }            else                m_uiResurrectSelfTimer -= uiDiff;        }        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        // don't use spells during transition        if (m_bIsFakingDeath)            return;        if (m_uiBlindingPassionTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))            {                if (DoCastSpellIfCan(pTarget, SPELL_BLINDING_PASSION) == CAST_OK)                    m_uiBlindingPassionTimer = urand(30000, 45000);            }        }        else            m_uiBlindingPassionTimer -= uiDiff;        if (m_uiDevotionTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_DEVOTION) == CAST_OK)                m_uiDevotionTimer = urand(15000, 45000);        }        else            m_uiDevotionTimer -= uiDiff;        if (m_uiPowerfulAttractionTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))            {                if (DoCastSpellIfCan(pTarget, SPELL_POWERFUL_ATTRACTION) == CAST_OK)                    m_uiPowerfulAttractionTimer = urand(5000, 30000);            }        }        else            m_uiPowerfulAttractionTimer -= uiDiff;        if (m_uiEternalAffectionTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(30.0f))            {                if (DoCastSpellIfCan(pTarget, SPELL_ETERNAL_AFFECTION) == CAST_OK)                    m_uiEternalAffectionTimer = urand(45000, 60000);            }        }        else            m_uiEternalAffectionTimer -= uiDiff;        DoMeleeAttackIfReady();    }

        void UpdateAI(const uint32 diff)        {            if (isInMountedGauntlet())            {                npc_mounted_championAI::UpdateAI(diff);                return;            }            if (!UpdateVictim())                return;            if(defeated)                return;            if(me->HasUnitState(UNIT_STATE_CASTING))                return;            if (chainLightningTimer <= diff)            {                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))                    DoCast(target, SPELL_CHAIN_LIGHTNING);                chainLightningTimer = 8000;            } else chainLightningTimer -= diff;            if (healingWaveTimer <= diff)            {                bool chance = urand(0, 1);                if(!chance)                {                    if (Unit* friendUnit = DoSelectLowestHpFriendly(40))                    {                        DoCast(friendUnit, SPELL_HEALING_WAVE);                        healingWaveTimer = 5000;                    }                }else                {                    DoCast(me, SPELL_HEALING_WAVE);                    healingWaveTimer = 8000;                }            } else healingWaveTimer -= diff;            if (eartShieldTimer <= diff)            {                Unit* friendUnit = DoSelectLowestHpFriendly(40);                if (friendUnit && friendUnit->HealthBelowPct(60) && !friendUnit->HasAura(SPELL_EARTH_SHIELD))                {                    DoCast(friendUnit, SPELL_EARTH_SHIELD);                    eartShieldTimer = urand(30000, 35000);                }else if(!me->HasAura(SPELL_EARTH_SHIELD))                {                    DoCast(me, SPELL_EARTH_SHIELD);                    eartShieldTimer = urand(30000, 35000);                } else eartShieldTimer = urand(1500, 3500);            } else eartShieldTimer -= diff;            if (hexMendingTimer <= diff)            {                DoCastVictim(SPELL_HEX_OF_MENDING, true);                hexMendingTimer = urand(12000, 15000);            } else hexMendingTimer -= diff;            DoMeleeAttackIfReady();        }

        void UpdateAI(const uint32 uiDiff)        {            if (!bDone && GrandChampionsOutVehicle(me))            {                bDone = true;                if (instance && me->GetGUID() == instance->GetData64(DATA_GRAND_CHAMPION_1))                    me->SetHomePosition(739.678f, 662.541f, 412.393f, 4.49f);                else if (instance && me->GetGUID() == instance->GetData64(DATA_GRAND_CHAMPION_2))                    me->SetHomePosition(746.71f, 661.02f, 411.69f, 4.6f);                else if (instance && me->GetGUID() == instance->GetData64(DATA_GRAND_CHAMPION_3))                    me->SetHomePosition(754.34f, 660.70f, 412.39f, 4.79f);                if (instance)                    instance->SetData(BOSS_GRAND_CHAMPIONS, IN_PROGRESS);                EnterEvadeMode();                bHome = true;            }            if (uiPhaseTimer <= uiDiff)            {                if (uiPhase == 1)                {                    AggroAllPlayers(me);                    uiPhase = 0;                }            }else uiPhaseTimer -= uiDiff;            if (!UpdateVictim() || me->HasUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT))                return;            if (uiChainLightningTimer <= uiDiff)            {                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))                    DoCast(target, SPELL_CHAIN_LIGHTNING);                uiChainLightningTimer = 16000;            } else uiChainLightningTimer -= uiDiff;            if (uiHealingWaveTimer <= uiDiff)            {                bool bChance = urand(0, 1);                if (!bChance)                {                    if (Unit* pFriend = DoSelectLowestHpFriendly(40))                        DoCast(pFriend, SPELL_HEALING_WAVE);                } else                    DoCast(me, SPELL_HEALING_WAVE);                uiHealingWaveTimer = 12000;            } else uiHealingWaveTimer -= uiDiff;            if (uiEartShieldTimer <= uiDiff)            {                DoCast(me, SPELL_EARTH_SHIELD);                uiEartShieldTimer = urand(30000, 35000);            } else uiEartShieldTimer -= uiDiff;            if (uiHexMendingTimer <= uiDiff)            {                DoCastVictim(SPELL_HEX_OF_MENDING, true);                uiHexMendingTimer = urand(20000, 25000);            } else uiHexMendingTimer -= uiDiff;            DoMeleeAttackIfReady();        }

    void UpdateEscortAI(const uint32 uiDiff) override    {        DialogueUpdate(uiDiff);        if (m_uiOutroTimer)        {            if (m_uiOutroTimer <= uiDiff)            {                switch (m_uiOutroPhase)                {                    case 0:                        DoScriptText(SAY_REMULOS_OUTRO_1, m_creature);                        m_uiOutroTimer = 3000;                        break;                    case 1:                        // Despawn Remulos after the outro is finished - he will respawn automatically at his home position after a few min                        DoScriptText(SAY_REMULOS_OUTRO_2, m_creature);                        m_creature->SetRespawnDelay(1 * MINUTE);                        m_creature->ForcedDespawn(3000);                        m_uiOutroTimer = 0;                        break;                }                ++m_uiOutroPhase;            }            else                m_uiOutroTimer -= uiDiff;        }        // during the battle        if (m_uiShadesummonTimer)        {            if (m_uiShadesummonTimer <= uiDiff)            {                // do this yell only first time                if (m_bIsFirstWave)                {                    // summon 3 shades inside the house                    for (uint8 i = 0; i < MAX_SHADOWS; ++i)                        m_creature->SummonCreature(NPC_NIGHTMARE_PHANTASM, aShadowsLocations[i].m_fX, aShadowsLocations[i].m_fY, aShadowsLocations[i].m_fZ, 0, TEMPSPAWN_DEAD_DESPAWN, 0);                    if (Creature* pEranikus = m_creature->GetMap()->GetCreature(m_eranikusGuid))                        DoScriptText(SAY_ERANIKUS_ATTACK_1, pEranikus);                    ++m_uiSummonCount;                    SetEscortPaused(false);                    m_bIsFirstWave = false;                }                // Summon 3 shades per turn until the maximum summon turns are reached                float fX, fY, fZ;                // Randomize the summon point                uint8 uiSummonPoint = roll_chance_i(70) ? uint32(MAX_SHADOWS) : urand(MAX_SHADOWS + 1, MAX_SHADOWS + 2);                if (m_uiSummonCount < MAX_SUMMON_TURNS)                {                    for (uint8 i = 0; i < MAX_SHADOWS; ++i)                    {                        m_creature->GetRandomPoint(aShadowsLocations[uiSummonPoint].m_fX, aShadowsLocations[uiSummonPoint].m_fY, aShadowsLocations[uiSummonPoint].m_fZ, 10.0f, fX, fY, fZ);                        m_creature->SummonCreature(NPC_NIGHTMARE_PHANTASM, fX, fY, fZ, 0.0f, TEMPSPAWN_DEAD_DESPAWN, 0);                    }                    ++m_uiSummonCount;                }                // If all the shades were summoned then set Eranikus in combat                // We don't count the dead shades, because the boss is usually set in combat before all shades are dead                if (m_uiSummonCount == MAX_SUMMON_TURNS)                {                    m_uiShadesummonTimer = 0;                    if (Creature* pEranikus = m_creature->GetMap()->GetCreature(m_eranikusGuid))                    {                        pEranikus->SetByteFlag(UNIT_FIELD_BYTES_1, 3, 0);                        pEranikus->SetLevitate(false);                        pEranikus->GetMotionMaster()->MovePoint(POINT_ID_ERANIKUS_COMBAT, aEranikusLocations[2].m_fX, aEranikusLocations[2].m_fY, aEranikusLocations[2].m_fZ);                    }                }                else                    m_uiShadesummonTimer = urand(20000, 30000);            }            else                m_uiShadesummonTimer -= uiDiff;        }        // Combat spells        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        if (m_uiHealTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(DEFAULT_VISIBILITY_DISTANCE))            {                switch (urand(0, 2))                {                    case 0: DoCastSpellIfCan(pTarget, SPELL_HEALING_TOUCH); break;                    case 1: DoCastSpellIfCan(pTarget, SPELL_REJUVENATION);  break;                    case 2: DoCastSpellIfCan(pTarget, SPELL_REGROWTH);      break;                }            }            m_uiHealTimer = 10000;//.........这里部分代码省略.........

    void UpdateEscortAI(const uint32 uiDiff) override    {        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        // start event epilog        if (!m_bTirionSpawned && m_creature->GetHealthPercent() < 20.0f)        {            if (Creature* pTaelan = m_creature->GetMap()->GetCreature(m_taelanGuid))                SendAIEvent(AI_EVENT_CUSTOM_B, m_creature, pTaelan);            m_bTirionSpawned = true;        }        // combat spells        if (m_uiMindBlastTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_MIND_BLAST) == CAST_OK)                m_uiMindBlastTimer = urand(3000, 5000);        }        else            m_uiMindBlastTimer -= uiDiff;        if (m_uiMindFlayTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_MIND_FLAY) == CAST_OK)                m_uiMindFlayTimer = urand(9000, 15000);        }        else            m_uiMindFlayTimer -= uiDiff;        if (m_uiManaBurnTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_MANA_BURN) == CAST_OK)                m_uiManaBurnTimer = urand(8000, 12000);        }        else            m_uiManaBurnTimer -= uiDiff;        if (m_uiDominateTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 1, SPELL_DOMINATE_MIND, SELECT_FLAG_PLAYER))            {                if (DoCastSpellIfCan(pTarget, SPELL_DOMINATE_MIND) == CAST_OK)                    m_uiDominateTimer = urand(25000, 30000);            }        }        else            m_uiDominateTimer -= uiDiff;        if (m_uFlashHealTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(50.0f))            {                if (DoCastSpellIfCan(pTarget, SPELL_FLASH_HEAL) == CAST_OK)                    m_uFlashHealTimer = urand(10000, 15000);            }        }        else            m_uFlashHealTimer -= uiDiff;        if (m_creature->GetHealthPercent() < 50.0f)        {            if (m_uiGreaterHealTimer < uiDiff)            {                if (DoCastSpellIfCan(m_creature, SPELL_GREATER_HEAL) == CAST_OK)                    m_uiGreaterHealTimer = urand(15000, 20000);            }            else                m_uiGreaterHealTimer -= uiDiff;        }        DoMeleeAttackIfReady();    }

//.........这里部分代码省略.........    case EVENT_T_OOC_LOS:        //Repeat Timers        holder.UpdateRepeatTimer(me, event.ooc_los.repeatMin, event.ooc_los.repeatMax);        break;    case EVENT_T_RESET:    case EVENT_T_SPAWNED:        break;    case EVENT_T_TARGET_HP:    {        if (!me->isInCombat() || !me->getVictim() || !me->getVictim()->GetMaxHealth())            return false;        uint32 perc = uint32(me->getVictim()->GetHealthPct());        if (perc > event.percent_range.percentMax || perc < event.percent_range.percentMin)            return false;        //Repeat Timers        holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);        break;    }    case EVENT_T_TARGET_CASTING:        if (!me->isInCombat() || !me->getVictim() || !me->getVictim()->IsNonMeleeSpellCasted(false, false, true))            return false;        //Repeat Timers        holder.UpdateRepeatTimer(me, event.target_casting.repeatMin, event.target_casting.repeatMax);        break;    case EVENT_T_FRIENDLY_HP:    {        if (!me->isInCombat())            return false;        Unit* unit = DoSelectLowestHpFriendly((float)event.friendly_hp.radius, event.friendly_hp.hpDeficit);        if (!unit)            return false;        actionInvoker = unit;        //Repeat Timers        holder.UpdateRepeatTimer(me, event.friendly_hp.repeatMin, event.friendly_hp.repeatMax);        break;    }    case EVENT_T_FRIENDLY_IS_CC:    {        if (!me->isInCombat())            return false;        std::list<Creature*> pList;        DoFindFriendlyCC(pList, (float)event.friendly_is_cc.radius);        //List is empty        if (pList.empty())            return false;        //We don't really care about the whole list, just return first available        actionInvoker = *(pList.begin());        //Repeat Timers        holder.UpdateRepeatTimer(me, event.friendly_is_cc.repeatMin, event.friendly_is_cc.repeatMax);        break;    }    case EVENT_T_FRIENDLY_MISSING_BUFF:    {        std::list<Creature*> pList;        DoFindFriendlyMissingBuff(pList, (float)event.friendly_buff.radius, event.friendly_buff.spellId);

    void UpdateAI(const uint32 uiDiff) override    {        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        if (m_uiHealTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(50.0f))            {                if (DoCastSpellIfCan(pTarget, SPELL_FLASH_HEAL) == CAST_OK)                    m_uiHealTimer = urand(15000, 20000);            }        }        else            m_uiHealTimer -= uiDiff;        if (m_uiRenewTimer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(50.0f))            {                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_RENEW : SPELL_RENEW_H) == CAST_OK)                    m_uiRenewTimer = urand(5000, 10000);            }        }        else            m_uiRenewTimer -= uiDiff;        if (m_uiShieldTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, m_bIsRegularMode ? SPELL_SHIELD : SPELL_SHIELD_H) == CAST_OK)                m_uiShieldTimer = urand(30000, 35000);        }        else            m_uiShieldTimer -= uiDiff;        if (m_uiDispelTimer < uiDiff)        {            Unit* pTarget = nullptr;            CreatureList lTempList = DoFindFriendlyCC(50.0f);            if (!lTempList.empty())                pTarget = *(lTempList.begin());            else                pTarget = DoSelectLowestHpFriendly(50.0f);            if (pTarget)            {                if (DoCastSpellIfCan(pTarget, SPELL_DISPEL_MAGIC) == CAST_OK)                    m_uiDispelTimer = urand(12000, 15000);            }        }        else            m_uiDispelTimer -= uiDiff;        // Use the Medallion if CC - only on heroic. Not sure how many times they are allowed to use it.        if (!m_bIsRegularMode && m_uiMedallionTimer)        {            if (m_creature->isFrozen() || m_creature->hasUnitState(UNIT_STAT_CAN_NOT_REACT))            {                if (m_uiMedallionTimer <= uiDiff)                {                    if (DoCastSpellIfCan(m_creature, SPELL_MEDALLION, CAST_TRIGGERED) == CAST_OK)                        m_uiMedallionTimer = 0;                }                else                    m_uiMedallionTimer -= uiDiff;            }        }        if (m_uiSWPainTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0, nullptr, SELECT_FLAG_PLAYER))            {                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_SHADOW_WORD_PAIN : SPELL_SHADOW_WORD_PAIN_H) == CAST_OK)                    m_uiSWPainTimer = 10000;            }        }        else            m_uiSWPainTimer -= uiDiff;        if (m_uiScreamTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_SCREAM) == CAST_OK)                m_uiScreamTimer = urand(15000, 20000);        }        else            m_uiScreamTimer -= uiDiff;        DoMeleeAttackIfReady();    }

    bool UpdateCompanionAI(const uint32 uiDiff)    {        if (m_uiGoblinDragonGunTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, m_bIsRegularMode ? SPELL_GOBLIN_DRAGON_GUN : SPELL_GOBLIN_DRAGON_GUN_H) == CAST_OK)                m_uiGoblinDragonGunTimer = urand(10000, 20000);        }        else            m_uiGoblinDragonGunTimer -= uiDiff;        if (m_uiRocketLaunchTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0, nullptr, SELECT_FLAG_PLAYER))            {                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_ROCKET_LAUNCH : SPELL_ROCKET_LAUNCH_H) == CAST_OK)                    m_uiRocketLaunchTimer = 9000;            }        }        else            m_uiRocketLaunchTimer -= uiDiff;        if (m_uiFelIronBombTimer < uiDiff)        {            if (Unit* pTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0, nullptr, SELECT_FLAG_PLAYER))            {                if (DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_FEL_IRON_BOMB : SPELL_FEL_IRON_BOMB_H) == CAST_OK)                    m_uiFelIronBombTimer = 15000;            }        }        else            m_uiFelIronBombTimer -= uiDiff;        if (m_uiRecombobulateTimer < uiDiff)        {            // Note: this should be casted only on Polyformed targets            Unit* pTarget = nullptr;            CreatureList lTempList = DoFindFriendlyCC(50.0f);            if (!lTempList.empty())                pTarget = *(lTempList.begin());            else                pTarget = DoSelectLowestHpFriendly(50.0f);            if (pTarget)            {                if (DoCastSpellIfCan(pTarget, SPELL_RECOMBOBULATE) == CAST_OK)                    m_uiRecombobulateTimer = 2000;            }        }        else            m_uiRecombobulateTimer -= uiDiff;        if (m_uiHighExplosiveSheepTimer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_HIGH_EXPLOSIVE_SHEEP) == CAST_OK)                m_uiHighExplosiveSheepTimer = 65000;        }        else            m_uiHighExplosiveSheepTimer -= uiDiff;        return true;    }

    void UpdateAI(const uint32 uiDiff) override    {        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())            return;        if (m_bCanResurrect)        {            // When casting resuruction make sure to delay so on rez when reinstate battle deepsleep runs out            if (m_uiWait_Timer < uiDiff)            {                // spell has script target on Mograine                DoCastSpellIfCan(m_creature, SPELL_SCARLETRESURRECTION);                DoScriptText(SAY_WH_RESSURECT, m_creature);                m_bCanResurrect = false;            }            else                m_uiWait_Timer -= uiDiff;        }        // Cast Deep sleep when health is less than 50%        if (!m_bCanResurrectCheck && m_creature->GetHealthPercent() <= 50.0f)        {            DoCastSpellIfCan(m_creature, SPELL_DEEPSLEEP, CAST_INTERRUPT_PREVIOUS);            m_bCanResurrectCheck = true;            m_bCanResurrect = true;            return;        }        // while in "resurrect-mode", don't do anything        if (m_bCanResurrect)            return;        // If we are <75% hp cast healing spells at self or Mograine        if (m_uiHeal_Timer < uiDiff)        {            if (Unit* pTarget = DoSelectLowestHpFriendly(50.0f))            {                if (DoCastSpellIfCan(pTarget, SPELL_HEAL) == CAST_OK)                    m_uiHeal_Timer = 13000;            }        }        else            m_uiHeal_Timer -= uiDiff;        // m_uiPowerWordShield_Timer        if (m_uiPowerWordShield_Timer < uiDiff)        {            if (DoCastSpellIfCan(m_creature, SPELL_POWERWORDSHIELD) == CAST_OK)                m_uiPowerWordShield_Timer = urand(22000, 45000);        }        else            m_uiPowerWordShield_Timer -= uiDiff;        // m_uiHolySmite_Timer        if (m_uiHolySmite_Timer < uiDiff)        {            if (DoCastSpellIfCan(m_creature->getVictim(), SPELL_HOLYSMITE) == CAST_OK)                m_uiHolySmite_Timer = urand(3500, 5000);        }        else            m_uiHolySmite_Timer -= uiDiff;        DoMeleeAttackIfReady();    }

void bot_ai::ResetOrGetNextTarget(){    if (master->GetBotMustDie()) return;    uint64 targetGUID = 0;    // check if anyone has raid target    //targetGUID = getTargetWithIcon();    Group *group = master->GetGroup();    targetGUID = group->GetTargetWithIconByGroup (m_creature->GetGUID());    if (targetGUID && targetGUID!=master->GetGUID())    {        Unit * target = m_creature->GetCreature(*master, targetGUID);        if (target && target->isAlive() && target->IsHostileTo(master) && target->isInCombat() /*&& m_creature->IsWithinDist(target, 30)*/)        {            BotAttackStart(target);            return;        }    }    AttackerSet m_attackers = master->getAttackers();    //check if anyone is attacking master    if(gettingAttacked(m_attackers)) return;    //check if anyone is attacking me    m_attackers = m_creature->getAttackers();    if(gettingAttacked(m_attackers)) return;    //check if master has a victim    if(master->getVictim() && master->getVictim()->IsHostileTo(master))    {        if(m_creature->IsWithinDist(m_creature->getVictim(), 50))        {            BotAttackStart(master->getVictim());            return;        }    }    //lastly check a random victim, including bots, pets, etc    Unit *target = DoSelectLowestHpFriendly(30);    if(target != NULL && target->isAlive() && !target->IsHostileToPlayers())    {        m_attackers = target->getAttackers();        if(gettingAttacked(m_attackers)) {            return;        }    }    //if there is no one to attack, make sure we are following master    if(m_creature->getVictim() == NULL &&        m_creature->GetCharmInfo()->GetCommandState() != COMMAND_STAY &&        master->GetDistance(m_creature) > 20 &&        !master->IsBeingTeleported())    {        if (!master->isAlive())            master->SetBotCommandState(COMMAND_STAY);        else if (master->GetBotCommandState()==COMMAND_ATTACK)            master->SetBotCommandState(prevCommandState);        return;    }}

//.........这里部分代码省略.........            {                if(DoSupportRaid(GetMaster())) return;                else if(m_bot->GetGroup() && GetMaster()->GetGroup() != m_bot->GetGroup() && DoSupportRaid(m_bot)) { return; }            }            if (MOONKIN_FORM) { if (ChangeForm(MOONKIN_FORM)) { return; } }            else if (ai->GetForm() != FORM_NONE && ChangeForm(1)) { } //Normal Form            TakePosition(pTarget);            // BUFF UP            if(DoSupportRaid(GetMaster(),false,false,false)) return;            else if(m_bot->GetGroup() && GetMaster()->GetGroup() != m_bot->GetGroup() && DoSupportRaid(m_bot,false,false,false)) { return; }            break;        #pragma endregion        #pragma region BOT_ROLE_SUPPORT        case BOT_ROLE_SUPPORT:            if ( ai->GetManaPercent() < 20 && CastSpell (INNERVATE,m_bot)) { return; }            //Get to tree form only if you will no longer cast attack spells            if( TREE_OF_LIFE_FORM && (ai->GetManaPercent() < offensiveSpellThreshold || isUnderAttack()) )            {                 if (ChangeForm(TREE_OF_LIFE_FORM)) { return; }            }            else if (ai->GetForm() != FORM_NONE && ChangeForm(1)) { }  //Normal Form no gcd            TakePosition(pTarget);            //RezGroup(REBIRTH, GetMaster());            if (DoSupportRaid(GetMaster())) { return; }            if (m_bot->GetGroup() && GetMaster()->GetGroup() != m_bot->GetGroup() && DoSupportRaid(m_bot)) { return; }            //heal pets and bots            Unit *target = DoSelectLowestHpFriendly(30, 1000);            if(target && target->isAlive() && HealTarget(target, target->GetHealth()*100 / target->GetMaxHealth()) ) { return; }            break;        #pragma endregion    }    #pragma region DruidCommon    // Common Dps and protection routine    if (ai->GetHealthPercent() <= 70 && CastSpell(BARKSKIN,m_bot)) { return; }    if (isUnderAttack() && CastSpell(NATURES_GRASP,m_bot)) { return; }    if (ai->GetForm() == FORM_CAT)    {        // If at threat limit, use Cower to reduce threat        if (pThreat > threatThreshold && m_tank->GetGUID() != m_bot->GetGUID() && !isUnderAttack())        {            if (m_tank->getVictim() && m_tank->getVictim()->GetGUID() != pTarget->GetGUID()) // I am attacking wrong target!!            {                m_bot->SetSelection(m_tank->getVictim()->GetGUID());                return;            }            else            {                if (CastSpell(COWER,pTarget)) { return; } //Lets see if we can manage                else { return; } //use no spells and wait threat to be reduced            }        }        if (CastSpell(FERAL_CHARGE_CAT,pTarget)) { return; }        if (m_bot->GetComboPoints() >= 1 && pTarget->IsNonMeleeSpellCasted(true) && CastSpell(MAIM, pTarget)) { return; }        if (CastSpell(BERSERK, m_bot)) { return; }        if (ai->GetHealthPercent() <= 75 && CastSpell(SURVIVAL_INSTINCTS, m_bot)) { return; }

        void UpdateAI(uint32 diff)        {            npc_escortAI::UpdateAI(diff);            if( !UpdateVictim() )                return;            events.Update(diff);            if( me->HasUnitState(UNIT_STATE_CASTING) )                return;            switch( events.GetEvent() )            {                case 0:                    break;                case EVENT_MONK_SPELL_FLURRY_OF_BLOWS:                    me->CastSpell(me, SPELL_FLURRY_OF_BLOWS, false);                    events.RepeatEvent(urand(12000,18000));                    break;                case EVENT_MONK_SPELL_PUMMEL:                    if( me->GetVictim() )                        me->CastSpell(me->GetVictim(), SPELL_PUMMEL, false);                    events.RepeatEvent(urand(8000,11000));                    break;                case EVENT_PRIESTESS_SPELL_HOLY_SMITE:                    if( me->GetVictim() )                        me->CastSpell(me->GetVictim(), SPELL_HOLY_SMITE, false);                    events.RepeatEvent(urand(6000,8000));                    break;                case EVENT_PRIESTESS_SPELL_SHADOW_WORD_PAIN:                    if( me->GetVictim() )                        me->CastSpell(me->GetVictim(), SPELL_SHADOW_WORD_PAIN, false);                    events.RepeatEvent(urand(12000,15000));                    break;                case EVENT_PRIESTESS_SPELL_FOUNTAIN_OF_LIGHT:                    me->CastSpell((Unit*)NULL, SPELL_FOUNTAIN_OF_LIGHT, false);                    events.RepeatEvent(urand(35000,45000));                    break;                case EVENT_PRIESTESS_SPELL_MIND_CONTROL_H:                    if( Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 30.0f, true) )                        me->CastSpell(target, SPELL_MIND_CONTROL_H, false);                    events.RepeatEvent(urand(22000,30000));                    break;                case EVENT_LIGHTWIELDER_SPELL_BLAZING_LIGHT:                    {                        Unit* target = DoSelectLowestHpFriendly(40.0f);                        if( !target )                            target = me;                        me->CastSpell(target, SPELL_BLAZING_LIGHT, false);                        events.RepeatEvent(urand(8000,12000));                    }                    break;                case EVENT_LIGHTWIELDER_SPELL_CLEAVE:                    if( me->GetVictim() )                        me->CastSpell(me->GetVictim(), SPELL_CLEAVE, false);                    events.RepeatEvent(urand(6000,8000));                    break;                case EVENT_LIGHTWIELDER_SPELL_UNBALANCING_STRIKE_H:                    if( me->GetVictim() )                        me->CastSpell(me->GetVictim(), SPELL_UNBALANCING_STRIKE_H, false);                    events.RepeatEvent(urand(12000,15000));                    break;            }            DoMeleeAttackIfReady();        }