Changeset 9631 for ps

Timestamp:

06/18/11 00:13:39 (14 years ago)

Author:

Badmadblacksad

Message:

Stances draft, refs #865

Location:

ps/trunk

Files:

• binaries/data/mods/public/gui/session/input.js (modified) (1 diff)
• binaries/data/mods/public/gui/session/session.js (modified) (1 diff)
• binaries/data/mods/public/gui/session/session.xml (modified) (2 diffs)
• binaries/data/mods/public/gui/session/unit_commands.js (modified) (7 diffs)
• binaries/data/mods/public/maps/scenarios/Combat_demo.xml (modified) (1 diff)
• binaries/data/mods/public/maps/scenarios/Pathfinding_demo.xml (modified) (1 diff)
• binaries/data/mods/public/simulation/components/Attack.js (modified) (1 diff)
• binaries/data/mods/public/simulation/components/GuiInterface.js (modified) (2 diffs)
• binaries/data/mods/public/simulation/components/Promotion.js (modified) (1 diff)
• binaries/data/mods/public/simulation/components/UnitAI.js (modified) (23 diffs)
• binaries/data/mods/public/simulation/helpers/Commands.js (modified) (1 diff)
• binaries/data/mods/public/simulation/helpers/Entity.js (added)
• binaries/data/mods/public/simulation/helpers/Setup.js (modified) (1 diff)
• binaries/data/mods/public/simulation/templates/template_unit_support.xml (modified) (1 diff)
• source/simulation2/components/CCmpRangeManager.cpp (modified) (1 diff)
• source/simulation2/components/ICmpRangeManager.cpp (modified) (1 diff)
• source/simulation2/components/ICmpRangeManager.h (modified) (1 diff)

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

@@ -1146 +1146 @@
 }
 
+// Performs the specified stance
+function performStance(entity, stanceName)
+{
+    if (entity)
+    {
+        var selection = g_Selection.toList();
+        Engine.PostNetworkCommand({
+            "type": "stance",
+            "entities": selection,
+            "name": stanceName
+        });
+    }
+}
+
 // Set the camera to follow the given unit
 function setCameraFollow(entity)

ps/trunk/binaries/data/mods/public/gui/session/session.js

@@ -236 +236 @@
 {
     var guiName = "Group";
+    g_Groups.update();
     for (var i = 0; i < 10; i++)
     {
         var button = getGUIObjectByName("unit"+guiName+"Button["+i+"]");
         var label = getGUIObjectByName("unit"+guiName+"Label["+i+"]").caption = i;
-        g_Groups.update();
         if (g_Groups.groups[i].getTotalCount() == 0)
             button.hidden = true;

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

@@ -406 +406 @@
             </object>
         </repeat>
+    </object>
+
+    <!-- ================================  ================================ -->
+    <!-- Stance Selection (Temporary location) -->
+    <!-- ================================  ================================ -->
+    <object name="unitStancePanel"
+        sprite="bottomMiddle"
+        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" ghost="true" size="3 3 33 33"/>
+                </object>
+            </repeat>
+        </object>
     </object>
 
@@ -639 +659 @@
             </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"

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

@@ -7 +7 @@
 const CONSTRUCTION = "Construction";
 const COMMAND = "Command";
+const STANCE = "Stance";
 
 // Constants
@@ -14 +15 @@
 
 // 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
@@ -121 +122 @@
                 numberOfItems =  16;
     }
-    if (guiName == "Formation")
+    else if (guiName == "Formation")
     {
         if (numberOfItems > 16)
                 numberOfItems =  16;
+    }   
+    else if (guiName == "Stance")
+    {
+        if (numberOfItems > 5)
+                numberOfItems =  5;
     }
     else if (guiName == "Queue")
@@ -154 +160 @@
         var entType = ((guiName == "Queue")? item.template : item);
         var template;
-        if (guiName != "Formation" && guiName != "Command")
+        if (guiName != "Formation" && guiName != "Command" && guiName != "Stance")
         {
             template = GetTemplateData(entType);
@@ -191 +197 @@
             break;
 
+        case STANCE:
         case FORMATION:
             var tooltip = toTitleCase(item);
@@ -265 +272 @@
                 icon.sprite = "formation";
             }
+        }
+        else if (guiName == "Stance")
+        {
+            var stanceSelected = Engine.GuiInterfaceCall("StanceSelected", {
+                "ents": g_Selection.toList(),
+                "stance": item
+            });
+
+            icon.cell_id = i;
+            if (stanceSelected)
+                icon.sprite = "snIconSheetStanceButton";
+            else
+                icon.sprite = "snIconSheetStanceButtonDisabled";
         }
         else if (guiName == "Command")
@@ -369 +389 @@
                 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)
         {

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

@@ -41 +41 @@
     }
   ],
-  "RevealMap": true
+  "RevealMap": true,
+  "DefaultStance": "defensive"
 }
 ]]></ScriptSettings>

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

@@ -42 +42 @@
   ],
   "RevealMap": true,
-  "DefaultStance": "holdfire",
+  "DefaultStance": "defensive",
   "GameType": "endless"
 }

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

@@ -246 +246 @@
 
     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);

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

@@ -299 +299 @@
 };
 
+GuiInterface.prototype.StanceSelected = function(player, data)
+{
+    for each (var ent in data.ents)
+    {
+        var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+        if (cmpUnitAI)
+        {
+            if (cmpUnitAI.GetStanceName() == data.stance)
+                return true;
+        }
+    }
+    return false;
+};
+
 GuiInterface.prototype.SetSelectionHighlight = function(player, cmd)
 {
@@ -554 +568 @@
 
     "CanMoveEntsIntoFormation": 1,
+    "StanceSelected": 1,
 
     "SetSelectionHighlight": 1,

ps/trunk/binaries/data/mods/public/simulation/components/Promotion.js

@@ -66 +66 @@
     var cmpCurrentUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
     var cmpPromotedUnitAI = Engine.QueryInterface(promotedUnitEntity, IID_UnitAI);
+    cmpPromotedUnitAI.SetHeldPosition(cmpCurrentUnitAI.GetHeldPosition());
+    if (cmpCurrentUnitAI.GetStanceName())
+        cmpPromotedUnitAI.SetStance(cmpCurrentUnitAI.GetStanceName());
     cmpPromotedUnitAI.Cheer();
     var orders = cmpCurrentUnitAI.GetOrders();

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

@@ -7 +7 @@
         "<choice>" +
             "<value>aggressive</value>" +
-            "<value>holdfire</value>" +
-            "<value>noncombat</value>" +
+            "<value>defensive</value>" +
+            "<value>passive</value>" +
         "</choice>" +
     "</element>" +
@@ -60 +60 @@
 // dynamic stance changes).
 var g_Stances = {
+    "violent": {
+        targetVisibleEnemies: true,
+        targetAttackers: true,
+        respondFlee: false,
+        respondChase: true,
+        respondStandGround : false,
+        respondHoldGround : false,
+        respondChaseToHell : true,
+    },
     "aggressive": {
         targetVisibleEnemies: true,
@@ -65 +74 @@
         respondFlee: false,
         respondChase: true,
-    },
-    "holdfire": {
-        targetVisibleEnemies: false,
+        respondStandGround : false,
+        respondHoldGround : false,
+    },
+    "defensive": {
+        targetVisibleEnemies: true,
         targetAttackers: true,
         respondFlee: false,
-        respondChase: true,
-    },
-    "noncombat": {
+        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,
     },
 };
@@ -115 +138 @@
     },
 
+    "StanceChanged": function(msg) {
+        if (this.StanceSpecificQuery(this.stance,true))
+            return;
+    },
+
     // Formation handlers:
 
@@ -155 +183 @@
         }
 
+        this.SetHeldPosition(this.order.data.x, this.order.data.z);
         this.MoveToPoint(this.order.data.x, this.order.data.z);
         this.SetNextState("INDIVIDUAL.WALKING");
@@ -218 +247 @@
         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.GetStance().respondStandGround || this.order.data.force) && this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
         {
             // We've started walking to the given point
@@ -228 +267 @@
         }
         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.FinishOrder();
     },
 
@@ -253 +283 @@
             }
 
-            this.PushOrderFront("Attack", { "target": this.order.data.target });
+            this.PushOrderFront("Attack", { "target": this.order.data.target, "force": false });
             return;
         }
@@ -485 +515 @@
                 // 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
@@ -552 +574 @@
             },
 
+            "StanceChanged": function(msg) {
+                if (this.StanceSpecificQuery(this.stance))
+                    return;
+            },
         },
 
@@ -601 +627 @@
                 "enter": function () {
                     this.SelectAnimation("move");
+                    this.StartTimer(1000, 1000);
+                },
+
+                "leave": function() {
+                    this.StopTimer();
+                },
+
+                "Timer": function(msg) {
+                    if (!this.ChaseTargetedEntity(this.order.data.target, this.order.data.force))
+                    {
+                        this.StopMoving();
+                        this.FinishOrder();
+
+                        // we return to our position
+                        if (this.GetStance().respondHoldGround)
+                            this.WalkToHeldPosition();
+                    }
                 },
 
                 "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]);
+                    }
                 },
             },
@@ -641 +692 @@
                         }
 
-                        // Can't reach it - try to chase after it
-                        if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+                        if (this.ChaseTargetedEntity(this.order.data.target))
                         {
-                            this.SetNextState("COMBAT.CHASING");
+                            if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+                            {
+                                this.SetNextState("COMBAT.CHASING");
+                                return;
+                            }
+                        }
+
+                    }
+
+                    // Can't reach it, or it doesn't exist any more - give up
+                    if (this.FinishOrder())
+                        return;
+
+                    // see if we can switch to a new nearby enemy
+                    if (this.StanceSpecificQuery(this.stance, true))
+                        return;
+
+                    // we return to our position
+                    if (this.GetStance().respondHoldGround)
+                    {
+                        if (this.WalkToHeldPosition())
                             return;
-                        }
                     }
-
-                    // Can't reach it, or it doesn't exist any more - give up
-                    this.FinishOrder();
-
-                    // TODO: see if we can switch to a new nearby enemy
                 },
 
@@ -662 +726 @@
                 "enter": function () {
                     this.SelectAnimation("move");
-                },
-            
+                    this.StartTimer(1000, 1000);
+                },
+
+                "leave": function() {
+                    this.StopTimer();
+                },
+
+                "Timer": function(msg) {
+                    if (!this.ChaseTargetedEntity(this.order.data.target))
+                    {
+                        this.StopMoving();
+                        this.FinishOrder();
+
+                        // we return to our position
+                        if (this.GetStance().respondHoldGround)
+                            this.WalkToHeldPosition();
+                    }
+                },
+
                 "MoveCompleted": function() {
                     this.SetNextState("ATTACKING");
@@ -1304 +1385 @@
 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)
     {
@@ -1335 +1410 @@
         }
     }
-    
-    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 ////
@@ -1834 +1911 @@
 }
 
+UnitAI.prototype.CheckTargetDistanceFromHeldPosition = function(target, type)
+{
+    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 cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
+    if (!cmpVision)
+        return false;
+    var halfvision = cmpVision.GetRange() / 2;
+
+    var pos = cmpPosition.GetPosition();
+    var dx = this.heldPosition.x - pos.x;
+    var dz = this.heldPosition.z - pos.z;
+    var dist = Math.sqrt(dx*dx + dz*dz);
+
+    return dist < halfvision + range.max;
+};
+
+UnitAI.prototype.CheckTargetIsInVisionRange = function(target)
+{
+    var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
+    if (!cmpVision)
+        return false;
+    var range = cmpVision.GetRange();
+
+    var distance = DistanceBetweenEntities(this.entity,target);
+
+    return distance < range;
+}
+
 UnitAI.prototype.GetBestAttack = function()
 {
@@ -1853 +1964 @@
         if (this.CanAttack(target))
         {
-            this.PushOrderFront("Attack", { "target": target });
+            this.PushOrderFront("Attack", { "target": target, "force": false });
+            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.CheckTargetDistanceFromHeldPosition(target, type))
+        {
+            this.PushOrderFront("Attack", { "target": target, "force": false });
             return true;
         }
@@ -1873 +2003 @@
         return this.AttackVisibleEntity(ents);
 
+    if (this.GetStance().respondStandGround)
+        return this.AttackVisibleEntity(ents);
+
+    if (this.GetStance().respondHoldGround)
+        return this.AttackEntityInZone(ents);
+
     if (this.GetStance().respondFlee)
     {
@@ -1881 +2017 @@
     return false;
 };
+
+/*
+ * Try to chase targeted entity given our current stance
+ */
+UnitAI.prototype.ChaseTargetedEntity = function(ent, force)
+{
+  if (this.GetStance().respondChase)
+  {
+    if (this.CheckTargetIsInVisionRange(ent))
+    {
+      return true;
+    }
+  }
+
+  if (this.GetStance().respondChaseToHell || force)
+  {
+    //if ( TODO : Check ent is not in Shroud of Darkness)
+    {
+      return true;
+    }
+  }
+
+  if (this.GetStance().respondHoldGround)
+  {
+    if (this.CheckTargetDistanceFromHeldPosition(ent, this.attackType))
+    {
+      return true;
+    }
+  }
+
+  return false;
+
+}
 
 //// External interface functions ////
@@ -2022 +2191 @@
     }
 
-    this.AddOrder("Attack", { "target": target }, queued);
+    this.AddOrder("Attack", { "target": target, "force": true }, queued);
 };
 
@@ -2107 +2276 @@
     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.SetHeldPosition(pos.x, 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());
+        var cmpVision = Engine.QueryInterface(this.entity, IID_Vision);
+        if (!cmpVision)
+            return ret;
+        var halfvision = cmpVision.GetRange() / 2;
+        ret.max = range.max + halfvision;
+    }
+    return ret;
 };
 
@@ -2112 +2353 @@
 {
     return g_Stances[this.stance];
+};
+
+UnitAI.prototype.GetStanceName = function()
+{
+    return this.stance;
 };
 
@@ -2253 +2499 @@
 };
 
+UnitAI.prototype.SetHeldPosition = function(x, z)
+{
+    this.heldPosition = {"x": x, "z": z};
+};
+
+UnitAI.prototype.GetHeldPosition = function(pos)
+{
+    return this.heldPosition;
+};
+
+UnitAI.prototype.WalkToHeldPosition = function()
+{
+    if (this.heldPosition)
+    {
+        this.Walk(this.heldPosition.x, this.heldPosition.z, false);
+        return true;
+    }
+    return false;
+};
+
 Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);

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

@@ -259 +259 @@
             if (cmpPromotion)
                 cmpPromotion.IncreaseXp(cmpPromotion.GetRequiredXp() - cmpPromotion.GetCurrentXp());
+        }
+        break;
+
+    case "stance":
+        for each (var ent in cmd.entities)
+        {
+            var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
+            if (cmpUnitAI)
+                cmpUnitAI.SwitchToStance(cmd.name);
         }
         break;

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

@@ -15 +15 @@
         {
             var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
-            cmpUnitAI.SetStance(settings.DefaultStance);
+            cmpUnitAI.SwitchToStance(settings.DefaultStance);
         }
     }

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

@@ -9 +9 @@
   </Minimap>
   <UnitAI>
-    <DefaultStance>noncombat</DefaultStance>
+    <DefaultStance>passive</DefaultStance>
   </UnitAI>
   <Cost>

ps/trunk/source/simulation2/components/CCmpRangeManager.cpp

@@ -458 +458 @@
 
         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);
     }
 

ps/trunk/source/simulation2/components/ICmpRangeManager.cpp

@@ -37 +37 @@
 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)

ps/trunk/source/simulation2/components/ICmpRangeManager.h

@@ -103 +103 @@
 
     /**
+     * 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).