Ticket #672: shuttle.patch

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

@@ -58 +58 @@
 
 ResourceGatherer.prototype.Init = function()
 {
-    this.carrying = {}; // { type: integer amount currently carried }
+    this.carrying = {}; // { generic type: integer amount currently carried }
     // (Note that this component supports carrying multiple types of resources,
     // each with an independent capacity, but the rest of the game currently
     // ensures and assumes we'll only be carrying one type at once)
@@ -86 +86 @@
 };
 
 /**
- * Returns the type of one particular resource this unit is
+ * Returns the generic type of one particular resource this unit is
  * currently carrying, or undefined if none.
  */
 ResourceGatherer.prototype.GetMainCarryingType = function()

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

@@ -425 +425 @@
         },
 
         "GATHER": {
+            "enter": function() {
+                // Remember the position of our target, if any, in case it disappears
+                // later and we want to head to its last known position
+                // (TODO: if the target moves a lot (e.g. it's an animal), maybe we
+                // need to update this lastPos regularly rather than just on enter?)
+                var cmpTargetPosition = Engine.QueryInterface(this.order.data.target, IID_Position);
+                if (cmpTargetPosition && cmpTargetPosition.IsInWorld())
+                    this.order.data.lastPos = cmpTargetPosition.GetPosition();
+            },
+
             "APPROACHING": {
-                "enter": function () {
+                "enter": function() {
                     this.SelectAnimation("move");
                 },
 
@@ -500 +510 @@
                         // return to the nearest dropsite
                         if (status.filled)
                         {
-                            var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-
-                            // Find dropsites owned by this unit's player
-                            var players = [];
-                            var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
-                            if (cmpOwnership)
-                                players.push(cmpOwnership.GetOwner());
-
-                            var dropsites = cmpRangeManager.ExecuteQuery(this.entity, 0, -1, players, IID_ResourceDropsite);
-
-                            // Try to find the first (nearest) dropsite which supports this resource type
-                            for each (var dropsite in dropsites)
+                            var nearby = this.FindNearestDropsite(this.order.data.type.generic);
+                            if (nearby)
                             {
-                                var cmpDropsite = Engine.QueryInterface(dropsite, IID_ResourceDropsite);
-                                if (!cmpDropsite.AcceptsType(this.order.data.type.generic))
-                                    continue;
-
-                                // This dropsite is okay - return our resources to it
-                                this.PushOrderFront("ReturnResource", { "target": dropsite });
+                                // (Keep this Gather order on the stack so we'll
+                                // continue gathering after returning)
+                                this.PushOrderFront("ReturnResource", { "target": nearby });
                                 return;
                             }
 
-                            // Oh no, couldn't find any drop sites.
-                            // Give up and stand here like a lemon.
+                            // Oh no, couldn't find any drop sites. Give up on gathering.
+                            this.FinishOrder();
                         }
                     }
                     else
                     {
-                        // Try to follow it
+                        // Try to follow the target
                         if (this.MoveToTargetRange(this.order.data.target, IID_ResourceGatherer))
                         {
                             this.SetNextState("APPROACHING");
+                            return;
                         }
-                        else
+
+                        // Can't reach the target, or it doesn't exist any more
+
+                        // We want to carry on gathering resources in the same area as
+                        // the old one. So try to get close to the old resource's
+                        // last known position
+
+                        if (this.order.data.lastPos &&
+                            this.MoveToPointRange(this.order.data.lastPos.x, this.order.data.lastPos.z,
+                                IID_ResourceGatherer))
                         {
-                            // Save the current order's type in case we need it later
-                            var oldType = this.order.data.type;
+                            this.SetNextState("APPROACHING");
+                            return;
+                        }
 
-                            // Can't reach it, or it doesn't exist any more - give up on this order
-                            if (this.FinishOrder())
-                                return;
+                        // We're already in range, or can't get anywhere near it.
 
-                            // No remaining orders - pick a useful default behaviour
+                        // Save the current order's type in case we need it later
+                        var oldType = this.order.data.type;
 
-                            // Try to find a nearby target of the same type
+                        // Give up on this order and try our next queued order
+                        if (this.FinishOrder())
+                            return;
 
-                            var nearby = this.FindNearbyResource(oldType);
-                            if (nearby)
-                            {
-                                this.Gather(nearby, true);
-                                return;
-                            }
+                        // No remaining orders - pick a useful default behaviour
 
-                            // Nothing else to gather - just give up
+                        // Try to find a new resource of the same type near our current position:
+
+                        var nearby = this.FindNearbyResource(oldType);
+                        if (nearby)
+                        {
+                            this.Gather(nearby, true);
+                            return;
                         }
+
+                        // Nothing else to gather - if we're carrying anything then we should
+                        // drop it off, and if not then we might as well head to the dropsite
+                        // anyway because that's a nice enough place to congregate and idle
+
+                        var nearby = this.FindNearestDropsite(oldType.generic);
+                        if (nearby)
+                        {
+                            this.PushOrderFront("ReturnResource", { "target": nearby });
+                            return;
+                        }
+
+                        // No dropsites - just give up
                     }
                 },
             },
@@ -577 +600 @@
                 },
 
                 "MoveCompleted": function() {
-                    var cmpResourceDropsite = Engine.QueryInterface(this.order.data.target, IID_ResourceDropsite);
-                    if (cmpResourceDropsite)
+                    // Check the dropsite really is in range
+                    // (we didn't get stopped before reaching it)
+                    if (this.CheckTargetRange(this.order.data.target, IID_ResourceGatherer))
                     {
-                        // TODO: check the dropsite really is in range
-                        // (we didn't get stopped before reaching it)
+                        var cmpResourceDropsite = Engine.QueryInterface(this.order.data.target, IID_ResourceDropsite);
+                        if (cmpResourceDropsite)
+                        {
+                            // Dump any resources we can
+                            var dropsiteTypes = cmpResourceDropsite.GetTypes();
 
-                        var dropsiteTypes = cmpResourceDropsite.GetTypes();
+                            var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
+                            cmpResourceGatherer.CommitResources(dropsiteTypes);
 
-                        var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
-                        cmpResourceGatherer.CommitResources(dropsiteTypes);
-                    }
-                    else
-                    {
-                        // The dropsite was destroyed or something.
-                        // TODO: We ought to look for a new one, probably.
+                            // Our next order should always be a Gather,
+                            // so just switch back to that order
+                            this.FinishOrder();
+                            return;
+                        }
                     }
 
+                    // The dropsite was destroyed, or we couldn't reach it.
+                    // Look for a new one.
+
+                    var cmpResourceGatherer = Engine.QueryInterface(this.entity, IID_ResourceGatherer);
+                    var genericType = cmpResourceGatherer.GetMainCarryingType();
+                    var nearby = this.FindNearestDropsite(genericType);
+                    if (nearby)
+                    {
+                        this.FinishOrder();
+                        this.PushOrderFront("ReturnResource", { "target": nearby });
+                        return;
+                    }
+
+                    // Oh no, couldn't find any drop sites. Give up on returning.
                     this.FinishOrder();
                 },
             },
@@ -989 +1029 @@
 };
 
 /**
+ * Returns the entity ID of the nearest resource dropsite that accepts the given
+ * type, excluding the one with ID 'exclude',
+ * or undefined if none can be found.
+ */
+UnitAI.prototype.FindNearestDropsite = function(genericType, exclude)
+{
+    // Find dropsites owned by this unit's player
+    var players = [];
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (cmpOwnership)
+        players.push(cmpOwnership.GetOwner());
+
+    var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    var nearby = rangeMan.ExecuteQuery(this.entity, 0, -1, players, IID_ResourceDropsite);
+    for each (var ent in nearby)
+    {
+        if (ent == exclude)
+            continue;
+
+        var cmpDropsite = Engine.QueryInterface(ent, IID_ResourceDropsite);
+        if (!cmpDropsite.AcceptsType(genericType))
+            continue;
+
+        return ent;
+    }
+
+    return undefined;
+};
+
+/**
  * Play a sound appropriate to the current entity.
  */
 UnitAI.prototype.PlaySound = function(name)
@@ -1066 +1136 @@
     return cmpUnitMotion.MoveToPointRange(x, z, 0, 0);
 };
 
+UnitAI.prototype.MoveToPointRange = function(x, z, iid, type)
+{
+    var cmpRanged = Engine.QueryInterface(this.entity, iid);
+    var range = cmpRanged.GetRange(type);
+
+    var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    return cmpUnitMotion.MoveToPointRange(x, z, range.min, range.max);
+};
+
 UnitAI.prototype.MoveToTarget = function(target)
 {
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);