Changeset 25191

Timestamp:

Apr 4, 2021, 8:52:20 AM (3 years ago)

Author:

Freagarach

Message:

Add Upkeep component.

Adds a new component effectively handling negative resource trickles.
Prevents resources from going negative and provides an effect for not being able to pay.
The effect chosen for 0 A.D. is having the entity not being controllable.

Not used in the public mod itself, but it is in quite some mods.

Based on an idea of @Nescio
Differential revision: D1323
Comments by: @Angen, (@smiley,) @Stan

Location:

ps/trunk/binaries/data/mods/public

Files:

• globalscripts/Templates.js (modified) (1 diff)
• gui/common/tooltips.js (modified) (1 diff)
• gui/reference/common/ReferencePage.js (modified) (1 diff)
• gui/session/selection_details.js (modified) (1 diff)
• simulation/components/GuiInterface.js (modified) (1 diff)
• simulation/components/Upkeep.js (copied) (copied from ps/trunk/binaries/data/mods/public/simulation/components/ResourceTrickle.js ) (6 diffs, 1 prop)
• simulation/components/interfaces/Upkeep.js (copied) (copied from ps/trunk/binaries/data/mods/public/simulation/components/interfaces/ResourceTrickle.js ) (1 diff, 1 prop)
• simulation/components/tests/test_GuiInterface.js (modified) (1 diff)
• simulation/components/tests/test_Upkeep.js (copied) (copied from ps/trunk/binaries/data/mods/public/simulation/components/tests/test_ResourceTrickle.js ) (2 diffs, 1 prop)

ps/trunk/binaries/data/mods/public/globalscripts/Templates.js

@@ -497 +497 @@
         };
 
+
+
+
+
+
+
+
+
+
+
     if (template.WallSet)
     {

ps/trunk/binaries/data/mods/public/gui/common/tooltips.js

@@ -847 +847 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /**
  * Returns an array of strings for a set of wall pieces. If the pieces share

ps/trunk/binaries/data/mods/public/gui/reference/common/ReferencePage.js

@@ -66 +66 @@
     getPopulationBonusTooltip,
     getResourceTrickleTooltip,
+
     getLootTooltip
 ];

ps/trunk/binaries/data/mods/public/gui/session/selection_details.js

@@ -330 +330 @@
         getProjectilesTooltip,
         getResourceTrickleTooltip,
+
         getLootTooltip
     ].map(func => func(entState)).filter(tip => tip).join("\n");

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

@@ -575 +575 @@
             "walk": cmpUnitMotion.GetWalkSpeed(),
             "run": cmpUnitMotion.GetWalkSpeed() * cmpUnitMotion.GetRunMultiplier()
+
+
+
+
+
+
+
         };
 

ps/trunk/binaries/data/mods/public/simulation/components/Upkeep.js

@@ -1 @@
-function ResourceTrickle() {}
+function () {}
 
-ResourceTrickle.prototype.Schema =
-    "<a:help>Controls the resource trickle ability of the unit.</a:help>" +
-    "<element name='Rates' a:help='Trickle Rates'>" +
+.prototype.Schema =
+    "<a:help>Controls the resource .</a:help>" +
+    "<element name='Rates' a:help=' Rates'>" +
         Resources.BuildSchema("nonNegativeDecimal") +
     "</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 mil.'>" +
         "<ref name='nonNegativeDecimal'/>" +
     "</element>";
 
-ResourceTrickle.prototype.Init = function()
+.prototype.Init = function()
 {
-    this.trickleInterval = +this.template.Interval;
+    this.Interval = +this.template.Interval;
     this.CheckTimer();
 };
 
-ResourceTrickle.prototype.GetInterval = function()
+/**
+ * @return {number} - The interval between resource subtractions, in ms.
+ */
+Upkeep.prototype.GetInterval = function()
 {
-    return this.trickleInterval;
+    return this.Interval;
 };
 
-ResourceTrickle.prototype.GetRates = function()
+/**
+ * @return {Object} - The upkeep rates in the form of { "resourceName": {number} }.
+ */
+Upkeep.prototype.GetRates = function()
 {
     return this.rates;
@@ -27 +33 @@
 
 /**
- * @return {boolean} - Whether this entity has at least one non-zero trickle rate.
+ * @return {boolean} - Whether this entity has at least one non-zero .
  */
-ResourceTrickle.prototype.ComputeRates = function()
+.prototype.ComputeRates = function()
 {
     this.rates = {};
-    let hasTrickle = false;
+    let has = false;
     for (let resource in this.template.Rates)
     {
-        let rate = ApplyValueModificationsToEntity("ResourceTrickle/Rates/" + resource, +this.template.Rates[resource], this.entity);
+        let rate = ApplyValueModificationsToEntity("/Rates/" + resource, +this.template.Rates[resource], this.entity);
         if (rate)
         {
             this.rates[resource] = rate;
-            hasTrickle = true;
+            has = true;
         }
     }
 
-    return hasTrickle;
+    return has;
 };
 
-ResourceTrickle.prototype.Trickle = function(data, lateness)
+/**
+ * Try to subtract the needed resources.
+ * Data and lateness are unused.
+ */
+Upkeep.prototype.Pay = function(data, lateness)
 {
-    // The player entity may also have a ResourceTrickle component
-    let cmpPlayer = QueryOwnerInterface(this.entity) || Engine.QueryInterface(this.entity, IID_Player);
+    let cmpPlayer = QueryOwnerInterface(this.entity);
     if (!cmpPlayer)
         return;
 
-    cmpPlayer.AddResources(this.rates);
+    if (!cmpPlayer.TrySubtractResources(this.rates))
+        this.HandleInsufficientUpkeep();
+    else
+        this.HandleSufficientUpkeep();
 };
 
-ResourceTrickle.prototype.OnValueModification = function(msg)
+/**
+ * E.g. take a hitpoint, reduce CP.
+ */
+Upkeep.prototype.HandleInsufficientUpkeep = function()
 {
-    if (msg.component != "ResourceTrickle")
+    if (this.unpayed)
+        return;
+
+    let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+    if (cmpIdentity)
+        cmpIdentity.SetControllable(false);
+    this.unpayed = true;
+};
+
+/**
+ * Reset to the previous stage.
+ */
+Upkeep.prototype.HandleSufficientUpkeep = function()
+{
+    if (!this.unpayed)
+        return;
+
+    let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+    if (cmpIdentity)
+        cmpIdentity.SetControllable(true);
+    delete this.unpayed;
+};
+
+Upkeep.prototype.OnValueModification = function(msg)
+{
+    if (msg.component != "Upkeep")
         return;
 
@@ -64 +104 @@
 };
 
-ResourceTrickle.prototype.CheckTimer = function()
+/**
+ * Recalculate the interval and update the timer accordingly.
+ */
+Upkeep.prototype.CheckTimer = function()
 {
     if (!this.ComputeRates())
@@ -77 +120 @@
     }
 
-    let oldTrickleInterval = this.trickleInterval;
-    this.trickleInterval = ApplyValueModificationsToEntity("ResourceTrickle/Interval", +this.template.Interval, this.entity);
-    if (this.trickleInterval < 0)
+    let oldInterval;
+    this./Interval", +this.template.Interval, this.entity);
+    if (this.Interval < 0)
     {
         let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
@@ -89 +132 @@
     if (this.timer)
     {
-        if (this.trickleInterval == oldTrickleInterval)
+        if (this.Interval)
             return;
 
         // If the timer wasn't invalidated before (interval <= 0), just update it.
-        if (oldTrickleInterval > 0)
+        if (oldInterval > 0)
         {
             let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-            cmpTimer.UpdateRepeatTime(this.timer, this.trickleInterval);
+            cmpTimer.UpdateRepeatTime(this.timer, this.Interval);
             return;
         }
@@ -102 +145 @@
 
     let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-    this.timer = cmpTimer.SetInterval(this.entity, IID_ResourceTrickle, "Trickle", this.trickleInterval, this.trickleInterval, undefined);
+    this.timer = cmpTimer.SetInterval(this.entity, IID_Interval, undefined);
 };
 
-Engine.RegisterComponentType(IID_ResourceTrickle, "ResourceTrickle", ResourceTrickle);
+Engine.RegisterComponentType(IID_);

ps/trunk/binaries/data/mods/public/simulation/components/interfaces/Upkeep.js

@@ -1 @@
-Engine.RegisterInterface("ResourceTrickle");
+Engine.RegisterInterface("");

ps/trunk/binaries/data/mods/public/simulation/components/tests/test_GuiInterface.js

@@ -40 +40 @@
 Engine.LoadComponentScript("interfaces/UnitAI.js");
 Engine.LoadComponentScript("interfaces/Upgrade.js");
+
 Engine.LoadComponentScript("interfaces/BuildingAI.js");
 Engine.LoadComponentScript("GuiInterface.js");

ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Upkeep.js

@@ -17 +17 @@
 };
 
-Engine.LoadComponentScript("interfaces/ResourceTrickle.js");
+Engine.LoadComponentScript("interfaces/Player.js");
+Engine.LoadComponentScript("interfaces/StatisticsTracker.js");
 Engine.LoadComponentScript("interfaces/Timer.js");
-Engine.LoadComponentScript("interfaces/Player.js");
+Engine.LoadComponentScript("interfaces/.js");
 Engine.LoadComponentScript("Player.js");
-Engine.LoadComponentScript("ResourceTrickle.js");
 Engine.LoadComponentScript("Timer.js");
-
-// Resource Trickle requires this function to be defined before the component is built.
+Engine.LoadComponentScript("Upkeep.js");
+
+// Upkeep requires this function to be defined before the component is built.
 let ApplyValueModificationsToEntity = (valueName, currentValue, entity) => currentValue;
 Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-let wonderEnt = 1;
+let ;
 let turnLength = 0.2;
-let playerEnt = 10;
+let playerEnt = 1;
 let cmpTimer = ConstructComponent(SYSTEM_ENTITY, "Timer", {});
 
-let cmpResourceTrickle = ConstructComponent(wonderEnt, "ResourceTrickle", {
+let cmp", {
     "Interval": "200",
     "Rates": {
@@ -56 +57 @@
 let QueryOwnerInterface = () => cmpPlayer;
 Engine.RegisterGlobal("QueryOwnerInterface", QueryOwnerInterface);
+
 TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 300, "metal": 300 });
-TS_ASSERT_EQUALS(cmpResourceTrickle.GetInterval(), 200);
+TS_ASSERT_EQUALS(cmp.GetInterval(), 200);
 
 // Since there is no rate > 0, nothing should change.
-TS_ASSERT_UNEVAL_EQUALS(cmpResourceTrickle.GetRates(), {});
-TS_ASSERT_EQUALS(cmpResourceTrickle.ComputeRates(), false);
+TS_ASSERT_UNEVAL_EQUALS(cmp.GetRates(), {});
+TS_ASSERT_EQUALS(cmp.ComputeRates(), false);
 cmpTimer.OnUpdate({ "turnLength": turnLength });
 TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 300, "metal": 300 });
 
-// Test that only trickling food works.
-ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
-    if (valueName == "ResourceTrickle/Rates/food")
-        return currentValue + 1;
-
-    return currentValue;
-};
-Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-// Calling OnValueModification will reset the timer, which can then be called, thus increasing the resources of the player.
-cmpResourceTrickle.OnValueModification({ "component": "ResourceTrickle" });
-TS_ASSERT_UNEVAL_EQUALS(cmpResourceTrickle.GetRates(), { "food": 1 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 301, "metal": 300 });
-TS_ASSERT_EQUALS(cmpResourceTrickle.ComputeRates(), true);
-
-// Reset the trickle modification.
+// Test that only ing food works.
+ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
+    if (valueName == "/Rates/food")
+        return currentValue + 1;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+// Calling OnValueModification will reset the timer, which can then be called, thus creasing the resources of the player.
+cmp" });
+TS_ASSERT_UNEVAL_EQUALS(cmp.GetRates(), { "food": 1 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
+TS_ASSERT_EQUALS(cmp.ComputeRates(), true);
+
+// Reset the  modification.
 ApplyValueModificationsToEntity = (valueName, currentValue, entity) => currentValue;
 Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-cmpResourceTrickle.OnValueModification({ "component": "ResourceTrickle" });
-TS_ASSERT_UNEVAL_EQUALS(cmpResourceTrickle.GetRates(), {});
-TS_ASSERT_EQUALS(cmpResourceTrickle.ComputeRates(), false);
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 301, "metal": 300 });
-
-ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
-    if (valueName == "ResourceTrickle/Interval")
+cmp" });
+TS_ASSERT_UNEVAL_EQUALS(cmp.GetRates(), {});
+TS_ASSERT_EQUALS(cmp.ComputeRates(), false);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
+
+ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
+    if (valueName == "/Interval")
         return currentValue + 200;
-    if (valueName == "ResourceTrickle/Rates/food")
-        return currentValue + 1;
-
-    return currentValue;
-};
-Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-cmpResourceTrickle.OnValueModification({ "component": "ResourceTrickle" });
-TS_ASSERT_EQUALS(cmpResourceTrickle.GetInterval(), 400);
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 301, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 302, "metal": 300 });
+    if (valueName == "/Rates/food")
+        return currentValue + 1;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+cmp" });
+TS_ASSERT_EQUALS(cmp.GetInterval(), 400);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
 
 // Interval becomes a normal timer, thus cancelled after the first execution.
 ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
-    if (valueName == "ResourceTrickle/Interval")
+    if (valueName == "/Interval")
         return currentValue - 200;
-    if (valueName == "ResourceTrickle/Rates/food")
-        return currentValue + 1;
-
-    return currentValue;
-};
-Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-cmpResourceTrickle.OnValueModification({ "component": "ResourceTrickle" });
-TS_ASSERT_EQUALS(cmpResourceTrickle.GetInterval(), 0);
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 302, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 303, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 303, "metal": 300 });
+    if (valueName == "/Rates/food")
+        return currentValue + 1;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+cmp" });
+TS_ASSERT_EQUALS(cmp.GetInterval(), 0);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
 
 // Timer became invalidated, check whether it's recreated properly after that.
 ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
-    if (valueName == "ResourceTrickle/Interval")
+    if (valueName == "/Interval")
         return currentValue - 100;
-    if (valueName == "ResourceTrickle/Rates/food")
-        return currentValue + 1;
-
-    return currentValue;
-};
-Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-cmpResourceTrickle.OnValueModification({ "component": "ResourceTrickle" });
-TS_ASSERT_EQUALS(cmpResourceTrickle.GetInterval(), 100);
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 305, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 307, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 309, "metal": 300 });
+    if (valueName == "/Rates/food")
+        return currentValue + 1;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+cmp" });
+TS_ASSERT_EQUALS(cmp.GetInterval(), 100);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 5, "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
 
 // Value is now invalid, timer should be cancelled.
 ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
-    if (valueName == "ResourceTrickle/Interval")
+    if (valueName == "/Interval")
         return currentValue - 201;
-    if (valueName == "ResourceTrickle/Rates/food")
-        return currentValue + 1;
-
-    return currentValue;
-};
-Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-cmpResourceTrickle.OnValueModification({ "component": "ResourceTrickle" });
-TS_ASSERT_EQUALS(cmpResourceTrickle.GetInterval(), -1);
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 309, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 309, "metal": 300 });
+    if (valueName == "/Rates/food")
+        return currentValue + 1;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+cmp" });
+TS_ASSERT_EQUALS(cmp.GetInterval(), -1);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": , "metal": 300 });
 
 // Timer became invalidated, check whether it's recreated properly after that.
 ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
-    if (valueName == "ResourceTrickle/Rates/food")
-        return currentValue + 1;
-
-    return currentValue;
-};
-Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
-cmpResourceTrickle.OnValueModification({ "component": "ResourceTrickle" });
-TS_ASSERT_EQUALS(cmpResourceTrickle.GetInterval(), 200);
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 310, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 311, "metal": 300 });
-cmpTimer.OnUpdate({ "turnLength": turnLength });
-TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 312, "metal": 300 });
+    if (valueName == "Upkeep/Rates/food")
+        return currentValue + 1;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+cmpUpkeep.OnValueModification({ "component": "Upkeep" });
+TS_ASSERT_EQUALS(cmpUpkeep.GetInterval(), 200);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 290, "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 289, "metal": 300 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 288, "metal": 300 });
+
+// Test multiple upkeep resources.
+ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
+    if (valueName == "Upkeep/Rates/food")
+        return currentValue + 1;
+    if (valueName == "Upkeep/Rates/metal")
+        return currentValue + 2;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+cmpUpkeep.OnValueModification({ "component": "Upkeep" });
+TS_ASSERT_EQUALS(cmpUpkeep.GetInterval(), 200);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 287, "metal": 298 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 286, "metal": 296 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 285, "metal": 294 });
+
+// Test we don't go into negative resources.
+let cmpGUI = AddMock(SYSTEM_ENTITY, IID_GuiInterface, {
+    "PushNotification": () => {}
+});
+let notificationSpy = new Spy(cmpGUI, "PushNotification");
+ApplyValueModificationsToEntity = (valueName, currentValue, entity) => {
+    if (valueName == "Upkeep/Rates/food")
+        return currentValue + 1;
+
+    return currentValue;
+};
+Engine.RegisterGlobal("ApplyValueModificationsToEntity", ApplyValueModificationsToEntity);
+cmpUpkeep.OnValueModification({ "component": "Upkeep" });
+TS_ASSERT_EQUALS(cmpUpkeep.GetInterval(), 200);
+cmpTimer.OnUpdate({ "turnLength": turnLength * 285 });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 0, "metal": 294 });
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 0, "metal": 294 });
+TS_ASSERT_EQUALS(notificationSpy._called, 1);
+cmpTimer.OnUpdate({ "turnLength": turnLength });
+TS_ASSERT_UNEVAL_EQUALS(cmpPlayer.GetResourceCounts(), { "food": 0, "metal": 294 });
+TS_ASSERT_EQUALS(notificationSpy._called, 2);