Ticket #1716: formation-order-queues_formation-atack.patch

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

@@ -50 +50 @@
     }
 
     this.inPosition.push(ent);
-    if (this.inPosition.length >= this.members.length)
+    if (this.inPosition.length >= this.members.length) {
         this.Disband();
+    }
 };
 
 /**
@@ -81 +82 @@
 Formation.prototype.SetMembers = function(ents)
 {
     this.members = ents;
-
     for each (var ent in this.members)
     {
         var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
@@ -122 +122 @@
     this.ComputeMotionParameters();
 
     // Rearrange the remaining members
-    this.MoveMembersIntoFormation(true);
+    this.MoveMembersIntoFormation(true, true);
 };
 
 /**
@@ -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
+ * If moveCenter is true, the formation center will be reinitialized
  * to the center of the units.
+ * If force is true, all individual orders of the formation units are replaced,
+ * otherwise the order to walk into formation is just pushed to the front.
  */
-Formation.prototype.MoveMembersIntoFormation = function(moveCenter)
+Formation.prototype.MoveMembersIntoFormation = function(moveCenter, force)
 {
     var active = [];
     var positions = [];
@@ -213 +230 @@
         var offset = offsets[i];
 
         var cmpUnitAI = Engine.QueryInterface(offset.ent, IID_UnitAI);
-        cmpUnitAI.ReplaceOrder("FormationWalk", {
-            "target": this.entity,
-            "x": offset.x - avgoffset.x,
-            "z": offset.z - avgoffset.z
-        });
+        
+        if (force)
+        {
+            cmpUnitAI.ReplaceOrder("FormationWalk", {
+                "target": this.entity,
+                "x": offset.x - avgoffset.x,
+                "z": offset.z - avgoffset.z
+            });
+        }
+        else
+        {
+            cmpUnitAI.PushOrderFront("FormationWalk", {
+                "target": this.entity,
+                "x": offset.x - avgoffset.x,
+                "z": offset.z - avgoffset.z
+            });
+        }
     }
 };
 
@@ -651 +680 @@
     var walkingDistance = cmpUnitAI.ComputeWalkingDistance();
     var columnar = (walkingDistance > g_ColumnDistanceThreshold);
     if (columnar != this.columnar)
-        this.MoveMembersIntoFormation(false);
+        this.MoveMembersIntoFormation(false, true);
         // (disable moveCenter so we can't get stuck in a loop of switching
         // shape causing center to change causing shape to switch back)
 };

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

@@ -145 +145 @@
         TS_FAIL("invalid mode");
 }
 
+function TestMoveIntoFormationWhileAttacking()
+{
+    ResetState();
+
+    var playerEntity = 5;
+    var controller = 10;
+    var enemy = 20;
+    var unit = 30;
+    var units = [];
+    var unitCount = 8;
+    var unitAIs = [];
+
+    AddMock(SYSTEM_ENTITY, IID_Timer, {
+        SetInterval: function() { },
+        SetTimeout: function() { },
+    });
+
+
+    AddMock(SYSTEM_ENTITY, IID_RangeManager, {
+        CreateActiveQuery: function(ent, minRange, maxRange, players, iid, flags) {
+            return 1;
+        },
+        EnableActiveQuery: function(id) { },
+        ResetActiveQuery: function(id) { return [enemy]; },
+        DisableActiveQuery: function(id) { },
+        GetEntityFlagMask: function(identifier) { },
+    });;
+
+    AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
+        GetPlayerByID: function(id) { return playerEntity; },
+        GetNumPlayers: function() { return 2; },
+    });
+
+    AddMock(playerEntity, IID_Player, {
+        IsAlly: function() { return []; },
+        IsEnemy: function() { return []; },
+    });
+
+    // create units
+    for (var i = 0; i < unitCount; i++) {
+    
+        units.push(unit + i);
+        
+        var unitAI = ConstructComponent(unit + i, "UnitAI", { "FormationController": "false", "DefaultStance": "aggressive" });
+    
+        AddMock(unit + i, IID_Identity, {
+            GetClassesList: function() { return []; },
+        });
+    
+        AddMock(unit + i, IID_Ownership, {
+            GetOwner: function() { return 1; },
+        });
+    
+        AddMock(unit + i, IID_Position, {
+            GetPosition: function() { return { "x": 0, "z": 0 }; },
+            IsInWorld: function() { return true; },
+        });
+    
+        AddMock(unit + i, IID_UnitMotion, {
+            GetWalkSpeed: function() { return 1; },
+            MoveToFormationOffset: function(target, x, z) { },
+            IsInTargetRange: function(target, min, max) { return true; },
+            MoveToTargetRange: function(target, min, max) { },
+            StopMoving: function() { },
+        });
+    
+        AddMock(unit + i, IID_Vision, {
+            GetRange: function() { return 10; },
+        });
+    
+        AddMock(unit + i, IID_Attack, {
+            GetRange: function() { return 10; },
+            GetBestAttack: function() { return "melee"; },
+            GetBestAttackAgainst: function(t) { return "melee"; },
+            GetTimers: function() { return { "prepare": 500, "repeat": 1000 }; },
+            CanAttack: function(v) { return true; },
+            CompareEntitiesByPreference: function(a, b) { return 0; },
+        });
+        
+        unitAI.OnCreate();
+        
+        unitAI.SetupRangeQuery(1);
+        
+        unitAIs.push(unitAI);
+    }
+    
+    // create enemy
+    AddMock(enemy, IID_Health, {
+        GetHitpoints: function() { return 40; },
+    });
+
+    var controllerFormation = ConstructComponent(controller, "Formation");
+    var controllerAI = ConstructComponent(controller, "UnitAI", { "FormationController": "true", "DefaultStance": "aggressive" });
+
+    AddMock(controller, IID_Position, {
+        JumpTo: function(x, z) { this.x = x; this.z = z; },
+        GetPosition: function() { return { "x": this.x, "z": this.z }; },
+        IsInWorld: function() { return true; },
+    });
+
+    AddMock(controller, IID_UnitMotion, {
+        SetUnitRadius: function(r) { },
+        SetSpeed: function(speed) { },
+        MoveToPointRange: function(x, z, minRange, maxRange) { },
+        IsInTargetRange: function(target, min, max) { return true; },
+    });
+
+    controllerAI.OnCreate();
+
+    controllerFormation.SetMembers(units);
+    
+    controllerAI.Attack(enemy, []);
+    
+    for each (var ent in unitAIs) {
+        TS_ASSERT_EQUALS(unitAI.fsmStateName, "INDIVIDUAL.COMBAT.ATTACKING");
+    }
+    
+    controllerAI.MoveIntoFormation({"name": "Circle"});
+    
+    // let all units be in position
+    for each (var ent in unitAIs) {
+        controllerFormation.SetInPosition(ent);
+    }
+
+    for each (var ent in unitAIs) {
+        TS_ASSERT_EQUALS(unitAI.fsmStateName, "INDIVIDUAL.COMBAT.ATTACKING");
+    }
+    
+    controllerFormation.Disband();
+}
+
 TestFormationExiting(0);
 TestFormationExiting(1);
 TestFormationExiting(2);
+
+TestMoveIntoFormationWhileAttacking();
+ No newline at end of file

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

@@ -496 +496 @@
             this.MoveToPoint(this.order.data.x, this.order.data.z);
             this.SetNextState("WALKING");
         },
+        
+        "Order.MoveIntoFormation": function(msg) {
+            var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            cmpFormation.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
 
+            this.MoveToPoint(this.order.data.x, this.order.data.z);
+            this.SetNextState("FORMING");
+        },
+
         // Only used by other orders to walk there in formation
         "Order.WalkToTargetRange": function(msg) {
             if(this.MoveToTargetRangeExplicit(this.order.data.target, this.order.data.min, this.order.data.max))
@@ -512 +520 @@
         },
 
         "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 +585 @@
             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": {
@@ -595 +691 @@
             "MoveStarted": function(msg) {
                 var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
                 cmpFormation.SetRearrange(true);
-                cmpFormation.MoveMembersIntoFormation(true);
+                cmpFormation.MoveMembersIntoFormation(true, true);
             },
 
             "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();
             },
         },
+        
+        "FORMING": {
+            "MoveStarted": function(msg) {
+                var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+                cmpFormation.SetRearrange(true);
+                cmpFormation.MoveMembersIntoFormation(true, false);
+            },
 
+            "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();
+            }
+        },
+
         "REPAIR": {
             "ConstructionFinished": function(msg) {
                 if (msg.data.entity != this.order.data.target)
@@ -620 +733 @@
                 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;
+
+                cmpFormation.CallMemberFunction("ResetFinishOrder", []);
+                
+                // Execute the next order
+                if (this.FinishOrder())
+                    return;
+
+                // No more order left.
+                cmpFormation.Disband();
+            },
+
+            "leave": function(msg) {
+                this.StopTimer();
+            },
+        },
     },
 
 
     // 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();
 
@@ -685 +829 @@
             // is done moving. The controller is notified, and will disband the
             // formation if all units are in formation and no orders remain.
             "MoveCompleted": function(msg) {
+                if(this.FinishOrder())
+                    return;
                 var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
                 cmpFormation.SetInPosition(this.entity);
             },
@@ -1849 +1995 @@
     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 +2009 @@
     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 +2311 @@
     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;
     }
 };
@@ -2887 +3065 @@
     return this.lastFormationName;
 };
 
+UnitAI.prototype.MoveIntoFormation = function(cmd)
+{
+    var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+    if (!cmpFormation)
+        return;
+    cmpFormation.LoadFormation(cmd.name);
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return;
+    var pos = cmpPosition.GetPosition();
+    
+    // add new order to get in formation at the current position
+    this.PushOrderFront("MoveIntoFormation", { "x": pos.x, "z": pos.z, "force": true });
+};
+
 /**
  * Returns the estimated distance that this unit will travel before either
  * finishing all of its orders, or reaching a non-walk target (attack, gather, etc).
@@ -2909 +3102 @@
         switch (order.type)
         {
         case "Walk":
+        case "MoveIntoFormation":
         case "GatherNearPosition":
             // Add the distance to the target point
             var dx = order.data.x - pos.x;

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -370 +370 @@
     case "formation":
         var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
         GetFormationUnitAIs(entities, player, cmd.name).forEach(function(cmpUnitAI) {
-            var cmpFormation = Engine.QueryInterface(cmpUnitAI.entity, IID_Formation);
-            if (!cmpFormation)
-                return;
-            cmpFormation.LoadFormation(cmd.name);
-            cmpFormation.MoveMembersIntoFormation(true);
+            cmpUnitAI.MoveIntoFormation(cmd);
         });
         break;