Changeset 9665 for ps

Timestamp:

06/26/11 09:03:08 (14 years ago)

Author:

kennethalong

Message:

#788 Eliminate delay in path finding (and therefore moving)

Location:

ps/trunk

Files:

• binaries/data/mods/public/simulation/data/pathfinder.xml (modified) (1 diff)
• source/simulation2/Simulation2.cpp (modified) (3 diffs)
• source/simulation2/components/CCmpPathfinder.cpp (modified) (5 diffs)
• source/simulation2/components/CCmpPathfinder_Common.h (modified) (3 diffs)
• source/simulation2/components/ICmpPathfinder.h (modified) (1 diff)

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

@@ -2 +2 @@
 <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>64</MaxSameTurnMoves>
+  
   <PassabilityClasses>
 

ps/trunk/source/simulation2/Simulation2.cpp

@@ -230 +230 @@
         cmpCommandQueue->FlushTurn(commands);
 
+    // Process newly generated move commands so the UI feels snappy
+    if (!cmpPathfinder.null())
+        cmpPathfinder->ProcessSameTurnMoves();
+
     // Send all the update phases
     {
@@ -239 +243 @@
         m_ComponentManager.BroadcastMessage(msgUpdate);
     }
+
+    // Process move commands for formations (group proxy)
+    if (!cmpPathfinder.null())
+        cmpPathfinder->ProcessSameTurnMoves();
+
     {
         CMessageUpdate_MotionUnit msgUpdate(turnLengthFixed);
@@ -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

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

@@ -59 +59 @@
     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();
@@ -200 +203 @@
         break;
     }
+    case MT_TurnStart:
+    {
+        m_SameTurnMovesCount = 0;
+        break;
+    }
     }
 }
@@ -436 +444 @@
     // 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)
     {
@@ -444 +458 @@
         GetSimContext().GetComponentManager().PostMessage(req.notify, msg);
     }
-
+}
+
+void CCmpPathfinder::ProcessShortRequests(const std::vector<AsyncShortPathRequest>& shortRequests)
+{
     for (size_t i = 0; i < shortRequests.size(); ++i)
     {
@@ -455 +472 @@
     }
 }
+
+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;
+    }
+}
+

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

@@ -162 +162 @@
         componentManager.SubscribeToMessageType(MT_RenderSubmit); // for debug overlays
         componentManager.SubscribeToMessageType(MT_TerrainChanged);
+        componentManager.SubscribeToMessageType(MT_TurnStart);
     }
 
@@ -188 +189 @@
     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;
@@ -243 +250 @@
     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

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

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