Ticket #3834: smallerOOSlog.diff

binaries/data/mods/public/simulation/components/AIInterface.js

@@ -48 +48 @@
             continue;
         if (typeof this[key] == "function")
             continue;
+        if (key == "templates")
+            continue;
         state[key] = this[key];
     }
     return state;

source/simulation2/components/CCmpRangeManager.cpp

@@ -415 +415 @@
 
         serialize.Bool("global visibility update", m_GlobalVisibilityUpdate);
         SerializeVector<SerializeU8_Unbounded>()(serialize, "global player visibility update", m_GlobalPlayerVisibilityUpdate);
-        SerializeVector<SerializeU16_Unbounded>()(serialize, "dirty visibility", m_DirtyVisibility);
+        SerializeRepetitiveVector<SerializeU16_Unbounded>()(serialize, "dirty visibility", m_DirtyVisibility);
         SerializeVector<SerializeU32_Unbounded>()(serialize, "modified entities", m_ModifiedEntities);
 
         // We don't serialize m_Subdivision, m_LosPlayerCounts or m_LosTiles
@@ -422 +422 @@
         // since they can be recomputed from the entity data when deserializing;
         // m_LosState must be serialized since it depends on the history of exploration
 
-        SerializeVector<SerializeU32_Unbounded>()(serialize, "los state", m_LosState);
+        SerializeRepetitiveVector<SerializeU32_Unbounded>()(serialize, "los state", m_LosState);
         SerializeVector<SerializeU32_Unbounded>()(serialize, "shared los masks", m_SharedLosMasks);
         SerializeVector<SerializeU16_Unbounded>()(serialize, "shared dirty visibility masks", m_SharedDirtyVisibilityMasks);
     }

source/simulation2/components/CCmpTemplateManager.cpp

@@ -68 +68 @@
         }
         serialize.NumberU32_Unbounded("num entities", (u32)count);
 
-        for (std::map<entity_id_t, std::string>::const_iterator it = m_LatestTemplates.begin(); it != m_LatestTemplates.end(); ++it)
+        count = 1;
+        u32 prevId = m_LatestTemplates.begin()->first;
+        CStr prevTemplate = m_LatestTemplates.begin()->second;
+        for (std::map<entity_id_t, std::string>::const_iterator it = ++m_LatestTemplates.begin(); it != m_LatestTemplates.end(); ++it)
         {
             if (ENTITY_IS_LOCAL(it->first))
                 continue;
-            serialize.NumberU32_Unbounded("id", it->first);
-            serialize.StringASCII("template", it->second, 0, 256);
+            if (prevId + 1 == it->first && prevTemplate == it->second)
+            {
+                count++;
+                prevId = it->first;
+                continue;
+            }
+            serialize.NumberU32_Unbounded("id", prevId - count + 1);
+            serialize.NumberU32_Unbounded("#", count);
+            serialize.StringASCII("template", prevTemplate, 0, 256);
+            prevId = it->first;
+            prevTemplate = it->second;
+            count = 1;
         }
-        // TODO: maybe we should do some kind of interning thing instead of printing so many strings?
-
-        // TODO: will need to serialize techs too, because we need to be giving out
-        // template data before other components (like the tech components) have been deserialized
+        serialize.NumberU32_Unbounded("id", prevId + 1 - count);
+        serialize.NumberU32_Unbounded("#", count);
+        serialize.StringASCII("template", prevTemplate, 0, 256);
     }
 
     virtual void Deserialize(const CParamNode& paramNode, IDeserializer& deserialize)
@@ -87 +99 @@
 
         u32 numEntities;
         deserialize.NumberU32_Unbounded("num entities", numEntities);
-        for (u32 i = 0; i < numEntities; ++i)
+        for (u32 i = 0; i < numEntities;)
         {
             entity_id_t ent;
+            u32 count;
             std::string templateName;
             deserialize.NumberU32_Unbounded("id", ent);
+            deserialize.NumberU32_Unbounded("#", count);
             deserialize.StringASCII("template", templateName, 0, 256);
-            m_LatestTemplates[ent] = templateName;
+            i += count;
+            for (; count > 0; --count)
+                m_LatestTemplates[ent++] = templateName;    
         }
     }
 

source/simulation2/serialization/SerializeTemplates.h

@@ -24 +24 @@
  */
 
 #include "simulation2/components/ICmpPathfinder.h"
+#include <type_traits>
 
 template<typename ELEM>
 struct SerializeVector
@@ -53 +54 @@
     }
 };
 
+template<typename ELEM>
+struct SerializeRepetitiveVector
+{
+    template<typename T>
+    void operator()(ISerializer& serialize, const char* name, std::vector<T>& value)
+    {
+        size_t len = value.size();
+        serialize.NumberU32_Unbounded("length", (u32)len);
+        if (len == 0)
+            return;
+        u32 count = 1;
+        T prevVal = value[0];
+        for (size_t i = 1; i < len; ++i)
+        {
+            if (prevVal == value[i])
+            {
+                count++;
+                continue;
+            }
+            serialize.NumberU32_Unbounded("#", count);
+            ELEM()(serialize, name, prevVal);
+            count = 1;
+            prevVal = value[i];
+        }
+        serialize.NumberU32_Unbounded("#", count);
+        ELEM()(serialize, name, prevVal);
+    }
+
+    template<typename T>
+    void operator()(IDeserializer& deserialize, const char* name, std::vector<T>& value)
+    {
+        value.clear();
+        u32 len;
+        deserialize.NumberU32_Unbounded("length", len);
+        value.reserve(len); // TODO: watch out for out-of-memory
+        for (size_t i = 0; i < len;)
+        {
+            u32 count;
+            deserialize.NumberU32_Unbounded("#", count);
+            T el;
+            ELEM()(deserialize, name, el);
+            i += count;
+            for (; count > 0; --count)
+                value.push_back(el);
+        }
+    }
+};
+
 template<typename KS, typename VS>
 struct SerializeMap
 {