Ticket #1001: attack-move-v2.diff

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

@@ -177 +177 @@
     {
         if (action == "set-rallypoint" && haveRallyPoints)
             return {"possible": true};
-        else if (action == "move")
+        else if (action == "move" || action == "attack-move")
             return {"possible": true};
         else
             return {"possible": false};
@@ -394 +394 @@
             break;
         }
     }
-    if (action == "move")
+    if (action == "move" || action == "attack-move")
         return {"possible": true};
     else
         return {"possible": false};
@@ -474 +474 @@
     {
         if (getActionInfo("garrison", target).possible)
             return {"type": "garrison", "cursor": "action-garrison", "target": target};
+        else if (getActionInfo("attack-move", target).possible)
+            return {"type": "attack-move", "cursor": "action-attack"};
         else
-            return  {"type": "none", "cursor": "action-garrison-disabled", "target": undefined};
+            return {"type": "none", "cursor": "action-garrison-disabled", "target": undefined};
     }
     else
     {
@@ -1307 +1309 @@
         Engine.GuiInterfaceCall("PlaySound", { "name": "order_walk", "entity": selection[0] });
         return true;
 
+    case "attack-move":
+        var target = Engine.GetTerrainAtScreenPoint(ev.x, ev.y);
+        Engine.PostNetworkCommand({"type": "attack-walk", "entities": selection, "x": target.x, "z": target.z, "queued": queued});
+        Engine.GuiInterfaceCall("PlaySound", { "name": "order_walk", "entity": selection[0] });
+        return true;
+
     case "attack":
         Engine.PostNetworkCommand({"type": "attack", "entities": selection, "target": action.target, "queued": queued});
         Engine.GuiInterfaceCall("PlaySound", { "name": "order_attack", "entity": selection[0] });
@@ -1406 +1414 @@
             Engine.GuiInterfaceCall("PlaySound", { "name": "order_walk", "entity": selection[0] });
             return true;
 
+        case "attack-move":
+            Engine.PostNetworkCommand({"type": "attack-walk", "entities": selection, "x": target.x, "z": target.z, "queued": queued});
+            Engine.GuiInterfaceCall("PlaySound", { "name": "order_walk", "entity": selection[0] });
+            return true;
+
         case "set-rallypoint":
             Engine.PostNetworkCommand({"type": "set-rallypoint", "entities": selection, "x": target.x, "z": target.z});
             // Display rally point at the new coordinates, to avoid display lag

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

@@ -88 +88 @@
         });
         break;
 
+    case "attack-walk":
+        var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
+        GetFormationUnitAIs(entities, player).forEach(function(cmpUnitAI) {
+            cmpUnitAI.WalkAndFight(cmd.x, cmd.z, cmd.queued);
+        });
+        break;
+
     case "attack":
         if (g_DebugCommands && !(IsOwnedByEnemyOfPlayer(player, cmd.target) || IsOwnedByNeutralOfPlayer(player, cmd.target)))
         {

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

@@ -270 +270 @@
             this.SetNextState("INDIVIDUAL.WALKING");
     },
 
+    "Order.WalkAndFight": function(msg) {
+        // Let players move captured domestic animals around
+        if (this.IsAnimal() && !this.IsDomestic())
+        {
+            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.SetHeldPosition(this.order.data.x, this.order.data.z);
+        this.MoveToPoint(this.order.data.x, this.order.data.z);
+        if (this.IsAnimal())
+            this.SetNextState("ANIMAL.WALKING");   // WalkAndFight not applicable for animals
+        else
+            this.SetNextState("INDIVIDUAL.WALKINGANDFIGHTING");
+    },
+
+
     "Order.WalkToTarget": function(msg) {
         // Let players move captured domestic animals around
         if (this.IsAnimal() && !this.IsDomestic())
@@ -353 +380 @@
             if (this.CanUnpack())
             {
                 // Ignore unforced attacks
+                // this would prevent attacks from AttackVisibleEntity or AttackEntityInZone ?
+                // so we accept attacks against targets for which we have a bonus
                 // TODO: use special stances instead?
-                if (!this.order.data.force)
+                if (!this.order.data.force && this.GetAttackBonus(type, this.order.data.target) < 1.5)
                 {
                     this.FinishOrder();
                     return;
@@ -613 +642 @@
             this.MoveToPoint(this.order.data.x, this.order.data.z);
             this.SetNextState("WALKING");
         },
+
+        "Order.WalkAndFight": 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("WALKINGANDFIGHTING");
+        },
         
         "Order.MoveIntoFormation": function(msg) {
             var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
@@ -853 +890 @@
             },
         },
 
+        "WALKINGANDFIGHTING": {
+            "enter": function(msg) {
+                this.StartTimer(0, 1000);
+            },
+
+            "Timer": function(msg) {
+                var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+                for each (var ent in cmpFormation.members)
+                {
+                    var cmpUnitAI =  Engine.QueryInterface(ent, IID_UnitAI);
+                        if (cmpUnitAI.FindNewTargets())
+                    {
+                        if (cmpUnitAI.orderQueue[0] && cmpUnitAI.orderQueue[0].type == "Attack")
+                        {
+                            var data = cmpUnitAI.orderQueue[0].data;
+                            cmpUnitAI.FinishOrder();
+                            this.PushOrderFront("Attack", { "target": data.target, "force": false, "forceResponse": data.forceResponse });
+                            break;
+                        }
+                    }
+                }
+            },
+
+            "leave": function(msg) {
+                this.StopTimer();
+            },
+
+            "MoveStarted": function(msg) {
+                var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+                cmpFormation.SetRearrange(true);
+                cmpFormation.MoveMembersIntoFormation(true, true);
+            },
+
+            "MoveCompleted": function(msg) {
+                var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+
+                if (this.FinishOrder())
+                {
+                    cmpFormation.CallMemberFunction("ResetFinishOrder", []);
+                    return;
+                }
+
+                // No more orders left.
+                cmpFormation.Disband();
+            },
+        },
+
         "FORMING": {
             "MoveStarted": function(msg) {
                 var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
@@ -1114 +1198 @@
             },
         },
 
+        "WALKINGANDFIGHTING": {
+            "enter": function () {
+                this.StartTimer(0, 1000);
+                this.SelectAnimation("move");
+            },
+
+            "Timer": function(msg) {
+                this.FindNewTargets();
+            },
+
+            "leave": function(msg) {
+                this.StopTimer();
+            },
+
+            "MoveCompleted": function() {
+                this.FinishOrder();
+            },
+        },
+
         "FLEEING": {
             "enter": function() {
                 this.PlaySound("panic");
@@ -3181 +3284 @@
     return cmpAttack.GetBestAttackAgainst(target);
 };
 
+UnitAI.prototype.GetAttackBonus = function(type, target)
+{
+    var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+    if (!cmpAttack)
+        return 1;
+    return cmpAttack.GetAttackBonus(type, target);
+};
+
 /**
  * Try to find one of the given entities which can be attacked,
  * and start attacking it.
@@ -3393 +3504 @@
         switch (order.type)
         {
         case "Walk":
+        case "WalkAndFight":
         case "WalkToPointRange":
         case "MoveIntoFormation":
         case "GatherNearPosition":
@@ -3479 +3591 @@
 };
 
 /**
+ * Adds walk-to-target order to queue, this only occurs in response
+ * to a player order, and so is forced.
+ */
+UnitAI.prototype.WalkAndFight = function(x, z, queued)
+{
+    this.AddOrder("WalkAndFight", { "x": x, "z": z, "force": true }, queued);
+};
+
+/**
  * Adds leave foundation order to queue, treated as forced.
  */
 UnitAI.prototype.LeaveFoundation = function(target)