Ticket #4003: t4003-part1.patch

binaries/data/mods/public/simulation/ai/common-api/entity.js

@@ -103 +103 @@
         return this.get("Identity/Civ");
     },
 
-    cost: function() {
+    "cost": function(productionQueue) {
         if (!this.get("Cost"))
             return undefined;
 
         let ret = {};
+        let typeCost;
         for (let type in this.get("Cost/Resources"))
-            ret[type] = +this.get("Cost/Resources/" + type);
+        {
+            typeCost = +this.get("Cost/Resources/" + type);
+            if (productionQueue)
+                typeCost *= productionQueue.techCostMultiplier(type);
+            ret[type] = typeCost;
+        }
         return ret;
     },
 
-    costSum: function() {
-        if (!this.get("Cost"))
+    "costSum": function(productionQueue) {
+        let cost = this.cost(productionQueue);
+        if (!cost)
             return undefined;
-
         let ret = 0;
-        for (let type in this.get("Cost/Resources"))
-            ret += +this.get("Cost/Resources/" + type);
+        for (let type in cost)
+            ret += cost[type];
         return ret;
     },
 
+    "techCostMultiplier": function(type) {
+        return +(this.get("ProductionQueue/TechCostMultiplier/"+type) || 1);
+    },
+
     /**
      * Returns the radius of a circle surrounding this entity's
      * obstruction shape, or undefined if no obstruction.
@@ -462 +472 @@
         return this.get("BuildRestrictions/Category");
     },
 
-    buildTime: function() {
-        return +this.get("Cost/BuildTime");
+    "buildTime": function(productionQueue) {
+        let time = +this.get("Cost/BuildTime");
+        if (productionQueue)
+            time *= productionQueue.techCostMultiplier("time");
+        return time;
     },
 
     buildDistance: function() {

binaries/data/mods/public/simulation/ai/common-api/gamestate.js

@@ -693 +693 @@
 };
 
 /**
- * Find buildings that are capable of training that template.
+ * Return true if we have a building able to train that template
  */
+m.GameState.prototype.hasTrainer = function(template)
+{   
+    let civ = this.playerData.civ;
+    for (let ent of this.getOwnTrainingFacilities().values())
+    {
+        let trainable = ent.trainableEntities(civ);
+        if (trainable && trainable.indexOf(template) !== -1)
+            return true;
+    }
+    return false;
+};
+
+/**
+ * Find buildings able to train that template.
+ */
 m.GameState.prototype.findTrainers = function(template)
 {   
     let civ = this.playerData.civ;
     return this.getOwnTrainingFacilities().filter(function(ent) {
         let trainable = ent.trainableEntities(civ);
-        return trainable && trainable.indexOf(template) != -1;
+        return trainable && trainable.indexOf(template) !== -1;
     });
 };
 
@@ -718 +733 @@
     return undefined;
 };
 
-/** Return true if one of the buildings is capable of researching the given tech */
+/** Return true if one of our buildings is capable of researching the given tech */
 m.GameState.prototype.hasResearchers = function(templateName, noRequirementCheck)
 {
     // let's check we can research the tech.
@@ -752 +767 @@
 {
     // let's check we can research the tech.
     if (!this.canResearch(templateName, noRequirementCheck))
-        return [];
+        return undefined;
 
     let self = this;
     let civ = this.playerData.civ;

binaries/data/mods/public/simulation/ai/common-api/technology.js

@@ -65 +65 @@
     return this._pairedWith;
 };
 
-m.Technology.prototype.cost = function()
+m.Technology.prototype.cost = function(productionQueue)
 {
     if (!this._template.cost)
         return undefined;
-    return this._template.cost;
+    let cost = {};
+    for (let type in this._template.cost)
+    {
+        cost[type] = +this._template.cost[type];
+        if (productionQueue)
+            cost[type] *= productionQueue.techCostMultiplier(type);
+    }
+    return cost;
 };
 
+m.Technology.prototype.costSum = function(productionQueue)
+{
+    let cost = this.cost(productionQueue);
+    if (!cost)
+        return undefined;
+    let ret = 0;
+    for (let type in cost)
+        ret += cost[type];
+    return ret;
+};
+
 // seconds
 m.Technology.prototype.researchTime = function()
 {

binaries/data/mods/public/simulation/ai/petra/queueManager.js

@@ -355 +355 @@
             let item = queue.getNext();
             if (this.accounts[name].canAfford(item.getCost()) && item.canStart(gameState))
             {
-                this.finishingTime = gameState.ai.elapsedTime;
-                this.accounts[name].subtract(item.getCost());
-                queue.startNext(gameState);
-                queue.switched = 0;
+                // canStart may update the cost because of the costMultiplier so we must check it again
+                if (this.accounts[name].canAfford(item.getCost()))
+                {
+                    this.finishingTime = gameState.ai.elapsedTime;
+                    this.accounts[name].subtract(item.getCost());
+                    queue.startNext(gameState);
+                    queue.switched = 0;
+                }
             }
         }
         else if (!queue.hasQueuedUnits())

binaries/data/mods/public/simulation/ai/petra/queueplan.js

@@ -12 +12 @@
     this.template = gameState.getTemplate(this.type);
     if (!this.template)
     {
-        API3.warn("Tried to add the inexisting template " + this.type + " to Petra. Please report this on the forums");
+        API3.warn("Tried to add the inexisting template " + this.type + " to Petra.");
         return false;
     }
     this.ID = gameState.ai.uniqueIDs.plans++;
     this.cost = new API3.Resources(this.template.cost());
     this.number = 1;
-
     this.category = "";
 
     return true;

binaries/data/mods/public/simulation/ai/petra/queueplanResearch.js

@@ -9 +9 @@
     if (this.template.researchTime === undefined)
         return false;
 
+    // Refine the estimated cost
+    let researchers = this.getBestResearchers(gameState, true);
+    if (researchers)
+        this.cost = new API3.Resources(this.template.cost(researchers[0]));
+
     this.category = "technology";
 
     this.rush = rush;
@@ -20 +25 @@
 
 m.ResearchPlan.prototype.canStart = function(gameState)
 {
-    // also checks canResearch
-    return gameState.hasResearchers(this.type);
+    this.researchers = this.getBestResearchers(gameState);
+    if (!this.researchers)
+        return false;
+    this.cost = new API3.Resources(this.template.cost(this.researchers[0]));
+    return true;
 };
 
+m.ResearchPlan.prototype.getBestResearchers = function(gameState, noRequirementCheck = false)
+{
+    let allResearchers = gameState.findResearchers(this.type, noRequirementCheck);
+    if (!allResearchers || !allResearchers.hasEntities())
+        return undefined;
+
+    // Keep only researchers with smallest cost
+    let costMin = Math.min();
+    let researchers;
+    for (let ent of allResearchers.values())
+    {
+        let cost = this.template.costSum(ent);
+        if (cost === costMin)
+            researchers.push(ent);
+        else if (cost < costMin)
+        {
+            costMin = cost;
+            researchers = [ent];
+        }
+    }
+    return researchers;
+};
+
 m.ResearchPlan.prototype.isInvalid = function(gameState)
 {
     return gameState.isResearched(this.type) || gameState.isResearching(this.type);
@@ -31 +62 @@
 
 m.ResearchPlan.prototype.start = function(gameState)
 {
-    let trainers = gameState.findResearchers(this.type).toEntityArray();
-
-    // Prefer training buildings with short queues
-    // (TODO: this should also account for units added to the queue by
-    // plans that have already been executed this turn)
-    if (trainers.length)
-    {
-        trainers.sort((a, b) => a.trainingQueueTime() - b.trainingQueueTime());
-        // drop anything in the queue if we rush it.
-        if (this.rush)
-            trainers[0].stopAllProduction(0.45);
-        trainers[0].research(this.type);
-    }
+    // Prefer researcher with shortest queues (no need to serialize this.researchers
+    // as the functions canStart and start are always called on the same turn)
+    this.researchers.sort((a, b) => a.trainingQueueTime() - b.trainingQueueTime());
+    // Drop anything in the queue if we rush it.
+    if (this.rush)
+        this.researchers[0].stopAllProduction(0.45);
+    this.researchers[0].research(this.type);
     this.onStart(gameState);
 };
 

binaries/data/mods/public/simulation/ai/petra/queueplanTraining.js

@@ -110 +110 @@
     this.number += amount;
 };
 
-// Find the promoted types corresponding to this.type
+/** Find the promoted types corresponding to this.type */
 m.TrainingPlan.prototype.promotedTypes = function(gameState)
 {
     let types = [];