Ticket #3899: patch.diff

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

@@ -139 +139 @@
  */
 ProductionQueue.prototype.GetTechnologiesList = function()
 {
     if (!this.template.Technologies)
         return [];
-    
+
     var string = this.template.Technologies._string;
     if (!string)
         return [];
-    
+
     var cmpTechnologyManager = QueryOwnerInterface(this.entity, IID_TechnologyManager);
     if (!cmpTechnologyManager)
         return [];
     
     var cmpPlayer = QueryOwnerInterface(this.entity);
     var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
     if (!cmpPlayer || !cmpIdentity)
         return [];
 
     var techs = string.split(/\s+/);
+
+    // Remove any technologies that can't be searched by this civ (after capture for example)
+    if (cmpIdentity.GetCiv() != cmpPlayer.GetCiv())
+    {
+        let  techList = [];
+        for (let tech of techs)
+        {
+            let reqs = cmpTechnologyManager.GetTechnologyTemplate(tech).requirements || null;
+            if (cmpTechnologyManager.CheckTechnologyRequirements(reqs, true))
+                techList.push(tech);
+        }
+    techs = techList;
+    }
+
     var techList = [];
     var superseded = {}; // Stores the tech which supersedes the key
 
     var disabledTechnologies = cmpPlayer.GetDisabledTechnologies();
-    
+
     // Add any top level technologies to an array which corresponds to the displayed icons
     // Also store what a technology is superceded by in the superceded object {"tech1":"techWhichSupercedesTech1", ...}
     for (var i in techs)
     {
         var tech = techs[i];
@@ -172 +186 @@
         if (!template.supersedes || techs.indexOf(template.supersedes) === -1)
             techList.push(tech);
         else
             superseded[template.supersedes] = tech;
     }
-    
+
     // Now make researched/in progress techs invisible
     for (var i in techList)
     {
         var tech = techList[i];
         while (this.IsTechnologyResearchedOrInProgress(tech))
@@ -184 +198 @@
             tech = superseded[tech];
         }
         
         techList[i] = tech;
     }
-    
+
     var ret = [];
-    
+
     // This inserts the techs into the correct positions to line up the technology pairs
     for (var i = 0; i < techList.length; i++)
     {
         var tech = techList[i];
         if (!tech)
         {
             ret[i] = undefined;
             continue;
         }
-        
+
         var template = cmpTechnologyManager.GetTechnologyTemplate(tech);
         if (template.top)
             ret[i] = {"pair": true, "top": template.top, "bottom": template.bottom};
         else
             ret[i] = tech;
     }
-    
+
     return ret;
 };
 
 ProductionQueue.prototype.IsTechnologyResearchedOrInProgress = function(tech)
 {

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

@@ -83 +83 @@
     var cmpTempManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
     var template = cmpTempManager.GetTemplate(templateName);
 
     if (template.Identity && template.Identity.RequiredTechnology)
         return this.IsTechnologyResearched(template.Identity.RequiredTechnology);
-    else
-        return true; // If there is no required technology then this entity can be produced
+    // If there is no required technology then this entity can be produced
+    return true;
 };
 
 TechnologyManager.prototype.IsTechnologyResearched = function(tech)
 {
     return (this.researchedTechs[tech] !== undefined);
@@ -123 +123 @@
 
     return this.CheckTechnologyRequirements(template.requirements || null);
 };
 
 // Private function for checking a set of requirements is met
-TechnologyManager.prototype.CheckTechnologyRequirements = function(reqs)
+TechnologyManager.prototype.CheckTechnologyRequirements = function(reqs, civonly)
 {
     // If there are no requirements then all requirements are met
     if (!reqs)
         return true;
 
-    if (reqs.tech)
-    {
-        return this.IsTechnologyResearched(reqs.tech);
-    }
-    else if (reqs.all)
+    if (reqs.all)
     {
         for (var i = 0; i < reqs.all.length; i++)
         {
-            if (!this.CheckTechnologyRequirements(reqs.all[i]))
+            if (!this.CheckTechnologyRequirements(reqs.all[i]), civonly)
                 return false;
         }
         return true;
     }
     else if (reqs.any)
     {
         for (var i = 0; i < reqs.any.length; i++)
         {
-            if (this.CheckTechnologyRequirements(reqs.any[i]))
+            if (this.CheckTechnologyRequirements(reqs.any[i]), civonly)
                 return true;
         }
         return false;
     }
+    else if (reqs.civ)
+    {
+        let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
+        return cmpPlayer && cmpPlayer.GetCiv() == reqs.civ;
+    }
+    else if (reqs.notciv)
+    {
+        let cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
+        return (cmpPlayer && cmpPlayer.GetCiv() == reqs.notciv);
+    }
+    else if (civonly)
+        return true;
+    else if (reqs.tech)
+        return this.IsTechnologyResearched(reqs.tech);
     else if (reqs.class)
     {
         if (reqs.numberOfTypes)
         {
             if (this.typeCountsByClass[reqs.class])
                 return (reqs.numberOfTypes <= Object.keys(this.typeCountsByClass[reqs.class]).length);
-            else
-                return false;
+            return false;
         }
         else if (reqs.number)
         {
             if (this.classCounts[reqs.class])
                 return (reqs.number <= this.classCounts[reqs.class]);
-            else
-                return false;
-        }
-    }
-    else if (reqs.civ)
-    {
-        var cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
-        if (cmpPlayer && cmpPlayer.GetCiv() == reqs.civ)
-            return true;
-        else 
             return false;
+        }
     }
-    else if (reqs.notciv)
-    {
-        var cmpPlayer = Engine.QueryInterface(this.entity, IID_Player);
-        if (cmpPlayer && cmpPlayer.GetCiv() == reqs.notciv)
-            return false;
-        else
-            return true;
-    }
-
     // The technologies requirements are not a recognised format
     error("Bad requirements " + uneval(reqs));
     return false;
 };