Ticket #865: diffStances-29-05-2011.patch

source/simulation2/components/ICmpRangeManager.cpp

@@ -36 +36 @@
 BEGIN_INTERFACE_WRAPPER(RangeManager)
 DEFINE_INTERFACE_METHOD_5("ExecuteQuery", std::vector<entity_id_t>, ICmpRangeManager, ExecuteQuery, entity_id_t, entity_pos_t, entity_pos_t, std::vector<int>, int)
 DEFINE_INTERFACE_METHOD_5("CreateActiveQuery", ICmpRangeManager::tag_t, ICmpRangeManager, CreateActiveQuery, entity_id_t, entity_pos_t, entity_pos_t, std::vector<int>, int)
+DEFINE_INTERFACE_METHOD_3("ModifyRangeActiveQuery", std::vector<entity_id_t>, ICmpRangeManager, ModifyRangeActiveQuery, ICmpRangeManager::tag_t, entity_pos_t, entity_pos_t)
 DEFINE_INTERFACE_METHOD_1("DestroyActiveQuery", void, ICmpRangeManager, DestroyActiveQuery, ICmpRangeManager::tag_t)
 DEFINE_INTERFACE_METHOD_1("EnableActiveQuery", void, ICmpRangeManager, EnableActiveQuery, ICmpRangeManager::tag_t)
 DEFINE_INTERFACE_METHOD_1("DisableActiveQuery", void, ICmpRangeManager, DisableActiveQuery, ICmpRangeManager::tag_t)

source/simulation2/components/ICmpRangeManager.h

@@ -102 +102 @@
         entity_pos_t minRange, entity_pos_t maxRange, std::vector<int> owners, int requiredInterface) = 0;
 
     /**
+     * Modify an active query's range parameters and execute a ResetActiveQuery.
+     * @param tag identifier of query.
+     * @param minRange non-negative minimum distance in metres (inclusive).
+     * @param maxRange non-negative maximum distance in metres (inclusive); or -1.0 to ignore distance.
+     * @return list of entities matching the query, ordered by increasing distance from the source entity.
+     */
+    virtual std::vector<entity_id_t> ModifyRangeActiveQuery(tag_t tag,
+        entity_pos_t minRange, entity_pos_t maxRange) = 0;
+
+    /**
      * Destroy a query and clean up resources. This must be called when an entity no longer needs its
      * query (e.g. when the entity is destroyed).
      * @param tag identifier of query.

source/simulation2/components/CCmpRangeManager.cpp

@@ -459 +459 @@
         return (tag_t)id;
     }
 
+    virtual std::vector<entity_id_t> ModifyRangeActiveQuery(tag_t tag,
+        entity_pos_t minRange, entity_pos_t maxRange)
+    {
+        std::map<tag_t, Query>::iterator it = m_Queries.find(tag);
+        if (it == m_Queries.end())
+        {
+            LOGERROR(L"CCmpRangeManager: ModifyRangeActiveQuery called with invalid tag %d", tag);
+            std::vector<entity_id_t> r;
+            return r;
+        }
+
+        Query& q = it->second;
+        q.minRange = minRange;
+        q.maxRange = maxRange;
+        return ResetActiveQuery(tag);
+    }
+
     virtual void DestroyActiveQuery(tag_t tag)
     {
         if (m_Queries.find(tag) == m_Queries.end())

binaries/data/mods/public/maps/scenarios/Combat_demo.xml

@@ -40 +40 @@
       "Civ": "hele"
     }
   ],
-  "RevealMap": true
+  "RevealMap": true,
+  "DefaultStance": "stand"
 }
 ]]></ScriptSettings>
     <Entities>
@@ -1285 +1286 @@
         </Entity>
     </Entities>
     <Paths/>
-</Scenario>
- No newline at end of file
+</Scenario>

binaries/data/mods/public/maps/scenarios/Pathfinding_demo.xml

@@ -41 +41 @@
     }
   ],
   "RevealMap": true,
-  "DefaultStance": "holdfire",
+  "DefaultStance": "defensive",
   "GameType": "endless"
 }
 ]]></ScriptSettings>
@@ -684 +684 @@
         </Entity>
     </Entities>
     <Paths/>
-</Scenario>
- No newline at end of file
+</Scenario>

binaries/data/mods/public/gui/session/session.xml

@@ -408 +408 @@
     </object>
 
     <!-- ================================  ================================ -->
+    <!-- Stance Selection (Temporary location) -->
+    <!-- ================================  ================================ -->
+    <object name="unitStancePanel"
+        style="goldPanelFrilly"
+        size="50 50 300 106"
+        type="text"
+    >
+        <object size="-5 -2 59 62" type="image" sprite="snIconSheetTab" tooltip_style="sessionToolTipBottom"
+             cell_id="4" tooltip="Stances"/>
+
+        <object size="56 12 100% 100%">
+            <repeat count="5">
+                <object name="unitStanceButton[n]" hidden="true" style="iconButton" type="button" size="0 0 36 36" tooltip_style="sessionToolTipBottomBold" z="100">
+                    <object name="unitStanceIcon[n]" type="image" style="formationIcon" ghost="true" size="3 3 33 33"/>
+                </object>
+            </repeat>
+        </object>
+    </object>
+
+    <!-- ================================  ================================ -->
     <!-- Idle Worker Button -->
     <!-- ================================  ================================ -->
     <object type="image"
@@ -640 +660 @@
                 </object>
             </object>
 
-            <object name="unitStancePanel"
-                style="goldPanelFrilly"
-                size="0 100%-56 100% 100%"
-                type="text"
-            >
-                <object size="-5 -2 59 62" type="image" sprite="snIconSheetTab" tooltip_style="sessionToolTipBottom"
-                     cell_id="4" tooltip="Stances"/>
-
-                [stance commands]
-            </object>
-
             <object name="unitResearchPanel"
                 style="goldPanelFrilly"
                 size="0 100%-56 100% 100%"

binaries/data/mods/public/gui/session/styles.xml

@@ -123 +123 @@
         ghost="true"
     />
 
+    <style name="stanceIcon"
+        sprite="snIconSheetStance"
+        sprite_disabled="snIconSheetStance"
+        ghost="true"
+    />
+
     <style name="commandIcon"
         sprite="commands"
         ghost="true"

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

@@ -46 +46 @@
 var doubleClicked = false;
 // Store the previously clicked entity - ensure a double/triple click happens on the same entity
 var prevClickedEntity = 0;
+var prevIsRight = false;
 
 // Same double-click behaviour for hotkey presses
 const doublePressTime = 500;
@@ -641 +642 @@
             {
                 dragStart = [ ev.x, ev.y ];
                 inputState = INPUT_SELECTING;
+                prevIsRight = false;
                 return true;
             }
             else if (ev.button == SDL_BUTTON_RIGHT)
@@ -648 +650 @@
                 var action = determineAction(ev.x, ev.y);
                 if (!action)
                     break;
-                return doAction(action, ev);
+
+                var v = false;
+
+                var now = new Date();
+                if ((now.getTime() - doubleClickTimer < doubleClickTime) && (prevIsRight == true))
+                {
+                    v = true;
+                }
+                else
+                {
+                    prevIsRight = true;
+                    doubleClickTimer = now.getTime();
+                }
+
+                return doAction(action, ev, v);
             }
             break;
 
@@ -861 +877 @@
     return false;
 }
 
-function doAction(action, ev)
+function doAction(action, ev, d)
 {
     var selection = g_Selection.toList();
 
@@ -873 +889 @@
     {
     case "move":
         var target = Engine.GetTerrainAtPoint(ev.x, ev.y);
-        Engine.PostNetworkCommand({"type": "walk", "entities": selection, "x": target.x, "z": target.z, "queued": queued});
+        var type = d ? "run" : "walk";
+        Engine.PostNetworkCommand({"type": type, "entities": selection, "x": target.x, "z": target.z, "queued": queued});
         Engine.GuiInterfaceCall("PlaySound", { "name": "order_walk", "entity": selection[0] });
         return true;
 
@@ -1111 +1128 @@
     }
 }
 
+// Performs the specified stance
+function performStance(entity, stanceName)
+{
+    if (entity)
+    {
+        var selection = g_Selection.toList();
+        Engine.PostNetworkCommand({
+            "type": "stance",
+            "entities": selection,
+            "name": stanceName
+        });
+    }
+}
+
 // Performs the specified group
 function performGroup(action, groupId)
 {

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

@@ -6 +6 @@
 const TRAINING = "Training";
 const CONSTRUCTION = "Construction";
 const COMMAND = "Command";
+const STANCE = "Stance";
 
 // Constants
 const COMMANDS_PANEL_WIDTH = 228;
@@ -13 +14 @@
 const UNIT_PANEL_HEIGHT = 44; // QUEUE: The height needed for a row of buttons
 
 // The number of currently visible buttons (used to optimise showing/hiding)
-var g_unitPanelButtons = {"Selection": 0, "Queue": 0, "Formation": 0, "Garrison": 0, "Training": 0, "Construction": 0, "Command": 0};
+var g_unitPanelButtons = {"Selection": 0, "Queue": 0, "Formation": 0, "Garrison": 0, "Training": 0, "Construction": 0, "Command": 0, "Stance": 0};
 
 // Unit panels are panels with row(s) of buttons
 var g_unitPanels = ["Selection", "Queue", "Formation", "Garrison", "Training", "Construction", "Research", "Stance", "Command"];
@@ -153 +154 @@
         var item = items[i];
         var entType = ((guiName == "Queue")? item.template : item);
         var template;
-        if (guiName != "Formation" && guiName != "Command")
+        if (guiName != "Formation" && guiName != "Command" && guiName != "Stance")
         {
             template = GetTemplateData(entType);
             if (!template)
@@ -190 +191 @@
             getGUIObjectByName("unit"+guiName+"Count["+i+"]").caption = (count > 1 ? count : "");
             break;
 
+        case STANCE:
         case FORMATION:
             var tooltip = toTitleCase(item);
             break;
@@ -265 +267 @@
                 icon.sprite = "formation";
             }
         }
+        else if (guiName == "Stance")
+        {
+            icon.cell_id = i;
+            icon.sprite = "snIconSheetStance";
+        }
         else if (guiName == "Command")
         {
             //icon.cell_id = i;
@@ -368 +375 @@
             setupUnitPanel("Formation", usedPanels, entState, formations,
                 function (item) { performFormation(entState.id, item); } );
 
+        var stances = ["violent","aggressive","passive","defensive","stand"];
+        if (isUnit(entState) && !isAnimal(entState) && !entState.garrisonHolder && stances.length)
+            setupUnitPanel("Stance", usedPanels, entState, stances,
+                function (item) { performStance(entState.id, item); } );
+
         if (entState.buildEntities && entState.buildEntities.length)
         {
             setupUnitPanel("Construction", usedPanels, entState, entState.buildEntities, startBuildingPlacement);

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

@@ -14 +14 @@
         for each (var ent in Engine.GetEntitiesWithInterface(IID_UnitAI))
         {
             var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
-            cmpUnitAI.SetStance(settings.DefaultStance);
+            cmpUnitAI.SwitchToStance(settings.DefaultStance);
         }
     }
 

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

@@ -27 +27 @@
             cmpUnitAI.Walk(cmd.x, cmd.z, cmd.queued);
         break;
 
+    case "run":
+        var cmpUnitAI = GetFormationUnitAI(cmd.entities);
+        if (cmpUnitAI)
+            cmpUnitAI.Run(cmd.x, cmd.z, cmd.queued);
+        break;
+
     case "attack":
         var cmpUnitAI = GetFormationUnitAI(cmd.entities);
         if (cmpUnitAI)
@@ -261 +267 @@
         }
         break;
 
+    case "stance":
+        for each (var ent in cmd.entities)
+        {
+            var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+            if (cmpUnitAI)
+                cmpUnitAI.SwitchToStance(cmd.name);
+        }
+        break;
+
     default:
         error("Ignoring unrecognised command type '" + cmd.type + "'");
     }

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

@@ -6 +6 @@
     "<element name='DefaultStance'>" +
         "<choice>" +
             "<value>aggressive</value>" +
-            "<value>holdfire</value>" +
-            "<value>noncombat</value>" +
+            "<value>defensive</value>" +
+            "<value>passive</value>" +
         "</choice>" +
     "</element>" +
     "<element name='FormationController'>" +
@@ -59 +59 @@
 // TODO: even this limited version isn't implemented properly yet (e.g. it can't handle
 // dynamic stance changes).
 var g_Stances = {
-    "aggressive": {
+    "violent": {
         targetVisibleEnemies: true,
         targetAttackers: true,
         respondFlee: false,
         respondChase: true,
+        respondStandGround : false,
+        respondHoldGround : false,
     },
-    "holdfire": {
-        targetVisibleEnemies: false,
+    "aggressive": {
+        targetVisibleEnemies: true,
         targetAttackers: true,
         respondFlee: false,
         respondChase: true,
+        respondStandGround : false,
+        respondHoldGround : false,
     },
-    "noncombat": {
+    "defensive": {
+        targetVisibleEnemies: true,
+        targetAttackers: true,
+        respondFlee: false,
+        respondChase: false,
+        respondStandGround : false,
+        respondHoldGround : true,
+    },
+    "passive": {
         targetVisibleEnemies: false,
         targetAttackers: true,
         respondFlee: true,
         respondChase: false,
+        respondStandGround : false,
+        respondHoldGround : false,
     },
+    "stand": {
+        targetVisibleEnemies: true,
+        targetAttackers: true,
+        respondFlee: false,
+        respondChase: false,
+        respondStandGround : true,
+        respondHoldGround : false,
+    },
 };
 
 // See ../helpers/FSM.js for some documentation of this FSM specification syntax
@@ -114 +136 @@
         // ignore
     },
 
+    "StanceChanged": function(msg) {
+        if (this.StanceSpecificQuery(this.stance,true))
+            return;
+    },
+
     // Formation handlers:
 
     "FormationLeave": function(msg) {
@@ -154 +181 @@
             return;
         }
 
+        this.SetReturnPoint({"x": this.order.data.x, "z": this.order.data.z});
         this.MoveToPoint(this.order.data.x, this.order.data.z);
         this.SetNextState("INDIVIDUAL.WALKING");
     },
@@ -180 +208 @@
         }
     },
 
+    "Order.Run": function(msg) {
+        if (this.IsAnimal())
+        {
+            // TODO: let players move captured animals around
+            this.FinishOrder();
+            return;
+        }
+
+        this.SetReturnPoint({"x": this.order.data.x, "z": this.order.data.z});
+        this.MoveToPoint(this.order.data.x, this.order.data.z);
+        this.SetNextState("INDIVIDUAL.RUNNING");
+    },
+
     "Order.Flee": function(msg) {
         // TODO: if we were attacked by a ranged unit, we need to flee much further away
         var ok = this.MoveToTargetRangeExplicit(this.order.data.target, +this.template.FleeDistance, -1);
@@ -217 +258 @@
         }
         this.attackType = type;
 
+        if (this.CheckTargetRange(this.order.data.target, IID_Attack, this.attackType))
+        {
+            // We are already at the target
+            // so try attacking it from here.
+            this.StopMoving();
+            if (this.IsAnimal())
+                this.SetNextState("ANIMAL.COMBAT.ATTACKING");
+            else
+                this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
+        }
         // Try to move within attack range
-        if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+        else if (!this.order.data.stand && this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
         {
             // We've started walking to the given point
             if (this.IsAnimal())
@@ -227 +278 @@
                 this.SetNextState("INDIVIDUAL.COMBAT.APPROACHING");
         }
         else
-        {
-            // We are already at the target, or can't move at all,
-            // so try attacking it from here.
-            // TODO: need better handling of the can't-reach-target case
-            this.StopMoving();
-            if (this.IsAnimal())
-                this.SetNextState("ANIMAL.COMBAT.ATTACKING");
-            else
-                this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
-        }
+            this.FinisOrder();
     },
 
     "Order.Gather": function(msg) {
@@ -484 +526 @@
                 // If we entered the idle state we must have nothing better to do,
                 // so immediately check whether there's anybody nearby to attack.
                 // (If anyone approaches later, it'll be handled via LosRangeUpdate.)
-                if (this.losRangeQuery)
-                {
-                    var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-                    var ents = rangeMan.ResetActiveQuery(this.losRangeQuery);
-                    if (this.GetStance().targetVisibleEnemies)
-                    {
-                        if (this.RespondToTargetedEntities(ents))
-                            return true; // (abort the FSM transition since we may have already switched state)
-                    }
-                }
+                if (this.StanceSpecificQuery(this.stance))
+                    return true;
 
                 // Nobody to attack - stay in idle
                 return false;
@@ -551 +585 @@
                 }
             },
 
+            "StanceChanged": function(msg) {
+                if (this.StanceSpecificQuery(this.stance))
+                    return;
+            },
         },
 
         "WALKING": {
@@ -563 +601 @@
             },
         },
 
+        "RUNNING": {
+            "enter": function () {
+                // Run quickly
+                var speed = this.GetRunSpeed();
+                this.SelectAnimation("move");
+                this.SetMoveSpeed(speed);
+                // TODO: stamina
+            },
+
+            "leave": function() {
+                var speed = this.GetWalkSpeed();
+                this.SelectAnimation("move");
+                this.SetMoveSpeed(speed);
+            },
+
+            "MoveCompleted": function() {
+                this.FinishOrder();
+            },
+        },
+
         "FLEEING": {
             "enter": function() {
                 this.PlaySound("panic");
@@ -605 +663 @@
                 "MoveCompleted": function() {
                     this.SetNextState("ATTACKING");
                 },
+
+                "Attacked": function(msg) {
+                    // If we're attacked by a close enemy, we should try to defend ourself
+                    if (this.GetStance().targetAttackers && msg.data.type == "Melee")
+                    {
+                        this.RespondToTargetedEntities([msg.data.attacker]);
+                    }
+                },
             },
 
             "ATTACKING": {
@@ -638 +704 @@
                         }
 
                         // Can't reach it - try to chase after it
-                        if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+                        if (this.GetStance().respondChase && this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
                         {
-                            this.SetNextState("COMBAT.CHASING");
+                            this.SetNextState("COMBAT.APPROACHING");
                             return;
                         }
+
+                        if (this.GetStance().respondHoldGround && this.CheckTargetDistance(this.order.data.target, this.attackType, 50))
+                        {
+                            if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+                            {
+                                this.SetNextState("COMBAT.APPROACHING");
+                                return;
+                            }
+                        }
                     }
 
                     // Can't reach it, or it doesn't exist any more - give up
-                    this.FinishOrder();
+                    if (this.FinishOrder())
+                        return;
 
-                    // TODO: see if we can switch to a new nearby enemy
+                    // see if we can switch to a new nearby enemy
+                    if (this.StanceSpecificQuery(this.stance, true))
+                        return;
+
+                    if (this.GetStance().respondHoldGround)
+                        this.Walk(this.returnPoint.x, this.returnPoint.z, false);
                 },
 
                 // TODO: respond to target deaths immediately, rather than waiting
                 // until the next Timer event
             },
-
-            "CHASING": {
-                "enter": function () {
-                    this.SelectAnimation("move");
-                },
-            
-                "MoveCompleted": function() {
-                    this.SetNextState("ATTACKING");
-                },
-            },
         },
 
         "GATHER": {
@@ -1303 +1374 @@
 // This should be called whenever our ownership changes.
 UnitAI.prototype.SetupRangeQuery = function(owner)
 {
-    var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
-    if (!cmpVision)
-        return;
-    
     var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     var playerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
-    
+
     if (this.losRangeQuery)
         rangeMan.DestroyActiveQuery(this.losRangeQuery);
 
-    var range = cmpVision.GetRange();
-    
     var players = [];
-    
+
     if (owner != -1)
     {
         // If unit not just killed, get enemy players via diplomacy
@@ -1334 +1399 @@
                 players.push(i);
         }
     }
-    
-    this.losRangeQuery = rangeMan.CreateActiveQuery(this.entity, 0, range, players, IID_DamageReceiver);
+
+    var range = this.StanceSpecificRange();
+
+    this.losRangeQuery = rangeMan.CreateActiveQuery(this.entity, 0, range.max, players, IID_DamageReceiver);
     rangeMan.EnableActiveQuery(this.losRangeQuery);
-};
+}
 
 //// FSM linkage functions ////
 
@@ -1812 +1879 @@
     return cmpUnitMotion.IsInTargetRange(target, range.min, range.max);
 };
 
+UnitAI.prototype.CheckTargetDistance = function(target, type, distance)
+{
+    var cmpRanged = Engine.QueryInterface(this.entity, IID_Attack);
+    var range = cmpRanged.GetRange(type);
+
+    var cmpPosition = Engine.QueryInterface(target, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return false;
+
+    var pos = cmpPosition.GetPosition();
+    var dx = this.returnPoint.x - pos.x;
+    var dz = this.returnPoint.z - pos.z;
+    var dist = Math.sqrt(dx*dx + dz*dz);
+
+    return dist < distance + range.max;
+};
+
 UnitAI.prototype.GetBestAttack = function()
 {
     var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
@@ -1839 +1923 @@
 };
 
 /**
+ * Try to find one of the given entities which can be attacked,
+ * without moving.
+ * Returns true if it found something to attack.
+ */
+UnitAI.prototype.AttackEntityInRange = function(ents)
+{
+    var type = this.GetBestAttack();
+    for each (var target in ents)
+    {
+        if (this.CanAttack(target) && this.CheckTargetRange(target, IID_Attack, type))
+        {
+            this.PushOrderFront("Attack", { "target": target, "stand": true });
+            return true;
+        }
+    }
+    return false;
+};
+
+/**
+ * Try to find one of the given entities which can be attacked,
+ * within zone.
+ * Returns true if it found something to attack.
+ */
+UnitAI.prototype.AttackEntityInZone = function(ents)
+{
+    var type = this.GetBestAttack();
+    for each (var target in ents)
+    {
+        if (this.CanAttack(target) && this.CheckTargetDistance(target, type, 50))
+        {
+            this.PushOrderFront("Attack", { "target": target });
+            return true;
+        }
+    }
+    return false;
+};
+
+/**
  * Try to respond appropriately given our current stance,
  * given a list of entities that match our stance's target criteria.
  * Returns true if it responded.
@@ -1851 +1973 @@
     if (this.GetStance().respondChase)
         return this.AttackVisibleEntity(ents);
 
+    if (this.GetStance().respondStandGround)
+        return this.AttackEntityInRange(ents);
+
+    if (this.GetStance().respondHoldGround)
+        return this.AttackEntityInZone(ents);
+
     if (this.GetStance().respondFlee)
     {
         this.PushOrderFront("Flee", { "target": ents[0] });
@@ -1919 +2047 @@
         switch (order.type)
         {
         case "Walk":
+        case "Run":
             // Add the distance to the target point
             var dx = order.data.x - pos.x;
             var dz = order.data.z - pos.z;
@@ -1981 +2110 @@
     this.AddOrder("WalkToTarget", { "target": target }, queued);
 };
 
+UnitAI.prototype.Run = function(x, z, queued)
+{
+    if (this.IsFormationController())
+        this.AddOrder("Walk", { "x": x, "z": z }, queued);
+    else
+        this.AddOrder("Run", { "x": x, "z": z }, queued);
+};
+
 UnitAI.prototype.LeaveFoundation = function(target)
 {
     // TODO: we should verify this is a friendly foundation, otherwise
@@ -2088 +2225 @@
         this.stance = stance;
     else
         error("UnitAI: Setting to invalid stance '"+stance+"'");
+}
+
+UnitAI.prototype.SwitchToStance = function(stance)
+{
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition || !cmpPosition.IsInWorld())
+        return;
+    var pos = cmpPosition.GetPosition();
+    this.SetReturnPoint({"x": pos.x, "z": pos.z});
+
+    this.SetStance(stance);
+    if (stance == "stand" || stance == "defensive" || stance == "passive")
+        this.StopMoving();
+
+    UnitFsm.ProcessMessage(this, {"type": "StanceChanged", "stance": stance});
+}
+
+UnitAI.prototype.StanceSpecificQuery = function(stance, disable)
+{
+    if (!g_Stances[stance])
+    {
+        error("UnitAI: Setting to invalid stance '"+stance+"'");
+        return false;
+    }
+
+    if (!this.losRangeQuery)
+        return false;
+
+    var range = this.StanceSpecificRange();
+
+    var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    var ents = rangeMan.ModifyRangeActiveQuery(this.losRangeQuery, range.min, range.max);
+
+    if (disable && !this.IsAnimal())
+        rangeMan.DisableActiveQuery(this.losRangeQuery);
+
+    return this.RespondToTargetedEntities(ents);
 };
 
+UnitAI.prototype.StanceSpecificRange = function()
+{
+    var ret = { "min": 0, "max": 0 };
+    if (this.GetStance().respondStandGround)
+    {
+        var cmpRanged = Engine.QueryInterface(this.entity, IID_Attack);
+        if (!cmpRanged)
+            return ret;
+        var range = cmpRanged.GetRange(cmpRanged.GetBestAttack());
+        ret.min = range.min;
+        ret.max = range.max;
+    }
+    else if (this.GetStance().respondChase)
+    {
+        var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
+        if (!cmpVision)
+            return ret;
+        var range = cmpVision.GetRange();
+        ret.max = range;
+    }
+    else if (this.GetStance().respondHoldGround)
+    {
+        var cmpRanged = Engine.QueryInterface(this.entity, IID_Attack);
+        if (!cmpRanged)
+            return ret;
+        var range = cmpRanged.GetRange(cmpRanged.GetBestAttack());
+        ret.max = range.max + 50;
+    }
+    return ret;
+};
+
 UnitAI.prototype.GetStance = function()
 {
     return g_Stances[this.stance];
@@ -2234 +2439 @@
     cmpMotion.SetSpeed(speed);
 };
 
+UnitAI.prototype.SetReturnPoint = function(pos)
+{
+    this.returnPoint = {"x": pos.x, "z": pos.z};
+};
+
 Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);

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

@@ -245 +245 @@
     }
 
     Engine.PostMessage(data.target, MT_Attacked,
-        { "attacker": this.entity, "target": data.target });
+        { "attacker": this.entity, "target": data.target, "type": data.type });
 
     PlaySound("attack_impact", this.entity);
 };

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

@@ -8 +8 @@
     <Type>support</Type>
   </Minimap>
   <UnitAI>
-    <DefaultStance>noncombat</DefaultStance>
+    <DefaultStance>passive</DefaultStance>
   </UnitAI>
   <Cost>
     <BuildTime>15</BuildTime>