Ticket #788: SameTurnMovesPatch.patch

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

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Pathfinder>
 
+  <!--
+    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.
+  -->
+  <MaxSameTurnMoves>16</MaxSameTurnMoves>
+  
   <PassabilityClasses>
 
     <!-- Unit pathfinding classes: -->

source/simulation2/components/CCmpPathfinder.cpp

@@ -58 +58 @@
     CParamNode externalParamNode;
     CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml");
 
+    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)
     {
@@ -199 +202 @@
         m_TerrainDirty = true;
         break;
     }
+    case MT_TurnStart:
+    {
+        m_SameTurnMovesCount = 0;
+        break;
     }
+    }
 }
 
 void CCmpPathfinder::RenderSubmit(SceneCollector& collector)
@@ -435 +443 @@
     // 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 +457 @@
         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 +471 @@
         GetSimContext().GetComponentManager().PostMessage(req.notify, msg);
     }
 }
+
+void CCmpPathfinder::ProcessSameTurnMoves()
+{
+    u32 moveCount;
+
+    if (m_AsyncLongPathRequests.size() > 0)
+    {
+        // 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.size() > 0)
+    {
+        // 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)
@@ -187 +188 @@
     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 procees 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
+    u16 m_SameTurnMovesCount; // current number of same turn moves we have processed this turn
 
     // Debugging - output from last pathfind operation:
+
     PathfindTileGrid* m_DebugGrid;
     u32 m_DebugSteps;
     Path* m_DebugPath;
@@ -242 +249 @@
 
     virtual void FinishAsyncRequests();
 
+    virtual void ProcessLongRequests(const std::vector<AsyncLongPathRequest>& longRequests);
+    
+    virtual 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();