Changeset 25170

Timestamp:

Mar 31, 2021, 5:55:19 PM (3 years ago)

Author:

wraitii

Message:

Remember OOS on a per-client basis.

Change the OOS notification logic to remember the OOS-ness of each client. Reset it on client leave.
The server will thus continue checking for OOS if the OOS-client leaves.
This is convenient to ignore observer OOS, or wait for an OOS player without restarting the game.

Also add the turn number to the OOS dump, to fix #3348: particularly following rP25001 the turn is likely to not be the same between different clients.

Agree by: asterix

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

Location:

ps/trunk/source

Files:

• network/NetClientTurnManager.cpp (modified) (3 diffs)
• network/NetServerTurnManager.cpp (modified) (10 diffs)
• network/NetServerTurnManager.h (modified) (2 diffs)
• simulation2/Simulation2.cpp (modified) (1 diff)
• simulation2/system/ReplayTurnManager.h (modified) (2 diffs)
• simulation2/system/TurnManager.cpp (modified) (1 diff)
• simulation2/system/TurnManager.h (modified) (1 diff)

ps/trunk/source/network/NetClientTurnManager.cpp

@@ -85 +85 @@
     m_Replay.Hash(hash, quick);
 
-    // Don't send the hash if OOS
-    if (m_HasSyncError)
-        return;
-
     // Send message to the server
     CSyncCheckMessage msg;
@@ -115 +111 @@
     NETCLIENTTURN_LOG("OnSyncError(%d, %hs)\n", turn, expectedHashHex.c_str());
 
-    // Only complain the first time
-    if (m_HasSyncError)
-        return;
-
-    m_HasSyncError = true;
-
     std::string hash;
     ENSURE(m_Simulation2.ComputeStateHash(hash, !TurnNeedsFullHash(turn)));
@@ -126 +116 @@
     OsPath oosdumpPath(psLogDir() / (L"oos_dump" + g_UniqueLogPostfix + L".txt"));
     std::ofstream file (OsString(oosdumpPath).c_str(), std::ofstream::out | std::ofstream::trunc);
+
+
     m_Simulation2.DumpDebugState(file);
     file.close();

ps/trunk/source/network/NetServerTurnManager.cpp

@@ -36 +36 @@
 
 CNetServerTurnManager::CNetServerTurnManager(CNetServerWorker& server)
-    : m_NetServer(server), m_ReadyTurn(COMMAND_DELAY_MP - 1), m_TurnLength(DEFAULT_TURN_LENGTH), m_HasSyncError(false)
+    : m_NetServer(server), m_ReadyTurn(COMMAND_DELAY_MP - 1), m_TurnLength(DEFAULT_TURN_LENGTH)
 {
     // Turn 0 is not actually executed, store a dummy value.
@@ -53 +53 @@
 
     // Must be a client we've already heard of
-    ENSURE(m_ClientsReady.find(client) != m_ClientsReady.end());
+    ENSURE(m_Clients.end());
 
     // Clients must advance one turn at a time
-    if (turn != m_ClientsReady[client] + 1)
+    if (turn != m_Clients + 1)
     {
         LOGERROR("NotifyFinishedClientCommands: Client %d (%s) is ready for turn %d, but expected %d",
@@ -62 +62 @@
             utf8_from_wstring(session.GetUserName()).c_str(),
             turn,
-            m_ClientsReady[client] + 1);
+            m_Clients + 1);
 
         session.Disconnect(NDR_INCORRECT_READY_TURN_COMMANDS);
     }
 
-    m_ClientsReady[client] = turn;
+    m_Clients = turn;
 
     // Check whether this was the final client to become ready
@@ -81 +81 @@
 
     // See if all clients (including self) are ready for a new turn
-    for (const std::pair<const int, u32>& clientReady : m_ClientsReady)
+    for (const std::pair<const int, )
     {
         // Observers are allowed to lag more than regular clients.
-        if (m_ClientsObserver[clientReady.first] && (max_observer_lag == -1 || clientReady.second > m_ReadyTurn - max_observer_lag))
+        if ( > m_ReadyTurn - max_observer_lag))
             continue;
         NETSERVERTURN_LOG("  %d: %d <=? %d\n", clientReady.first, clientReady.second, m_ReadyTurn);
-        if (clientReady.second <= m_ReadyTurn)
+        if (client <= m_ReadyTurn)
             return; // wasn't ready for m_ReadyTurn+1
     }
@@ -112 +112 @@
 
     // Clients must advance one turn at a time
-    if (turn != m_ClientsSimulated[client] + 1)
+    if (turn != m_Clients + 1)
     {
         LOGERROR("NotifyFinishedClientUpdate: Client %d (%s) is ready for turn %d, but expected %d",
@@ -118 +118 @@
             utf8_from_wstring(playername).c_str(),
             turn,
-            m_ClientsReady[client] + 1);
+            m_Clients + 1);
 
         session.Disconnect(NDR_INCORRECT_READY_TURN_SIMULATED);
     }
 
-    m_ClientsSimulated[client] = turn;
+    m_Clients = turn;
 
     // Check for OOS only if in sync
@@ -129 +129 @@
         return;
 
-    m_ClientPlayernames[client] = playername;
+    m_Client = playername;
     m_ClientStateHashes[turn][client] = hash;
 
     // Find the newest turn which we know all clients have simulated
     u32 newest = std::numeric_limits<u32>::max();
-    for (const std::pair<const int, u32>& clientSimulated : m_ClientsSimulated)
-        if (clientSimulated.second < newest)
-            newest = clientSimulated.second;
+    for (const std::pair<const int, )
+        if (client < newest)
+            newest = client;
 
     // For every set of state hashes that all clients have simulated, check for OOS
@@ -156 +156 @@
                 // Oh no, out of sync
                 m_HasSyncError = true;
-                OOSPlayerNames.push_back(m_ClientPlayernames[hashPair.first]);
+                m_ClientsData[hashPair.first].isOOS = true;
+                OOSPlayerNames.push_back(m_ClientsData[hashPair.first].playerName);
             }
         }
@@ -185 +186 @@
     NETSERVERTURN_LOG("InitialiseClient(client=%d, turn=%d)\n", client, turn);
 
-    ENSURE(m_ClientsReady.find(client) == m_ClientsReady.end());
-    m_ClientsReady[client] = turn + COMMAND_DELAY_MP - 1;
-    m_ClientsSimulated[client] = turn;
-    m_ClientsObserver[client] = observer;
+    ENSURE(m_ClientsData.find(client) == m_ClientsData.end());
+    Client& data = m_ClientsData[client];
+    data.readyTurn = turn + COMMAND_DELAY_MP - 1;
+    data.simulatedTurn = turn;
+    data.isObserver = observer;
 }
 
@@ -195 +197 @@
     NETSERVERTURN_LOG("UninitialiseClient(client=%d)\n", client);
 
-    ENSURE(m_ClientsReady.find(client) != m_ClientsReady.end());
-    m_ClientsReady.erase(client);
-    m_ClientsSimulated.erase(client);
-    m_ClientsObserver.erase(client);
+    ENSURE(m_ClientsData.find(client) != m_ClientsData.end());
+    bool checkOOS = m_ClientsData[client].isOOS;
+    m_ClientsData.erase(client);
 
     // Check whether we're ready for the next turn now that we're not
     // waiting for this client any more
     CheckClientsReady();
+
+
+
+
+
+
+
+
+
 }
 

ps/trunk/source/network/NetServerTurnManager.h

@@ -73 +73 @@
     void CheckClientsReady();
 
-    /// The latest turn for which we have received all commands from all clients
-    u32 m_ReadyTurn;
+    struct Client
+    {
+        CStrW playerName;
+        // Latest turn for which all commands have been received.
+        u32 readyTurn;
+        // Last known simulated turn.
+        u32 simulatedTurn;
+        bool isObserver;
+        bool isOOS = false;
+    };
 
-    // Client ID -> whether they are only an observer.
-    std::unordered_map<int, bool> m_ClientsObserver;
+    std::unordered_map<int, Client> m_ClientsData;
 
-    // Client ID -> ready turn number (the latest turn for which all commands have been received from that client)
-    std::map<int, u32> m_ClientsReady;
-
-    // Client ID -> last known simulated turn number (for which we have the state hash)
-    // (the client has reached the start of this turn, not done the update for it yet)
-    std::map<int, u32> m_ClientsSimulated;
+    // Cached value - is any client OOS? This is reset when the OOS client leaves.
+    bool m_HasSyncError = false;
 
     // Map of turn -> {Client ID -> state hash}; old indexes <= min(m_ClientsSimulated) are deleted
     std::map<u32, std::map<int, std::string>> m_ClientStateHashes;
 
-    // Map of client ID -> playername
-    std::map<int, CStrW> m_ClientPlayernames;
+    //
+    ;
 
     // Current turn length
@@ -99 +102 @@
 
     CNetServerWorker& m_NetServer;
-
-    bool m_HasSyncError;
 };
 

ps/trunk/source/simulation2/Simulation2.cpp

@@ -886 +886 @@
 bool CSimulation2::DumpDebugState(std::ostream& stream)
 {
+
     return m->m_ComponentManager.DumpDebugState(stream, true);
 }

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

@@ -1 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 202 Wildfire Games.
  * This file is part of 0 A.D.
  *
@@ -45 +45 @@
     static const CStr EventNameReplayOutOfSync;
 
+
+
     // Contains the commands of every player on each turn
     std::map<u32, std::vector<std::pair<player_id_t, std::string>>> m_ReplayCommands;

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

@@ -41 +41 @@
 CTurnManager::CTurnManager(CSimulation2& simulation, u32 defaultTurnLength, u32 commandDelay, int clientId, IReplayLogger& replay)
     : m_Simulation2(simulation), m_CurrentTurn(0), m_CommandDelay(commandDelay), m_ReadyTurn(commandDelay - 1), m_TurnLength(defaultTurnLength),
-    m_PlayerId(-1), m_ClientId(clientId), m_DeltaSimTime(0), m_HasSyncError(false), m_Replay(replay),
+    m_PlayerId(-1), m_ClientId(clientId), m_DeltaSimTime(0), m_Replay(replay),
     m_FinalTurn(std::numeric_limits<u32>::max()), m_TimeWarpNumTurns(0),
     m_QuickSaveMetadata(m_Simulation2.GetScriptInterface().GetGeneralJSContext())

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

@@ -210 +210 @@
     float m_DeltaSimTime;
 
-    bool m_HasSyncError;
-
     IReplayLogger& m_Replay;