Ticket #1521: technology-queue.patch

binaries/data/mods/public/gui/session/unit_commands.js

@@ -505 +505 @@
                 grayscale = "grayscale:";
             }
             
-            if (guiName == RESEARCH && !Engine.GuiInterfaceCall("CheckTechnologyRequirements", entType))
+            if (guiName == RESEARCH && !Engine.GuiInterfaceCall("CheckTechnologyRequirements", { "tech": entType, "researcher": unitEntState.id }))
             {
                 button.enabled = false;
                 button.tooltip += "\n" + GetTechnologyData(entType).requirementsTooltip;
@@ -520 +520 @@
                 {
                     grayscale = "";
                     button1.enabled = true;
-                    if (guiName == RESEARCH && !Engine.GuiInterfaceCall("CheckTechnologyRequirements", entType1))
+                    if (guiName == RESEARCH && !Engine.GuiInterfaceCall("CheckTechnologyRequirements", { "tech": entType1, "researcher": unitEntState.id }))
                     {
                         button1.enabled = false;
                         button1.tooltip += "\n" + GetTechnologyData(entType1).requirementsTooltip;

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

@@ -521 +521 @@
 };
 
 // Checks whether the requirements for this technology have been met
-GuiInterface.prototype.CheckTechnologyRequirements = function(player, tech)
+GuiInterface.prototype.CheckTechnologyRequirements = function(player, data)
 {
     var cmpTechnologyManager = QueryPlayerIDInterface(player, IID_TechnologyManager);
     
     if (!cmpTechnologyManager)
         return false;
     
-    return cmpTechnologyManager.CanResearch(tech);
+    return cmpTechnologyManager.CanResearch(data.tech, data.researcher);
 };
 
 GuiInterface.prototype.PushNotification = function(notification)

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

@@ -233 +233 @@
             // Tell the technology manager that we have started researching this so that people can't research the same 
             // thing twice.
             var cmpTechMan = QueryOwnerInterface(this.entity, IID_TechnologyManager);
-            cmpTechMan.StartedResearch(templateName);
+            cmpTechMan.StartedResearch(templateName, this.entity);
 
             this.queue.push({
                 "id": this.nextID++,
@@ -306 +306 @@
         // Mark the research as stopped if we cancel it
         if (item.technologyTemplate)
         {
-            var cmpTechMan = QueryOwnerInterface(this.entity, IID_TechnologyManager);
+            // item.player is used as this.entity's owner may be invalid (deletion, etc.)
+            var cmpTechMan = QueryPlayerIDInterface(item.player, IID_TechnologyManager);
+            var template = cmpTechMan.GetTechnologyTemplate(item.technologyTemplate);
+            var removed = item.technologyTemplate;
+            if (template.pair)
+                removed = template.pair;
+
+            // Recurse to remove any technologies that supersede this one.
+            for (var j = i; j < this.queue.length; ++j)
+            {
+                if (!this.queue[j].technologyTemplate)
+                    continue;
+
+                var queued = cmpTechMan.GetTechnologyTemplate(this.queue[j].technologyTemplate);
+                if (!queued.supersedes && queued.pair)
+                    queued = cmpTechMan.GetTechnologyTemplate(queued.pair);
+
+                if (queued.supersedes == removed)
+                    this.RemoveBatch(this.queue[j--].id);
+            }
             cmpTechMan.StoppedResearch(item.technologyTemplate);
         }
         

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

@@ -90 +90 @@
 };
 
 // Checks the requirements for a technology to see if it can be researched at the current time
-TechnologyManager.prototype.CanResearch = function (tech)
+TechnologyManager.prototype.CanResearch = function (tech, researcher)
 {
     var template = this.GetTechnologyTemplate(tech);
     if (!template)
@@ -98 +98 @@
         warn("Technology \"" + tech + "\" does not exist");
         return false;
     }
-    
-    // The technology which this technology supersedes is required
+
+    // A technology can be researched if a technology that it supersedes
+    // is already being researched at the same building.
     if (template.supersedes && !this.IsTechnologyResearched(template.supersedes))
+    {
+        if (!researcher)
+            return false;
+
+        var oldtech = this.GetTechnologyTemplate(template.supersedes);
+
+        // Pairs are handled specially, as it's their members that are
+        // researched, not the actual pairs themselves.
+        if (oldtech.top)
+        {
+            if ((this.GetResearcher(oldtech.top) || this.GetResearcher(oldtech.bottom)) != researcher)
+            return false;
+        }
+        else if (this.GetResearcher(template.supersedes) != researcher)
+            return false;
+    }
+    if (template.pair && !this.CanResearch(template.pair, researcher))
         return false;
     
-    if (template.pair && !this.CanResearch(template.pair))
-        return false;
-    
     return this.CheckTechnologyRequirements(template.requirements);
 };
 
@@ -326 +341 @@
 }
 
 // Marks a technology as being currently researched
-TechnologyManager.prototype.StartedResearch = function (tech)
+TechnologyManager.prototype.StartedResearch = function (tech, researcher)
 {
-    this.inProgressTechs[tech] = true;
+    this.inProgressTechs[tech] = researcher;
 };
 
 // Marks a technology as not being currently researched
@@ -346 +361 @@
         return false;
 };
 
+// Gets the entity currently researching a technology
+TechnologyManager.prototype.GetResearcher = function(tech)
+{
+    if (this.inProgressTechs[tech])
+        return this.inProgressTechs[tech];
+    return undefined;
+};
+
 // Get helper data for tech modifications
 TechnologyManager.prototype.GetTechModifications = function()
 {