Changeset 9666 for ps

Timestamp:

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

Author:

kennethalong

Message:

Post code review version - previous commit was pre code review version.

Location:

ps/trunk

Files:

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

ps/trunk/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.
-  -->
+  <!-- Sets limit on the number of same turns moves we will process -->
+  <!-- Setting the value to 0 disable this functionality -->
   <MaxSameTurnMoves>64</MaxSameTurnMoves>
   

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

@@ -53 +53 @@
     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),
@@ -59 +61 @@
     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();
@@ -176 +193 @@
     SerializeVector<SerializeShortRequest>()(serialize, "short requests", m_AsyncShortPathRequests);
     serialize.NumberU32_Unbounded("next ticket", m_NextAsyncTicket);
+    serialize.NumberU16_Unbounded("same turn moves count", m_SameTurnMovesCount);
 }
 
@@ -185 +203 @@
     SerializeVector<SerializeShortRequest>()(deserialize, "short requests", m_AsyncShortPathRequests);
     deserialize.NumberU32_Unbounded("next ticket", m_NextAsyncTicket);
+    deserialize.NumberU16_Unbounded("same turn moves count", m_SameTurnMovesCount);
 }
 
@@ -477 +496 @@
     u32 moveCount;
 
-    if (m_AsyncLongPathRequests.size() > 0)
+    if (!m_AsyncLongPathRequests.empty())
     {
         // Figure out how many moves we can do this time
@@ -504 +523 @@
     }
     
-    if (m_AsyncShortPathRequests.size() > 0)
+    if (!m_AsyncShortPathRequests.empty())
     {
         // Figure out how many moves we can do now

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

@@ -182 +182 @@
     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):
@@ -190 +191 @@
     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
+    // 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
-    u16 m_SameTurnMovesCount; // current number of same turn moves we have processed this turn
 
     // Debugging - output from last pathfind operation:
@@ -250 +250 @@
     virtual void FinishAsyncRequests();
 
-    virtual void ProcessLongRequests(const std::vector<AsyncLongPathRequest>& longRequests);
+    void ProcessLongRequests(const std::vector<AsyncLongPathRequest>& longRequests);
     
-    virtual void ProcessShortRequests(const std::vector<AsyncShortPathRequest>& shortRequests);
+    void ProcessShortRequests(const std::vector<AsyncShortPathRequest>& shortRequests);
 
     virtual void ProcessSameTurnMoves();