Merge af28ee3 into 050a010

bozimmerman · web-flow · commit 53a89e07fc1b · 2026-04-04T20:54:57.000-05:00
diff --git a/src/modules/Bots/playerbot/strategy/Action.h b/src/modules/Bots/playerbot/strategy/Action.h
@@ -112,13 +112,13 @@ namespace ai
     class ActionBasket
     {
     public:
-        ActionBasket(ActionNode* action, float relevance, bool skipPrerequisites, Event event) :
+        ActionBasket(ActionNode* action, float relevance, bool skipPrerequisites, const Event& event) :
           action(action), relevance(relevance), skipPrerequisites(skipPrerequisites), event(event) {}
         virtual ~ActionBasket(void) {}
     public:
         float getRelevance() {return relevance;}
         ActionNode* getAction() {return action;}
-        Event getEvent() { return event; }
+        const Event& getEvent() { return event; }
         bool isSkipPrerequisites() { return skipPrerequisites; }
         void AmendRelevance(float k) {relevance *= k; }
         void setRelevance(float relevance) { this->relevance = relevance; }
diff --git a/src/modules/Bots/playerbot/strategy/Engine.cpp b/src/modules/Bots/playerbot/strategy/Engine.cpp
@@ -12,10 +12,11 @@ Engine::Engine(PlayerbotAI* ai, AiObjectContext *factory) : PlayerbotAIAware(ai)
 {
     lastRelevance = 0.0f;
     testMode = false;
+    strategiesDirty = false;
 }
 
 // Executes actions before the main action
-bool ActionExecutionListeners::Before(Action* action, Event event)
+bool ActionExecutionListeners::Before(Action* action, const Event& event)
 {
     bool result = true;
     for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)
@@ -26,7 +27,7 @@ bool ActionExecutionListeners::Before(Action* action, Event event)
 }
 
 // Executes actions after the main action
-void ActionExecutionListeners::After(Action* action, bool executed, Event event)
+void ActionExecutionListeners::After(Action* action, bool executed, const Event& event)
 {
     for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)
     {
@@ -35,7 +36,7 @@ void ActionExecutionListeners::After(Action* action, bool executed, Event event)
 }
 
 // Overrides the result of the action execution
-bool ActionExecutionListeners::OverrideResult(Action* action, bool executed, Event event)
+bool ActionExecutionListeners::OverrideResult(Action* action, bool executed, const Event& event)
 {
     bool result = executed;
     for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)
@@ -46,7 +47,7 @@ bool ActionExecutionListeners::OverrideResult(Action* action, bool executed, Eve
 }
 
 // Checks if the action execution is allowed
-bool ActionExecutionListeners::AllowExecution(Action* action, Event event)
+bool ActionExecutionListeners::AllowExecution(Action* action, const Event& event)
 {
     bool result = true;
     for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)
@@ -71,6 +72,16 @@ Engine::~Engine(void)
 {
     Reset();
     strategies.clear();
+    ClearActionNodeCache();
+}
+
+void Engine::ClearActionNodeCache()
+{
+    for (unordered_map<string, ActionNode*>::iterator i = actionNodeCache.begin(); i != actionNodeCache.end(); i++)
+    {
+        delete i->second;
+    }
+    actionNodeCache.clear();
 }
 
 // Resets the engine by clearing the action queue, triggers, and multipliers
@@ -79,8 +90,7 @@ void Engine::Reset()
     ActionNode* action = NULL;
     do
     {
-        action = queue.Pop();
-        delete action;
+        action = queue.Pop(); // popped from queue, remain in cache
     } while (action != NULL);
 
     for (list<TriggerNode*>::iterator i = triggers.begin(); i != triggers.end(); i++)
@@ -98,10 +108,18 @@ void Engine::Reset()
     multipliers.clear();
 }
 
-// Initializes the engine by resetting it and initializing strategies
+// Marks the engine for reinitialization at the next DoNextAction entry
 void Engine::Init()
+{
+    strategiesDirty = true;
+}
+
+// Initializes strategies, triggers, multipliers, and default actions
+void Engine::InitStrategies()
 {
     Reset();
+    ClearActionNodeCache();
+    strategiesDirty = false;
 
     for (map<string, Strategy*>::iterator i = strategies.begin(); i != strategies.end(); i++)
     {
@@ -132,6 +150,11 @@ bool Engine::DoNextAction(Unit* unit, int depth)
     bool actionExecuted = false;
     ActionBasket* basket = NULL;
 
+    if (strategiesDirty)
+    {
+        InitStrategies();
+    }
+
     time_t currentTime = time(0);
     aiObjectContext->Update();
     ProcessTriggers();
@@ -188,7 +211,6 @@ bool Engine::DoNextAction(Unit* unit, int depth)
                         LogAction("A:%s - OK", action->getName().c_str());
                         MultiplyAndPush(actionNode->getContinuers(), 0, false, event);
                         lastRelevance = relevance;
-                        delete actionNode;
                         break;
                     }
                     else
@@ -208,7 +230,6 @@ bool Engine::DoNextAction(Unit* unit, int depth)
                 lastRelevance = relevance;
                 LogAction("A:%s - USELESS", action->getName().c_str());
             }
-            delete actionNode;
         }
     }
     while (basket);
@@ -240,23 +261,30 @@ bool Engine::DoNextAction(Unit* unit, int depth)
 // Creates an action node based on the action name
 ActionNode* Engine::CreateActionNode(string name)
 {
+    unordered_map<string, ActionNode*>::iterator cached = actionNodeCache.find(name);
+    if (cached != actionNodeCache.end())
+    {
+        return cached->second;
+    }
+
+    ActionNode* node = NULL;
     for (map<string, Strategy*>::iterator i = strategies.begin(); i != strategies.end(); i++)
     {
-        Strategy* strategy = i->second;
-        ActionNode* node = strategy->GetAction(name);
+        node = i->second->GetAction(name);
         if (node)
-        {
-            return node;
-        }
+            break;
+    }
+    if (!node)
+    {
+        node = new ActionNode(name, /*P*/ NULL, /*A*/ NULL, /*C*/ NULL);
     }
-    return new ActionNode (name,
-        /*P*/ NULL,
-        /*A*/ NULL,
-        /*C*/ NULL);
+
+    actionNodeCache[name] = node;
+    return node;
 }
 
 // Multiplies the relevance of actions and pushes them to the queue
-bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event)
+bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, const Event& event)
 {
     bool pushed = false;
     if (actions)
@@ -281,11 +309,6 @@ bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool sk
                     queue.Push(new ActionBasket(action, k, skipPrerequisites, event));
                     pushed = true;
                 }
-                else
-                {
-                    delete action;
-                }
-
                 delete nextAction;
             }
             else
@@ -317,21 +340,18 @@ ActionResult Engine::ExecuteAction(string &name)
 
     if (!action->isPossible())
     {
-        delete actionNode;
         return ACTION_RESULT_IMPOSSIBLE;
     }
 
     if (!action->isUseful())
     {
-        delete actionNode;
         return ACTION_RESULT_USELESS;
     }
 
     action->MakeVerbose();
     Event emptyEvent;
     result = ListenAndExecute(action, emptyEvent);
     MultiplyAndPush(action->getContinuers(), 0.0f, false, emptyEvent);
-    delete actionNode;
     return result ? ACTION_RESULT_OK : ACTION_RESULT_FAILED;
 }
 
@@ -487,13 +507,12 @@ string Engine::ListStrategies()
 }
 
 // Pushes an action node to the queue again
-void Engine::PushAgain(ActionNode* actionNode, float relevance, Event event)
+void Engine::PushAgain(ActionNode* actionNode, float relevance, const Event& event)
 {
     NextAction** nextAction = new NextAction*[2];
     nextAction[0] = new NextAction(actionNode->getName(), relevance);
     nextAction[1] = NULL;
     MultiplyAndPush(nextAction, relevance, true, event);
-    delete actionNode;
 }
 
 // Checks if the engine contains a specific strategy type
@@ -523,7 +542,7 @@ Action* Engine::InitializeAction(ActionNode* actionNode)
 }
 
 // Listens and executes an action
-bool Engine::ListenAndExecute(Action* action, Event event)
+bool Engine::ListenAndExecute(Action* action, const Event& event)
 {
     bool actionExecuted = false;
 
diff --git a/src/modules/Bots/playerbot/strategy/Engine.h b/src/modules/Bots/playerbot/strategy/Engine.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <unordered_map>
 #include "Action.h"
 #include "Queue.h"
 #include "Trigger.h"
@@ -16,10 +17,10 @@ namespace ai
     {
     public:
         virtual ~ActionExecutionListener() = default; // Add a virtual destructor
-        virtual bool Before(Action* action, Event event) = 0;
-        virtual bool AllowExecution(Action* action, Event event) = 0;
-        virtual void After(Action* action, bool executed, Event event) = 0;
-        virtual bool OverrideResult(Action* action, bool executed, Event event) = 0;
+        virtual bool Before(Action* action, const Event& event) = 0;
+        virtual bool AllowExecution(Action* action, const Event& event) = 0;
+        virtual void After(Action* action, bool executed, const Event& event) = 0;
+        virtual bool OverrideResult(Action* action, bool executed, const Event& event) = 0;
     };
 
     // -----------------------------------------------------------------------------------------------------------------------
@@ -34,10 +35,10 @@ namespace ai
 
     // ActionExecutionListener
     public:
-        virtual bool Before(Action* action, Event event);
-        virtual bool AllowExecution(Action* action, Event event);
-        virtual void After(Action* action, bool executed, Event event);
-        virtual bool OverrideResult(Action* action, bool executed, Event event);
+        virtual bool Before(Action* action, const Event& event);
+        virtual bool AllowExecution(Action* action, const Event& event);
+        virtual void After(Action* action, bool executed, const Event& event);
+        virtual bool OverrideResult(Action* action, bool executed, const Event& event);
 
     public:
         /**
@@ -127,14 +128,16 @@ namespace ai
         virtual ~Engine(void);
 
     private:
-        bool MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event);
+        bool MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, const Event& event);
         void Reset();
         void ProcessTriggers();
         void PushDefaultActions();
-        void PushAgain(ActionNode* actionNode, float relevance, Event event);
+        void PushAgain(ActionNode* actionNode, float relevance, const Event& event);
         ActionNode* CreateActionNode(string name);
         Action* InitializeAction(ActionNode* actionNode);
-        bool ListenAndExecute(Action* action, Event event);
+        bool ListenAndExecute(Action* action, const Event& event);
+        void ClearActionNodeCache();
+        void InitStrategies();
 
     private:
         void LogAction(const char* format, ...);
@@ -146,8 +149,10 @@ namespace ai
         std::list<Multiplier*> multipliers; /**< List of multipliers */
         AiObjectContext* aiObjectContext; /**< AI object context */
         std::map<string, Strategy*> strategies; /**< Map of strategies */
+        std::unordered_map<string, ActionNode*> actionNodeCache; /**< Cache of action nodes by name */
         float lastRelevance; /**< Last relevance value */
         std::string lastAction; /**< Last executed action */
+        bool strategiesDirty; /**< True when strategies changed and ActualInit() is pending */
 
     public:
         bool testMode; /**< Flag for test mode */
diff --git a/src/modules/Bots/playerbot/strategy/Event.h b/src/modules/Bots/playerbot/strategy/Event.h
@@ -62,14 +62,14 @@ namespace ai
          *
          * @return string The source of the event
          */
-        string getSource() { return source; }
+        const string& getSource() { return source; }
 
         /**
          * @brief Get the parameter of the event
          *
          * @return string The parameter of the event
          */
-        string getParam() { return param; }
+        const string& getParam() { return param; }
 
         /**
          * @brief Get the packet associated with the event
diff --git a/src/modules/Bots/playerbot/strategy/NamedObjectContext.h b/src/modules/Bots/playerbot/strategy/NamedObjectContext.h
diff --git a/src/modules/Bots/playerbot/strategy/Queue.cpp b/src/modules/Bots/playerbot/strategy/Queue.cpp

Original file line number	Diff line number	Diff line change
`@@ -12,10 +12,11 @@ Engine::Engine(PlayerbotAI* ai, AiObjectContext *factory) : PlayerbotAIAware(ai)`
`12`	`12`	`{`
`13`	`13`	`lastRelevance = 0.0f;`
`14`	`14`	`testMode = false;`
	`15`	`+ strategiesDirty = false;`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`// Executes actions before the main action`
`18`		`-bool ActionExecutionListeners::Before(Action* action, Event event)`
	`19`	`+bool ActionExecutionListeners::Before(Action* action, const Event& event)`
`19`	`20`	`{`
`20`	`21`	`bool result = true;`
`21`	`22`	`for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)`
`@@ -26,7 +27,7 @@ bool ActionExecutionListeners::Before(Action* action, Event event)`
`26`	`27`	`}`
`27`	`28`
`28`	`29`	`// Executes actions after the main action`
`29`		`-void ActionExecutionListeners::After(Action* action, bool executed, Event event)`
	`30`	`+void ActionExecutionListeners::After(Action* action, bool executed, const Event& event)`
`30`	`31`	`{`
`31`	`32`	`for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)`
`32`	`33`	`{`
`@@ -35,7 +36,7 @@ void ActionExecutionListeners::After(Action* action, bool executed, Event event)`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`// Overrides the result of the action execution`
`38`		`-bool ActionExecutionListeners::OverrideResult(Action* action, bool executed, Event event)`
	`39`	`+bool ActionExecutionListeners::OverrideResult(Action* action, bool executed, const Event& event)`
`39`	`40`	`{`
`40`	`41`	`bool result = executed;`
`41`	`42`	`for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)`
`@@ -46,7 +47,7 @@ bool ActionExecutionListeners::OverrideResult(Action* action, bool executed, Eve`
`46`	`47`	`}`
`47`	`48`
`48`	`49`	`// Checks if the action execution is allowed`
`49`		`-bool ActionExecutionListeners::AllowExecution(Action* action, Event event)`
	`50`	`+bool ActionExecutionListeners::AllowExecution(Action* action, const Event& event)`
`50`	`51`	`{`
`51`	`52`	`bool result = true;`
`52`	`53`	`for (list<ActionExecutionListener*>::iterator i = listeners.begin(); i!=listeners.end(); i++)`
`@@ -71,6 +72,16 @@ Engine::~Engine(void)`
`71`	`72`	`{`
`72`	`73`	`Reset();`
`73`	`74`	`strategies.clear();`
	`75`	`+ ClearActionNodeCache();`
	`76`	`+}`
	`77`	`+`
	`78`	`+void Engine::ClearActionNodeCache()`
	`79`	`+{`
	`80`	`+ for (unordered_map<string, ActionNode*>::iterator i = actionNodeCache.begin(); i != actionNodeCache.end(); i++)`
	`81`	`+ {`
	`82`	`+ delete i->second;`
	`83`	`+ }`
	`84`	`+ actionNodeCache.clear();`
`74`	`85`	`}`
`75`	`86`
`76`	`87`	`// Resets the engine by clearing the action queue, triggers, and multipliers`
`@@ -79,8 +90,7 @@ void Engine::Reset()`
`79`	`90`	`ActionNode* action = NULL;`
`80`	`91`	`do`
`81`	`92`	`{`
`82`		`- action = queue.Pop();`
`83`		`- delete action;`
	`93`	`+ action = queue.Pop(); // popped from queue, remain in cache`
`84`	`94`	`} while (action != NULL);`
`85`	`95`
`86`	`96`	`for (list<TriggerNode*>::iterator i = triggers.begin(); i != triggers.end(); i++)`
`@@ -98,10 +108,18 @@ void Engine::Reset()`
`98`	`108`	`multipliers.clear();`
`99`	`109`	`}`
`100`	`110`
`101`		`-// Initializes the engine by resetting it and initializing strategies`
	`111`	`+// Marks the engine for reinitialization at the next DoNextAction entry`
`102`	`112`	`void Engine::Init()`
	`113`	`+{`
	`114`	`+ strategiesDirty = true;`
	`115`	`+}`
	`116`	`+`
	`117`	`+// Initializes strategies, triggers, multipliers, and default actions`
	`118`	`+void Engine::InitStrategies()`
`103`	`119`	`{`
`104`	`120`	`Reset();`
	`121`	`+ ClearActionNodeCache();`
	`122`	`+ strategiesDirty = false;`
`105`	`123`
`106`	`124`	`for (map<string, Strategy*>::iterator i = strategies.begin(); i != strategies.end(); i++)`
`107`	`125`	`{`
`@@ -132,6 +150,11 @@ bool Engine::DoNextAction(Unit* unit, int depth)`
`132`	`150`	`bool actionExecuted = false;`
`133`	`151`	`ActionBasket* basket = NULL;`
`134`	`152`
	`153`	`+ if (strategiesDirty)`
	`154`	`+ {`
	`155`	`+ InitStrategies();`
	`156`	`+ }`
	`157`	`+`
`135`	`158`	`time_t currentTime = time(0);`
`136`	`159`	`aiObjectContext->Update();`
`137`	`160`	`ProcessTriggers();`
`@@ -188,7 +211,6 @@ bool Engine::DoNextAction(Unit* unit, int depth)`
`188`	`211`	`LogAction("A:%s - OK", action->getName().c_str());`
`189`	`212`	`MultiplyAndPush(actionNode->getContinuers(), 0, false, event);`
`190`	`213`	`lastRelevance = relevance;`
`191`		`- delete actionNode;`
`192`	`214`	`break;`
`193`	`215`	`}`
`194`	`216`	`else`
`@@ -208,7 +230,6 @@ bool Engine::DoNextAction(Unit* unit, int depth)`
`208`	`230`	`lastRelevance = relevance;`
`209`	`231`	`LogAction("A:%s - USELESS", action->getName().c_str());`
`210`	`232`	`}`
`211`		`- delete actionNode;`
`212`	`233`	`}`
`213`	`234`	`}`
`214`	`235`	`while (basket);`
`@@ -240,23 +261,30 @@ bool Engine::DoNextAction(Unit* unit, int depth)`
`240`	`261`	`// Creates an action node based on the action name`
`241`	`262`	`ActionNode* Engine::CreateActionNode(string name)`
`242`	`263`	`{`
	`264`	`+ unordered_map<string, ActionNode*>::iterator cached = actionNodeCache.find(name);`
	`265`	`+ if (cached != actionNodeCache.end())`
	`266`	`+ {`
	`267`	`+ return cached->second;`
	`268`	`+ }`
	`269`	`+`
	`270`	`+ ActionNode* node = NULL;`
`243`	`271`	`for (map<string, Strategy*>::iterator i = strategies.begin(); i != strategies.end(); i++)`
`244`	`272`	`{`
`245`		`- Strategy* strategy = i->second;`
`246`		`- ActionNode* node = strategy->GetAction(name);`
	`273`	`+ node = i->second->GetAction(name);`
`247`	`274`	`if (node)`
`248`		`- {`
`249`		`- return node;`
`250`		`- }`
	`275`	`+ break;`
	`276`	`+ }`
	`277`	`+ if (!node)`
	`278`	`+ {`
	`279`	`+ node = new ActionNode(name, /P/ NULL, /A/ NULL, /C/ NULL);`
`251`	`280`	`}`
`252`		`- return new ActionNode (name,`
`253`		`- /P/ NULL,`
`254`		`- /A/ NULL,`
`255`		`- /C/ NULL);`
	`281`	`+`
	`282`	`+ actionNodeCache[name] = node;`
	`283`	`+ return node;`
`256`	`284`	`}`
`257`	`285`
`258`	`286`	`// Multiplies the relevance of actions and pushes them to the queue`
`259`		`-bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, Event event)`
	`287`	`+bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool skipPrerequisites, const Event& event)`
`260`	`288`	`{`
`261`	`289`	`bool pushed = false;`
`262`	`290`	`if (actions)`
`@@ -281,11 +309,6 @@ bool Engine::MultiplyAndPush(NextAction** actions, float forceRelevance, bool sk`
`281`	`309`	`queue.Push(new ActionBasket(action, k, skipPrerequisites, event));`
`282`	`310`	`pushed = true;`
`283`	`311`	`}`
`284`		`- else`
`285`		`- {`
`286`		`- delete action;`
`287`		`- }`
`288`		`-`
`289`	`312`	`delete nextAction;`
`290`	`313`	`}`
`291`	`314`	`else`
`@@ -317,21 +340,18 @@ ActionResult Engine::ExecuteAction(string &name)`
`317`	`340`
`318`	`341`	`if (!action->isPossible())`
`319`	`342`	`{`
`320`		`- delete actionNode;`
`321`	`343`	`return ACTION_RESULT_IMPOSSIBLE;`
`322`	`344`	`}`
`323`	`345`
`324`	`346`	`if (!action->isUseful())`
`325`	`347`	`{`
`326`		`- delete actionNode;`
`327`	`348`	`return ACTION_RESULT_USELESS;`
`328`	`349`	`}`
`329`	`350`
`330`	`351`	`action->MakeVerbose();`
`331`	`352`	`Event emptyEvent;`
`332`	`353`	`result = ListenAndExecute(action, emptyEvent);`
`333`	`354`	`MultiplyAndPush(action->getContinuers(), 0.0f, false, emptyEvent);`
`334`		`- delete actionNode;`
`335`	`355`	`return result ? ACTION_RESULT_OK : ACTION_RESULT_FAILED;`
`336`	`356`	`}`
`337`	`357`
`@@ -487,13 +507,12 @@ string Engine::ListStrategies()`
`487`	`507`	`}`
`488`	`508`
`489`	`509`	`// Pushes an action node to the queue again`
`490`		`-void Engine::PushAgain(ActionNode* actionNode, float relevance, Event event)`
	`510`	`+void Engine::PushAgain(ActionNode* actionNode, float relevance, const Event& event)`
`491`	`511`	`{`
`492`	`512`	`NextAction** nextAction = new NextAction*[2];`
`493`	`513`	`nextAction[0] = new NextAction(actionNode->getName(), relevance);`
`494`	`514`	`nextAction[1] = NULL;`
`495`	`515`	`MultiplyAndPush(nextAction, relevance, true, event);`
`496`		`- delete actionNode;`
`497`	`516`	`}`
`498`	`517`
`499`	`518`	`// Checks if the engine contains a specific strategy type`
`@@ -523,7 +542,7 @@ Action* Engine::InitializeAction(ActionNode* actionNode)`
`523`	`542`	`}`
`524`	`543`
`525`	`544`	`// Listens and executes an action`
`526`		`-bool Engine::ListenAndExecute(Action* action, Event event)`
	`545`	`+bool Engine::ListenAndExecute(Action* action, const Event& event)`
`527`	`546`	`{`
`528`	`547`	`bool actionExecuted = false;`
`529`	`548`