Ticket #3700: 3700.4.patch

source/gui/scripting/ScriptFunctions.cpp

@@ -349 +349 @@
     }
 
     g_Game = new CGame();
-    g_NetClient = new CNetClient(g_Game, true);
+    g_NetClient = new CNetClientWorker(g_Game, true);
     g_NetClient->SetUserName(playerName);
 
     if (!g_NetClient->SetupConnection("127.0.0.1", serverPort))
@@ -367 +367 @@
     ENSURE(!g_Game);
 
     g_Game = new CGame();
-    g_NetClient = new CNetClient(g_Game, false);
+    g_NetClient = new CNetClientWorker(g_Game, false);
     g_NetClient->SetUserName(playerName);
     if (!g_NetClient->SetupConnection(serverAddress, serverPort))
     {

source/network/NetClient.cpp

@@ -45 +45 @@
 {
     NONCOPYABLE(CNetFileReceiveTask_ClientRejoin);
 public:
-    CNetFileReceiveTask_ClientRejoin(CNetClient& client)
+    CNetFileReceiveTask_ClientRejoin(CNetClientWorker& client)
         : m_Client(client)
     {
     }
@@ -63 +63 @@
     }
 
 private:
-    CNetClient& m_Client;
+    CNetClientWorker& m_Client;
 };
 
-CNetClient::CNetClient(CGame* game, bool isLocalClient) :
+CNetClientWorker::CNetClientWorker(CGame* game, bool isLocalClient) :
     m_Session(NULL),
     m_UserName(L"anonymous"),
     m_GUID(ps_generate_guid()), m_HostID((u32)-1), m_ClientTurnManager(NULL), m_Game(game),
@@ -79 +79 @@
 
     void* context = this;
 
-    JS_AddExtraGCRootsTracer(GetScriptInterface().GetJSRuntime(), CNetClient::Trace, this);
-
-    // Set up transitions for session
+        // Set up transitions for session
     AddTransition(NCS_UNCONNECTED, (uint)NMT_CONNECT_COMPLETE, NCS_CONNECT, (void*)&OnConnect, context);
 
     AddTransition(NCS_CONNECT, (uint)NMT_SERVER_HANDSHAKE, NCS_HANDSHAKE, (void*)&OnHandshake, context);
@@ -139 +137 @@
     SetFirstState(NCS_UNCONNECTED);
 }
 
-CNetClient::~CNetClient()
+CNetClientWorker::~CNetClientWorker()
 {
     DestroyConnection();
-    JS_RemoveExtraGCRootsTracer(GetScriptInterface().GetJSRuntime(), CNetClient::Trace, this);
-}
 
-void CNetClient::TraceMember(JSTracer *trc)
-{
-    for (JS::Heap<JS::Value>& guiMessage : m_GuiMessageQueue)
-        JS_CallValueTracer(trc, &guiMessage, "m_GuiMessageQueue");
+    /*  if (m_State != SERVER_STATE_UNCONNECTED)
+    {
+        // Tell the thread to shut down
+        {
+            CScopeLock lock(m_WorkerMutex);
+            m_Shutdown = true;
+        }
+
+        // Wait for it to shut down cleanly
+        pthread_join(m_WorkerThread, NULL);
+    }
+
+    // Clean up resources
+
+    delete m_Stats;
+
+    for (CNetServerSession* session : m_Sessions)
+    {
+        session->DisconnectNow(NDR_SERVER_SHUTDOWN);
+        delete session;
+    }
+
+    if (m_Host)
+        enet_host_destroy(m_Host);
+
+    delete m_ServerTurnManager; */
 }
 
-void CNetClient::SetUserName(const CStrW& username)
+void CNetClientWorker::SetUserName(const CStrW& username)
 {
     ENSURE(!m_Session); // must be called before we start the connection
 
@@ -158 +176 @@
     m_UserName = username;
 }
 
-bool CNetClient::SetupConnection(const CStr& server, const u16 port)
+bool CNetClientWorker::SetupConnection(const CStr& server, const u16 port)
 {
     CNetClientSession* session = new CNetClientSession(*this);
     bool ok = session->Connect(server, port, m_IsLocalClient);
     SetAndOwnSession(session);
+
+    //m_State = SERVER_STATE_PREGAME;
+
+    // Launch the worker thread
+    int ret = pthread_create(&m_WorkerThread, NULL, &RunThread, this);
+    ENSURE(ret == 0);
+
     return ok;
 }
 
-void CNetClient::SetAndOwnSession(CNetClientSession* session)
+void CNetClientWorker::SetAndOwnSession(CNetClientSession* session)
 {
     delete m_Session;
     m_Session = session;
 }
 
-void CNetClient::DestroyConnection()
+void CNetClientWorker::DestroyConnection()
 {
     // Send network messages from the current frame before connection is destroyed.
     if (m_ClientTurnManager)
@@ -183 +208 @@
     SAFE_DELETE(m_Session);
 }
 
-void CNetClient::Poll()
+void CNetClientWorker::Poll()
 {
     if (!m_Session)
         return;
@@ -192 +217 @@
     m_Session->Poll();
 }
 
-void CNetClient::CheckServerConnection()
+void* CNetClientWorker::RunThread(void* data)
 {
+    debug_SetThreadName("NetClient");
+
+    static_cast<CNetClientWorker*>(data)->Run();
+
+    return NULL;
+}
+
+void CNetClientWorker::Run()
+{
+    // The script runtime uses the profiler and therefore the thread must be registered before the runtime is created
+    g_Profiler2.RegisterCurrentThread("Net client");
+
+    while (true)
+    {
+        if (!RunStep())
+            break;
+
+        // Implement autostart mode
+        //if (m_State == CLIENT_STATE_PREGAME && (int)m_PlayerAssignments.size() == m_AutostartPlayers)
+        //  StartGame();
+
+        // Update profiler stats
+        //m_Stats->LatchHostState(m_Host);
+    }
+}
+
+bool CNetClientWorker::RunStep()
+{
+    // Check for messages from the game thread.
+    // (Do as little work as possible while the mutex is held open,
+    // to avoid performance problems and deadlocks.)
+
+    CheckServerConnection();
+
+    return true;
+}
+
+void CNetClientWorker::CheckServerConnection()
+{
     // Trigger local warnings if the connection to the server is bad.
     // At most once per second.
     std::time_t now = std::time(nullptr);
@@ -227 +291 @@
     }
 }
 
-void CNetClient::Flush()
+void CNetClientWorker::Flush()
 {
     if (m_Session)
         m_Session->Flush();
 }
 
-void CNetClient::GuiPoll(JS::MutableHandleValue ret)
+void CNetClientWorker::GuiPoll(JS::MutableHandleValue ret)
 {
     if (m_GuiMessageQueue.empty())
     {
@@ -245 +309 @@
     m_GuiMessageQueue.pop_front();
 }
 
-void CNetClient::PushGuiMessage(const JS::HandleValue message)
+void CNetClientWorker::PushGuiMessage(const JS::HandleValue message)
 {
     ENSURE(!message.isUndefined());
 
@@ -252 +316 @@
     m_GuiMessageQueue.push_back(JS::Heap<JS::Value>(message));
 }
 
-std::string CNetClient::TestReadGuiMessages()
+std::string CNetClientWorker::TestReadGuiMessages()
 {
     JSContext* cx = GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
@@ -269 +333 @@
     return r;
 }
 
-ScriptInterface& CNetClient::GetScriptInterface()
+ScriptInterface& CNetClientWorker::GetScriptInterface()
 {
     return m_Game->GetSimulation2()->GetScriptInterface();
 }
 
-void CNetClient::PostPlayerAssignmentsToScript()
+void CNetClientWorker::PostPlayerAssignmentsToScript()
 {
     JSContext* cx = GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
@@ -298 +362 @@
     PushGuiMessage(msg);
 }
 
-bool CNetClient::SendMessage(const CNetMessage* message)
+bool CNetClientWorker::SendMessage(const CNetMessage* message)
 {
     if (!m_Session)
         return false;
@@ -306 +370 @@
     return m_Session->SendMessage(message);
 }
 
-void CNetClient::HandleConnect()
+void CNetClientWorker::HandleConnect()
 {
     Update((uint)NMT_CONNECT_COMPLETE, NULL);
 }
 
-void CNetClient::HandleDisconnect(u32 reason)
+void CNetClientWorker::HandleDisconnect(u32 reason)
 {
     JSContext* cx = GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
@@ -328 +392 @@
     SetCurrState(NCS_UNCONNECTED);
 }
 
-void CNetClient::SendGameSetupMessage(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface)
+void CNetClientWorker::SendGameSetupMessage(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface)
 {
     CGameSetupMessage gameSetup(scriptInterface);
     gameSetup.m_Data = attrs;
@@ -335 +399 @@
     SendMessage(&gameSetup);
 }
 
-void CNetClient::SendAssignPlayerMessage(const int playerID, const CStr& guid)
+void CNetClientWorker::SendAssignPlayerMessage(const int playerID, const CStr& guid)
 {
     CAssignPlayerMessage assignPlayer;
     assignPlayer.m_PlayerID = playerID;
@@ -343 +407 @@
     SendMessage(&assignPlayer);
 }
 
-void CNetClient::SendChatMessage(const std::wstring& text)
+void CNetClientWorker::SendChatMessage(const std::wstring& text)
 {
     CChatMessage chat;
     chat.m_Message = text;
@@ -350 +414 @@
     SendMessage(&chat);
 }
 
-void CNetClient::SendReadyMessage(const int status)
+void CNetClientWorker::SendReadyMessage(const int status)
 {
     CReadyMessage readyStatus;
     readyStatus.m_Status = status;
@@ -357 +421 @@
     SendMessage(&readyStatus);
 }
 
-void CNetClient::SendClearAllReadyMessage()
+void CNetClientWorker::SendClearAllReadyMessage()
 {
     CClearAllReadyMessage clearAllReady;
     SendMessage(&clearAllReady);
 }
 
-void CNetClient::SendStartGameMessage()
+void CNetClientWorker::SendStartGameMessage()
 {
     CGameStartMessage gameStart;
     SendMessage(&gameStart);
 }
 
-void CNetClient::SendRejoinedMessage()
+void CNetClientWorker::SendRejoinedMessage()
 {
     CRejoinedMessage rejoinedMessage;
     SendMessage(&rejoinedMessage);
 }
 
-void CNetClient::SendKickPlayerMessage(const CStrW& playerName, bool ban)
+void CNetClientWorker::SendKickPlayerMessage(const CStrW& playerName, bool ban)
 {
     CKickedMessage kickPlayer;
     kickPlayer.m_Name = playerName;
@@ -383 +447 @@
     SendMessage(&kickPlayer);
 }
 
-void CNetClient::SendPausedMessage(bool pause)
+void CNetClientWorker::SendPausedMessage(bool pause)
 {
     CClientPausedMessage pausedMessage;
     pausedMessage.m_Pause = pause;
@@ -390 +454 @@
     SendMessage(&pausedMessage);
 }
 
-bool CNetClient::HandleMessage(CNetMessage* message)
+bool CNetClientWorker::HandleMessage(CNetMessage* message)
 {
     // Handle non-FSM messages first
 
@@ -433 +497 @@
     return ok;
 }
 
-void CNetClient::LoadFinished()
+void CNetClientWorker::LoadFinished()
 {
     JSContext* cx = GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
@@ -476 +540 @@
     SendMessage(&loaded);
 }
 
-bool CNetClient::OnConnect(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnConnect(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_CONNECT_COMPLETE);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
@@ -492 +556 @@
     return true;
 }
 
-bool CNetClient::OnHandshake(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnHandshake(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_SERVER_HANDSHAKE);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     CCliHandshakeMessage handshake;
     handshake.m_MagicResponse = PS_PROTOCOL_MAGIC_RESPONSE;
@@ -507 +571 @@
     return true;
 }
 
-bool CNetClient::OnHandshakeResponse(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnHandshakeResponse(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_SERVER_HANDSHAKE_RESPONSE);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     CAuthenticateMessage authenticate;
     authenticate.m_GUID = client->m_GUID;
@@ -523 +587 @@
     return true;
 }
 
-bool CNetClient::OnAuthenticate(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnAuthenticate(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_AUTHENTICATE_RESULT);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
@@ -547 +611 @@
     return true;
 }
 
-bool CNetClient::OnChat(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnChat(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_CHAT);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -566 +630 @@
     return true;
 }
 
-bool CNetClient::OnReady(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnReady(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_READY);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -585 +649 @@
     return true;
 }
 
-bool CNetClient::OnGameSetup(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnGameSetup(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_GAME_SETUP);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -605 +669 @@
     return true;
 }
 
-bool CNetClient::OnPlayerAssignment(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnPlayerAssignment(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_PLAYER_ASSIGNMENT);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     CPlayerAssignmentMessage* message = (CPlayerAssignmentMessage*)event->GetParamRef();
 
@@ -632 +696 @@
     return true;
 }
 
-bool CNetClient::OnGameStart(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnGameStart(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_GAME_START);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -658 +722 @@
     return true;
 }
 
-bool CNetClient::OnJoinSyncStart(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnJoinSyncStart(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_JOIN_SYNC_START);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     // The server wants us to start downloading the game state from it, so do so
     client->m_Session->GetFileTransferer().StartTask(
@@ -672 +736 @@
     return true;
 }
 
-bool CNetClient::OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_END_COMMAND_BATCH);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     CEndCommandBatchMessage* endMessage = (CEndCommandBatchMessage*)event->GetParamRef();
 
@@ -688 +752 @@
     return true;
 }
 
-bool CNetClient::OnRejoined(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnRejoined(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_REJOINED);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -705 +769 @@
     return true;
 }
 
-bool CNetClient::OnKicked(void *context, CFsmEvent* event)
+bool CNetClientWorker::OnKicked(void *context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_KICKED);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -725 +789 @@
     return true;
 }
 
-bool CNetClient::OnClientTimeout(void *context, CFsmEvent* event)
+bool CNetClientWorker::OnClientTimeout(void *context, CFsmEvent* event)
 {
     // Report the timeout of some other client
 
     ENSURE(event->GetType() == (uint)NMT_CLIENT_TIMEOUT);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -749 +813 @@
     return true;
 }
 
-bool CNetClient::OnClientPerformance(void *context, CFsmEvent* event)
+bool CNetClientWorker::OnClientPerformance(void *context, CFsmEvent* event)
 {
     // Performance statistics for one or multiple clients
 
     ENSURE(event->GetType() == (uint)NMT_CLIENT_PERFORMANCE);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -780 +844 @@
     return true;
 }
 
-bool CNetClient::OnClientsLoading(void *context, CFsmEvent *event)
+bool CNetClientWorker::OnClientsLoading(void *context, CFsmEvent *event)
 {
     ENSURE(event->GetType() == (uint)NMT_CLIENTS_LOADING);
 
@@ -791 +855 @@
     for (const CClientsLoadingMessage::S_m_Clients& client : message->m_Clients)
         guids.push_back(client.m_GUID);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -802 +866 @@
     return true;
 }
 
-bool CNetClient::OnClientPaused(void *context, CFsmEvent *event)
+bool CNetClientWorker::OnClientPaused(void *context, CFsmEvent *event)
 {
     ENSURE(event->GetType() == (uint)NMT_CLIENT_PAUSED);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -821 +885 @@
     return true;
 }
 
-bool CNetClient::OnLoadedGame(void* context, CFsmEvent* event)
+bool CNetClientWorker::OnLoadedGame(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
@@ -844 +908 @@
     return true;
 }
 
-bool CNetClient::OnInGame(void *context, CFsmEvent* event)
+bool CNetClientWorker::OnInGame(void *context, CFsmEvent* event)
 {
     // TODO: should split each of these cases into a separate method
 
-    CNetClient* client = (CNetClient*)context;
+    CNetClientWorker* client = (CNetClientWorker*)context;
 
     CNetMessage* message = (CNetMessage*)event->GetParamRef();
     if (message)
@@ -872 +936 @@
 
     return true;
 }
+
+CNetClient::CNetClient(CGame* game, bool isLocalClient) :
+    m_Worker(new CNetClientWorker(game, isLocalClient))
+{
+}
+
+CNetClient::~CNetClient()
+{
+    delete m_Worker;
+}
+
+void CNetClient::SetUserName(const CStrW& username)
+{
+    m_Worker->m_UserName = username;
+}
+
+bool CNetClient::SetupConnection(const CStr& server, const u16 port)
+{
+    return m_Worker->SetupConnection(server, port);
+}
+
+
+
+

source/network/NetClient.h

@@ -23 +23 @@
 #include "network/NetHost.h"
 #include "scriptinterface/ScriptVal.h"
 
+#include "ps/ThreadUtil.h"
 #include "ps/CStr.h"
 
 #include <deque>
@@ -33 +34 @@
 class CNetServer;
 class ScriptInterface;
 
+class CNetClientWorker;
+
 // NetClient session FSM states
 enum
 {
@@ -70 +73 @@
     virtual ~CNetClient();
 
     /**
-     * We assume that adding a tracing function that's only called
-     * during GC is better for performance than using a
-     * PersistentRooted<T> where each value needs to be added to
-     * the root set.
-     */
-    static void Trace(JSTracer *trc, void *data)
-    {
-        reinterpret_cast<CNetClient*>(data)->TraceMember(trc);
-    }
-
-    void TraceMember(JSTracer *trc);
-
-    /**
      * Set the user's name that will be displayed to all players.
      * This must not be called after the connection setup.
      */
@@ -105 +95 @@
      * Destroy the connection to the server.
      * This client probably cannot be used again.
      */
+
+private:
+    CStr m_GUID;
+    CNetClientWorker* m_Worker;
+};
+
+/**
+ * Network client worker thread.
+ *
+ * Thread-safety:
+ *
+ *
+ */
+class CNetClientWorker : public CFsm
+{
+    NONCOPYABLE(CNetClientWorker);
+
+public:
+    /**
+     * Returns the GUID of the local client.
+     * Used for distinguishing observers.
+     */
+    CStr GetGUID() const { return m_GUID; }
+
+    /**
+     * Send a message to the server.
+     * @param message message to send
+     * @return true on success
+     */
+    bool SendMessage(const CNetMessage* message);
+
+    /**
+     * Call when the network connection has been successfully initiated.
+     */
+    void HandleConnect();
+
+    /**
+     * Call when the network connection has been lost.
+     */
+    void HandleDisconnect(u32 reason);
+
+    /**
+     * Call when a message has been received from the network.
+     */
+    bool HandleMessage(CNetMessage* message);
+
+    /**
+     * Get the script interface associated with this network client,
+     * which is equivalent to the one used by the CGame in the constructor.
+     */
+    ScriptInterface& GetScriptInterface();
+
+private:
+    friend class CNetClient;
+    friend class CNetFileReceiveTask_ClientRejoin;
+
+    CNetClientWorker(CGame* game, bool isLocalClient);
+  ~CNetClientWorker();
+
+    void SetUserName(const CStrW& username);
+
+    bool SetupConnection(const CStr& server, const u16 port);
+
+    /**
+     * Destroy the connection to the server.
+     * This client probably cannot be used again.
+     */
     void DestroyConnection();
 
     /**
@@ -154 +211 @@
     std::string TestReadGuiMessages();
 
     /**
-     * Get the script interface associated with this network client,
-     * which is equivalent to the one used by the CGame in the constructor.
-     */
-    ScriptInterface& GetScriptInterface();
-
-    /**
-     * Send a message to the server.
-     * @param message message to send
-     * @return true on success
-     */
-    bool SendMessage(const CNetMessage* message);
-
-    /**
-     * Call when the network connection has been successfully initiated.
-     */
-    void HandleConnect();
-
-    /**
-     * Call when the network connection has been lost.
-     */
-    void HandleDisconnect(u32 reason);
-
-    /**
-     * Call when a message has been received from the network.
-     */
-    bool HandleMessage(CNetMessage* message);
-
-    /**
      * Call when the game has started and all data files have been loaded,
      * to signal to the server that we are ready to begin the game.
      */
@@ -215 +244 @@
      */
     void SendPausedMessage(bool pause);
 
-private:
     // Net message / FSM transition handlers
     static bool OnConnect(void* context, CFsmEvent* event);
     static bool OnHandshake(void* context, CFsmEvent* event);
@@ -282 +310 @@
 
     /// Time when the server was last checked for timeouts and bad latency
     std::time_t m_LastConnectionCheck;
+
+        // Thread-related stuff:
+
+    static void* RunThread(void* data);
+    void Run();
+    bool RunStep();
+
+    pthread_t m_WorkerThread;
+    CMutex m_WorkerMutex;
+
+    bool m_Shutdown; // protected by m_WorkerMutex
+
+    // Queues for messages sent by the game thread:
+    std::vector<bool> m_StartGameQueue; // protected by m_WorkerMutex
+    std::vector<std::string> m_GameAttributesQueue; // protected by m_WorkerMutex
+    std::vector<u32> m_TurnLengthQueue; // protected by m_WorkerMutex
 };
 
 /// Global network client for the standard game

source/network/NetClientTurnManager.cpp

@@ -33 +33 @@
 #define NETCLIENTTURN_LOG(...)
 #endif
 
-CNetClientTurnManager::CNetClientTurnManager(CSimulation2& simulation, CNetClient& client, int clientId, IReplayLogger& replay)
+CNetClientTurnManager::CNetClientTurnManager(CSimulation2& simulation, CNetClientWorker& client, int clientId, IReplayLogger& replay)
     : CTurnManager(simulation, DEFAULT_TURN_LENGTH_MP, clientId, replay), m_NetClient(client)
 {
 }

source/network/NetClientTurnManager.h

@@ -21 +21 @@
 #include "simulation2/system/TurnManager.h"
 #include "NetMessage.h"
 
-class CNetClient;
+class CNetClientWorker;
 
 /**
  * Implementation of CTurnManager for network clients.
@@ -30 +30 @@
 {
     NONCOPYABLE(CNetClientTurnManager);
 public:
-    CNetClientTurnManager(CSimulation2& simulation, CNetClient& client, int clientId, IReplayLogger& replay);
+    CNetClientTurnManager(CSimulation2& simulation, CNetClientWorker& client, int clientId, IReplayLogger& replay);
 
     void OnSimulationMessage(CSimulationMessage* msg) override;
 
@@ -48 +48 @@
 
     void NotifyFinishedUpdate(u32 turn) override;
 
-    CNetClient& m_NetClient;
+    CNetClientWorker& m_NetClient;
 };
 
 #endif // INCLUDED_NETCLIENTTURNMANAGER

source/network/NetSession.cpp

@@ -32 +32 @@
 
 static const int CHANNEL_COUNT = 1;
 
-CNetClientSession::CNetClientSession(CNetClient& client) :
+CNetClientSession::CNetClientSession(CNetClientWorker& client) :
     m_Client(client), m_FileTransferer(this), m_Host(NULL), m_Server(NULL), m_Stats(NULL)
 {
 }

source/network/NetSession.h

@@ -34 +34 @@
  */
 extern const u32 MAXIMUM_HOST_TIMEOUT;
 
-class CNetClient;
+class CNetClientWorker;
 class CNetServerWorker;
 
 class CNetStatsTable;
@@ -67 +67 @@
     NONCOPYABLE(CNetClientSession);
 
 public:
-    CNetClientSession(CNetClient& client);
+    CNetClientSession(CNetClientWorker& client);
     ~CNetClientSession();
 
     bool Connect(const CStr& server, const u16 port, const bool isLocalClient);
@@ -106 +106 @@
     CNetFileTransferer& GetFileTransferer() { return m_FileTransferer; }
 
 private:
-    CNetClient& m_Client;
+    CNetClientWorker& m_Client;
 
     CNetFileTransferer m_FileTransferer;
 

source/ps/GameSetup/GameSetup.cpp

@@ -1498 +1498 @@
         bool ok = g_NetServer->SetupConnection(PS_DEFAULT_PORT);
         ENSURE(ok);
 
-        g_NetClient = new CNetClient(g_Game, true);
+        g_NetClient = new CNetClientWorker(g_Game, true);
         g_NetClient->SetUserName(userName);
         g_NetClient->SetupConnection("127.0.0.1", PS_DEFAULT_PORT);
     }
@@ -1506 +1506 @@
     {
         InitPs(true, L"page_loading.xml", &scriptInterface, mpInitData);
 
-        g_NetClient = new CNetClient(g_Game, false);
+        g_NetClient = new CNetClientWorker(g_Game, false);
         g_NetClient->SetUserName(userName);
 
         CStr ip = args.Get("autostart-client");