Ticket #252: t252_secondattack_20.diff

binaries/data/config/default.cfg

@@ -278 +278 @@
 [hotkey.session]
 kill = Delete                ; Destroy selected units
 stop = "H"                   ; Stop the current action
-attack = Ctrl                ; Modifier to attack instead of another action (eg capture)
-attackmove = Ctrl            ; Modifier to attackmove when clicking on a point
-attackmoveUnit = "Ctrl+Q"    ; Modifier to attackmove targeting only units when clicking on a point (should contain the attackmove keys)
+attack = Ctrl                ; Modifier to primary attack instead of another action (eg capture)
+attackmove = Ctrl            ; Modifier to primary attackmove when clicking on a point
+attackmoveUnit = "Ctrl+Q"    ; Modifier to primary attackmove targeting only units when clicking on a point (should contain the attackmove keys)
 garrison = Ctrl              ; Modifier to garrison when clicking on building
 autorallypoint = Ctrl        ; Modifier to set the rally point on the building itself
+meleeattack = Alt            ; Modifier to melee attack instead of another action
+rangedattack = space         ; Modifier to ranged attack instead of another action
 guard = "G"                  ; Modifier to escort/guard when clicking on unit/building
 queue = Shift                ; Modifier to queue unit orders instead of replacing
 batchtrain = Shift           ; Modifier to train units in batches

binaries/data/mods/public/art/actors/units/persians/champion_unit_1.xml

@@ -42 +42 @@
   <group>
     <variant frequency="1" name="Idle"/>
     <variant file="biped/attack_capture.xml"/>
+    <variant file="biped/attack_ranged_archer.xml">
+      <props>
+        <prop attachpoint="r_hand"/>
+        <prop actor="props/units/weapons/bow_recurve.xml" attachpoint="l_hand"/>
+      </props>
+    </variant>
   </group>
   <material>player_trans.xml</material>
 </actor>

binaries/data/mods/public/art/actors/units/persians/infantry_archer_a.xml

@@ -36 +36 @@
   <group>
     <variant frequency="100" name="Idle"/>
     <variant file="biped/attack_ranged_archer.xml"/>
+    <variant file="biped/attack_melee_ranged.xml"/>
     <variant file="biped/attack_capture.xml"/>
     <variant file="biped/attack_slaughter.xml"/>
     <variant file="biped/gather_tree.xml"/>

binaries/data/mods/public/art/actors/units/persians/infantry_archer_b.xml

@@ -24 +24 @@
   <group>
     <variant frequency="100" name="Idle"/>
     <variant file="biped/attack_ranged_archer.xml"/>
+    <variant file="biped/attack_melee_ranged.xml"/>
     <variant file="biped/attack_capture.xml"/>
     <variant file="biped/attack_slaughter.xml"/>
     <variant file="biped/gather_tree.xml"/>

binaries/data/mods/public/art/actors/units/persians/infantry_archer_e.xml

@@ -37 +37 @@
   <group>
     <variant frequency="100" name="Idle"/>
     <variant file="biped/attack_ranged_archer.xml"/>
+    <variant file="biped/attack_melee_ranged.xml"/>
     <variant file="biped/attack_capture.xml"/>
     <variant file="biped/attack_slaughter.xml"/>
     <variant file="biped/gather_tree.xml"/>

binaries/data/mods/public/art/textures/cursors/action-melee-attack.txt

@@ +1 @@
+1 1

binaries/data/mods/public/art/textures/cursors/action-ranged-attack.txt

@@ +1 @@
+1 1

binaries/data/mods/public/art/variants/biped/attack_melee_ranged.xml

@@ +1 @@
+<variant name="attack_melee">
+  <animations>
+    <animation event="0.5" file="infantry/sword/attack/isw_s_off_05.psa" name="attack_melee" speed="100"/>
+  </animations>
+  <props>
+    <prop actor="props/units/weapons/knife.xml" attachpoint="r_hand"/>
+  </props>
+</variant>

binaries/data/mods/public/globalscripts/Templates.js

@@ -66 +66 @@
 }
 
 /**
+ * Check if entity has all needed attack types.
+ */
+function HasNeededAttackTypes(attack, neededAttackTypes)
+{
+    if (!neededAttackTypes)
+        return true;
+    // transform the string to an array
+    if (typeof neededAttackTypes == "string")
+        neededAttackTypes = neededAttackTypes.split(/\s+/);
+
+    for (let type of neededAttackTypes)
+        if (!attack || attack.constructor === Object && !attack[type] || 
+            attack.constructor === Array && attack.indexOf(type) == -1)
+            return false;
+    return true; 
+}
+
+/**
  * Get information about a template with or without technology modifications.
  *
  * NOTICE: The data returned here should have the same structure as

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

@@ -205 +205 @@
                 data.targetClasses = Engine.HotkeyIsPressed("session.attackmoveUnit") ? { "attack": ["Unit"] } : { "attack": ["Unit", "Structure"] };
                 cursor = "action-attack-move";
             }
+
             return { "possible": true, "data": data, "cursor": cursor };
         }
 
@@ -219 +220 @@
     // Check if the target entity is a resource, dropsite, foundation, or enemy unit.
     // Check if any entities in the selection can gather the requested resource,
     // can return to the dropsite, can build the foundation, or can attack the enemy
-    for each (var entityID in selection)
+    for (let entityID of selection)
     {
-        var entState = GetExtendedEntityState(entityID);
+        let entState = GetExtendedEntityState(entityID);
         if (!entState)
             continue;
 
@@ -228 +229 @@
         if (unitActions[action] && unitActions[action].getActionInfo)
         {
             var r = unitActions[action].getActionInfo(entState, targetState, simState);
-            if (r) // return true if it's possible for one of the entities
+            if (r && r.possible) // return true if it's possible for one of the entities
                 return r;
         }
     }

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

@@ -58 +58 @@
 
             return { "type": "move" };
         },
-        "specificness": 12,
+        "specificness": 13,
     },
 
     "attack-move":
@@ -77 +77 @@
                 "x": target.x,
                 "z": target.z,
                 "targetClasses": targetClasses,
-                "queued": queued
+                "queued": queued,
+                "prefAttackType": "noCapture"
             });
 
             Engine.GuiInterfaceCall("PlaySound", {
@@ -114 +115 @@
                 "type": "attack",
                 "entities": selection,
                 "target": action.target,
-                "allowCapture": true,
-                "queued": queued
+                "queued": queued,
+                "prefAttackType": "Capture"
             });
 
             Engine.GuiInterfaceCall("PlaySound", {
@@ -130 +131 @@
             if (!entState.attack || !targetState.hitpoints)
                 return false;
 
-            return {
-                "possible": Engine.GuiInterfaceCall("CanCapture", {
+            return { "possible": Engine.GuiInterfaceCall("CanCapture", {
                     "entity": entState.id,
                     "target": targetState.id
                 })
@@ -148 +148 @@
                 "target": target
             };
         },
-        "specificness": 9,
+        "specificness": 7,
     },
 
     "attack":
@@ -160 +160 @@
                 "entities": selection,
                 "target": action.target,
                 "queued": queued,
-                "allowCapture": false
+                "prefAttackType": "noCapture"
             });
 
             Engine.GuiInterfaceCall("PlaySound", {
@@ -205 +205 @@
                 "target": target
             };
         },
+        "specificness": 8,
+    },
+
+    "melee-attack":
+    {
+        "execute": function(target, action, selection, queued)
+        {
+            Engine.PostNetworkCommand({
+                "type": "attack",
+                "entities": selection,
+                "target": action.target,
+                "queued": queued,
+                "prefAttackType": "Melee"
+            });
+
+            Engine.GuiInterfaceCall("PlaySound", {
+                "name": "order_attack",
+                "entity": selection[0]
+            });
+
+            return true;
+        },
+        "getActionInfo": function(entState, targetState)
+        {
+            if (!entState.attack || !targetState.hitpoints)
+                return false;
+
+            return { "possible": Engine.GuiInterfaceCall("CanAttack", {
+                "entity": entState.id,
+                "target": targetState.id,
+                "type": "Melee"
+            }) };
+        },
+        "hotkeyActionCheck": function(target)
+        {
+            if (!Engine.HotkeyIsPressed("session.meleeattack") || !getActionInfo("melee-attack", target).possible)
+                return false;
+
+            return {
+                "type": "melee-attack",
+                "cursor": "action-melee-attack",
+                "target": target
+            };
+        },
+        "actionCheck": function(target)
+        {
+            if (!getActionInfo("melee-attack", target).possible)
+                return false;
+
+            return {
+                "type": "melee-attack",
+                "cursor": "action-melee-attack",
+                "target": target
+            };
+        },
+        "specificness": 9,
+    },
+
+    "ranged-attack":
+    {
+        "execute": function(target, action, selection, queued)
+        {
+            Engine.PostNetworkCommand({
+                "type": "attack",
+                "entities": selection,
+                "target": action.target,
+                "queued": queued,
+                "prefAttackType": "Ranged"
+            });
+
+            Engine.GuiInterfaceCall("PlaySound", {
+                "name": "order_attack",
+                "entity": selection[0]
+            });
+
+            return true;
+        },
+        "getActionInfo": function(entState, targetState)
+        {
+            if (!entState.attack || !targetState.hitpoints)
+                return false;
+
+            return { "possible": Engine.GuiInterfaceCall("CanAttack", {
+                "entity": entState.id,
+                "target": targetState.id,
+                "type": "Ranged"
+            }) };
+        },
+        "hotkeyActionCheck": function(target, selection)
+        {
+            if (!Engine.HotkeyIsPressed("session.rangedattack") || !getActionInfo("ranged-attack", target).possible)
+                return false;
+
+            return {
+                "type": "ranged-attack",
+                "cursor": "action-ranged-attack",
+                "target": target
+            };
+        },
+        "actionCheck": function(target, selection)
+        {
+            if (!getActionInfo("ranged-attack", target).possible)
+                return false;
+
+            return {
+                "type": "ranged-attack",
+                "cursor": "action-ranged-attack",
+                "target": target
+            };
+        },
         "specificness": 10,
     },
 
@@ -255 +365 @@
                 "target": target
             };
         },
-        "specificness": 7,
+        "specificness": 6,
     },
 
     "build":
@@ -355 +465 @@
                 "target": target
             };
         },
-        "specificness": 11,
+        "specificness": 12,
     },
 
     "gather":
@@ -376 +486 @@
 
             return true;
         },
-        "getActionInfo":  function(entState, targetState)
+        "getActionInfo": function(entState, targetState)
         {
             if (!targetState.resourceSupply)
                 return false;
@@ -595 +705 @@
             if (targetState.garrisonHolder.garrisonedEntitiesCount + extraCount >= targetState.garrisonHolder.capacity)
                 tooltip = "[color=\"orange\"]" + tooltip + "[/color]";
 
-            if (!MatchesClassList(entState.identity.classes, targetState.garrisonHolder.allowedClasses))
-                return false;
+            if (!MatchesClassList(entState.identity.classes, targetState.garrisonHolder.allowedClasses) ||
+                !HasNeededAttackTypes(entState.attack, targetState.garrisonHolder.neededAttackTypes))
+                return { "possible": false };
 
             return {
                 "possible": true,
@@ -901 +1012 @@
                 "position": actionInfo.position
             };
         },
-        "specificness": 6,
+        "specificness": 5,
     },
 
     "unset-rallypoint":
@@ -983 +1094 @@
             unloadAll();
         },
     },
+
     "delete": {
         "getInfo": function(entState)
         {
@@ -1021 +1133 @@
                 openDeleteDialog(selection);
         },
     },
+
     "stop": {
         "getInfo": function(entState)
         {

binaries/data/mods/public/simulation/ai/common-api/entity.js

@@ -742 +742 @@
         return false;
     },
 
+    isCapturable: function() { return this.get("Capturable") !== undefined; },
     isGarrisonHolder: function() { return this.get("GarrisonHolder") !== undefined; },
     garrisoned: function() { return this._entity.garrisoned; },
     canGarrisonInside: function() { return this._entity.garrisoned.length < this.garrisonMax(); },
@@ -752 +753 @@
     },
 
     moveToRange: function(x, z, min, max, queued = false) {
-        Engine.PostCommand(PlayerID,{"type": "walk-to-range", "entities": [this.id()], "x": x, "z": z, "min": min, "max": max, "queued": queued });
+        Engine.PostCommand(PlayerID,{"type": "walk-to-range", "entities": [this.id()], "x": x, "z": z, "min": min, "max": max, "queued": queued});
         return this;
     },
 
-    attackMove: function(x, z, targetClasses, queued = false) {
-        Engine.PostCommand(PlayerID,{"type": "attack-walk", "entities": [this.id()], "x": x, "z": z, "targetClasses": targetClasses, "queued": queued });
+    attackMove: function(x, z, targetClasses, prefAttackType = "undefined", queued = false) {
+        Engine.PostCommand(PlayerID,{"type": "attack-walk", "entities": [this.id()], "x": x, "z": z, "targetClasses": targetClasses, "prefAttackType": prefAttackType, "queued": queued });
         return this;
     },
 
@@ -791 +792 @@
         return this;
     },
 
-    attack: function(unitId, allowCapture = true, queued = false) {
-        Engine.PostCommand(PlayerID,{"type": "attack", "entities": [this.id()], "target": unitId, "allowCapture": allowCapture, "queued": queued});
+    attack: function(unitId, prefAttackType = undefined, queued = false) {
+        Engine.PostCommand(PlayerID,{"type": "attack", "entities": [this.id()], "target": unitId, "prefAttackType": prefAttackType, "queued": queued});
         return this;
     },
 

binaries/data/mods/public/simulation/ai/common-api/entitycollection.js

@@ -156 +156 @@
 m.EntityCollection.prototype.attackMove = function(x, z, targetClasses, queued)
 {
     queued = queued || false;
-    Engine.PostCommand(PlayerID,{"type": "attack-walk", "entities": this.toIdArray(), "x": x, "z": z, "targetClasses": targetClasses, "queued": queued});
+    Engine.PostCommand(PlayerID, {"type": "attack-walk", "entities": this.toIdArray(), "x": x, "z": z, "targetClasses": targetClasses, "queued": queued, "prefAttackType": undefined});
     return this;
 };
 
@@ -182 +182 @@
 
 m.EntityCollection.prototype.attack = function(unitId)
 {
-    Engine.PostCommand(PlayerID,{"type": "attack", "entities": this.toIdArray(), "target": unitId, "queued": false});
+    Engine.PostCommand(PlayerID,{"type": "attack", "entities": this.toIdArray(), "target": unitId, "queued": false, "prefAttackType": undefined});
     return this;
 };
 

binaries/data/mods/public/simulation/ai/petra/attackPlan.js

@@ -1237 +1237 @@
                 {
                     if (this.isSiegeUnit(gameState, ent))   // needed as mauryan elephants are not filtered out
                         continue;
-                    ent.attack(attacker.id(), !this.noCapture.has(attacker.id()));
+                    ent.attack(attacker.id(), m.getPrefAttackType(ent, attacker, this.noCapture));
                     ent.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
                 }
                 // And if this attacker is a non-ranged siege unit and our unit also, attack it
                 if (this.isSiegeUnit(gameState, attacker) && attacker.hasClass("Melee") && ourUnit.hasClass("Melee"))
                 {
-                    ourUnit.attack(attacker.id(), false);
+                    ourUnit.attack(attacker.id(), "Melee");
                     ourUnit.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
                 }
             }
@@ -1260 +1260 @@
                     let collec = this.unitCollection.filter(API3.Filters.byClass("Melee")).filterNearest(ourUnit.position(), 5);
                     for (let ent of collec.values())
                     {
-                        ent.attack(attacker.id(), false);
+                        ent.attack(attacker.id(), m.getPrefAttackType(ent, attacker, this.noCapture));
                         ent.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
                     }
                 }
@@ -1279 +1279 @@
                                 continue;
                         }
                     }
-                    ourUnit.attack(attacker.id(), !this.noCapture.has(attacker.id()));
+                    ourUnit.attack(attacker.id(), m.getPrefAttackType(ourUnit, attacker, this.noCapture));
                     ourUnit.setMetadata(PlayerID, "lastAttackPlanUpdateTime", time);
                 }
             }
@@ -1459 +1459 @@
                         return valb - vala;
                     });
                     if (mStruct[0].hasClass("Gates"))
-                        ent.attack(mStruct[0].id(), false);
+                        ent.attack(mStruct[0].id(), m.getPrefAttackType(ent, mStruct[0], this.noCapture));
                     else
                     {
                         let rand = Math.floor(Math.random() * mStruct.length * 0.2);
-                        let newTargetId = mStruct[rand].id();
-                        ent.attack(newTargetId, !this.noCapture.has(newTargetId));
+                        let newTarget = mStruct[rand];
+                        ent.attack(newTarget.id(), m.getPrefAttackType(ent, newTarget, this.noCapture));
                     }
                 }
                 else
@@ -1522 +1522 @@
                         return valb - vala;
                     });
                     let rand = Math.floor(Math.random() * mUnit.length * 0.1);
-                    let newTargetId = mUnit[rand].id();
-                    ent.attack(newTargetId, !this.noCapture.has(newTargetId));
+                    let newTarget = mUnit[rand];
+                    ent.attack(newTarget.id(), m.getPrefAttackType(ent, newTarget, this.noCapture));
                 }
                 else if (this.isBlocked)
                     ent.attack(this.target.id(), false);
@@ -1570 +1570 @@
                             return valb - vala;
                         });
                         if (mStruct[0].hasClass("Gates"))
-                            ent.attack(mStruct[0].id(), false);
+                            ent.attack(mStruct[0].id(), m.getPrefAttackType(ent, mStruct[0], this.noCapture));
                         else
                         {
                             let rand = Math.floor(Math.random() * mStruct.length * 0.2);
-                            let newTargetId = mStruct[rand].id();
-                            ent.attack(newTargetId, !this.noCapture.has(newTargetId));
+                            let newTarget = mStruct[rand];
+                            ent.attack(newTarget.id(), m.getPrefAttackType(ent, newTarget, this.noCapture));
                         }
                     }
                     else if (needsUpdate)  // really nothing   let's try to help our nearest unit
@@ -1582 +1582 @@
                     {
                         let distmin = Math.min();
                         let attackerId;
+                        let attacker;
                         this.unitCollection.forEach( function (unit) {
                             if (!unit.position())
                                 return;
@@ -1591 +1592 @@
                             let dist = API3.SquareVectorDistance(unit.position(), ent.position());
                             if (dist > distmin)
                                 return;
+                            if (!gameState.getEntityById(unit.unitAIOrderData()[0].target)) 
+                                return;
                             distmin = dist;
                             attackerId = unit.unitAIOrderData()[0].target;
+                            attacker = gameState.getEntityById(attackerId);
                         });
                         if (attackerId)
-                            ent.attack(attackerId, !this.noCapture.has(attackerId));
+                            ent.attack(attackerId, m.getPrefAttackType(ent, attacker, this.noCapture));
                     }
                 }
             }
@@ -1648 +1652 @@
                 continue;
             if (!ent.isIdle())
                 continue;
-            ent.attack(attacker.id(), !this.noCapture.has(attacker.id()));
+            ent.attack(attacker.id(), !this.noCapture.has(attacker.id(), this.noCapture));
         }
         break;
     }
@@ -2006 +2010 @@
 
     if (this.noCapture.has(targetId))
     {
-        ent.attack(targetId, false);
+        ent.attack(targetId, m.getPrefAttackType(ent, target, this.noCapture));
         return true;
     }
 
@@ -2018 +2022 @@
     if (target.hasClass("Siege") && target.hasClass("Melee"))
     {
         this.noCapture.add(targetId);
-        ent.attack(targetId, false);
+        ent.attack(targetId, m.getPrefAttackType(ent, target, this.noCapture));
         return true;
     }
 
@@ -2035 +2039 @@
     if (antiCapture >= this.captureStrength)
     {
         this.noCapture.add(targetId);
-        ent.attack(targetId, false);
+        ent.attack(targetId, "noCapture");
         return true;
     }
 
@@ -2044 +2048 @@
         this.unitCollection.length < 2*target.garrisoned().length)
     {
         this.noCapture.add(targetId);
-        ent.attack(targetId, false);
+        ent.attack(targetId, "noCapture");
         return true;
     }
 

binaries/data/mods/public/simulation/ai/petra/defenseArmy.js

@@ -77 +77 @@
     {
         this.assignedTo[entID] = idFoe;
         this.assignedAgainst[idFoe].push(entID);
-        ent.attack(idFoe, m.allowCapture(ent, foeEnt), queued);
+        ent.attack(idFoe, m.getPrefAttackType(ent, foeEnt), queued);
     }
     else
         gameState.ai.HQ.navalManager.requireTransport(gameState, ent, ownIndex, foeIndex, foePosition);
@@ -115 +115 @@
         else if (orderData.length && orderData[0].target && orderData[0].attackType && orderData[0].attackType === "Capture")
         {
             let target = gameState.getEntityById(orderData[0].target);
-            if (target && !m.allowCapture(ent, target))
-                ent.attack(orderData[0].target, false);
+            if (target)
+            {
+                let prefAttackType = m.getPrefAttackType(ent, target);
+                if (prefAttackType !== "Capture")
+                    ent.attack(orderData[0].target, prefAttackType);
+            }
         }
     }
 

binaries/data/mods/public/simulation/ai/petra/entityExtend.js

@@ -81 +81 @@
     return strength * ent.maxHitpoints() / 100.0;
 };
 
-/** Decide if we should try to capture or destroy */
-m.allowCapture = function(ent, target)
+// Decide if we should try to capture, melee or range attack
+// TODO make this function less hacky
+m.getPrefAttackType = function(ent, target, noCapture)
 {
-    return !target.hasClass("Siege") || !ent.hasClass("Melee") ||
-        !target.isGarrisonHolder() || !target.garrisoned().length;
+    if (target.hasClass("Siege") || (noCapture && noCapture.has(target.id())))
+        return ent.hasClass("Melee") ? "Melee" : "Range"; // Don't capture for now
+
+    if (target.isCapturable() && (!target.isGarrisonHolder() || !target.garrisoned().length))
+        return "Capture";
+    return "noCapture";
 };
 
 /** Makes the worker deposit the currently carried resources at the closest accessible dropsite */

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

@@ -51 +51 @@
     if (this.invulnerable) 
         return { "killed": false, "change": 0 };
 
-    // Adjust damage values based on armour; exponential armour: damage = attack * 0.9^armour
-    var armourStrengths = this.GetArmourStrengths();
-    var adjHack = hack * Math.pow(0.9, armourStrengths.hack);
-    var adjPierce = pierce * Math.pow(0.9, armourStrengths.pierce);
-    var adjCrush = crush * Math.pow(0.9, armourStrengths.crush);
+    let damage = this.GetDamage(hack, pierce, crush);
 
-    // Total is sum of individual damages
-    // Don't bother rounding, since HP is no longer integral.
-    var total = adjHack + adjPierce + adjCrush;
-
     // Reduce health
-    var cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
-    return cmpHealth.Reduce(total);
+    let cmpHealth = Engine.QueryInterface(this.entity, IID_Health);
+    return cmpHealth.Reduce(damage);
 };
 
 Armour.prototype.GetArmourStrengths = function()
 {
     // Work out the armour values with technology effects
-    var applyMods = (type, foundation) => {
-        var strength;
+    let applyMods = (type, foundation) => {
+        let strength;
         if (foundation) 
         {
             strength = +this.template.Foundation[type];
@@ -82 +74 @@
         return ApplyValueModificationsToEntity("Armour/" + type, strength, this.entity);
     };
     
-    var foundation = Engine.QueryInterface(this.entity, IID_Foundation) && this.template.Foundation;
+    let foundation = Engine.QueryInterface(this.entity, IID_Foundation) && this.template.Foundation;
 
     return {
         "hack": applyMods("Hack", foundation),
@@ -91 +83 @@
     };
 };
 
+Armour.prototype.GetDamage = function(hack, pierce, crush)
+{
+    // Adjust damage values based on armour; exponential armour: damage = attack * 0.9^armour
+    let armourStrengths = this.GetArmourStrengths();
+    let adjHack = hack * Math.pow(0.9, armourStrengths.hack);
+    let adjPierce = pierce * Math.pow(0.9, armourStrengths.pierce);
+    let adjCrush = crush * Math.pow(0.9, armourStrengths.crush);
+
+    // Total is sum of individual damages
+    // Don't bother rounding, since HP is no longer integral.
+    return adjHack + adjPierce + adjCrush;
+};
+
 Engine.RegisterComponentType(IID_DamageReceiver, "Armour", Armour);

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

@@ -229 +229 @@
     return [];
 };
 
-Attack.prototype.CanAttack = function(target)
+Attack.prototype.CanAttack = function(target, wantedType)
 {
     let cmpFormation = Engine.QueryInterface(target, IID_Formation);
     if (cmpFormation)
         return true;
 
+    if (wantedType && !this.template[wantedType])
+        return false;
+
     let cmpThisPosition = Engine.QueryInterface(this.entity, IID_Position);
     let cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
     if (!cmpThisPosition || !cmpTargetPosition || !cmpThisPosition.IsInWorld() || !cmpTargetPosition.IsInWorld())
         return false;
 
-    // Check if the relative height difference is larger than the attack range
-    // If the relative height is bigger, it means they will never be able to
-    // reach each other, no matter how close they come.
-    let heightDiff = Math.abs(cmpThisPosition.GetHeightOffset() - cmpTargetPosition.GetHeightOffset());
-
     const cmpIdentity = Engine.QueryInterface(target, IID_Identity);
     if (!cmpIdentity)
         return undefined;
 
+    let cmpEntityPlayer = QueryOwnerInterface(this.entity);
+    let cmpTargetPlayer = QueryOwnerInterface(target);
+    if (!cmpTargetPlayer || !cmpEntityPlayer)
+        return false;
+
     const targetClasses = cmpIdentity.GetClassesList();
+    let cmpCapturable = QueryMiragedInterface(target, IID_Capturable);
+    if (targetClasses.indexOf("Domestic") == -1 && !cmpEntityPlayer.IsEnemy(cmpTargetPlayer.GetPlayerID()) &&
+       (!cmpCapturable || !cmpCapturable.CanCapture(cmpEntityPlayer.GetPlayerID())))
+        return false;
 
+    // Check if the relative height difference is larger than the attack range
+    // If the relative height is bigger, it means they will never be able to
+    // reach each other, no matter how close they come.
+    let heightDiff = Math.abs(cmpThisPosition.GetHeightOffset() - cmpTargetPosition.GetHeightOffset());
+
     for (let type of this.GetAttackTypes())
     {
-        if (type == "Capture" && !QueryMiragedInterface(target, IID_Capturable))
+        if (wantedType && type != wantedType)
             continue;
 
+        if (type == "Capture" && !cmpCapturable)
+            continue;
+
         if (heightDiff > this.GetRange(type).max)
             continue;
 
@@ -312 +327 @@
     return ret;
 };
 
-Attack.prototype.GetBestAttackAgainst = function(target, allowCapture)
+Attack.prototype.GetBestAttackAgainst = function(target, prefAttackType)
 {
     let cmpFormation = Engine.QueryInterface(target, IID_Formation);
     if (cmpFormation)
@@ -319 +334 @@
     {
         // TODO: Formation against formation needs review
         let types = this.GetAttackTypes();
-        return ["Ranged", "Melee", "Capture"].find(attack => types.indexOf(attack) != -1);
+        return ["Ranged", "Melee", "Capture"].find(attack => types.indexOf(attack) != -1
+            && (!prefAttackType || "no" + attack != prefAttackType));
     }
 
     let cmpIdentity = Engine.QueryInterface(target, IID_Identity);
@@ -326 +342 @@
     if (!cmpIdentity)
         return undefined;
 
+    // If we are visisble garrisoned always do ranged attack if we can.
+    let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (cmpPosition && cmpPosition.GetTurretParent() != INVALID_ENTITY)
+        return this.template.Ranged && "Ranged";
+
     let targetClasses = cmpIdentity.GetClassesList();
     let isTargetClass = className => targetClasses.indexOf(className) != -1;
 
@@ -334 +355 @@
         return "Slaughter";
 
     let attack = this;
+    let isAllowed = function (type) { return !attack.GetRestrictedClasses(type).some(isTargetClass)
+        && (!prefAttackType || "no" + type != prefAttackType); };
+
     let types = this.GetAttackTypes().filter(type => !attack.GetRestrictedClasses(type).some(isTargetClass));
+    if (!types.length)
+        return undefined;
 
-    // check if the target is capturable
-    let captureIndex = types.indexOf("Capture");
-    if (captureIndex != -1)
+    if (prefAttackType && prefAttackType != "Capture" && types.indexOf(prefAttackType) != -1)
+        return prefAttackType;
+    else if (!prefAttackType || prefAttackType == "Capture")
     {
-        let cmpCapturable = QueryMiragedInterface(target, IID_Capturable);
-
-        let cmpPlayer = QueryOwnerInterface(this.entity);
-        if (allowCapture && cmpPlayer && cmpCapturable && cmpCapturable.CanCapture(cmpPlayer.GetPlayerID()))
-            return "Capture";
-        // not captureable, so remove this attack
-        types.splice(captureIndex, 1);
+        // check if the target is capturable
+        let captureIndex = types.indexOf("Capture");
+        if (captureIndex != -1)
+        {
+            let cmpCapturable = QueryMiragedInterface(target, IID_Capturable);
+            let cmpPlayer = QueryOwnerInterface(this.entity);
+            if (cmpPlayer && cmpCapturable && cmpCapturable.CanCapture(cmpPlayer.GetPlayerID()))
+                return "Capture";
+            // not captureable, so remove this attack
+            types.splice(captureIndex, 1);
+        }
     }
 
-    let isPreferred = className => attack.GetPreferredClasses(className).some(isTargetClass);
+    // ignore charges for now: TODO implement these
+    let chargeIndex = types.indexOf("Charge");
+    if (chargeIndex != -1)
+        types.splice(chargeIndex, 1);
 
-    return types.sort((a, b) =>
-        (types.indexOf(a) + (isPreferred(a) ? types.length : 0)) -
-        (types.indexOf(b) + (isPreferred(b) ? types.length : 0))).pop();
+    if (!types.length)
+        return undefined;
+
+    // assume ranged and/or melee attack left
+    // TODO stop assuming that?
+    let meleeIndex = types.indexOf("Melee");
+    let rangedIndex = types.indexOf("Ranged");
+    if (meleeIndex != -1 && rangedIndex != -1)
+    {
+        if (!cmpPosition.IsInWorld())
+            return undefined;
+        let selfPosition = cmpPosition.GetPosition2D();
+        let cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
+        if (!cmpTargetPosition || !cmpTargetPosition.IsInWorld())
+            return undefined;
+        let targetPosition = cmpTargetPosition.GetPosition2D();
+        let distanceToSquared = targetPosition.distanceToSquared(selfPosition);
+        if (distanceToSquared <= Math.pow(this.GetRange("Ranged").min, 2))
+            return "Melee";
+
+        let cmpDamageReceiver = Engine.QueryInterface(target, IID_DamageReceiver);
+        if (!cmpDamageReceiver)
+            return undefined;
+
+        let attackStrengthsMelee = this.GetAttackStrengths("Melee");
+        let attackBonusMelee = this.GetAttackBonus("Melee", target);
+        let DPSMelee = cmpDamageReceiver.GetDamage(
+            attackStrengthsMelee.hack * attackBonusMelee,
+            attackStrengthsMelee.pierce * attackBonusMelee,
+            attackStrengthsMelee.crush * attackBonusMelee
+            ) / this.GetTimers("Melee").repeat;
+
+        let attackStrengthsRanged = this.GetAttackStrengths("Ranged");
+        let attackBonusRanged = this.GetAttackBonus("Ranged", target);
+        let DPSRanged = cmpDamageReceiver.GetDamage(
+            attackStrengthsRanged.hack * attackBonusRanged,
+            attackStrengthsRanged.pierce * attackBonusRanged,
+            attackStrengthsRanged.crush * attackBonusRanged
+            ) / this.GetTimers("Ranged").repeat;
+
+        // When we are out of range do DPS only else take distance into account
+        let maxRange = this.GetFullAttackRange().max;
+        if (distanceToSquared > 1.2 * Math.pow(maxRange, 2))
+        {
+            if (DPSRanged > DPSMelee)
+                return "Ranged";
+            return "Melee";
+        }
+
+        let strenghtRanged = DPSRanged * distanceToSquared / Math.pow(maxRange, 2);
+        let strenghtMelee = DPSMelee * (1 - distanceToSquared / Math.pow(maxRange, 2));
+
+        if (strenghtRanged > strenghtMelee)
+            return "Ranged";
+        return "Melee";
+    }
+    else if (meleeIndex != -1)
+        return "Melee";
+    else if (rangedIndex != -1)
+        return "Ranged";
+    return types[0];
 };
 
 Attack.prototype.CompareEntitiesByPreference = function(a, b)
@@ -517 +608 @@
 
         let horizDistance = targetPosition.horizDistanceTo(selfPosition);
 
-        // This is an approximation of the time ot the target, it assumes that the target has a constant radial
+        // This is an approximation of the time to the target, it assumes that the target has a constant radial
         // velocity, but since units move in straight lines this is not true.  The exact value would be more
         // difficult to calculate and I think this is sufficiently accurate.  (I tested and for cavalry it was
         // about 5% of the units radius out in the worst case)
@@ -593 +684 @@
             "target": target,
             "attacker": this.entity,
             "multiplier": this.GetAttackBonus(type, target),
-            "type":type
+            "type": type
         });
     }
     // TODO: charge attacks (need to design how they work)

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

@@ -10 +10 @@
         "</attribute>" +
         "<text/>" +
     "</element>" +
+    "<optional>" +
+        "<element name='NeededAttackTypes' a:help='AttackType which are needed to garrison inside this holder (from Identity)'>" +
+            "<attribute name='datatype'>" +
+                "<value>tokens</value>" +
+            "</attribute>" +
+            "<text/>" +
+        "</element>" +
+    "</optional>" +
     "<element name='EjectHealth' a:help='Percentage of maximum health below which this holder no longer allows garrisoning'>" +
         "<ref name='nonNegativeDecimal'/>" +
     "</element>" +
@@ -119 +127 @@
 };
 
 /**
+ * Returns an array of attack types which the unit garrisoned inside this
+ * particualar entity needs to have. Obtained from the entity's template 
+ */
+GarrisonHolder.prototype.GetNeededAttackTypes = function()
+{
+    return this.template.NeededAttackTypes ? this.template.NeededAttackTypes._string : undefined;
+};
+
+/**
  * Get Maximum pop which can be garrisoned
  */
 GarrisonHolder.prototype.GetCapacity = function()

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

@@ -357 +357 @@
         ret.garrisonHolder = {
             "entities": cmpGarrisonHolder.GetEntities(),
             "allowedClasses": cmpGarrisonHolder.GetAllowedClasses(),
+            "neededAttackTypes": cmpGarrisonHolder.GetNeededAttackTypes(),
             "capacity": cmpGarrisonHolder.GetCapacity(),
             "garrisonedEntitiesCount": cmpGarrisonHolder.GetGarrisonedEntitiesCount()
         };
@@ -438 +439 @@
         let types = cmpAttack.GetAttackTypes();
         if (types.length)
             ret.attack = {};
+
         for (let type of types)
         {
             ret.attack[type] = cmpAttack.GetAttackStrengths(type);
@@ -1827 +1829 @@
     if (!cmpAttack)
         return false;
 
-    let cmpEntityPlayer = QueryOwnerInterface(data.entity, IID_Player);
-    let cmpTargetPlayer = QueryOwnerInterface(data.target, IID_Player);
-    if (!cmpEntityPlayer || !cmpTargetPlayer)
-        return false;
-
-    // if the owner is an enemy, it's up to the attack component to decide
-    if (cmpEntityPlayer.IsEnemy(cmpTargetPlayer.GetPlayerID()))
-        return cmpAttack.CanAttack(data.target);
-
-    return false;
+    let attackType = data.type || undefined;
+    return cmpAttack.CanAttack(data.target, attackType);
 };
 
 /*

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

@@ -420 +420 @@
         }
 
         // Work out how to attack the given target
-        var type = this.GetBestAttackAgainst(this.order.data.target, this.order.data.allowCapture);
+        let type = this.GetBestAttackAgainst(this.order.data.target, this.order.data.prefAttackType);
         if (!type)
         {
             // Oops, we can't attack at all
@@ -563 +563 @@
         if (this.MustKillGatherTarget(this.order.data.target))
         {
             // Make sure we can attack the target, else we'll get very stuck
-            if (!this.GetBestAttackAgainst(this.order.data.target, false))
+            if (!this.GetBestAttackAgainst(this.order.data.target))
             {
                 // Oops, we can't attack at all - give up
                 // TODO: should do something so the player knows why this failed
@@ -587 +587 @@
                 return;
             }
 
-            this.PushOrderFront("Attack", { "target": this.order.data.target, "force": false, "hunting": true, "allowCapture": false });
+            this.PushOrderFront("Attack", { "target": this.order.data.target, "force": false, "hunting": true, "prefAttackType": undefined });
             return;
         }
 
@@ -842 +842 @@
         },
 
         "Order.Attack": function(msg) {
-            var target = msg.data.target;
-            var allowCapture = msg.data.allowCapture;
-            var cmpTargetUnitAI = Engine.QueryInterface(target, IID_UnitAI);
+            let target = msg.data.target;
+            let prefAttackType = msg.data.prefAttackType;
+            let cmpTargetUnitAI = Engine.QueryInterface(target, IID_UnitAI);
             if (cmpTargetUnitAI && cmpTargetUnitAI.IsFormationMember())
                 target = cmpTargetUnitAI.GetFormationController();
 
@@ -863 +863 @@
                 this.FinishOrder();
                 return;
             }
-            this.CallMemberFunction("Attack", [target, false, allowCapture]);
+            this.CallMemberFunction("Attack", [target, false, prefAttackType]);
             if (cmpAttack.CanAttackAsFormation())
                 this.SetNextState("COMBAT.ATTACKING");
             else
@@ -918 +918 @@
                     return;
                 }
 
-                this.PushOrderFront("Attack", { "target": msg.data.target, "hunting": true, "allowCapture": false });
+                this.PushOrderFront("Attack", { "target": msg.data.target, "hunting": true, "prefAttackType": undefined });
                 return;
             }
 
@@ -1155 +1155 @@
 
                 "MoveCompleted": function(msg) {
                     var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
-                    this.CallMemberFunction("Attack", [this.order.data.target, false, this.order.data.allowCapture]);
+                    this.CallMemberFunction("Attack", [this.order.data.target, false, this.order.data.prefAttackType]);
                     if (cmpAttack.CanAttackAsFormation())
                         this.SetNextState("COMBAT.ATTACKING");
                     else
@@ -1166 +1166 @@
             "ATTACKING": {
                 // Wait for individual members to finish
                 "enter": function(msg) {
-                    var target = this.order.data.target;
-                    var allowCapture = this.order.data.allowCapture;
+                    let target = this.order.data.target;
+                    let prefAttackType = this.order.data.prefAttackType;
                     // Check if we are already in range, otherwise walk there
                     if (!this.CheckTargetAttackRange(target, target))
                     {
@@ -1174 +1174 @@
                         if (this.TargetIsAlive(target) && this.CheckTargetVisible(target))
                         {
                             this.FinishOrder();
-                            this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": allowCapture });
+                            this.PushOrderFront("Attack", { "target": target, "force": false, "prefAttackType": prefAttackType });
                             return true;
                         }
                         this.FinishOrder();
@@ -1190 +1190 @@
                 },
 
                 "Timer": function(msg) {
-                    var target = this.order.data.target;
-                    var allowCapture = this.order.data.allowCapture;
+                    let target = this.order.data.target;
+                    let prefAttackType = this.order.data.prefAttackType;
                     // Check if we are already in range, otherwise walk there
                     if (!this.CheckTargetAttackRange(target, target))
                     {
@@ -1198 +1198 @@
                         if (this.TargetIsAlive(target) && this.CheckTargetVisible(target))
                         {
                             this.FinishOrder();
-                            this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": allowCapture });
+                            this.PushOrderFront("Attack", { "target": target, "force": false, "prefAttackType": prefAttackType });
                             return;
                         }
                         this.FinishOrder();
@@ -1410 +1410 @@
 
             // target the unit
             if (this.CheckTargetVisible(msg.data.attacker))
-                this.PushOrderFront("Attack", { "target": msg.data.attacker, "force": false, "allowCapture": true });
+                this.PushOrderFront("Attack", { "target": msg.data.attacker, "force": false, "prefAttackType": undefined });
             else
             {
                 var cmpPosition = Engine.QueryInterface(msg.data.attacker, IID_Position);
@@ -1805 +1805 @@
                         // Can't reach it - try to chase after it
                         if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
                         {
+                            if (!this.order.data.force)
+                                this.order.data.attackType = this.GetBestAttackAgainst(target);
                             if (this.MoveToTargetAttackRange(target, this.order.data.attackType))
                             {
                                 this.SetNextState("COMBAT.CHASING");
@@ -1916 +1918 @@
                         // Can't reach it - try to chase after it
                         if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
                         {
+                            if (!this.order.data.force)
+                            {
+                                let type = this.GetBestAttackAgainst(target);
+                                if (type)
+                                    this.order.data.attackType = type;
+                            }
                             if (this.MoveToTargetRange(target, IID_Attack, this.order.data.attackType))
                             {
                                 this.SetNextState("COMBAT.CHASING");
@@ -4549 +4557 @@
     return distance < range;
 };
 
-UnitAI.prototype.GetBestAttackAgainst = function(target, allowCapture)
+UnitAI.prototype.GetBestAttackAgainst = function(target, prefAttackType)
 {
     var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
     if (!cmpAttack)
         return undefined;
-    return cmpAttack.GetBestAttackAgainst(target, allowCapture);
+    return cmpAttack.GetBestAttackAgainst(target, prefAttackType);
 };
 
 UnitAI.prototype.GetAttackBonus = function(type, target)
@@ -4572 +4580 @@
  */
 UnitAI.prototype.AttackVisibleEntity = function(ents, forceResponse)
 {
-    var target = ents.find(target => this.CanAttack(target, forceResponse));
+    let target = ents.find(target => this.CanAttack(target, forceResponse));
     if (!target)
         return false;
 
-    this.PushOrderFront("Attack", { "target": target, "force": false, "forceResponse": forceResponse, "allowCapture": true });
+    let prefAttackType = this.GetStance().respondStandGround && "Ranged";
+    this.PushOrderFront("Attack", { "target": target, "force": false, "forceResponse": forceResponse, "prefAttackType": prefAttackType });
     return true;
 };
 
@@ -4589 +4598 @@
 {
     var target = ents.find(target =>
         this.CanAttack(target, forceResponse)
-        && this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
+        && this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target))
         && (this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
     );
     if (!target)
         return false;
 
-    this.PushOrderFront("Attack", { "target": target, "force": false, "forceResponse": forceResponse, "allowCapture": true });
+    this.PushOrderFront("Attack", { "target": target, "force": false, "forceResponse": forceResponse, "prefAttackType": undefined });
     return true;
 };
 
@@ -4986 +4995 @@
  * to a player order, and so is forced.
  * If targetClasses is given, only entities matching the targetClasses can be attacked.
  */
-UnitAI.prototype.WalkAndFight = function(x, z, targetClasses, queued)
+UnitAI.prototype.WalkAndFight = function(x, z, targetClasses, queued, prefAttackType)
 {
-    this.AddOrder("WalkAndFight", { "x": x, "z": z, "targetClasses": targetClasses, "force": true }, queued);
+    this.AddOrder("WalkAndFight", { "x": x, "z": z, "targetClasses": targetClasses, "force": true, "prefAttackType": prefAttackType }, queued);
 };
 
 /**
@@ -5009 +5018 @@
 /**
  * Adds attack order to the queue, forced by the player.
  */
-UnitAI.prototype.Attack = function(target, queued, allowCapture)
+UnitAI.prototype.Attack = function(target, queued, prefAttackType)
 {
     if (!this.CanAttack(target))
     {
@@ -5021 +5030 @@
             this.WalkToTarget(target, queued);
         return;
     }
-    this.AddOrder("Attack", { "target": target, "force": true, "allowCapture": allowCapture}, queued);
+    this.AddOrder("Attack", { "target": target, "force": true, "prefAttackType": prefAttackType }, queued);
 };
 
 /**
@@ -5450 +5459 @@
                     if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
                         continue;
                 }
-                this.PushOrderFront("Attack", { "target": targ, "force": true, "allowCapture": true });
+                this.PushOrderFront("Attack", { "target": targ, "force": true, "prefAttackType": undefined });
                 return true;
             }
         }
@@ -5476 +5485 @@
             if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
                 continue;
         }
-        this.PushOrderFront("Attack", { "target": targ, "force": true, "allowCapture": true });
+        this.PushOrderFront("Attack", { "target": targ, "force": true, "prefAttackType": undefined });
         return true;
     }
 
@@ -5676 +5685 @@
     if (this.IsFormationController())
         return true;
 
-    var cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
+    let cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
     if (!cmpGarrisonHolder)
         return false;
 
     // Verify that the target is owned by this entity's player or a mutual ally of this player
-    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    let cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
     if (!cmpOwnership || !(IsOwnedByPlayer(cmpOwnership.GetOwner(), target) || IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target)))
         return false;
 
@@ -5691 +5700 @@
     if (this.IsAnimal())
         return false;
 
+    let cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity)
+    if (!cmpIdentity)
+        return false;
+
+    let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack)
+    let attackTypes = cmpAttack ? cmpAttack.GetAttackTypes() : [];
+    if (!MatchesClassList(cmpIdentity.GetClassesList(), cmpGarrisonHolder.GetAllowedClasses()) || 
+        !HasNeededAttackTypes(attackTypes, cmpGarrisonHolder.GetNeededAttackTypes()))
+        return false;
     return true;
 };
 

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

@@ -97 +97 @@
     AddMock(unit, IID_Attack, {
         GetRange: function() { return { "max": 10, "min": 0}; },
         GetFullAttackRange: function() { return { "max": 40, "min": 0}; },
-        GetBestAttackAgainst: function(t) { return "melee"; },
+        GetBestAttackAgainst: function(t) { return "Melee"; },
         GetPreference: function(t) { return 0; },
         GetTimers: function() { return { "prepare": 500, "repeat": 1000 }; },
         CanAttack: function(v) { return true; },
@@ -247 +247 @@
         AddMock(unit + i, IID_Attack, {
             GetRange: function() { return {"max":10, "min": 0}; },
             GetFullAttackRange: function() { return { "max": 40, "min": 0}; },
-            GetBestAttackAgainst: function(t) { 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; },

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

@@ -160 +160 @@
     "attack-walk": function(player, cmd, data)
     {
         GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
-            cmpUnitAI.WalkAndFight(cmd.x, cmd.z, cmd.targetClasses, cmd.queued);
+            cmpUnitAI.WalkAndFight(cmd.x, cmd.z, cmd.targetClasses, cmd.queued, cmd.prefAttackType);
         });
     },
 
@@ -169 +169 @@
         if (g_DebugCommands && !(IsOwnedByEnemyOfPlayer(player, cmd.target) || IsOwnedByNeutralOfPlayer(player, cmd.target)))
             warn("Invalid command: attack target is not owned by enemy of player "+player+": "+uneval(cmd));
 
-        let allowCapture = cmd.allowCapture || cmd.allowCapture == null;
-
         GetFormationUnitAIs(data.entities, player).forEach(cmpUnitAI => {
-            cmpUnitAI.Attack(cmd.target, cmd.queued, allowCapture);
+            cmpUnitAI.Attack(cmd.target, cmd.queued, cmd.prefAttackType);
         });
     },
 

binaries/data/mods/public/simulation/templates/template_structure_defense_wall_long.xml

@@ -12 +12 @@
   </Health>
   <GarrisonHolder>
     <Max>5</Max>
-    <List datatype="tokens">Ranged+Infantry</List>
+    <List datatype="tokens">Infantry</List>
+    <NeededAttackTypes datatype="tokens">Ranged</NeededAttackTypes>
     <EjectHealth>0.1</EjectHealth>
     <EjectClassesOnDestroy datatype="tokens">Unit</EjectClassesOnDestroy>
     <BuffHeal>0</BuffHeal>

binaries/data/mods/public/simulation/templates/template_structure_defense_wall_medium.xml

@@ -9 +9 @@
   </Cost>
   <GarrisonHolder>
     <Max>3</Max>
-    <List datatype="tokens">Ranged+Infantry</List>
+    <List datatype="tokens">Infantry</List>
+    <NeededAttackTypes datatype="tokens">Ranged</NeededAttackTypes>
     <EjectHealth>0.1</EjectHealth>
     <EjectClassesOnDestroy datatype="tokens">Unit</EjectClassesOnDestroy>
     <BuffHeal>0</BuffHeal>

binaries/data/mods/public/simulation/templates/template_unit_infantry_ranged.xml

@@ -6 +6 @@
     <Crush>10</Crush>
   </Armour>
   <Attack>
+    <Melee>
+      <Hack>3</Hack>
+      <Pierce>0</Pierce>
+      <Crush>0</Crush>
+      <MaxRange>4.0</MaxRange>
+      <RepeatTime>1000</RepeatTime>
+      <PreferredClasses datatype="tokens">Human</PreferredClasses>
+    </Melee>
     <Ranged>
       <Hack>0</Hack>
       <Pierce>1.5</Pierce>

binaries/data/mods/public/simulation/templates/template_unit_infantry_ranged_archer.xml

@@ -10 +10 @@
       <Pierce>6.0</Pierce>
       <Crush>0</Crush>
       <MaxRange>72.0</MaxRange>
-      <MinRange>0.0</MinRange>
+      <MinRange>10.0</MinRange>
       <ProjectileSpeed>120.0</ProjectileSpeed>
       <PrepareTime>1000</PrepareTime>
       <RepeatTime>1000</RepeatTime>

binaries/data/mods/public/simulation/templates/units/pers_champion_infantry.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_champion_infantry_spearman">
+  <Attack>
+    <Ranged>
+      <Hack>0</Hack>
+      <Pierce>6.0</Pierce>
+      <Crush>0</Crush>
+      <MaxRange>65.0</MaxRange>
+      <MinRange>10.0</MinRange>
+      <ProjectileSpeed>120.0</ProjectileSpeed>
+      <PrepareTime>1000</PrepareTime>
+      <RepeatTime>1000</RepeatTime>
+      <Spread>3.0</Spread>
+    </Ranged>
+  </Attack>
   <Identity>
     <Civ>pers</Civ>
     <GenericName>Persian Immortal</GenericName>