Ticket #4355: ResourceSupply.js.patch

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

@@ -81 +81 @@
     return this.gatherers.reduce((a, b) => a + b.length, 0);
 };
 
+/**
+ * @summary Fetches the number of gatherers of a given player currently associated with the resource.
+ * @param playerId {Number} The id of the player whose gatherers are to be counted.
+ * @return {Number} Number of gatherers of the specified player currently associated with the resource.
+ */
+ResourceSupply.prototype.GetNumGatherersByPlayer = function (playerId)
+{
+    return this.gatherers[playerId] ? this.gatherers[playerId].length : 0;
+};
+
 /* The rate of each additionnal gatherer rate follow a geometric sequence, with diminishingReturns as common ratio. */
 ResourceSupply.prototype.GetDiminishingReturns = function()
 {
@@ -128 +138 @@
     return this.cachedType;
 };
 
+/**
+ * @summary Tests whether a particular unit may gather from this resource supply.
+ * @param player {Number} Id of the player the gatherer belongs to
+ * @param gathererID {Number} Id of the entity which is tested for gathering.
+ * @return {Boolean} true iff the tested gatherer may, at the current time, gather
+ *                   from this resource supply.
+ */
 ResourceSupply.prototype.IsAvailable = function(player, gathererID)
 {
-    if (this.GetNumGatherers() < this.GetMaxGatherers() || this.gatherers[player].indexOf(gathererID) !== -1)
+    if (this.gatherers[player].indexOf(gathererID) == -1)
+    {
+        if (this.cachedType.generic == "treasure")
+        {
+            return (this.GetNumGatherersByPlayer(player) < this.GetMaxGatherers());
+        }
+        else
+        {
+            return (this.GetNumGatherers() < this.GetMaxGatherers());
+        }
+    }
+    else
+    {
+        // Unit is already gathering
         return true;
-    return false;
+    }
 };
 
 ResourceSupply.prototype.AddGatherer = function(player, gathererID)

binaries/data/mods/public/simulation/components/tests/test_ResourceSupply.js

@@ +1 @@
+// This stub must be already present when loading ResourceSupply.js as it is
+// needed for the ResourceSupply schema definition which is built on load
+Resources =
+{
+    "BuildChoicesSchema" : function () { },
+    "GetNames" : function () { return {"type1":{}}; },
+    "GetResource" :
+        function () {
+            return {
+                "subtypes": {"type1" : {}}
+            }; 
+        }
+};
+
+Engine.LoadComponentScript("interfaces/ResourceSupply.js");
+Engine.LoadComponentScript("ResourceSupply.js");
+
+/**
+ * @summary Ensures consistent behavior of IsAvailable() for already-gathering units
+ * @description When a gatherer has been attached to a resource supply, IsAvailable()
+ *              shall still return true for that gatherer, so a simple test of "max
+ *              number of gatherers < actual number of gatherers" is not sufficient:
+ *              The resource supply may be crowded up and don't accept any futher
+ *              gatherers, but these already present may continue to work
+ * @param template {Object} DOM of the ResourceSupply template definition (as if loaded
+ *                          from XML files)
+ * @return undefined
+ */
+function entityGatheringCanContinue(template) {
+    ResetState();
+
+    AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+        GetNumPlayers: function() { return 1; }
+    });
+
+    var gathererId = 3;
+    var playerId = 1;
+    var treasureId = 2;
+
+    var testSupply = ConstructComponent(treasureId, "ResourceSupply", template);
+
+    TS_ASSERT(testSupply.IsAvailable(playerId));
+    testSupply.AddGatherer(playerId, gathererId);
+    
+    TS_ASSERT_EQUALS(testSupply.GetNumGatherers(), 1);
+    TS_ASSERT_EQUALS(testSupply.GetMaxGatherers(), 1);
+    TS_ASSERT(testSupply.IsAvailable(playerId, gathererId));
+};
+
+// Test cases to ensure that gatherers already working on a resource are granted
+// subsequent access to it
+entityGatheringCanContinue(
+    {
+        "Amount" : 100,
+        "MaxGatherers" : 1,
+        "Type" : "treasure.type1"
+    });
+entityGatheringCanContinue(
+    {
+        "Amount" : 100,
+        "MaxGatherers" : 1,
+        "Type" : "generic.type1"
+    });
+
+/**
+ * @summary Ensures normal resource supplies allow only as many concurrent gatherers
+ *          as defined in the template, not caring who they are.
+ * @return undefined
+ */
+function normalResourcesAllowOnlyMaxGatherersConcurrently() {
+    ResetState();
+
+    AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+        GetNumPlayers: function() { return 2; }
+    });
+
+    var gathererId1_Player1 = 3;
+    var gathererId2_Player1 = 5;
+    var gathererId_Player2 = 4;
+    var treasureId = 2;
+
+    var testSupply = ConstructComponent(treasureId, "ResourceSupply",
+        {
+            "Amount" : 100,
+            "MaxGatherers" : 1,
+            "Type" : "generic.type1"
+        });
+    // Player 1 approaches it
+    testSupply.AddGatherer(1, gathererId1_Player1);
+    // and no second gatherer from player 1 is allowed
+    TS_ASSERT(!testSupply.IsAvailable(1, gathererId2_Player1));
+    // also, no other player may access it at the same time
+    TS_ASSERT(!testSupply.IsAvailable(1, gathererId_Player2));
+};
+
+normalResourcesAllowOnlyMaxGatherersConcurrently();
+
+/**
+ * @summary Ensures that treasures grant access to multiple players independently.
+ * @description Usual treasure max limit is 1 (since they are instant pick-up), so
+ *              using the same gathering limits as for normal resources would allow
+ *              a player to hold out a treasure of all other players while he tries
+ *              to grab it.
+ *              Instead, each player may send up to one gatherer to it and the fastest
+ *              one wins.
+ * @return undefined
+ */
+function multiplePlayersMayHuntForSameTreasureConcurrently() {
+    ResetState();
+
+    AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+        GetNumPlayers: function() { return 2; }
+    });
+
+    var gathererId_Player1 = 3;
+    var gathererId_Player2 = 4;
+    var treasureId = 2;
+
+    var testSupply = ConstructComponent(treasureId, "ResourceSupply",
+        {
+            "Amount" : 100,
+            "MaxGatherers" : 1,
+            "Type" : "treasure.type1"
+        });
+    // Player 1 approaches it
+    testSupply.AddGatherer(1, gathererId_Player1);
+    // and player 2 is still allowed to try as well
+    TS_ASSERT(testSupply.IsAvailable(2, gathererId_Player2));
+};
+
+multiplePlayersMayHuntForSameTreasureConcurrently();
+