Ticket #4239: serialization-fix.patch

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

@@ -6 +6 @@
     "</attribute>" +
     "<text a:help='A whitespace-separated list of aura files, placed under simulation/data/auras/'/>";
 
+Auras.prototype.Serialize = function()
+{
+    let ret = {};
+    for (let key in this)
+    {
+        if (!this.hasOwnProperty(key))
+            continue;
+
+        // Don't serialize the templates themselves
+        if (key == "auras")
+            continue;
+
+        ret[key] = this[key];
+    }
+
+    return ret;
+};
+
+Auras.prototype.Deserialize = function(data)
+{
+    for (let key in data)
+        if (data.hasOwnProperty(key))
+            this[key] = data[key];
+
+    // Reload aura templates from the disk
+    this.auras = {};
+    let cmpDataTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager);
+    for (let name of this.GetAuraNames())
+        this.auras[name] = cmpDataTemplateManager.GetAuraTemplate(name);
+};
+
 Auras.prototype.Init = function()
 {
     let cmpDataTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager);
     this.auras = {};
     this.affectedPlayers = {};
-    let auraNames = this.GetAuraNames();
-    for (let name of auraNames)
+    for (let name of this.GetAuraNames())
     {
         this.affectedPlayers[name] = [];
         this.auras[name] = cmpDataTemplateManager.GetAuraTemplate(name);

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

@@ -15 +15 @@
         this.GetTechnologyTemplate(techNames[i]);
 };
 
+DataTemplateManager.prototype.Serialize = null; // we have no dynamic state to save
+
+DataTemplateManager.prototype.Deserialize = function()
+{
+    this.Init();
+};
+
 DataTemplateManager.prototype.GetTechnologyTemplate = function(template)
 {
     if (!this.allTechs[template])

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

@@ -5 +5 @@
 
 TechnologyManager.prototype.Serialize = function()
 {
-    // The modifications cache will be affected by property reads from the GUI and other places so we shouldn't 
-    // serialize it.
+    let ret = {};
 
-    var ret = {};
-    for (var i in this)
+    for (let key in this)
     {
-        if (this.hasOwnProperty(i))
-            ret[i] = this[i];
+        if (!this.hasOwnProperty(key))
+            continue;
+
+        // The modifications cache will be affected by property reads from the GUI and
+        // other places so we shouldn't serialize it.
+        if (key == "modificationCache")
+            continue;
+
+        // Only serialize the template name of researched technologies, to avoid serialization issues.
+        if (key == "researchedTechs")
+        {
+            ret[key] = [];
+            for (let templateName in this[key])
+                ret[key].push(templateName);
+            continue;
+        }
+
+        ret[key] = this[key];
     }
-    ret.modificationCache = {};
+
     return ret;
 };
 
+TechnologyManager.prototype.Deserialize = function(data)
+{
+    for (let key in data)
+    {
+        if (!data.hasOwnProperty(key))
+            continue;
+
+        if (key == "researchedTechs")
+        {
+            this[key] = {};
+            for (let templateName of data[key])
+                this[key][templateName] = this.GetTechnologyTemplate(templateName);
+            continue;
+        }
+
+        this[key] = data[key];
+    }
+
+    this.modificationCache = {};
+};
+
 TechnologyManager.prototype.Init = function()
 {
     this.researchedTechs = {}; // technologies which have been researched
@@ -40 +75 @@
 
     // Some technologies are automatically researched when their conditions are met.  They have no cost and are 
     // researched instantly.  This allows civ bonuses and more complicated technologies.
-    this.autoResearchTech = {};
-    var allTechs = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager).GetAllTechs();
-    for (var key in allTechs)
+    this.autoResearchTech = [];
+    let allTechs = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager).GetAllTechs();
+    for (let key in allTechs)
     {
         if (allTechs[key].autoResearch || allTechs[key].top)
-            this.autoResearchTech[key] = allTechs[key];
+            this.autoResearchTech.push(key);
     }
 };
 
@@ -58 +93 @@
 // This function checks if the requirements of any autoresearch techs are met and if they are it researches them
 TechnologyManager.prototype.UpdateAutoResearch = function()
 {
-    var cmpDataTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager);
-    for (var key in this.autoResearchTech)
+    let cmpDataTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_DataTemplateManager);
+    for (let i in this.autoResearchTech)
     {
-        var tech = cmpDataTempMan.GetTechnologyTemplate(key);
-        if ((tech.autoResearch && this.CanResearch(key))
+        let template = this.autoResearchTech[i];
+        let tech = cmpDataTempMan.GetTechnologyTemplate(template);
+        if ((tech.autoResearch && this.CanResearch(template))
             || (tech.top && (this.IsTechnologyResearched(tech.top) || this.IsTechnologyResearched(tech.bottom))))
         {
-            delete this.autoResearchTech[key];
-            this.ResearchTechnology(key);
+            // Remove the technology from the autoresearch list and research it
+            this.autoResearchTech.splice(i, 1);
+            this.ResearchTechnology(template);
             return; // We will have recursively handled any knock-on effects so can just return
         }
     }