Ticket #788: SameTurnMovesPatch2.patch

binaries/data/mods/public/simulation/data/pathfinder.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Pathfinder>
-
+  <!-- Sets limit on the number of same turns moves we will process -->
+  <!-- Setting the value to 0 disable this functionality -->
+  <MaxSameTurnMoves>16</MaxSameTurnMoves>
+  
   <PassabilityClasses>
 
     <!-- Unit pathfinding classes: -->

source/simulation2/components/CCmpPathfinder.cpp

@@ -52 +52 @@
     m_DebugGrid = NULL;
     m_DebugPath = NULL;
 
+    m_SameTurnMovesCount = 0;
+
     // Since this is used as a system component (not loaded from an entity template),
     // we can't use the real paramNode (it won't get handled properly when deserializing),
     // so load the data from a special XML file.
     CParamNode externalParamNode;
     CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml");
 
+    // Previously all move commands during a turn were
+    // queued up and processed asynchronously at the start
+    // of the next turn.  Now we are processing queued up 
+    // events several times duing the turn.  This improves
+    // responsiveness and units move more smoothly especially.
+    // when in formation.  There is still a call at the 
+    // beginning of a turn to process all outstanding moves - 
+    // this will handle any moves above the MaxSameTurnMoves 
+    // threshold.  
+    //
+    // TODO - The moves processed at the beginning of the 
+    // turn do not count against the maximum moves per turn 
+    // currently.  The thinking is that this will eventually 
+    // happen in another thread.  Either way this probably 
+    // will require some adjustment and rethinking.
+    const CParamNode pathingSettings = externalParamNode.GetChild("Pathfinder");
+    m_MaxSameTurnMoves = pathingSettings.GetChild("MaxSameTurnMoves").ToInt();
 
+
     const CParamNode::ChildrenMap& passClasses = externalParamNode.GetChild("Pathfinder").GetChild("PassabilityClasses").GetChildren();
     for (CParamNode::ChildrenMap::const_iterator it = passClasses.begin(); it != passClasses.end(); ++it)
     {
@@ -172 +192 @@
     SerializeVector<SerializeLongRequest>()(serialize, "long requests", m_AsyncLongPathRequests);
     SerializeVector<SerializeShortRequest>()(serialize, "short requests", m_AsyncShortPathRequests);
     serialize.NumberU32_Unbounded("next ticket", m_NextAsyncTicket);
+    serialize.NumberU16_Unbounded("same turn moves count", m_SameTurnMovesCount);
 }
 
 void CCmpPathfinder::Deserialize(const CParamNode& paramNode, IDeserializer& deserialize)
@@ -181 +202 @@
     SerializeVector<SerializeLongRequest>()(deserialize, "long requests", m_AsyncLongPathRequests);
     SerializeVector<SerializeShortRequest>()(deserialize, "short requests", m_AsyncShortPathRequests);
     deserialize.NumberU32_Unbounded("next ticket", m_NextAsyncTicket);
+    deserialize.NumberU16_Unbounded("same turn moves count", m_SameTurnMovesCount);
 }
 
 void CCmpPathfinder::HandleMessage(const CMessage& msg, bool UNUSED(global))
@@ -199 +221 @@
         m_TerrainDirty = true;
         break;
     }
+    case MT_TurnStart:
+    {
+        m_SameTurnMovesCount = 0;
+        break;
     }
+    }
 }
 
 void CCmpPathfinder::RenderSubmit(SceneCollector& collector)
@@ -435 +462 @@
     // TODO: this computation should be done incrementally, spread
     // across multiple frames (or even multiple turns)
 
+    ProcessLongRequests(longRequests);
+    ProcessShortRequests(shortRequests);
+}
+
+void CCmpPathfinder::ProcessLongRequests(const std::vector<AsyncLongPathRequest>& longRequests)
+{
     for (size_t i = 0; i < longRequests.size(); ++i)
     {
         const AsyncLongPathRequest& req = longRequests[i];
@@ -443 +476 @@
         CMessagePathResult msg(req.ticket, path);
         GetSimContext().GetComponentManager().PostMessage(req.notify, msg);
     }
+}
 
+void CCmpPathfinder::ProcessShortRequests(const std::vector<AsyncShortPathRequest>& shortRequests)
+{
     for (size_t i = 0; i < shortRequests.size(); ++i)
     {
         const AsyncShortPathRequest& req = shortRequests[i];
@@ -454 +490 @@
         GetSimContext().GetComponentManager().PostMessage(req.notify, msg);
     }
 }
+
+void CCmpPathfinder::ProcessSameTurnMoves()
+{
+    u32 moveCount;
+
+    if (!m_AsyncLongPathRequests.empty())
+    {
+        // Figure out how many moves we can do this time
+        moveCount = m_MaxSameTurnMoves - m_SameTurnMovesCount;
+    
+        if (moveCount <= 0)
+            return;
+
+        // Copy the long request elements we are going to process into a new array
+        std::vector<AsyncLongPathRequest> longRequests;
+        if (m_AsyncLongPathRequests.size() <= moveCount)
+        {
+            m_AsyncLongPathRequests.swap(longRequests);
+            moveCount = longRequests.size();
+        }
+        else
+        {
+            longRequests.resize(moveCount);
+            copy(m_AsyncLongPathRequests.begin(), m_AsyncLongPathRequests.begin() + moveCount, longRequests.begin());
+            m_AsyncLongPathRequests.erase(m_AsyncLongPathRequests.begin(), m_AsyncLongPathRequests.begin() + moveCount);
+        }
+
+        ProcessLongRequests(longRequests);
+
+        m_SameTurnMovesCount += moveCount;
+    }
+    
+    if (!m_AsyncShortPathRequests.empty())
+    {
+        // Figure out how many moves we can do now
+        moveCount = m_MaxSameTurnMoves - m_SameTurnMovesCount;
+
+        if (moveCount <= 0)
+            return;
+
+        // Copy the short request elements we are going to process into a new array
+        std::vector<AsyncShortPathRequest> shortRequests;
+        if (m_AsyncShortPathRequests.size() <= moveCount)
+        {
+            m_AsyncShortPathRequests.swap(shortRequests);
+            moveCount = shortRequests.size();
+        }
+        else
+        {
+            shortRequests.resize(moveCount);
+            copy(m_AsyncShortPathRequests.begin(), m_AsyncShortPathRequests.begin() + moveCount, shortRequests.begin());
+            m_AsyncShortPathRequests.erase(m_AsyncShortPathRequests.begin(), m_AsyncShortPathRequests.begin() + moveCount);
+        }
+
+        ProcessShortRequests(shortRequests);
+
+        m_SameTurnMovesCount += moveCount;
+    }
+}
+

source/simulation2/components/CCmpPathfinder_Common.h

@@ -161 +161 @@
         componentManager.SubscribeToMessageType(MT_Update);
         componentManager.SubscribeToMessageType(MT_RenderSubmit); // for debug overlays
         componentManager.SubscribeToMessageType(MT_TerrainChanged);
+        componentManager.SubscribeToMessageType(MT_TurnStart);
     }
 
     DEFAULT_COMPONENT_ALLOCATOR(Pathfinder)
@@ -180 +181 @@
     std::vector<AsyncLongPathRequest> m_AsyncLongPathRequests;
     std::vector<AsyncShortPathRequest> m_AsyncShortPathRequests;
     u32 m_NextAsyncTicket; // unique IDs for asynchronous path requests
+    u16 m_SameTurnMovesCount; // current number of same turn moves we have processed this turn
 
     // Lazily-constructed dynamic state (not serialized):
 
@@ -187 +189 @@
     Grid<TerrainTile>* m_Grid; // terrain/passability information
     Grid<u8>* m_ObstructionGrid; // cached obstruction information (TODO: we shouldn't bother storing this, it's redundant with LSBs of m_Grid)
     bool m_TerrainDirty; // indicates if m_Grid has been updated since terrain changed
+    
+    // For responsiveness we will process some moves in the same turn they were generated in
+    
+    u16 m_MaxSameTurnMoves; // max number of moves that can be created and processed in the same turn
 
     // Debugging - output from last pathfind operation:
+
     PathfindTileGrid* m_DebugGrid;
     u32 m_DebugSteps;
     Path* m_DebugPath;
@@ -242 +249 @@
 
     virtual void FinishAsyncRequests();
 
+    void ProcessLongRequests(const std::vector<AsyncLongPathRequest>& longRequests);
+    
+    void ProcessShortRequests(const std::vector<AsyncShortPathRequest>& shortRequests);
+
+    virtual void ProcessSameTurnMoves();
+
     /**
      * Returns the tile containing the given position
      */

source/simulation2/components/ICmpPathfinder.h

@@ -159 +159 @@
      */
     virtual void FinishAsyncRequests() = 0;
 
+    /**
+     * Process moves during the same turn they were created in to improve responsiveness.
+     */
+    virtual void ProcessSameTurnMoves() = 0;
+
     DECLARE_INTERFACE_TYPE(Pathfinder)
 };
 

source/simulation2/Simulation2.cpp

@@ -229 +229 @@
     if (!cmpCommandQueue.null())
         cmpCommandQueue->FlushTurn(commands);
 
+    // Process newly generated move commands so the UI feels snappy
+    if (!cmpPathfinder.null())
+        cmpPathfinder->ProcessSameTurnMoves();
+
     // Send all the update phases
     {
         CMessageUpdate msgUpdate(turnLengthFixed);
@@ -238 +242 @@
         CMessageUpdate_MotionFormation msgUpdate(turnLengthFixed);
         m_ComponentManager.BroadcastMessage(msgUpdate);
     }
+
+    // Process move commands for formations (group proxy)
+    if (!cmpPathfinder.null())
+        cmpPathfinder->ProcessSameTurnMoves();
+
     {
         CMessageUpdate_MotionUnit msgUpdate(turnLengthFixed);
         m_ComponentManager.BroadcastMessage(msgUpdate);
@@ -247 +256 @@
         m_ComponentManager.BroadcastMessage(msgUpdate);
     }
 
+    // Process moves resulting from group proxy movement (unit needs to catch up or realign) and any others
+    if (!cmpPathfinder.null())
+        cmpPathfinder->ProcessSameTurnMoves();
+
+
     // Clean up any entities destroyed during the simulation update
     m_ComponentManager.FlushDestroyedComponents();