Merge pull request #439 from liyunfan1223/performance

Improve performance

.github/workflows/macos_build.yml

@@ -1,9 +1,9 @@
 name: macos-build
 on:
   push:
-    branches: [ "master" ]
+    branches: [never-match-this-branch]
   pull_request:
-    branches: [ "master" ]
+    branches: [never-match-this-branch]
 
 # concurrency:
 #   group: ${{ github.head_ref }} || concat(${{ github.ref }}, ${{ github.workflow }})

src/PlayerbotAI.cpp

@@ -1379,7 +1379,7 @@ bool PlayerbotAI::ContainsStrategy(StrategyType type)
 {
     for (uint8 i = 0; i < BOT_STATE_MAX; i++)
     {
-        if (engines[i]->ContainsStrategy(type))
+        if (engines[i]->HasStrategyType(type))
             return true;
     }
 
@@ -3285,12 +3285,18 @@ bool PlayerbotAI::HasAuraToDispel(Unit* target, uint32 dispelType)
         return false;
     }
     bool isFriend = bot->IsFriendlyTo(target);
-    for (uint32 type = SPELL_AURA_NONE; type < TOTAL_AURAS; ++type)
+    Unit::VisibleAuraMap const* visibleAuras = target->GetVisibleAuras();
+    for (Unit::VisibleAuraMap::const_iterator itr = visibleAuras->begin(); itr != visibleAuras->end(); ++itr)
     {
-        Unit::AuraEffectList const& auras = target->GetAuraEffectsByType((AuraType)type);
+        Aura* aura = itr->second->GetBase();
-        for (AuraEffect const* aurEff : auras)
+
-        {
+        if (aura->IsPassive())
-            Aura const* aura = aurEff->GetBase();
+            continue;
+
+        if (sPlayerbotAIConfig->dispelAuraDuration && aura->GetDuration() &&
+            aura->GetDuration() < (int32)sPlayerbotAIConfig->dispelAuraDuration)
+            continue;
+
         SpellInfo const* spellInfo = aura->GetSpellInfo();
 
         bool isPositiveSpell = spellInfo->IsPositive();
@@ -3300,14 +3306,9 @@ bool PlayerbotAI::HasAuraToDispel(Unit* target, uint32 dispelType)
         if (!isPositiveSpell && !isFriend)
             continue;
 
-            if (sPlayerbotAIConfig->dispelAuraDuration && aura->GetDuration() &&
-                aura->GetDuration() < (int32)sPlayerbotAIConfig->dispelAuraDuration)
-                continue;
-
         if (canDispel(spellInfo, dispelType))
             return true;
     }
-    }
     return false;
 }
 

src/strategy/Engine.cpp

@@ -86,6 +86,7 @@ Engine::~Engine(void)
 
 void Engine::Reset()
 {
+    strategyTypeMask = 0;
     ActionNode* action = nullptr;
     do
     {
@@ -120,6 +121,7 @@ void Engine::Init()
     for (std::map<std::string, Strategy*>::iterator i = strategies.begin(); i != strategies.end(); i++)
     {
         Strategy* strategy = i->second;
+        strategyTypeMask |= strategy->GetType();
         strategy->InitMultipliers(multipliers);
         strategy->InitTriggers(triggers);
 

src/strategy/Engine.h

@@ -83,7 +83,7 @@ public:
     void AddActionExecutionListener(ActionExecutionListener* listener) { actionExecutionListeners.Add(listener); }
 
     void removeActionExecutionListener(ActionExecutionListener* listener) { actionExecutionListeners.Remove(listener); }
-
+    bool HasStrategyType(StrategyType type) { return strategyTypeMask & type; }
     virtual ~Engine(void);
 
     bool testMode;
@@ -112,6 +112,7 @@ protected:
     std::map<std::string, Strategy*> strategies;
     float lastRelevance;
     std::string lastAction;
+    uint32 strategyTypeMask;
 };
 
 #endif

src/strategy/hunter/GenericHunterStrategy.cpp

@@ -98,7 +98,9 @@ void GenericHunterStrategy::InitTriggers(std::vector<TriggerNode*>& triggers)
         new TriggerNode("misdirection on main tank",
                         NextAction::array(0, new NextAction("misdirection on main tank", ACTION_HIGH + 7), NULL)));
     triggers.push_back(
-        new TriggerNode("tranquilizing shot", NextAction::array(0, new NextAction("tranquilizing shot", 61.0f), NULL)));
+        new TriggerNode("tranquilizing shot enrage", NextAction::array(0, new NextAction("tranquilizing shot", 61.0f), NULL)));
+    triggers.push_back(
+        new TriggerNode("tranquilizing shot magic", NextAction::array(0, new NextAction("tranquilizing shot", 61.0f), NULL)));
 }
 
 NextAction** HunterBoostStrategy::getDefaultActions()

src/strategy/hunter/HunterAiObjectContext.cpp

@@ -85,7 +85,8 @@ public:
         creators["switch to melee"] = &HunterTriggerFactoryInternal::switch_to_melee;
         creators["switch to ranged"] = &HunterTriggerFactoryInternal::switch_to_ranged;
         creators["misdirection on main tank"] = &HunterTriggerFactoryInternal::misdirection_on_main_tank;
-        creators["tranquilizing shot"] = &HunterTriggerFactoryInternal::remove_enrage;
+        creators["tranquilizing shot enrage"] = &HunterTriggerFactoryInternal::remove_enrage;
+        creators["tranquilizing shot magic"] = &HunterTriggerFactoryInternal::remove_magic;
     }
 
 private:
@@ -118,6 +119,7 @@ private:
     static Trigger* switch_to_ranged(PlayerbotAI* botAI) { return new SwitchToRangedTrigger(botAI); }
     static Trigger* misdirection_on_main_tank(PlayerbotAI* ai) { return new MisdirectionOnMainTankTrigger(ai); }
     static Trigger* remove_enrage(PlayerbotAI* ai) { return new TargetRemoveEnrageTrigger(ai); }
+    static Trigger* remove_magic(PlayerbotAI* ai) { return new TargetRemoveMagicTrigger(ai); }
 };
 
 class HunterAiObjectContextInternal : public NamedObjectContext<Action>

src/strategy/hunter/HunterTriggers.cpp

@@ -88,9 +88,3 @@ bool SwitchToMeleeTrigger::IsActive()
            (target->GetVictim() == bot &&
             sServerFacade->IsDistanceLessOrEqualThan(AI_VALUE2(float, "distance", "current target"), 8.0f));
 }
-
-bool TargetRemoveEnrageTrigger::IsActive()
-{
-    Unit* target = GetTarget();
-    return target && (botAI->HasAuraToDispel(target, DISPEL_ENRAGE) || botAI->HasAuraToDispel(target, DISPEL_MAGIC));
-}

src/strategy/hunter/HunterTriggers.h

@@ -170,6 +170,11 @@ class TargetRemoveEnrageTrigger : public TargetAuraDispelTrigger
 {
 public:
     TargetRemoveEnrageTrigger(PlayerbotAI* ai) : TargetAuraDispelTrigger(ai, "tranquilizing shot", DISPEL_ENRAGE) {}
-    bool IsActive() override;
+};
+
+class TargetRemoveMagicTrigger : public TargetAuraDispelTrigger
+{
+public:
+    TargetRemoveMagicTrigger(PlayerbotAI* ai) : TargetAuraDispelTrigger(ai, "tranquilizing shot", DISPEL_MAGIC) {}
 };
 #endif

src/strategy/triggers/CureTriggers.cpp

@@ -19,4 +19,10 @@ Value<Unit*>* PartyMemberNeedCureTrigger::GetTargetValue()
     return context->GetValue<Unit*>("party member to dispel", dispelType);
 }
 
+bool PartyMemberNeedCureTrigger::IsActive()
+{
+    Unit* target = GetTarget();
+    return target && target->IsInWorld();
+}
+
 bool NeedWorldBuffTrigger::IsActive() { return !WorldBuffAction::NeedWorldBuffs(bot).empty(); }

src/strategy/triggers/CureTriggers.h

@@ -46,6 +46,7 @@ public:
     }
 
     Value<Unit*>* GetTargetValue() override;
+    bool IsActive() override;
 };
 
 class NeedWorldBuffTrigger : public Trigger

src/strategy/values/PartyMemberToHeal.cpp

@@ -41,36 +41,54 @@ Unit* PartyMemberToHeal::Calculate()
     for (GroupReference* gref = group->GetFirstMember(); gref; gref = gref->next())
     {
         Player* player = gref->GetSource();
-        if (player && Check(player) && player->IsAlive())
+        if (player && player->IsAlive())
         {
             uint8 health = player->GetHealthPct();
             if (isRaid || health < sPlayerbotAIConfig->mediumHealth || !IsTargetOfSpellCast(player, predicate))
             {
+                uint32 probeValue = 100;
                 if (player->GetDistance2d(bot) > sPlayerbotAIConfig->healDistance)
                 {
-                    calc.probe(health + 30, player);
+                    probeValue = health + 30;
                 }
                 else
                 {
-                    calc.probe(health + player->GetDistance2d(bot) / 10, player);
+                    probeValue = health + player->GetDistance2d(bot) / 10;
+                }
+                // delay Check player to here for better performance
+                if (probeValue < calc.minValue && Check(player))
+                {
+                    calc.probe(probeValue, player);
                 }
             }
         }
 
         Pet* pet = player->GetPet();
-        if (pet && Check(pet) && pet->IsAlive())
+        if (pet && pet->IsAlive())
         {
             uint8 health = ((Unit*)pet)->GetHealthPct();
+            uint32 probeValue = 100;
             if (isRaid || health < sPlayerbotAIConfig->mediumHealth)
-                calc.probe(health + 30, pet);
+                probeValue = health + 30;
+            // delay Check pet to here for better performance
+            if (probeValue < calc.minValue && Check(pet))
+            {
+                calc.probe(probeValue, pet);
+            }
         }
 
         Unit* charm = player->GetCharm();
-        if (charm && Check(charm) && charm->IsAlive())
+        if (charm && charm->IsAlive())
         {
             uint8 health = charm->GetHealthPct();
+            uint32 probeValue = 100;
             if (isRaid || health < sPlayerbotAIConfig->mediumHealth)
-                calc.probe(health, charm);
+                probeValue = health + 30;
+            // delay Check charm to here for better performance
+            if (probeValue < calc.minValue && Check(charm))
+            {
+                calc.probe(probeValue, charm);
+            }
         }
     }
     return (Unit*)calc.param;

src/strategy/values/PartyMemberValue.cpp

@@ -12,11 +12,11 @@ Unit* PartyMemberValue::FindPartyMember(std::vector<Player*>* party, FindPlayerP
 {
     for (Player* player : *party)
     {
-        if (Check(player) && predicate.Check(player))
+        if (predicate.Check(player) && Check(player))
             return player;
 
         if (Pet* pet = player->GetPet())
-            if (Check(pet) && predicate.Check(pet))
+            if (predicate.Check(pet) && Check(pet))
                 return pet;
     }