Ticket #1353: 1353_InconsistentGathering.B.patch

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

@@ -187 +187 @@
 /**
  * Gather from the target entity. This should only be called after a successful range check,
  * and if the target has a compatible ResourceSupply.
- * It should be called at a rate of once per second.
+ * Call interval will be determined by gather rate, so always gather 1 amount when called.
  */
 ResourceGatherer.prototype.PerformGather = function(target)
 {
-    var rate = this.GetTargetGatherRate(target);
-    if (!rate)
+    var cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
+    if (!cmpUnitAI || !cmpUnitAI.CanGather(target))
         return { "exhausted": true };
 
+    var gatherAmount = 1;
+
     var cmpResourceSupply = Engine.QueryInterface(target, IID_ResourceSupply);
     var type = cmpResourceSupply.GetType();
 
@@ -205 +207 @@
     // Find the maximum so we won't exceed our capacity
     var maxGathered = this.GetCapacities()[type.generic] - this.carrying[type.generic];
 
-    var status = cmpResourceSupply.TakeResources(Math.min(rate, maxGathered));
+    var status = cmpResourceSupply.TakeResources(Math.min(gatherAmount, maxGathered));
 
     this.carrying[type.generic] += status.amount;
 
@@ -244 +246 @@
 
     var type = cmpResourceSupply.GetType();
 
+    var rates = this.GetGatherRates();
+
     var rate;
-    if (type.specific && this.GetGatherRates()[type.generic+"."+type.specific])
-        rate = this.GetGatherRates()[type.generic+"."+type.specific];
+    if (type.specific && rates[type.generic+"."+type.specific])
+        rate = rates[type.generic+"."+type.specific];
     else
-        rate = this.GetGatherRates()[type.generic];
-
+        rate = rates[type.generic];
+    
     return (rate || 0);
 };
 

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

@@ -54 +54 @@
 
 ResourceSupply.prototype.TakeResources = function(rate)
 {
-    // Internally we handle fractional resource amounts (to be accurate
-    // over long periods of time), but want to return integers (so players
-    // have a nice simple integer amount of resources). So return the
-    // difference between rounded values:
+    // 'rate' should be a non-negative integer
 
     var old = this.amount;
     this.amount = Math.max(0, old - rate);
+    var change = old - this.amount;
 
-    // (use ceil instead of floor so that we continue returning non-zero values even if 0 < amount < 1)
-    var change = Math.ceil(old) - Math.ceil(this.amount);
-
     // Remove entities that have been exhausted
     if (this.amount == 0)
         Engine.DestroyEntity(this.entity);
 
     Engine.PostMessage(this.entity, MT_ResourceSupplyChanged, { "from": old, "to": this.amount });
 
-    return { "amount": change, "exhausted": (old == 0) };
+    return { "amount": change, "exhausted": (this.amount == 0) };
 };
 
 ResourceSupply.prototype.GetType = function()

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

@@ -944 +944 @@
 
             "GATHERING": {
                 "enter": function() {
-                    this.StartTimer(1000, 1000);
+                    var target = this.order.data.target;
+                    
+                    // Calculate timing based on gather rates
+                    // This allows the gather rate to control how often we gather, instead of how much.
+                    var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
+                    var rate = cmpResourceGatherer.GetTargetGatherRate(target);
 
+                    if (!rate)
+                    {
+                        // No rate, give up on gathering
+                        this.FinishOrder();
+                        return;
+                    }
+
+                    // Scale timing interval based on rate, and start timer
+                    var offset = 1000; // Should be at least longer than repeat time.  See attacking.enter.
+                    var repeat = 1000 / rate;
+                    this.StartTimer(offset, repeat);
+
                     // We want to start the gather animation as soon as possible,
                     // but only if we're actually at the target and it's still alive
                     // (else it'll look like we're chopping empty air).
                     // (If it's not alive, the Timer handler will deal with sending us
                     // off to a different target.)
-                    if (this.CheckTargetRange(this.order.data.target, IID_ResourceGatherer))
+                    if (this.CheckTargetRange(target, IID_ResourceGatherer))
                     {
                         var typename = "gather_" + this.order.data.type.specific;
                         this.SelectAnimation(typename, false, 1.0, typename);
@@ -1970 +1987 @@
     {
         this.timer = undefined;
     }
-    else
-    {
-        var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-        this.timer = cmpTimer.SetTimeout(this.entity, IID_UnitAI, "TimerHandler", data.timerRepeat - lateness, data);
-    }
 
     UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
 };
@@ -1992 +2004 @@
     var data = { "timerRepeat": repeat };
 
     var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-    this.timer = cmpTimer.SetTimeout(this.entity, IID_UnitAI, "TimerHandler", offset, data);
+    if (repeat === undefined)
+        this.timer = cmpTimer.SetTimeout(this.entity, IID_UnitAI, "TimerHandler", offset, data);
+    else
+        this.timer = cmpTimer.SetInterval(this.entity, IID_UnitAI, "TimerHandler", offset, repeat, data);
 };
 
 /**