Ticket #1716: formation-order-queues.patch

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

@@ -174 +174 @@
 };
 
 /**
+ * Call obj.functname(args) on UnitAI components of all members,
+ * and return true if all calls return true.
+ */
+Formation.prototype.TestAllMemberFunction = function(funcname, args)
+{
+    for each (var ent in this.members)
+    {
+        var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+        if (!cmpUnitAI[funcname].apply(cmpUnitAI, args))
+            return false;
+    }
+    return true;
+};
+
+/**
  * Set all members to form up into the formation shape.
  * If moveCenter is true, the formation center will be reinitialised
  * to the center of the units.

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

@@ -512 +512 @@
         },
 
         "Order.Attack": function(msg) {
-            // TODO: we should move in formation towards the target,
-            // then break up into individuals when close enough to it
+            // TODO on what should we base this range?
+            // Check if we are already in range, otherwise walk there
+            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 20))
+            {
+                if (!this.TargetIsAlive(msg.data.target))
+                    // The target was destroyed
+                    this.FinishOrder();
+                else
+                    // Out of range; move there in formation
+                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 20 });
+                return;
+            }
 
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            cmpFormation.SetRearrange(false);
             cmpFormation.CallMemberFunction("Attack", [msg.data.target, false]);
 
-            // TODO: we should wait until the target is killed, then
-            // move on to the next queued order.
-            // Don't bother now, just disband the formation immediately.
-            cmpFormation.Disband();
+            this.SetNextStateAlwaysEntering("MEMBER");
         },
 
         "Order.Heal": function(msg) {
-            // TODO: see notes in Order.Attack
+            // TODO on what should we base this range?
+            // Check if we are already in range, otherwise walk there
+            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
+            {
+                if (!this.TargetIsAlive(msg.data.target))
+                    // The target was destroyed
+                    this.FinishOrder();
+                else
+                    // Out of range; move there in formation
+                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
+                return;
+            }
+
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            cmpFormation.SetRearrange(false);
             cmpFormation.CallMemberFunction("Heal", [msg.data.target, false]);
-            cmpFormation.Disband();
+
+            this.SetNextStateAlwaysEntering("MEMBER");
         },
 
         "Order.Repair": function(msg) {
@@ -551 +577 @@
             cmpFormation.SetRearrange(false);
             cmpFormation.CallMemberFunction("Repair", [msg.data.target, msg.data.autocontinue, false]);
 
-            this.SetNextState("REPAIR");
+            this.SetNextStateAlwaysEntering("REPAIR");
         },
 
         "Order.Gather": function(msg) {
-            // TODO: see notes in Order.Attack
+            // TODO on what should we base this range?
+            // Check if we are already in range, otherwise walk there
+            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
+            {
+                if (!this.CanGather(msg.data.target))
+                    // The target isn't gatherable
+                    this.FinishOrder();
+                    // TODO should be a GatherNearPosition order.
+                // else if (!this.TargetIsAlive(msg.data.target))
+                    // gather near position
+                    //cmpFormation.CallMemberFunction("GatherNearPosition", [msg.data.lastPos.x, msg.data.lastPos.z, msg.data.type, msg.data.template, false]);
+                else
+                    // Out of range; move there in formation
+                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
+                return;
+            }
 
-            // If the resource no longer exists, send a GatherNearPosition order
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
-            if (this.CanGather(msg.data.target))
-                cmpFormation.CallMemberFunction("Gather", [msg.data.target, false]);
-            else
-                cmpFormation.CallMemberFunction("GatherNearPosition", [msg.data.lastPos.x, msg.data.lastPos.z, msg.data.type, msg.data.template, false]);
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            cmpFormation.SetRearrange(false);
+            cmpFormation.CallMemberFunction("Gather", [msg.data.target, false]);
 
-            cmpFormation.Disband();
+            this.SetNextStateAlwaysEntering("MEMBER");
         },
 
         "Order.GatherNearPosition": function(msg) {
-            // TODO: see notes in Order.Attack
+            // TODO on what should we base this range?
+            // Check if we are already in range, otherwise walk there
+            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 20))
+            {
+                if (!this.TargetIsAlive(msg.data.target))
+                    // The target was destroyed
+                    this.FinishOrder();
+                else
+                    // Out of range; move there in formation
+                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 20 });
+                return;
+            }
+
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            cmpFormation.SetRearrange(false);
             cmpFormation.CallMemberFunction("GatherNearPosition", [msg.data.x, msg.data.z, msg.data.type, msg.data.template, false]);
-            cmpFormation.Disband();
+
+            this.SetNextStateAlwaysEntering("MEMBER");
         },
 
         "Order.ReturnResource": function(msg) {
-            // TODO: see notes in Order.Attack
+            // TODO on what should we base this range?
+            // Check if we are already in range, otherwise walk there
+            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
+            {
+                if (!this.TargetIsAlive(msg.data.target))
+                    // The target was destroyed
+                    this.FinishOrder();
+                else
+                    // Out of range; move there in formation
+                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
+                return;
+            }
+
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            cmpFormation.SetRearrange(false);
             cmpFormation.CallMemberFunction("ReturnResource", [msg.data.target, false]);
-            cmpFormation.Disband();
+
+            this.SetNextStateAlwaysEntering("MEMBER");
         },
 
         "Order.Garrison": function(msg) {
-            // TODO: see notes in Order.Attack
+            // TODO on what should we base this range?
+            // Check if we are already in range, otherwise walk there
+            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
+            {
+                if (!this.TargetIsAlive(msg.data.target))
+                    // The target was destroyed
+                    this.FinishOrder();
+                else
+                    // Out of range; move there in formation
+                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
+                return;
+            }
+
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            cmpFormation.SetRearrange(false);
             cmpFormation.CallMemberFunction("Garrison", [msg.data.target, false]);
-            cmpFormation.Disband();
+
+            this.SetNextStateAlwaysEntering("MEMBER");
         },
 
         "IDLE": {
@@ -601 +689 @@
             "MoveCompleted": function(msg) {
                 if (this.FinishOrder())
                     return;
-                    
+
                 // If this was the last order, attempt to disband the formation.
                 var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
                 cmpFormation.FindInPosition();
@@ -620 +708 @@
                 cmpFormation.Disband();
             },
         },
+
+        "MEMBER": {
+            // Wait for individual members to finish
+            "enter": function(msg) {
+                this.StartTimer(1000, 1000);
+            },
+
+            "Timer": function(msg) {
+                var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+
+                // Have all members finished the task?
+                if (!cmpFormation.TestAllMemberFunction("HasFinishedOrder", []))
+                    return;
+
+                // Execute the next order
+                if (this.FinishOrder())
+                    return;
+
+                // No more order left.
+                cmpFormation.Disband();
+            },
+
+            "leave": function(msg) {
+                this.StopTimer();
+                var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+                cmpFormation.CallMemberFunction("ResetFinishOrder", []);
+            },
+        },
     },
 
 
     // States for entities moving as part of a formation:
     "FORMATIONMEMBER": {
         "FormationLeave": function(msg) {
+            // We're not in a formation anymore, so no need to track this.
+            this.finishedOrder = false;
+
             // Stop moving as soon as the formation disbands
             this.StopMoving();
 
@@ -1849 +1968 @@
     this.isGarrisoned = false;
     this.isIdle = false;
     this.lastFormationName = "";
+    this.finishedOrder = false; // used to find if all formation members finished the order
 
     // For preventing increased action rate due to Stop orders or target death.
     this.lastAttacked = undefined;
@@ -1862 +1982 @@
     return (this.template.FormationController == "true");
 };
 
+UnitAI.prototype.IsFormationMember = function()
+{
+    return (this.formationController != INVALID_ENTITY);
+};
+
+UnitAI.prototype.HasFinishedOrder = function()
+{
+    return this.finishedOrder;
+};
+
+UnitAI.prototype.ResetFinishOrder = function()
+{
+    this.finishedOrder = false;
+};
+
 UnitAI.prototype.IsAnimal = function()
 {
     return (this.template.NaturalBehaviour ? true : false);
@@ -2149 +2284 @@
     else
     {
         this.SetNextState("IDLE");
+
+        // Check if there are queued formation orders
+        if (this.IsFormationMember())
+        {
+            var cmpUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
+            if (cmpUnitAI)
+            {
+                // Inform the formation controller that we finished this task
+                this.finishedOrder = true;
+                // We don't want to carry out the default order
+                // if there are still queued formation orders left
+                if (cmpUnitAI.GetOrders().length > 1) 
+                    return true;
+            }
+        }
+
         return false;
     }
 };