Changeset 25156

Timestamp:

Mar 29, 2021, 9:53:06 AM (3 years ago)

Author:

wraitii

Message:

Netcode: allow observers to lag behind the live game.

Observers no longer lag the game for players. There is still some time to serialise the game when sending it to a joining observer, and depending on the chosen 'max lag' the game may stop while observers sufficiently catch up, but this impact too is reduced.

• Make the NetServerTurnManager ignore players marked as 'observers' for the purpose of ending a turn, effectively making it possible for observers to lag without it affecting the players in any way.
• Add a config option (network.observermaxlag) that specifies how many turns behind the live game observers are allowed to be. Default to 10 turns, or 2 seconds, to keep them 'largely live'.
• The controller is not treated as an observer.
• Implement a simple UI to show this delay & allow the game to speed up automatically to try and catch up. This can be deactivated via network.autocatchup.
• Move network options to the renamed 'Network / Lobby' options page.
• Do not debug_warn/crash when receiving commands from the past - instead warn and carry on, to avoid DOS and "coop play" issues.

Refs #5903, Refs #4210

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

Location:

ps/trunk

Files:

• binaries/data/config/default.cfg (modified) (1 diff)
• binaries/data/mods/public/gui/options/options.json (modified) (4 diffs)
• binaries/data/mods/public/gui/session/NetworkDelayOverlay.js (added)
• binaries/data/mods/public/gui/session/NetworkDelayOverlay.xml (added)
• binaries/data/mods/public/gui/session/session.js (modified) (2 diffs)
• binaries/data/mods/public/gui/session/session.xml (modified) (1 diff)
• source/network/NetServer.cpp (modified) (3 diffs)
• source/network/NetServerTurnManager.cpp (modified) (5 diffs)
• source/network/NetServerTurnManager.h (modified) (6 diffs)
• source/ps/scripting/JSInterface_Game.cpp (modified) (2 diffs)
• source/simulation2/system/TurnManager.cpp (modified) (5 diffs)
• source/simulation2/system/TurnManager.h (modified) (2 diffs)

ps/trunk/binaries/data/config/default.cfg

@@ -487 +487 @@
 lateobservers = everyone          ; Allow observers to join the game after it started. Possible values: everyone, buddies, disabled.
 observerlimit = 8                 ; Prevent further observer joins in running games if this limit is reached
+
+
 
 [overlay]

ps/trunk/binaries/data/mods/public/gui/options/options.json

@@ -30 +30 @@
             {
                 "type": "boolean",
-                "label": "Network warnings",
-                "tooltip": "Show which player has a bad connection in multiplayer games.",
-                "config": "overlay.netwarnings"
-            },
-            {
-                "type": "boolean",
                 "label": "FPS overlay",
                 "tooltip": "Show frames per second in top right corner.",
@@ -57 +51 @@
                 "tooltip": "Always show the remaining ceasefire time.",
                 "config": "gui.session.ceasefirecounter"
-            },
-            {
-                "type": "dropdown",
-                "label": "Late observer joins",
-                "tooltip": "Allow everybody or buddies only to join the game as observer after it started.",
-                "config": "network.lateobservers",
-                "list": [
-                    { "value": "everyone", "label": "Everyone" },
-                    { "value": "buddies", "label": "Buddies" },
-                    { "value": "disabled", "label": "Disabled" }
-                ]
-            },
-            {
-                "type": "number",
-                "label": "Observer limit",
-                "tooltip": "Prevent further observers from joining if the limit is reached.",
-                "config": "network.observerlimit",
-                "min": 0,
-                "max": 32
             },
             {
@@ -426 +401 @@
     },
     {
-        "label": "Lobby",
+        "label": "Lobby",
         "tooltip": "These settings only affect the multiplayer.",
         "options":
@@ -448 +423 @@
                 "tooltip": "Show the average rating of the participating players in a column of the gamelist.",
                 "config": "lobby.columns.gamerating"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
             }
         ]

ps/trunk/binaries/data/mods/public/gui/session/session.js

@@ -21 +21 @@
 var g_MiniMapPanel;
 var g_NetworkStatusOverlay;
+
 var g_ObjectivesDialog;
 var g_OutOfSyncNetwork;
@@ -290 +291 @@
     g_MiniMapPanel = new MiniMapPanel(g_PlayerViewControl, g_DiplomacyColors, g_WorkerTypes);
     g_NetworkStatusOverlay = new NetworkStatusOverlay();
+
     g_ObjectivesDialog = new ObjectivesDialog(g_PlayerViewControl, mapCache);
     g_OutOfSyncNetwork = new OutOfSyncNetwork();

ps/trunk/binaries/data/mods/public/gui/session/session.xml

@@ -39 +39 @@
 
     <include file="gui/session/NetworkStatusOverlay.xml"/>
+
     <include file="gui/session/PauseOverlay.xml"/>
     <include file="gui/session/TimeNotificationOverlay.xml"/>

ps/trunk/source/network/NetServer.cpp

@@ -748 +748 @@
 
     if (m_ServerTurnManager && session->GetCurrState() != NSS_JOIN_SYNCING)
-        m_ServerTurnManager->UninitialiseClient(session->GetHostID()); // TODO: only for non-observers
+        m_ServerTurnManager->UninitialiseClient(session->GetHostID());
 
     // TODO: ought to switch the player controlled by that client
@@ -1403 +1403 @@
 
     // Tell the turn manager to expect commands from this new client
-    server.m_ServerTurnManager->InitialiseClient(session->GetHostID(), readyTurn);
+    // Special case: the controller shouldn't be treated as an observer in any case.
+    bool isObserver = server.m_PlayerAssignments[session->GetGUID()].m_PlayerID == -1 && server.m_ControllerGUID != session->GetGUID();
+    server.m_ServerTurnManager->InitialiseClient(session->GetHostID(), readyTurn, isObserver);
 
     // Tell the client that everything has finished loading and it should start now
@@ -1531 +1533 @@
 
     for (CNetServerSession* session : m_Sessions)
-        m_ServerTurnManager->InitialiseClient(session->GetHostID(), 0); // TODO: only for non-observers
+    {
+        // Special case: the controller shouldn't be treated as an observer in any case.
+        bool isObserver = m_PlayerAssignments[session->GetGUID()].m_PlayerID == -1 && m_ControllerGUID != session->GetGUID();
+        m_ServerTurnManager->InitialiseClient(session->GetHostID(), 0, isObserver);
+    }
 
     m_State = SERVER_STATE_LOADING;

ps/trunk/source/network/NetServerTurnManager.cpp

@@ -25 +25 @@
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
+
 #include "simulation2/system/TurnManager.h"
 
@@ -74 +75 @@
 void CNetServerTurnManager::CheckClientsReady()
 {
+
+
+
+
+
     // See if all clients (including self) are ready for a new turn
     for (const std::pair<const int, u32>& clientReady : m_ClientsReady)
     {
+
+
+
         NETSERVERTURN_LOG("  %d: %d <=? %d\n", clientReady.first, clientReady.second, m_ReadyTurn);
         if (clientReady.second <= m_ReadyTurn)
@@ -172 +181 @@
 }
 
-void CNetServerTurnManager::InitialiseClient(int client, u32 turn)
+void CNetServerTurnManager::InitialiseClient(int client, u32 turn)
 {
     NETSERVERTURN_LOG("InitialiseClient(client=%d, turn=%d)\n", client, turn);
@@ -179 +188 @@
     m_ClientsReady[client] = turn + COMMAND_DELAY_MP - 1;
     m_ClientsSimulated[client] = turn;
+
 }
 
@@ -188 +198 @@
     m_ClientsReady.erase(client);
     m_ClientsSimulated.erase(client);
+
 
     // Check whether we're ready for the next turn now that we're not

ps/trunk/source/network/NetServerTurnManager.h

@@ -1 @@
-/* Copyright (C) 2018 Wildfire Games.
+/* Copyright (C) 20 Wildfire Games.
  * This file is part of 0 A.D.
  *
@@ -19 +19 @@
 #define INCLUDED_NETSERVERTURNMANAGER
 
+
+
 #include <map>
-#include "ps/CStr.h"
+#include 
 
 class CNetServerWorker;
@@ -28 +30 @@
  * The server-side counterpart to CNetClientTurnManager.
  * Records the turn state of each client, and sends turn advancement messages
- * when all clients are ready.
+ * when clients are ready.
  *
  * Thread-safety:
@@ -44 +46 @@
 
     /**
-     * Inform the turn manager of a new client who will be sending commands.
+     * Inform the turn manager of a new client
+     * @param observer - whether this client is an observer.
      */
-    void InitialiseClient(int client, u32 turn);
+    void InitialiseClient(int client, u32 turn);
 
     /**
-     * Inform the turn manager that a previously-initialised client has left the game
-     * and will no longer be sending commands.
+     * Inform the turn manager that a previously-initialised client has left the game.
      */
     void UninitialiseClient(int client);
@@ -74 +76 @@
     u32 m_ReadyTurn;
 
+
+
+
     // Client ID -> ready turn number (the latest turn for which all commands have been received from that client)
     std::map<int, u32> m_ClientsReady;
@@ -85 +90 @@
 
     // Map of client ID -> playername
-    std::map<u32, CStrW> m_ClientPlayernames;
+    std::map<, CStrW> m_ClientPlayernames;
 
     // Current turn length

ps/trunk/source/ps/scripting/JSInterface_Game.cpp

@@ -99 +99 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
 bool IsPaused(const ScriptRequest& rq)
 {
@@ -180 +191 @@
     ScriptFunction::Register<&GetSimRate>(rq, "GetSimRate");
     ScriptFunction::Register<&SetSimRate>(rq, "SetSimRate");
+
     ScriptFunction::Register<&IsPaused>(rq, "IsPaused");
     ScriptFunction::Register<&SetPaused>(rq, "SetPaused");

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

@@ -1 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 202 Wildfire Games.
  * This file is part of 0 A.D.
  *
@@ -37 +37 @@
 #endif
 
-/**
- * Maximum number of turns between two clients.
- * When we are on turn n, we schedule new commands for n+COMMAND_DELAY.
- * We know that all other clients have finished scheduling commands for n,
- * else we couldn't have got here, which means they're at least on turn n-COMMAND_DELAY+1.
- * We know we have not yet finished scheduling commands for n+COMMAND_DELAY, so no client can be there.
- * Hence other clients can be on turns [n-COMMAND_DELAY+1, ..., n+COMMAND_DELAY-1], and no other,
- * hence any two clients can only be this many turns apart.
- */
-constexpr int MaxClientTurnDelta(int commandDelay)
-{
-        return 2 * (commandDelay - 1);
-}
-
 const CStr CTurnManager::EventNameSavegameLoaded = "SavegameLoaded";
 
@@ -59 +45 @@
     m_QuickSaveMetadata(m_Simulation2.GetScriptInterface().GetGeneralJSContext())
 {
-    // Lag between any two clients is bounded. Add 1 for inclusive bounds.
-    m_QueuedCommands.resize(MaxClientTurnDelta(m_CommandDelay) + 1);
+    m_QueuedCommands.resize(1);
 }
 
@@ -238 +223 @@
     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");
+    // Reject commands for turns that we should not be able to compute (in the past).
+    if (m_CurrentTurn >= turn)
+    {
+        // The most likely explanation is that an observer that's lagging behind is sending commands,
+        // which is possible when cheats are enabled. Report & ignore.
+        // It seems a bad idea to error out too badly here:
+        // nefarious clients could try and send broken commands to DOS.
+        LOGWARNING("Received command for invalid turn %i (current turn is %i)", turn, m_CurrentTurn);
         return;
     }
@@ -248 +237 @@
 
     ScriptRequest rq(m_Simulation2.GetScriptInterface());
+
+
+
     m_QueuedCommands[turn - (m_CurrentTurn+1)][client].emplace_back(player, rq.cx, data);
 }

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

@@ -1 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 202 Wildfire Games.
  * This file is part of 0 A.D.
  *
@@ -156 +156 @@
     void QuickLoad();
 
-    u32 GetCurrentTurn() { return m_CurrentTurn; }
+    u32 GetCurrentTurn() const { return m_CurrentTurn; }
+
+    /**
+     * @return how many turns are ready to be computed.
+     * (used to detect players/observers that fall behind the live game.
+     */
+    u32 GetPendingTurns() const { return m_ReadyTurn - m_CurrentTurn; }
 
 protected: