Ticket #1720: patrol_V2.patch

binaries/data/config/default.cfg

@@ -278 +278 @@
 garrison = Ctrl              ; Modifier to garrison when clicking on building
 autorallypoint = Ctrl        ; Modifier to set the rally point on the building itself
 guard = "G"                  ; Modifier to escort/guard when clicking on unit/building
+patrol = "X"                 ; Modifier to patrol a unit
 queue = Shift                ; Modifier to queue unit orders instead of replacing
 batchtrain = Shift           ; Modifier to train units in batches
 massbarter = Shift           ; Modifier to barter bunch of resources

binaries/data/mods/public/gui/session/input.js

@@ -208 +208 @@
             return { "possible": true, "data": data, "cursor": cursor };
         }
 
+        if (action == "patrol")
+        {
+            // dirty hack
+            return { "possible": true };
+        }
+
         return { "possible": (action == "move" || action == "attack-move" || action == "remove-guard") };
     }
 
@@ -1161 +1167 @@
     // of running it immediately
     var queued = Engine.HotkeyIsPressed("session.queue");
     var target = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
-
+    
     if (unitActions[action.type] && unitActions[action.type].execute)
         return unitActions[action.type].execute(target, action, selection, queued);
     error("Invalid action.type "+action.type);

binaries/data/mods/public/gui/session/unit_actions.js

@@ -139 +139 @@
         "specificness": 10,
     },
 
+    "patrol":
+    {
+        "execute": function(target, action, selection, queued)
+        {
+            queued = true;
+            Engine.PostNetworkCommand({"type": "patrol", "entities": selection, "x": target.x, "z": target.z, "target": action.target, "queued": queued, "allowCapture": false});
+            Engine.GuiInterfaceCall("PlaySound", { "name": "order_patrol", "entity": selection[0] });
+            return true;
+        },
+        "getActionInfo": function(entState, targetState)
+        {
+            return {"possible": true};
+        },
+        "hotkeyActionCheck": function(target)
+        {
+            if (Engine.HotkeyIsPressed("session.patrol") && getActionInfo("patrol", target).possible)
+                return {"type": "patrol", "cursor": "action-patrol", "target": target};
+            return false;
+        },
+        "preSelectedActionCheck" : function(target)
+        {
+            let ACTION_PATROL = 9999; // TODO add in input.js and a gui btn
+            /*if (preSelectedAction != ACTION_PATROL)
+                return false;
+            if (getActionInfo("patrol", target).possible)
+                return {"type": "patrol", "cursor": "action-patrol", "target": target};
+            */
+            return false;
+        },
+        "specificness": 37,
+
+    },
+
     "heal": 
     {
         "execute": function(target, action, selection, queued)

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

@@ -510 +510 @@
         this.FinishOrder();
     },
 
+    "Order.Patrol": function(msg) {
+        // Let players move captured domestic animals around
+        if (this.IsAnimal() && !this.IsDomestic() || this.IsTurret())
+        {
+            this.FinishOrder();
+            return;
+        }
+
+        // For packable units:
+        // 1. If packed, we can move.
+        // 2. If unpacked, we first need to pack, then follow case 1.
+        if (this.CanPack())
+        {
+            // Case 2: pack
+            this.PushOrderFront("Pack", { "force": true });
+            return;
+        }
+
+        this.MoveToPoint(this.order.data.x, this.order.data.z);
+        this.SetNextState("INDIVIDUAL.PATROL");
+    },
+
     "Order.Heal": function(msg) {
         // Check the target is alive
         if (!this.TargetIsAlive(this.order.data.target))
@@ -1555 +1577 @@
             },
         },
 
+        "PATROL": {
+            "enter": function () {
+                this.StartTimer(0, 1000);
+                this.SelectAnimation("move");
+
+                // memorize the origin position in case that we want to go back
+                let cntPosition = Engine.QueryInterface(this.entity, IID_Position);
+                if (!cntPosition || !cntPosition.IsInWorld())
+                {
+                    this.FinishOrder();
+                    return;
+                }
+                this.patrolStartPos = cntPosition.GetPosition()
+            },
+
+            "leave": function() {
+                this.StopTimer();
+            },
+
+            "Timer": function(msg) {
+                this.FindWalkAndFightTargets();
+            },
+
+            "MoveCompleted": function() {   
+
+                // A-B-A-B-..: 
+                // if the user only commands one patrol order, the patrol will be between 
+                // last position and the defined waypoint
+                // A-B-C-..-A-B-..:
+                // otherwise, the patrol is only between the given patrol commands and the
+                // last position (position of the unit at the time of the first order) is
+                // not included
+                // -- this is a design decision because the order queue can be extended at
+                // any time and this makes it difficult to estimate the last walk back to the
+                // origin position
+                if (this.orderQueue.length == 1) 
+                {
+                    this.orderQueue.push({"type": "Patrol", "data": this.patrolStartPos});
+                }
+
+                this.orderQueue.push(this.order);
+                this.FinishOrder();
+            },
+        },
+
         "GUARD": {
             "RemoveGuard": function() {
                 this.StopMoving();
@@ -1799 +1866 @@
                     }
                     // Check the target is still alive and attackable
                     if (this.TargetIsAlive(target) &&
-                        this.CanAttack(target, this.order.data.forceResponse || null) &&
-                        !this.CheckTargetAttackRange(target, this.order.data.attackType))
+                        this.CanAttack(target, this.order.data.forceResponse || null) &&
+                        !this.CheckTargetAttackRange(target, this.order.data.attackType))
                     {
                         // Can't reach it - try to chase after it
                         if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
@@ -2035 +2102 @@
                     var cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
                     var cmpMirage = Engine.QueryInterface(this.gatheringTarget, IID_Mirage);
                     if ((!cmpMirage || !cmpMirage.Mirages(IID_ResourceSupply)) &&
-                        (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity)))
+                        (!cmpSupply || !cmpSupply.AddGatherer(cmpOwnership.GetOwner(), this.entity)))
                     {
                         // Save the current order's data in case we need it later
                         var oldType = this.order.data.type;
@@ -3563 +3630 @@
         error("FinishOrder called for entity " + this.entity + " (" + template + ") when order queue is empty\n" + stack);
     }
 
+    // next order
     this.orderQueue.shift();
     this.order = this.orderQueue[0];
 
@@ -4759 +4827 @@
         case "WalkToPointRange":
         case "MoveIntoFormation":
         case "GatherNearPosition":
+        case "Patrol":
             targetPositions.push(new Vector2D(order.data.x, order.data.z));
             break; // and continue the loop
 
@@ -4971 +5040 @@
     this.AddOrder("WalkAndFight", { "x": x, "z": z, "targetClasses": targetClasses, "force": true }, queued);
 };
 
+UnitAI.prototype.Patrol = function(x, z, queued)
+{
+    this.AddOrder("Patrol", { "x": x, "z": z, "targetClasses": "[ UNIT ]", "force": true }, queued);
+};
+
 /**
  * Adds leave foundation order to queue, treated as forced.
  */

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

@@ -156 +156 @@
         });
     },
 
+    "patrol": function(player, cmd, data)
+    {
+        GetFormationUnitAIs(data.entities, player).forEach(function(cmpUnitAI) {
+            cmpUnitAI.Patrol(cmd.x, cmd.z, cmd.queued);
+        });
+    },
+
     "heal": function(player, cmd, data)
     {
         if (g_DebugCommands && !(IsOwnedByPlayer(player, cmd.target) || IsOwnedByAllyOfPlayer(player, cmd.target)))