Ticket #4405: dynamic_noaiProxy.patch

binaries/data/mods/public/simulation/helpers/InitGame.js

@@ -76 +76 @@
     cmpAIManager.SetRNGSeed(seed);
     cmpAIManager.TryLoadSharedComponent();
     cmpAIManager.RunGamestateInit();
+
+    // If there are no AIs in the game, don't bother sending message to AIProxy, which takes a few ms per turn in MP games sometimes.
+    if (!cmpAIManager.HasActiveAIs())
+        Engine.SkipComponent("AIProxy");
 }
 
 Engine.RegisterGlobal("PreInitGame", PreInitGame);

source/simulation2/components/CCmpAIManager.cpp

@@ -1159 +1159 @@
         }
     }
 
+    virtual bool HasActiveAIs()
+    {
+        return m_Worker.getPlayerSize() > 0;
+    }
+
 private:
     std::vector<std::string> m_TemplateNames;
     size_t m_TemplateLoadedIdx;

source/simulation2/components/ICmpAIManager.cpp

@@ -29 +29 @@
 DEFINE_INTERFACE_METHOD_1("SetRNGSeed", void, ICmpAIManager, SetRNGSeed, uint32_t)
 DEFINE_INTERFACE_METHOD_0("TryLoadSharedComponent", void, ICmpAIManager, TryLoadSharedComponent)
 DEFINE_INTERFACE_METHOD_0("RunGamestateInit", void, ICmpAIManager, RunGamestateInit)
+DEFINE_INTERFACE_METHOD_0("HasActiveAIs", bool, ICmpAIManager, HasActiveAIs)
 END_INTERFACE_WRAPPER(AIManager)
 
 // Implement the static method that finds all AI scripts

source/simulation2/components/ICmpAIManager.h

@@ -48 +48 @@
     virtual void PushCommands() = 0;
 
     /**
+     * Returns true if there are currently any AI registered with the AiManager
+     */
+    virtual bool HasActiveAIs() = 0;
+
+    /**
      * Returns a vector of {"id":"value-for-AddPlayer", "name":"Human readable name"}
      * objects, based on all the available AI scripts.
      */

source/simulation2/system/ComponentManager.cpp

@@ -26 +26 @@
 
 #include "simulation2/MessageTypes.h"
 #include "simulation2/components/ICmpTemplateManager.h"
+#include "simulation2/components/ICmpAiManager.h"
 
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
@@ -74 +75 @@
         m_ScriptInterface.RegisterFunction<void, std::string, CComponentManager::Script_RegisterInterface> ("RegisterInterface");
         m_ScriptInterface.RegisterFunction<void, std::string, CComponentManager::Script_RegisterMessageType> ("RegisterMessageType");
         m_ScriptInterface.RegisterFunction<void, std::string, JS::HandleValue, CComponentManager::Script_RegisterGlobal> ("RegisterGlobal");
+        m_ScriptInterface.RegisterFunction<void, std::string, CComponentManager::Script_SkipComponent> ("SkipComponent");
         m_ScriptInterface.RegisterFunction<IComponent*, int, int, CComponentManager::Script_QueryInterface> ("QueryInterface");
         m_ScriptInterface.RegisterFunction<std::vector<int>, int, CComponentManager::Script_GetEntitiesWithInterface> ("GetEntitiesWithInterface");
         m_ScriptInterface.RegisterFunction<std::vector<IComponent*>, int, CComponentManager::Script_GetComponentsWithInterface> ("GetComponentsWithInterface");
@@ -359 +361 @@
     componentManager->m_ScriptInterface.SetGlobal(("IID_" + name).c_str(), (int)id);
 }
 
+void CComponentManager::Script_SkipComponent(ScriptInterface::CxPrivate* pCxPrivate, const std::string& cname)
+{
+    CComponentManager* componentManager = static_cast<CComponentManager*> (pCxPrivate->pCBData);
+    ComponentTypeId cid = componentManager->LookupCID(cname);
+    if (cid == CID__Invalid)
+    {
+        std::string msg("Trying to skip invalid component " + cname);
+        componentManager->m_ScriptInterface.ReportError(msg.c_str());
+        return;
+    }
+    componentManager->SkipComponent(cid);
+}
+
 void CComponentManager::Script_RegisterMessageType(ScriptInterface::CxPrivate* pCxPrivate, const std::string& name)
 {
     CComponentManager* componentManager = static_cast<CComponentManager*> (pCxPrivate->pCBData);
@@ -543 +558 @@
     m_RNG.seed(seed);
 }
 
+void CComponentManager::SkipComponent(const ComponentTypeId& ID)
+{
+    // unsubscribe the component from all messages, effectively this is similar to removing it altogether.
+    for (auto& messageType : m_LocalMessageSubscriptions)
+    {
+        std::vector<ComponentTypeId>::iterator component = std::find(messageType.second.begin(),messageType.second.end(), ID);
+        if (component != messageType.second.end())
+        {
+            // pop and swap, I do not believe we actually care about the order here.
+            std::swap(*component, messageType.second.back());
+            messageType.second.pop_back();
+        }
+    }
+}
+
+
 void CComponentManager::RegisterComponentType(InterfaceId iid, ComponentTypeId cid, AllocFunc alloc, DeallocFunc dealloc,
         const char* name, const std::string& schema)
 {
@@ -874 +905 @@
             continue;
 
         CComponentManager::ComponentTypeId cid = LookupCID(it->first);
+
         if (cid == CID__Invalid)
         {
             LOGERROR("Unrecognised component type name '%s' in entity template '%s'", it->first, utf8_from_wstring(templateName));

source/simulation2/system/ComponentManager.h

@@ -301 +301 @@
      */
     void SetRNGSeed(u32 seed);
 
+    /**
+     * Tells the Component Manager to remove all subscriptions of a given component type,
+     * effectively making it similar to altogether removing that component (but in a less intrusive way).
+     * This is called in public mod for AIProxy in player-only games.
+     * Since AIProxy can end up taking several ms (>3/4) per turn doing nothing useful otherwise
+     */
+    void SkipComponent(const ComponentTypeId& ID);
+
     // Various state serialization functions:
     bool ComputeStateHash(std::string& outHash, bool quick);
     bool DumpDebugState(std::ostream& stream, bool includeDebugInfo);
@@ -322 +330 @@
     static void Script_RegisterInterface(ScriptInterface::CxPrivate* pCxPrivate, const std::string& name);
     static void Script_RegisterMessageType(ScriptInterface::CxPrivate* pCxPrivate, const std::string& name);
     static void Script_RegisterGlobal(ScriptInterface::CxPrivate* pCxPrivate, const std::string& name, JS::HandleValue value);
+    static void Script_SkipComponent(ScriptInterface::CxPrivate* pCxPrivate, const std::string& cname);
     static IComponent* Script_QueryInterface(ScriptInterface::CxPrivate* pCxPrivate, int ent, int iid);
     static std::vector<int> Script_GetEntitiesWithInterface(ScriptInterface::CxPrivate* pCxPrivate, int iid);
     static std::vector<IComponent*> Script_GetComponentsWithInterface(ScriptInterface::CxPrivate* pCxPrivate, int iid);
@@ -385 +394 @@
 
     boost::rand48 m_RNG;
 
+    bool m_SkipAiProxy = false;
+
     friend class TestComponentManager;
 };