Changeset 9657 for ps

Timestamp:

06/24/11 14:35:15 (14 years ago)

Author:

philip

Message:

Attempt minor improvements to stances code (see #865).
Don't chase units that are no longer visible, beyond where they were last seen (fixes #595).

Location:

ps/trunk

Files:

• binaries/data/mods/public/gui/session/unit_commands.js (modified) (2 diffs)
• binaries/data/mods/public/simulation/components/GuiInterface.js (modified) (2 diffs)
• binaries/data/mods/public/simulation/components/UnitAI.js (modified) (29 diffs)
• source/simulation2/components/CCmpRangeManager.cpp (modified) (1 diff)
• source/simulation2/components/CCmpUnitMotion.cpp (modified) (2 diffs)
• source/simulation2/components/ICmpRangeManager.cpp (modified) (1 diff)
• source/simulation2/components/ICmpRangeManager.h (modified) (1 diff)

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

@@ -275 +275 @@
         else if (guiName == "Stance")
         {
-            var stanceSelected = Engine.GuiInterfaceCall("StanceSelected", {
+            var stanceSelected = Engine.GuiInterfaceCall("IsStanceSelected", {
                 "ents": g_Selection.toList(),
                 "stance": item
@@ -386 +386 @@
         var formations = getEntityFormationsList(entState);
         if (isUnit(entState) && !isAnimal(entState) && !entState.garrisonHolder && formations.length)
+        {
             setupUnitPanel("Formation", usedPanels, entState, formations,
                 function (item) { performFormation(entState.id, item); } );
-
-        var stances = ["violent","aggressive","passive","defensive","stand"];
+        }
+
+        // TODO: probably should load the stance list from a data file,
+        // and/or vary depending on what units are selected
+        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/simulation/components/GuiInterface.js

@@ -299 +299 @@
 };
 
-GuiInterface.prototype.StanceSelected = function(player, data)
+GuiInterface.prototype.IsStanceSelected = function(player, data)
 {
     for each (var ent in data.ents)
@@ -568 +568 @@
 
     "CanMoveEntsIntoFormation": 1,
-    "StanceSelected": 1,
+    "IsStanceSelected": 1,
 
     "SetSelectionHighlight": 1,

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

@@ -6 +6 @@
     "<element name='DefaultStance'>" +
         "<choice>" +
+            "<value>violent</value>" +
             "<value>aggressive</value>" +
             "<value>defensive</value>" +
             "<value>passive</value>" +
+            "<value>stand</value>" +
         "</choice>" +
     "</element>" +
@@ -46 +48 @@
     "</optional>";
 
-// Very basic stance support (currently just for test maps where we don't want
-// everyone killing each other immediately after loading, and for female citizens)
+// Unit stances.
 // There some targeting options:
 //   targetVisibleEnemies: anything in vision range is a viable target
@@ -54 +55 @@
 //   respondFlee: run away
 //   respondChase: start chasing after the enemy
-// TODO: maybe add respondStandGround, respondHoldGround (allow chasing a short distance then return),
-// targetAggressiveEnemies (don't worry about lone scouts, do worry around armies slaughtering
-// the guy standing next to you), etc.
-// TODO: even this limited version isn't implemented properly yet (e.g. it can't handle
-// dynamic stance changes).
+//   respondChaseBeyondVision: start chasing, and don't stop even if it's out
+//     of this unit's vision range (though still visible to the player)
+//   respondStandGround: attack enemy but don't move at all
+//   respondHoldGround: attack enemy but don't move far from current position
+// TODO: maybe add targetAggressiveEnemies (don't worry about lone scouts,
+// do worry around armies slaughtering the guy standing next to you), etc.
 var g_Stances = {
     "violent": {
@@ -65 +67 @@
         respondFlee: false,
         respondChase: true,
-        respondStandGround : false,
-        respondHoldGround : false,
-        respondChaseToHell : true,
+        respondChaseBeyondVision: true,
+        respondStandGround: false,
+        respondHoldGround: false,
     },
     "aggressive": {
@@ -74 +76 @@
         respondFlee: false,
         respondChase: true,
-        respondStandGround : false,
-        respondHoldGround : false,
+        respondChaseBeyondVision: false,
+        respondStandGround: false,
+        respondHoldGround: false,
     },
     "defensive": {
@@ -82 +85 @@
         respondFlee: false,
         respondChase: false,
-        respondStandGround : false,
-        respondHoldGround : true,
+        respondChaseBeyondVision: false,
+        respondStandGround: false,
+        respondHoldGround: true,
     },
     "passive": {
@@ -90 +94 @@
         respondFlee: true,
         respondChase: false,
-        respondStandGround : false,
-        respondHoldGround : false,
+        respondChaseBeyondVision: false,
+        respondStandGround: false,
+        respondHoldGround: false,
     },
     "stand": {
@@ -98 +103 @@
         respondFlee: false,
         respondChase: false,
-        respondStandGround : true,
-        respondHoldGround : false,
+        respondChaseBeyondVision: false,
+        respondStandGround: true,
+        respondHoldGround: false,
     },
 };
@@ -136 +142 @@
     "EntityRenamed": function(msg) {
         // ignore
-    },
-
-    "StanceChanged": function(msg) {
-        if (this.StanceSpecificQuery(this.stance,true))
-            return;
     },
 
@@ -247 +248 @@
         this.attackType = type;
 
+        // If we are already at the target, try attacking it from here
         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())
@@ -256 +256 @@
             else
                 this.SetNextState("INDIVIDUAL.COMBAT.ATTACKING");
-        }
+            return;
+        }
+
+        // If we can't reach the target, but are standing ground,
+        // then abandon this attack order
+        if (this.GetStance().respondStandGround && !this.order.data.force)
+        {
+            this.FinishOrder();
+            return;
+        }
+
         // Try to move within attack range
-        else if ((!this.GetStance().respondStandGround || this.order.data.force) && this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
+        if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
         {
             // We've started walking to the given point
@@ -265 +275 @@
             else
                 this.SetNextState("INDIVIDUAL.COMBAT.APPROACHING");
-        }
-        else
-            this.FinishOrder();
+            return;
+        }
+
+        // We can't reach the target, and can't move towards it,
+        // so abandon this attack order
+        this.FinishOrder();
     },
 
@@ -515 +528 @@
                 // so immediately check whether there's anybody nearby to attack.
                 // (If anyone approaches later, it'll be handled via LosRangeUpdate.)
-                if (this.StanceSpecificQuery(this.stance))
-                    return true;
+                if (this.FindNewTargets())
+                    return true; // (abort the FSM transition since we may have already switched state)
 
                 // Nobody to attack - stay in idle
@@ -573 +586 @@
                 }
             },
-
-            "StanceChanged": function(msg) {
-                if (this.StanceSpecificQuery(this.stance))
-                    return;
-            },
         },
 
@@ -635 +643 @@
 
                 "Timer": function(msg) {
-                    if (!this.ChaseTargetedEntity(this.order.data.target, this.order.data.force))
+                    if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force))
                     {
                         this.StopMoving();
                         this.FinishOrder();
 
-                        // we return to our position
+                        // Return to our original position
                         if (this.GetStance().respondHoldGround)
                             this.WalkToHeldPosition();
@@ -692 +700 @@
                         }
 
-                        if (this.ChaseTargetedEntity(this.order.data.target))
+                        // Can't reach it - try to chase after it
+                        if (this.ShouldChaseTargetedEntity(this.order.data.target, this.order.data.force))
                         {
                             if (this.MoveToTargetRange(this.order.data.target, IID_Attack, this.attackType))
@@ -707 +716 @@
                         return;
 
-                    // see if we can switch to a new nearby enemy
-                    if (this.StanceSpecificQuery(this.stance, true))
+                    // See if we can switch to a new nearby enemy
+                    if (this.FindNewTargets())
                         return;
 
-                    // we return to our position
+                    // Return to our original position
                     if (this.GetStance().respondHoldGround)
-                    {
-                        if (this.WalkToHeldPosition())
-                            return;
-                    }
+                        this.WalkToHeldPosition();
                 },
 
@@ -734 +740 @@
 
                 "Timer": function(msg) {
-                    if (!this.ChaseTargetedEntity(this.order.data.target))
+                    if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force))
                     {
                         this.StopMoving();
                         this.FinishOrder();
 
-                        // we return to our position
+                        // Return to our original position
                         if (this.GetStance().respondHoldGround)
                             this.WalkToHeldPosition();
@@ -1366 +1372 @@
 UnitAI.prototype.OnOwnershipChanged = function(msg)
 {
-    this.SetupRangeQuery(msg.to);
+    this.SetupRangeQuery();
 };
 
@@ -1383 +1389 @@
 // which can be attacked.
 // This should be called whenever our ownership changes.
-UnitAI.prototype.SetupRangeQuery = function(owner)
-{
+UnitAI.prototype.SetupRangeQuery = function()
+{
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    var owner = cmpOwnership.GetOwner();
+
     var rangeMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
     var playerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
@@ -1411 +1420 @@
     }
 
-    var range = this.StanceSpecificRange();
-
-    this.losRangeQuery = rangeMan.CreateActiveQuery(this.entity, 0, range.max, players, IID_DamageReceiver);
+    var range = this.GetQueryRange();
+
+    this.losRangeQuery = rangeMan.CreateActiveQuery(this.entity, range.min, range.max, players, IID_DamageReceiver);
     rangeMan.EnableActiveQuery(this.losRangeQuery);
-}
+};
 
 //// FSM linkage functions ////
@@ -1862 +1871 @@
 UnitAI.prototype.MoveToTarget = function(target)
 {
+    if (!this.CheckTargetVisible(target))
+        return false;
+
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
     return cmpUnitMotion.MoveToTargetRange(target, 0, 0);
@@ -1868 +1880 @@
 UnitAI.prototype.MoveToTargetRange = function(target, iid, type)
 {
+    if (!this.CheckTargetVisible(target))
+        return false;
+
     var cmpRanged = Engine.QueryInterface(this.entity, iid);
     var range = cmpRanged.GetRange(type);
@@ -1877 +1892 @@
 UnitAI.prototype.MoveToTargetRangeExplicit = function(target, min, max)
 {
+    if (!this.CheckTargetVisible(target))
+        return false;
+
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
     return cmpUnitMotion.MoveToTargetRange(target, min, max);
@@ -1888 +1906 @@
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
     return cmpUnitMotion.IsInTargetRange(target, range.min, range.max);
+};
+
+/**
+ * Returns true if the target entity is visible through the FoW/SoD.
+ */
+UnitAI.prototype.CheckTargetVisible = function(target)
+{
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (!cmpOwnership)
+        return false;
+
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    if (!cmpRangeManager)
+        return false;
+
+    if (cmpRangeManager.GetLosVisibility(target, cmpOwnership.GetOwner()) == "hidden")
+        return false;
+
+    // Either visible directly, or visible in fog
+    return true;
 };
 
@@ -1943 +1981 @@
 
     return distance < range;
-}
+};
 
 UnitAI.prototype.GetBestAttack = function()
@@ -1972 +2010 @@
 
 /**
- * Try to find one of the given entities which can be attacked,
- * within zone.
+ * Try to find one of the given entities which can be attacked
+ * and which is close to the hold position, and start attacking it.
  * Returns true if it found something to attack.
  */
@@ -2018 +2056 @@
 };
 
+/**
+ * Returns true if we should stop following the target entity.
+ */
+UnitAI.prototype.ShouldAbandonChase = function(target, force)
+{
+    // Stop if we're in hold-ground mode and it's too far from the holding point
+    if (this.GetStance().respondHoldGround)
+    {
+        if (!this.CheckTargetDistanceFromHeldPosition(target, this.attackType))
+            return true;
+    }
+
+    // Stop if it's left our vision range, unless we're especially persistent
+    if (!force && !this.GetStance().respondChaseBeyondVision)
+    {
+        if (!this.CheckTargetIsInVisionRange(target))
+            return true;
+    }
+
+    // (Note that CCmpUnitMotion will detect if the target is lost in FoW,
+    // and will continue moving to its last seen position and then stop)
+
+    return false;
+};
+
 /*
- * Try to chase targeted entity given our current stance
+ * Returns whether we should chase the 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;
-
-}
+UnitAI.prototype.ShouldChaseTargetedEntity = function(target, force)
+{
+    if (this.GetStance().respondChase)
+        return true;
+
+    if (force)
+        return true;
+
+    return false;
+};
 
 //// External interface functions ////
@@ -2290 +2335 @@
         this.StopMoving();
 
-    UnitFsm.ProcessMessage(this, {"type": "StanceChanged", "stance": stance});
+    // Reset the range query, since the range depends on stance
+    this.SetupRangeQuery();
 }
 
-UnitAI.prototype.StanceSpecificQuery = function(stance, disable)
-{
-    if (!g_Stances[stance])
-    {
-        error("UnitAI: Setting to invalid stance '"+stance+"'");
-        return false;
-    }
-
+/**
+ * Resets losRangeQuery, and if there are some targets in range that we can
+ * attack then we start attacking and this returns true; otherwise, returns false.
+ */
+UnitAI.prototype.FindNewTargets = function()
+{
     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);
+    var ents = rangeMan.ResetActiveQuery(this.losRangeQuery);
+
+    if (!this.GetStance().targetVisibleEnemies)
+        return false;
 
     return this.RespondToTargetedEntities(ents);
 };
 
-UnitAI.prototype.StanceSpecificRange = function()
+UnitAI.prototype.GetQueryRange = function()
 {
     var ret = { "min": 0, "max": 0 };

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/CCmpUnitMotion.cpp

@@ -23 +23 @@
 #include "ICmpObstruction.h"
 #include "ICmpObstructionManager.h"
+#include "ICmpOwnership.h"
 #include "ICmpPosition.h"
 #include "ICmpPathfinder.h"
+#include "ICmpRangeManager.h"
 #include "simulation2/MessageTypes.h"
 #include "simulation2/helpers/Geometry.h"
@@ -1004 +1006 @@
         return false;
 
+    // Fail if the target is no longer visible to this entity's owner
+    // (in which case we'll continue moving to its last known location,
+    // unless it comes back into view before we reach that location)
+    CmpPtr<ICmpOwnership> cmpOwnership(GetSimContext(), GetEntityId());
+    if (!cmpOwnership.null())
+    {
+        CmpPtr<ICmpRangeManager> cmpRangeManager(GetSimContext(), SYSTEM_ENTITY);
+        if (!cmpRangeManager.null())
+        {
+            if (cmpRangeManager->GetLosVisibility(m_TargetEntity, cmpOwnership->GetOwner()) == ICmpRangeManager::VIS_HIDDEN)
+                return false;
+        }
+    }
+
     // The target moved and we need to update our current path;
     // change the goal here and expect our caller to start the path request

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).