Ticket #1720: patrol_V3.8.patch

binaries/data/config/default.cfg

@@ -286 +286 @@
 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 = "P"                 ; Modifier to patrol a unit
 repair = "J"                 ; Modifier to repair when clicking on building/mechanical unit
 queue = Shift                ; Modifier to queue unit orders instead of replacing
 batchtrain = Shift           ; Modifier to train units in batches

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

@@ -16 +16 @@
 const ACTION_GARRISON = 1;
 const ACTION_REPAIR = 2;
 const ACTION_GUARD = 3;
+const ACTION_PATROL = 4;
 var preSelectedAction = ACTION_NONE;
 
 const INPUT_NORMAL = 0;
@@ -208 +209 @@
             return { "possible": true, "data": data, "cursor": cursor };
         }
 
-        return { "possible": (action == "move" || action == "attack-move" || action == "remove-guard") };
+        return { "possible": (action == "move" || action == "attack-move" || action == "remove-guard" || action == "patrol") };
     }
 
     // Look at the first targeted entity

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

@@ -208 +208 @@
         "specificness": 10,
     },
 
+    "patrol":
+    {
+        "execute": function(target, action, selection, queued)
+        {
+            Engine.PostNetworkCommand({
+                "type": "patrol",
+                "entities": selection,
+                "x": target.x,
+                "z": target.z,
+                "target": action.target,
+                "targetClasses": { "attack": ["Unit"] }, // patrol should only attack units
+                "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 false;
+            return {
+                "type": "patrol",
+                "cursor": "action-patrol",
+                "target": target
+            };
+        },
+        "preSelectedActionCheck" : function(target)
+        {
+            if (preSelectedAction != ACTION_PATROL || !getActionInfo("patrol", target).possible)
+                return false;
+            return {
+                "type": "patrol",
+                "cursor": "action-patrol",
+                "target": target
+            };
+        },
+        "specificness": 37,
+    },
+
     "heal":
     {
         "execute": function(target, action, selection, queued)
@@ -1218 +1262 @@
         },
     },
 
+    "patrol": {
+        "getInfo": function(entState)
+        {
+            if (!entState.unitAI)
+                return false;
+            return {
+                "tooltip": colorizeHotkey("%(hotkey)s" + " ", "session.patrol") + translate("Patrol"),
+                "icon": "patrol.png"
+            };
+        },
+        "execute": function(entState)
+        {
+            inputState = INPUT_PRESELECTEDACTION;
+            preSelectedAction = ACTION_PATROL;
+        },
+    },
+
     "share-dropsite": {
         "getInfo": function(entState)
         {

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

@@ -514 +514 @@
         this.FinishOrder();
     },
 
+    "Order.Patrol": function(msg) {
+        // Let players move captured domestic animals around
+        if (this.IsAnimal() || 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))
@@ -829 +851 @@
                 this.FinishOrder();
         },
 
+        "Order.Patrol": function(msg) {
+            this.CallMemberFunction("SetHeldPosition", [msg.data.x, msg.data.z]);
+
+            this.MoveToPoint(this.order.data.x, this.order.data.z);
+            this.SetNextState("PATROL");
+        },
+
         "Order.Guard": function(msg) {
             this.CallMemberFunction("Guard", [msg.data.target, false]);
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
@@ -1078 +1107 @@
             },
         },
 
+        "PATROL": {
+            "enter": function(msg) {
+                this.StartTimer(0, 1000);
+
+                // memorize the origin position in case that we want to go back
+                let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+                if (!cmpPosition || !cmpPosition.IsInWorld())
+                {
+                    this.FinishOrder();
+                    return;
+                }
+                this.patrolStartPos = cmpPosition.GetPosition();
+            },
+
+            "Timer": function(msg) {
+                // check if there are no enemies to attack
+                this.FindWalkAndFightTargets();
+            },
+
+            "leave": function(msg) {
+                this.StopTimer();
+            },
+
+            "MoveStarted": function(msg) {
+                let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+                cmpFormation.SetRearrange(true);
+                cmpFormation.MoveMembersIntoFormation(true, true);
+            },
+
+            "MoveCompleted": function() {   
+                // A-B-A-B-..: 
+                // if the user only commands one patrol order, the patrol will be between 
+                // the 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 is not included (last position = the position where the unit
+                // is located at the time of the first patrol order)
+                if (this.orderQueue.length == 1) 
+                    this.orderQueue.push({ "type": "Patrol", "data": this.patrolStartPos });
+
+                this.orderQueue.push(this.order);
+                this.FinishOrder();
+            },
+        },
+
         "GARRISON":{
             "enter": function() {
                 // If the garrisonholder should pickup, warn it so it can take needed action
@@ -1555 +1629 @@
             },
         },
 
+        "PATROL": {
+            "enter": function () {
+                this.StartTimer(0, 1000);
+                this.SelectAnimation("move");
+
+                // memorize the origin position in case that we want to go back
+                let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+                if (!cmpPosition || !cmpPosition.IsInWorld())
+                {
+                    this.FinishOrder();
+                    return;
+                }
+                this.patrolStartPos = cmpPosition.GetPosition();
+            },
+
+            "leave": function() {
+                this.StopTimer();
+            },
+
+            "Timer": function(msg) {
+                this.FindWalkAndFightTargets();
+            },
+
+            "MoveCompleted": function() {
+                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();
@@ -4779 +4885 @@
         case "WalkToPointRange":
         case "MoveIntoFormation":
         case "GatherNearPosition":
+        case "Patrol":
             targetPositions.push(new Vector2D(order.data.x, order.data.z));
             break; // and continue the loop
 
@@ -4991 +5098 @@
     this.AddOrder("WalkAndFight", { "x": x, "z": z, "targetClasses": targetClasses, "force": true }, queued);
 };
 
+UnitAI.prototype.Patrol = function(x, z, targetClasses, queued)
+{
+    this.AddOrder("Patrol", { "x": x, "z": z, "targetClasses": targetClasses, "force": true }, queued);
+};
+
 /**
  * Adds leave foundation order to queue, treated as forced.
  */

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

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