Ticket #3293: t3293_show_who_is_oos_v1.2.patch

source/network/NetClient.cpp

@@ -641 +641 @@
             client->m_ClientTurnManager->OnSimulationMessage(simMessage);
         }
         else if (message->GetType() == NMT_SYNC_ERROR)
         {
             CSyncErrorMessage* syncMessage = static_cast<CSyncErrorMessage*> (message);
-            client->m_ClientTurnManager->OnSyncError(syncMessage->m_Turn, syncMessage->m_HashExpected);
+            client->m_ClientTurnManager->OnSyncError(syncMessage->m_Turn, syncMessage->m_HashExpected, syncMessage->m_PlayerNames);
         }
         else if (message->GetType() == NMT_END_COMMAND_BATCH)
         {
             CEndCommandBatchMessage* endMessage = static_cast<CEndCommandBatchMessage*> (message);
             client->m_ClientTurnManager->FinishedAllCommands(endMessage->m_Turn, endMessage->m_TurnLength);

source/network/NetMessages.h

@@ -179 +179 @@
 END_NMT_CLASS()
 
 START_NMT_CLASS_(SyncError, NMT_SYNC_ERROR)
     NMT_FIELD_INT(m_Turn, u32, 4)
     NMT_FIELD(CStr, m_HashExpected)
+    NMT_START_ARRAY(m_PlayerNames)
+        NMT_FIELD(CStrW, m_Name)
+    NMT_END_ARRAY()
 END_NMT_CLASS()
 
 END_NMTS()
 
 #else

source/network/NetServer.cpp

@@ -878 +878 @@
         // TODO: we shouldn't send the message back to the client that first sent it
     }
     else if (message->GetType() == (uint)NMT_SYNC_CHECK)
     {
         CSyncCheckMessage* syncMessage = static_cast<CSyncCheckMessage*> (message);
-        server.m_ServerTurnManager->NotifyFinishedClientUpdate(session->GetHostID(), syncMessage->m_Turn, syncMessage->m_Hash);
+        server.m_ServerTurnManager->NotifyFinishedClientUpdate(session->GetHostID(), session->GetUserName(), syncMessage->m_Turn, syncMessage->m_Hash);
     }
     else if (message->GetType() == (uint)NMT_END_COMMAND_BATCH)
     {
         CEndCommandBatchMessage* endMessage = static_cast<CEndCommandBatchMessage*> (message);
         server.m_ServerTurnManager->NotifyFinishedClientCommands(session->GetHostID(), endMessage->m_Turn);

source/network/NetTurnManager.cpp

@@ -16 +16 @@
  */
 
 #include "precompiled.h"
 
 #include "NetTurnManager.h"
+#include "NetMessage.h"
 
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 #include "network/NetMessage.h"
 
@@ -216 +217 @@
     }
 
     return true;
 }
 
-void CNetTurnManager::OnSyncError(u32 turn, const std::string& expectedHash)
+void CNetTurnManager::OnSyncError(u32 turn, const CStr& expectedHash, std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames)
 {
     NETTURN_LOG((L"OnSyncError(%d, %hs)\n", turn, Hexify(expectedHash).c_str()));
 
     // Only complain the first time
     if (m_HasSyncError)
@@ -236 +237 @@
     file.close();
 
     hash = Hexify(hash);
     const std::string& expectedHashHex = Hexify(expectedHash);
 
-    DisplayOOSError(turn, hash, expectedHashHex, false, &path);
+    DisplayOOSError(turn, hash, expectedHashHex, false, &playerNames, &path);
 }
 
-void CNetTurnManager::DisplayOOSError(u32 turn, const std::string& hash, const std::string& expectedHash, bool isReplay, OsPath* path = NULL)
+void CNetTurnManager::DisplayOOSError(u32 turn, const CStr& hash, const CStr& expectedHash, bool isReplay, std::vector<CSyncErrorMessage::S_m_PlayerNames>* playerNames = NULL, OsPath* path = NULL)
 {
     m_HasSyncError = true;
 
     std::stringstream msg;
-    msg << "Out of sync on turn " << turn << ": expected hash " << expectedHash << "\n";
+    msg << "Out of sync on turn " << turn;
 
-    if (expectedHash != hash || m_CurrentTurn != turn)
-        msg << "\nCurrent state: turn " << m_CurrentTurn << ", hash " << hash << "\n\n";
+    if (playerNames)
+        for (size_t i = 0; i < playerNames->size(); ++i)
+            msg << (i == 0 ? "\nPlayers: " : ", ") << utf8_from_wstring((*playerNames)[i].m_Name);
 
     if (isReplay)
-        msg << "\nThe current game state is different from the original game state.\n\n";
+        msg << "\n\n" << "The current game state is different from the original game state.";
     else
-    {
-        if (expectedHash == hash)
-            msg << "Your game state is identical to the hosts game state.\n\n";
-        else
-            msg << "Your game state is different from the hosts game state.\n\n";
-    }
+        msg << "\n\n" << "Your game state is " << (expectedHash == hash ? "identical to" : "different from") << " the hosts game state.";
 
     if (path)
-        msg << "Dumping current state to " << utf8_from_wstring(OsPath(*path).string());
+        msg << "\n\n" << "Dumping current state to " << OsString(OsPath(*path));
 
     LOGERROR("%s", msg.str());
 
     if (g_GUI)
         g_GUI->DisplayMessageBox(600, 350, L"Sync error", wstring_from_utf8(msg.str()));
@@ -427 +424 @@
 
     NETTURN_LOG((L"NotifyFinishedUpdate(%d, %hs)\n", turn, Hexify(hash).c_str()));
 
     m_Replay.Hash(hash, quick);
 
+    // Don't send the hash if OOS
+    if (m_HasSyncError)
+        return;
+
     // Send message to the server
     CSyncCheckMessage msg;
     msg.m_Turn = turn;
     msg.m_Hash = hash;
     m_NetClient.SendMessage(&msg);
@@ -518 +519 @@
         return;
 
     debug_printf("Executing turn %d of %d\n", turn, m_FinalReplayTurn);
     DoTurn(turn);
 
-    // Compare hash if it exists in the replay and if we didn't have an oos already
+    // Compare hash if it exists in the replay and if we didn't have an OOS already
     if (m_HasSyncError || m_ReplayHash.find(turn) == m_ReplayHash.end())
         return;
 
     std::string expectedHash = m_ReplayHash[turn].first;
     bool quickHash = m_ReplayHash[turn].second;
@@ -552 +553 @@
     if (turn == m_FinalReplayTurn)
         g_GUI->SendEventToAll("ReplayFinished");
 }
 
 CNetServerTurnManager::CNetServerTurnManager(CNetServerWorker& server) :
-    m_NetServer(server), m_ReadyTurn(1), m_TurnLength(DEFAULT_TURN_LENGTH_MP)
+    m_NetServer(server), m_ReadyTurn(1), m_TurnLength(DEFAULT_TURN_LENGTH_MP), m_HasSyncError(false)
 {
     // The first turn we will actually execute is number 2,
     // so store dummy values into the saved lengths list
     m_SavedTurnLengths.push_back(0);
     m_SavedTurnLengths.push_back(0);
@@ -601 +602 @@
     // Save the turn length in case it's needed later
     ENSURE(m_SavedTurnLengths.size() == m_ReadyTurn);
     m_SavedTurnLengths.push_back(m_TurnLength);
 }
 
-void CNetServerTurnManager::NotifyFinishedClientUpdate(int client, u32 turn, const std::string& hash)
+void CNetServerTurnManager::NotifyFinishedClientUpdate(int client, const CStrW& playername, u32 turn, const CStr& hash)
 {
     // Clients must advance one turn at a time
     ENSURE(turn == m_ClientsSimulated[client] + 1);
     m_ClientsSimulated[client] = turn;
 
+    // Check for OOS only if in sync
+    if (m_HasSyncError)
+        return;
+
+    m_ClientPlayernames[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 (std::map<int, u32>::iterator it = m_ClientsSimulated.begin(); it != m_ClientsSimulated.end(); ++it)
@@ -626 +632 @@
             break;
 
         // Assume the host is correct (maybe we should choose the most common instead to help debugging)
         std::string expected = it->second.begin()->second;
 
+        // Find all players that are OOS on that turn
+        std::vector<CStrW> OOSPlayerNames;
         for (std::map<int, std::string>::iterator cit = it->second.begin(); cit != it->second.end(); ++cit)
         {
             NETTURN_LOG((L"sync check %d: %d = %hs\n", it->first, cit->first, Hexify(cit->second).c_str()));
             if (cit->second != expected)
             {
                 // Oh no, out of sync
+                m_HasSyncError = true;
+                OOSPlayerNames.push_back(m_ClientPlayernames[cit->first]);
+            }
+        }
 
-                // Tell everyone about it
-                CSyncErrorMessage msg;
-                msg.m_Turn = it->first;
-                msg.m_HashExpected = expected;
-                m_NetServer.Broadcast(&msg);
-
-                break;
+        // Tell everyone about it
+        if (m_HasSyncError)
+        {
+            CSyncErrorMessage msg;
+            msg.m_Turn = it->first;
+            msg.m_HashExpected = expected;
+            for (const CStrW& playername : OOSPlayerNames)
+            {
+                CSyncErrorMessage::S_m_PlayerNames h;
+                h.m_Name = playername;
+                msg.m_PlayerNames.push_back(h);
             }
+            m_NetServer.Broadcast(&msg);
+            break;
         }
     }
 
     // Delete the saved hashes for all turns that we've already verified
     m_ClientStateHashes.erase(m_ClientStateHashes.begin(), m_ClientStateHashes.lower_bound(newest+1));

source/network/NetTurnManager.h

@@ -18 +18 @@
 #ifndef INCLUDED_NETTURNMANAGER
 #define INCLUDED_NETTURNMANAGER
 
 #include "simulation2/helpers/SimulationCommand.h"
 #include "lib/os_path.h"
+#include "NetMessage.h"
 
 #include <list>
 #include <map>
 #include <vector>
 
@@ -105 +106 @@
     virtual void OnSimulationMessage(CSimulationMessage* msg) = 0;
 
     /**
      * Called when there has been an out-of-sync error.
      */
-    virtual void OnSyncError(u32 turn, const std::string& expectedHash);
+    virtual void OnSyncError(u32 turn, const CStr& expectedHash, std::vector<CSyncErrorMessage::S_m_PlayerNames>& playerNames);
 
     /**
      * Shows a message box when an out of sync error has been detected in the session or visual replay.
      */
-    virtual void DisplayOOSError(u32 turn, const std::string& hash, const std::string& expectedHash, bool isReplay, OsPath* path);
+    virtual void DisplayOOSError(u32 turn, const CStr& hash, const CStr& expectedHash, bool isReplay, std::vector<CSyncErrorMessage::S_m_PlayerNames>* playerNames, OsPath* path);
 
     /**
      * Called by simulation code, to add a new command to be distributed to all clients and executed soon.
      */
     virtual void PostCommand(JS::HandleValue data) = 0;
@@ -291 +292 @@
 public:
     CNetServerTurnManager(CNetServerWorker& server);
 
     void NotifyFinishedClientCommands(int client, u32 turn);
 
-    void NotifyFinishedClientUpdate(int client, u32 turn, const std::string& hash);
+    void NotifyFinishedClientUpdate(int client, const CStrW& playername, u32 turn, const CStr& hash);
 
     /**
      * Inform the turn manager of a new client who will be sending commands.
      */
     void InitialiseClient(int client, u32 turn);
@@ -334 +335 @@
     std::map<int, u32> m_ClientsSimulated;
 
     // 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<u32, CStrW> m_ClientPlayernames;
+
     // Current turn length
     u32 m_TurnLength;
 
     // Turn lengths for all previously executed turns
     std::vector<u32> m_SavedTurnLengths;
 
     CNetServerWorker& m_NetServer;
+
+    bool m_HasSyncError;
 };
 
 #endif // INCLUDED_NETTURNMANAGER