Changeset 25001

Timestamp:

Mar 3, 2021, 10:02:57 PM (3 years ago)

Author:

wraitii

Message:

Increase MP Command delay to 4 turns, decrease MP turns to 200ms.

To hide network latency, MP turns send commands not for the next turn but N turns after that (introduced in rP).
Further, MP turn length was increased to 500ms compared to 200ms SP turns (introduced in rP7551).
Unfortunately, increasing MP turn length has negative consequences:

• makes pathfinding/unit motion much worse & unit behaviour worse in general.
• makes the game more 'lag-spikey', since computations are done less often, but thus then can take more time.

This diff essentially reverts rP8400, instead increasing COMMAND_DELAY from 2 to 4 in MP. This:

• Reduces the 'inherent command lag' in MP from 1000ms to 800ms
• Increases the lag range at which MP will run smoothtly from 500ms to 600ms
• makes SP and MP turns behave identically again, removing the hindrances described above.

As a side effect, single-player was not actually using COMMAND_DELAY, this is now done (can be used to simulate MP command lag).

Refs #3752

Differential Revision: ​https://code.wildfiregames.com/D3275

Location:

ps/trunk/source

Files:

• main.cpp (modified) (1 diff)
• network/NetClient.cpp (modified) (3 diffs)
• network/NetClientTurnManager.cpp (modified) (3 diffs)
• network/NetServer.cpp (modified) (2 diffs)
• network/NetServerTurnManager.cpp (modified) (4 diffs)
• rlinterface/RLInterface.cpp (modified) (1 diff)
• simulation2/system/LocalTurnManager.cpp (modified) (2 diffs)
• simulation2/system/TurnManager.cpp (modified) (5 diffs)
• simulation2/system/TurnManager.h (modified) (4 diffs)

ps/trunk/source/main.cpp

@@ -469 +469 @@
 
     static u32 turn = 0;
-    debug_printf("Turn %u (%u)...\n", turn++, DEFAULT_TURN_LENGTH_SP);
-
-    g_Game->GetSimulation2()->Update(DEFAULT_TURN_LENGTH_SP);
+    debug_printf("Turn %u (%u)...\n", turn++, DEFAULT_TURN_LENGTH);
+
+    g_Game->GetSimulation2()->Update(DEFAULT_TURN_LENGTH);
 
     g_Profiler.Frame();

ps/trunk/source/network/NetClient.cpp

@@ -41 +41 @@
 #include "network/StunClient.h"
 
+
+
+
+
+
+
+
+
 CNetClient *g_NetClient = NULL;
 
@@ -335 +343 @@
     }
 
-    // Report if we have a bad ping to the server
+    // Report if we have a bad ping to the server
     u32 meanRTT = m_Session->GetMeanRTT();
-    if (meanRTT > DEFAULT_TURN_LENGTH_MP)
+    if (meanRTT > )
     {
         PushGuiMessage(
@@ -858 +866 @@
     for (size_t i = 0; i < message->m_Clients.size(); ++i)
     {
-        if (message->m_Clients[i].m_MeanRTT < DEFAULT_TURN_LENGTH_MP || message->m_Clients[i].m_GUID == client->m_GUID)
+        if (message->m_Clients[i].m_MeanRTT <  || message->m_Clients[i].m_GUID == client->m_GUID)
             continue;
 

ps/trunk/source/network/NetClientTurnManager.cpp

@@ -37 +37 @@
 
 CNetClientTurnManager::CNetClientTurnManager(CSimulation2& simulation, CNetClient& client, int clientId, IReplayLogger& replay)
-    : CTurnManager(simulation, DEFAULT_TURN_LENGTH_MP, clientId, replay), m_NetClient(client)
+    : CTurnManager(simulation, DEFAULT_TURN_LENGTH_MP, clientId, replay), m_NetClient(client)
 {
 }
@@ -46 +46 @@
 
     // Transmit command to server
-    CSimulationMessage msg(m_Simulation2.GetScriptInterface(), m_ClientId, m_PlayerId, m_CurrentTurn + COMMAND_DELAY, data);
+    CSimulationMessage msg(m_Simulation2.GetScriptInterface(), m_ClientId, m_PlayerId, m_CurrentTurn + , data);
     m_NetClient.SendMessage(&msg);
 
     // Add to our local queue
-    //AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + COMMAND_DELAY);
+    //AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + );
     // TODO: we should do this when the server stops sending our commands back to us
 }
@@ -99 +99 @@
     // Notice the sending is not reliable and rarely makes it to the Server.
     if (m_NetClient.GetCurrState() == NCS_INGAME)
-        NotifyFinishedOwnCommands(m_CurrentTurn + COMMAND_DELAY);
+        NotifyFinishedOwnCommands(m_CurrentTurn + );
 }
 

ps/trunk/source/network/NetServer.cpp

@@ -68 +68 @@
 static const int HOST_SERVICE_TIMEOUT = 50;
 
+
+
+
+
+
+
+
+
 CNetServer* g_NetServer = NULL;
 
@@ -605 +613 @@
         }
         // Report if the client has bad ping
-        else if (meanRTT > DEFAULT_TURN_LENGTH_MP)
+        else if (meanRTT > )
         {
             CClientPerformanceMessage* msg = new CClientPerformanceMessage();

ps/trunk/source/network/NetServerTurnManager.cpp

@@ -28 +28 @@
 
 #if 0
+
 #define NETSERVERTURN_LOG(...) debug_printf(__VA_ARGS__)
 #else
@@ -34 +35 @@
 
 CNetServerTurnManager::CNetServerTurnManager(CNetServerWorker& server)
-    : m_NetServer(server), m_ReadyTurn(1), m_TurnLength(DEFAULT_TURN_LENGTH_MP), m_HasSyncError(false)
+    : m_NetServer(server), m_ReadyTurn(), m_HasSyncError(false)
 {
     // Turn 0 is not actually executed, store a dummy value.
     m_SavedTurnLengths.push_back(0);
-    // Turn 1 is special: all clients run it without waiting on a server command batch.
-    // Because of this, it is always run with the default MP turn length.
-    m_SavedTurnLengths.push_back(m_TurnLength);
+    // Turns [1..COMMAND_DELAY - 1] are special: all clients run them without waiting on a server command batch.
+    // Because of this, they are always run with the default MP turn length.
+    for (u32 i = 1; i < COMMAND_DELAY_MP; ++i)
+        m_SavedTurnLengths.push_back(m_TurnLength);
 }
 
@@ -140 +142 @@
         for (const std::pair<const int, std::string>& hashPair : clientStateHash.second)
         {
-            NETSERVERTURN_LOG("sync check %d: %d = %hs\n", it->first, cit->first, Hexify(cit->second).c_str());
+            NETSERVERTURN_LOG("sync check %d: %d = %hs\n", second).c_str());
             if (hashPair.second != expected)
             {
@@ -175 +177 @@
 
     ENSURE(m_ClientsReady.find(client) == m_ClientsReady.end());
-    m_ClientsReady[client] = turn + 1;
+    m_ClientsReady[client] = turn + 1;
     m_ClientsSimulated[client] = turn;
 }

ps/trunk/source/rlinterface/RLInterface.cpp

@@ -390 +390 @@
             }
 
-            const u32 deltaRealTime = DEFAULT_TURN_LENGTH_SP;
+            const u32 deltaRealTime = DEFAULT_TURN_LENGTH;
             if (nonVisual)
             {

ps/trunk/source/simulation2/system/LocalTurnManager.cpp

@@ -21 +21 @@
 
 CLocalTurnManager::CLocalTurnManager(CSimulation2& simulation, IReplayLogger& replay)
-    : CTurnManager(simulation, DEFAULT_TURN_LENGTH_SP, 0, replay)
+    : CTurnManager(simulation, DEFAULT_TURN_LENGTH_SP, 0, replay)
 {
 }
@@ -27 +27 @@
 void CLocalTurnManager::PostCommand(player_id_t playerid, JS::HandleValue data)
 {
-    AddCommand(m_ClientId, playerid, data, m_CurrentTurn + 1);
+    AddCommand(m_ClientId, playerid, data, m_CurrentTurn + );
 }
 
 void CLocalTurnManager::PostCommand(JS::HandleValue data)
 {
-    // Add directly to the next turn, ignoring COMMAND_DELAY,
-    // because we don't need to compensate for network latency
-    AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + 1);
+    AddCommand(m_ClientId, m_PlayerId, data, m_CurrentTurn + m_CommandDelay);
 }
 

ps/trunk/source/simulation2/system/TurnManager.cpp

@@ -31 +31 @@
 #include "simulation2/Simulation2.h"
 
-const u32 DEFAULT_TURN_LENGTH_MP = 500;
-const u32 DEFAULT_TURN_LENGTH_SP = 200;
-
-const int COMMAND_DELAY = 2;
-
 #if 0
 #define NETTURN_LOG(...) debug_printf(__VA_ARGS__)
@@ -42 +37 @@
 #endif
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 const CStr CTurnManager::EventNameSavegameLoaded = "SavegameLoaded";
 
-CTurnManager::CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay)
-    : m_Simulation2(simulation), m_CurrentTurn(0), m_ReadyTurn(1), m_TurnLength(defaultTurnLength),
+CTurnManager::CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay)
+    : m_Simulation2(simulation), m_CurrentTurn(0), m_1), m_TurnLength(defaultTurnLength),
     m_PlayerId(-1), m_ClientId(clientId), m_DeltaSimTime(0), m_HasSyncError(false), m_Replay(replay),
     m_FinalTurn(std::numeric_limits<u32>::max()), m_TimeWarpNumTurns(0),
     m_QuickSaveMetadata(m_Simulation2.GetScriptInterface().GetGeneralJSContext())
 {
-    // When we are on turn n, we schedule new commands for n+2.
-    // We know that all other clients have finished scheduling commands for n (else we couldn't have got here).
-    // We know we have not yet finished scheduling commands for n+2.
-    // Hence other clients can be on turn n-1, n, n+1, and no other.
-    // So they can be sending us commands scheduled for n+1, n+2, n+3.
-    // So we need a 3-element buffer:
-    m_QueuedCommands.resize(COMMAND_DELAY + 1);
+    // Lag between any two clients is bounded. Add 1 for inclusive bounds.
+    m_QueuedCommands.resize(MaxClientTurnDelta(m_CommandDelay) + 1);
 }
 
@@ -109 +113 @@
 
     // Check that the next turn is ready for execution
-    if (m_ReadyTurn <= m_CurrentTurn)
+    if (m_ReadyTurn <= m_CurrentTurn)
     {
         // Oops, we wanted to start the next turn but it's not ready yet -
@@ -133 +137 @@
 
         // Check that the i'th next turn is still ready
-        if (m_ReadyTurn <= m_CurrentTurn)
+        if (m_ReadyTurn <= m_CurrentTurn)
             break;
 
-        NotifyFinishedOwnCommands(m_CurrentTurn + COMMAND_DELAY);
+        NotifyFinishedOwnCommands(m_CurrentTurn + );
 
         // Increase now, so Update can send new commands for a subsequent turn
@@ -232 +236 @@
 void CTurnManager::AddCommand(int client, int player, JS::HandleValue data, u32 turn)
 {
-    NETTURN_LOG("AddCommand(client=%d player=%d turn=%d)\n", client, player, turn);
-
-    if (!(m_CurrentTurn < turn && turn <= m_CurrentTurn + COMMAND_DELAY + 1))
+    NETTURN_LOG("AddCommand(client=%d player=%d turn=%d current=%d, ready=%d)\n", client, player, turn, m_CurrentTurn, m_ReadyTurn);
+
+    // Reject commands for turns that we should not be able to compute (in the past or too far future).
+    if (m_CurrentTurn >= turn || turn > m_CurrentTurn + MaxClientTurnDelta(m_CommandDelay) + 1)
     {
         debug_warn(L"Received command for invalid turn");

ps/trunk/source/simulation2/system/TurnManager.h

@@ -30 +30 @@
 class CSimulation2;
 class IReplayLogger;
-
-extern const u32 DEFAULT_TURN_LENGTH_SP;
-extern const u32 DEFAULT_TURN_LENGTH_MP;
-
-extern const int COMMAND_DELAY;
 
 /**
@@ -55 +50 @@
 
 /**
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
  * Common turn system (used by clients and offline games).
  */
@@ -64 +84 @@
      * Construct for a given network session ID.
      */
-    CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay);
+    CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, int clientId, IReplayLogger& replay);
 
     virtual ~CTurnManager() { }
@@ -165 +185 @@
     u32 m_CurrentTurn;
 
+
+
+
     /// The latest turn for which we have received all commands from all clients
     u32 m_ReadyTurn;