Ticket #3321: 2_ResourceTrickle.patch

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

@@ -2 +2 @@
 
 ResourceTrickle.prototype.Schema = 
     "<a:help>Controls the resource trickle ability of the unit.</a:help>" +
+    "<a:example>" +
+        "<Rates>" +
+            "<food>0.5</food>" +
+            "<stone>1.5</stone>" +
+        "</Rates>" +
+        "<Interval>1000</Interval>" +
+        "<Type>global</Type>" +
+    "</a:example>" +
     "<element name='Rates' a:help='Trickle Rates'>" +
         "<interleave>" +
             "<optional>" +
@@ -26 +34 @@
             "</optional>" +
         "</interleave>" +
     "</element>" +
-    "<element name='Interval' a:help='Number of miliseconds must pass for the player to gain the next trickle.'>" +
+    "<element name='Interval' a:help='Number of milliseconds of game time that must pass for the player to gain the next trickle.'>" +
         "<ref name='nonNegativeDecimal'/>" +
-    "</element>";
+    "</element>" +
+    "<optional>" +
+        "<element name='Type' a:help='Type of trickle.'>" +
+            "<choice>" +
+                "<value a:help='Trickle is at a continuous rate throughout the game. Default value'>global</value>" +
+                "<value a:help='Trickle rate is governed by the percentage of world controlled as defined by territory borders'>territory</value>" +
+                "<value a:help='Trickle rate is per garrisoned unit'>garrison</value>" +
+            "</choice>" +
+        "</element>" +
+    "</optional>";
 
 ResourceTrickle.prototype.Init = function()
 {
-    // Call the timer
-    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-    cmpTimer.SetInterval(this.entity, IID_ResourceTrickle, "Trickle", this.GetTimer(), this.GetTimer(), undefined)
+    // Set type
+    this.trickleType = this.template.Type || "global";
+    this.interval = +this.template.Interval;
+    
+    // Cache rates and interval
+    this.OnValueModification({"component":"ResourceTrickle"});
+    
+    // Check the timer
+    this.CheckTimer();
 };
 
-ResourceTrickle.prototype.GetTimer = function()
+/**
+ * Fetches the interval period between timer calls
+ */
+ResourceTrickle.prototype.GetInterval = function()
 {
-    var interval = +this.template.Interval;
-    return interval;
+    return this.interval;
 };
 
-ResourceTrickle.prototype.GetRates = function()
+/**
+ * Checks the timer, and starts/stops it if neccesary. By passing true to this function, the timer can be restarted.
+ */
+ResourceTrickle.prototype.CheckTimer = function(restart = false)
 {
-    var rates = {};
-    for (var resource in this.template.Rates)
-        rates[resource] = ApplyValueModificationsToEntity("ResourceTrickle/Rates/"+resource, +this.template.Rates[resource], this.entity);
+    var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
+    var garrisonCount = (cmpGarrisonHolder) ? cmpGarrisonHolder.GetEntities().length : -1;
+    
+    if (!this.timer)
+    {
+        if (this.trickleType !== "garrison" || garrisonCount > 0)
+        {
+            var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+            this.timer = cmpTimer.SetInterval(this.entity, IID_ResourceTrickle, "PerformTrickle", this.GetInterval(), this.GetInterval(), undefined);
+        }
+    }
+    else if (this.trickleType == "garrison" && garrisonCount <= 0)
+    {
+        var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+        cmpTimer.CancelTimer(this.timer);
+        this.timer = undefined;
+    }
+    else if (restart === true)
+    {
+        var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+        cmpTimer.CancelTimer(this.timer);
+        this.timer = cmpTimer.SetInterval(this.entity, IID_ResourceTrickle, "PerformTrickle", this.GetInterval(), this.GetInterval(), undefined);
+    }
+};
 
-    return rates;
+/**
+ * Listener for Garrison changes. Modifies the trickle rates if the trickle type is "garrison"
+ */
+ResourceTrickle.prototype.OnGarrisonedUnitsChanged = function(msg)
+{
+    if (this.trickleType !== "garrison")
+        return;
+    
+    this.OnValueModification({"component":"ResourceTrickle"});
+    var garrisonCount = Engine.QueryInterface(this.entity, IID_GarrisonHolder).GetEntities().length;
+    for (let res in this.rates)
+        this.rates[res] *= garrisonCount;
+    
+    this.CheckTimer();
 };
 
-// Do the actual work here
-ResourceTrickle.prototype.Trickle = function(data, lateness)
+/**
+ * Listener for Territory Changes. Modifies the trickle rates if the trickle type is "territory"
+ */
+ResourceTrickle.prototype.OnTerritoriesChanged = function(msg)
 {
+    if (this.trickleType !== "territory")
+        return;
+
+    this.OnValueModification({"component":"ResourceTrickle"});
+
     var cmpPlayer = QueryOwnerInterface(this.entity);
-    if (!cmpPlayer)
+    var cmpTerritoryManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TerritoryManager);
+    if (!cmpPlayer || !cmpTerritoryManager)
         return;
 
-    var rates = this.GetRates();
-    for (var resource in rates)
-        cmpPlayer.AddResource(resource, rates[resource]);
+    var percentage = cmpTerritoryManager.GetTerritoryPercentage(cmpPlayer.GetPlayerID());
+    for (let res in this.rates)
+        this.rates[res] *= percentage/100;
+
+    this.CheckTimer();
+}
+
+/**
+ * Listener for Value Modification changes. Permits adjustment of rates and the interval period via technology or auras
+ */
+ResourceTrickle.prototype.OnValueModification = function(msg)
+{
+    if (msg.component != "ResourceTrickle")
+        return;
+    
+    this.rates = {};
+    for (let res in this.template.Rates)
+    {
+        let rate = +this.template.Rates[res];
+        this.rates[res] = ApplyValueModificationsToEntity("ResourceTrickle/Rates/"+res, rate, this.entity);
+    }
+    
+    var oldInterval = this.interval;
+    this.interval = ApplyValueModificationsToEntity("ResourceTrickle/Interval", +this.template.Interval, this.entity);
+    if (this.interval !== oldInterval)
+        this.CheckTimer(true); // if interval has been changed, restart the timer
+};
+
+/**
+ * Fetch the Trickle Rates, with any modifications applied
+ */
+ResourceTrickle.prototype.GetRates = function()
+{
+    return this.rates;
+};
+
+/**
+ * Trickle Resources as defined by template.
+ */
+ResourceTrickle.prototype.PerformTrickle = function(data, lateness)
+{
+    var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+    if (cmpPlayer)
+        cmpPlayer.AddResources(this.GetRates());
 };
 
 Engine.RegisterComponentType(IID_ResourceTrickle, "ResourceTrickle", ResourceTrickle);