Ticket #4405: noAiProxy-serialized.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.DeafenComponent("AIProxy");
 }
 
 Engine.RegisterGlobal("PreInitGame", PreInitGame);

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

@@ -168 +168 @@
         }
 
     // Disable the AIIinterface when no AI players are present
-    if (playerData && !playerData.some(v => v && !!v.AI))
+    if (!Engine.HasActiveAIs())
         Engine.QueryInterface(SYSTEM_ENTITY, IID_AIInterface).Disable();
 }
 

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_DeafenComponent> ("DeafenComponent");
         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_DeafenComponent(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 deafen invalid component " + cname);
+        componentManager->m_ScriptInterface.ReportError(msg.c_str());
+        return;
+    }
+    componentManager->DeafenComponent(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::DeafenComponent(const ComponentTypeId& ID)
+{
+    m_DeafenedComponents.insert(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 +907 @@
             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 DeafenComponent(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_DeafenComponent(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);
@@ -374 +383 @@
 
     std::map<entity_id_t, SEntityComponentCache*> m_ComponentCaches;
 
+    std::set<ComponentTypeId> m_DeafenedComponents;
+
     // TODO: maintaining both ComponentsBy* is nasty; can we get rid of one,
     // while keeping QueryInterface and PostMessage sufficiently efficient?
 

source/simulation2/system/ComponentManagerSerialization.cpp

@@ -27 +27 @@
 #include "simulation2/serialization/HashSerializer.h"
 #include "simulation2/serialization/StdSerializer.h"
 #include "simulation2/serialization/StdDeserializer.h"
+#include "simulation2/serialization/StdDeserializer.h"
+#include "simulation2/serialization/SerializeTemplates.h"
 
 #include "simulation2/components/ICmpTemplateManager.h"
 
@@ -167 +169 @@
  *   For each entity:
  *     Entity id.
  *     Component state.
+ * Deafened components (by cid)
  *
  * Rationale:
  * Saved games should be valid across patches, which might change component
@@ -289 +292 @@
         }
     }
 
+    // deafened components
+    serializer.NumberU32_Unbounded("num deafened components", (uint32_t)m_DeafenedComponents.size());
+    for (ComponentTypeId cid : m_DeafenedComponents)
+        serializer.NumberU32_Unbounded("cid", cid);
+
     // TODO: catch exceptions
     return true;
 }
@@ -377 +385 @@
             }
         }
 
+        // deafened components
+        m_DeafenedComponents.clear();
+        uint32_t numDeafenedComponents;
+        deserializer.NumberU32_Unbounded("num deafened components", numDeafenedComponents);
+        for (size_t j = 0; j < numDeafenedComponents; ++j)
+        {
+            uint32_t cid;
+            deserializer.NumberU32_Unbounded("cid", cid);
+            DeafenComponent((ComponentTypeId)cid);
+        }
+
         if (stream.peek() != EOF)
         {
             LOGERROR("Deserialization didn't reach EOF");