Ticket #1949: rejoined_message_v3.patch

binaries/data/mods/public/gui/gamesetup/gamesetup_mp.js

@@ -94 +94 @@
                     return;
 
                 default:
                     error(sprintf("Unrecognised netstatus type %(netType)s", { netType: message.status }));
                     break;
                 }
                 break;
 
             case "gamesetup":
                 g_GameAttributes = message.data;
                 break;
 
             case "players":
                 g_PlayerAssignments = message.hosts;
                 break;
 
             case "start":
                 Engine.SwitchGuiPage("page_loading.xml", {
                     "attribs": g_GameAttributes,
                     "isNetworked" : true,
+                    "isRejoining" : g_IsRejoining,
                     "playerAssignments": g_PlayerAssignments
                 });
                 break;
 
             case "chat":
                 // Ignore, since we have nowhere to display chat messages
                 break;
 
             default:
                 error(sprintf("Unrecognised net message type %(messageType)s", { messageType: message.type }));
             }
         }
         else
         {
             // Not rejoining - just trying to connect to server
 
             switch (message.type)
             {
             case "netstatus":
                 switch (message.status)

binaries/data/mods/public/gui/loading/loading.js

@@ -96 +96 @@
         rightSide.size = size;
     }
 }
 
 // ====================================================================
 function reallyStartGame()
 {
     // Stop the music
 //  if (global.curr_music)
 //      global.curr_music.fade(-1, 0.0, 5.0); // fade to 0 over 5 seconds
 
 
     // This is a reserved function name that is executed by the engine when it is ready
     // to start the game (i.e. loading progress has reached 100%).
 
     // Switch GUI from loading screen to game session.
     Engine.SwitchGuiPage("page_session.xml", g_Data);
 
     // Restore default cursor.
     Engine.SetCursor("arrow-default");
+    
+    // Notify the other clients that we have finished the loading screen
+    if (g_Data.isNetworked && g_Data.isRejoining)
+        Engine.SendNetworkRejoined();
 }

binaries/data/mods/public/gui/session/messages.js

@@ -274 +274 @@
             }
         }
 
         g_PlayerAssignments = message.hosts;
 
         if (g_IsController && Engine.HasXmppClient())
         {
             var players = [ assignment.name for each (assignment in g_PlayerAssignments) ]
             Engine.SendChangeStateGame(Object.keys(g_PlayerAssignments).length, players.join(", "));
         }
 
         break;
 
     case "chat":
         addChatMessage({ "type": "message", "guid": message.guid, "text": message.text });
         break;
 
     case "aichat":
         addChatMessage({ "type": "message", "guid": message.guid, "text": message.text, "translate": true });
         break;
-
+        
+    case "rejoined":
+        addChatMessage({ "type": "rejoined", "guid": message.guid});
+        break;
+        
     // To prevent errors, ignore these message types that occur during autostart
     case "gamesetup":
     case "start":
         break;
 
     default:
         error("Unrecognised net message type '" + message.type + "'");
     }
 }
 
 function submitChatDirectly(text)
 {
     if (text.length)
     {
         if (g_IsNetworked)
             Engine.SendNetworkChat(text);
         else
             addChatMessage({ "type": "message", "guid": "local", "text": text });
     }
 }
@@ -414 +418 @@
     else if (msg.type == "defeat" && msg.player)
     {
         [username, playerColor] = getUsernameAndColor(msg.player);
     }
     else if (msg.type == "message")
     {
         [username, playerColor] = getUsernameAndColor(msg.player);
         parseChatCommands(msg, playerAssignments);
     }
     else
     {
         playerColor = "255 255 255";
         username = translate("Unknown player");
     }
 
     var formatted;
 
     switch (msg.type)
     {
     case "connect":
-        formatted = sprintf(translate("%(player)s has joined the game."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
+        formatted = sprintf(translate("%(player)s is connecting..."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
     case "disconnect":
         formatted = sprintf(translate("%(player)s has left the game."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
+    case "rejoined":
+        formatted = sprintf(translate("%(player)s has rejoined the game."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
+        break;
     case "defeat":
         // In singleplayer, the local player is "You". "You has" is incorrect.
         if (!g_IsNetworked && msg.player == Engine.GetPlayerID())
             formatted = translate("You have been defeated.");
         else
             formatted = sprintf(translate("%(player)s has been defeated."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
     case "diplomacy":
         var status = (msg.status == "ally" ? "allied" : (msg.status == "enemy" ? "at war" : "neutral"));
         if (msg.player == Engine.GetPlayerID())
         {
             [username, playerColor] = getUsernameAndColor(msg.player1);
             if (msg.status == "ally")
                 formatted = sprintf(translate("You are now allied with %(player)s."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
             else if (msg.status == "enemy")
                 formatted = sprintf(translate("You are now at war with %(player)s."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
             else // (msg.status == "neutral")
                 formatted = sprintf(translate("You are now neutral with %(player)s."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         }
         else if (msg.player1 == Engine.GetPlayerID())

source/gui/scripting/ScriptFunctions.cpp

@@ -371 +371 @@
 {
     ENSURE(g_NetServer);
 
     g_NetServer->SetPlayerReady(guid, ready);
 }
 
 void ClearAllPlayerReady (ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
 {
     ENSURE(g_NetServer);
 
     g_NetServer->ClearAllPlayerReady();
 }
 
 void SendNetworkChat(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring message)
 {
     ENSURE(g_NetClient);
 
     g_NetClient->SendChatMessage(message);
 }
 
+void SendNetworkRejoined(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+    ENSURE(g_NetClient);
+
+    g_NetClient->SendRejoinedMessage();
+}
+
 void SendNetworkReady(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int message)
 {
     ENSURE(g_NetClient);
 
     g_NetClient->SendReadyMessage(message);
 }
 
 JS::Value GetAIs(ScriptInterface::CxPrivate* pCxPrivate)
 {
     return ICmpAIManager::GetAIs(*(pCxPrivate->pScriptInterface));
 }
 
 JS::Value GetSavedGames(ScriptInterface::CxPrivate* pCxPrivate)
 {
     return SavedGames::GetSavedGames(*(pCxPrivate->pScriptInterface));
 }
 
 bool DeleteSavedGame(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring name)
 {
     return SavedGames::DeleteSavedGame(name);
@@ -934 +941 @@
     scriptInterface.RegisterFunction<entity_id_t, int, int, &PickEntityAtPoint>("PickEntityAtPoint");
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, int, int, int, int, &PickFriendlyEntitiesInRect>("PickFriendlyEntitiesInRect");
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, int, &PickFriendlyEntitiesOnScreen>("PickFriendlyEntitiesOnScreen");
     scriptInterface.RegisterFunction<std::vector<entity_id_t>, std::string, bool, bool, bool, &PickSimilarFriendlyEntities>("PickSimilarFriendlyEntities");
     scriptInterface.RegisterFunction<CFixedVector3D, int, int, &GetTerrainAtScreenPoint>("GetTerrainAtScreenPoint");
 
     // Network / game setup functions
     scriptInterface.RegisterFunction<void, &StartNetworkGame>("StartNetworkGame");
     scriptInterface.RegisterFunction<void, JS::HandleValue, int, &StartGame>("StartGame");
     scriptInterface.RegisterFunction<void, &Script_EndGame>("EndGame");
     scriptInterface.RegisterFunction<void, std::wstring, &StartNetworkHost>("StartNetworkHost");
     scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");
     scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
     scriptInterface.RegisterFunction<JS::Value, &PollNetworkClient>("PollNetworkClient");
     scriptInterface.RegisterFunction<void, JS::HandleValue, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
     scriptInterface.RegisterFunction<void, int, std::string, &AssignNetworkPlayer>("AssignNetworkPlayer");
     scriptInterface.RegisterFunction<void, std::string, int, &SetNetworkPlayerStatus>("SetNetworkPlayerStatus");
     scriptInterface.RegisterFunction<void, &ClearAllPlayerReady>("ClearAllPlayerReady");
     scriptInterface.RegisterFunction<void, std::wstring, &SendNetworkChat>("SendNetworkChat");
     scriptInterface.RegisterFunction<void, int, &SendNetworkReady>("SendNetworkReady");
+    scriptInterface.RegisterFunction<void, &SendNetworkRejoined>("SendNetworkRejoined");
     scriptInterface.RegisterFunction<JS::Value, &GetAIs>("GetAIs");
     scriptInterface.RegisterFunction<JS::Value, &GetEngineInfo>("GetEngineInfo");
 
     // Saved games
     scriptInterface.RegisterFunction<JS::Value, std::wstring, &StartSavedGame>("StartSavedGame");
     scriptInterface.RegisterFunction<JS::Value, &GetSavedGames>("GetSavedGames");
     scriptInterface.RegisterFunction<bool, std::wstring, &DeleteSavedGame>("DeleteSavedGame");
     scriptInterface.RegisterFunction<void, std::wstring, std::wstring, JS::HandleValue, &SaveGame>("SaveGame");
     scriptInterface.RegisterFunction<void, std::wstring, std::wstring, JS::HandleValue, &SaveGamePrefix>("SaveGamePrefix");
     scriptInterface.RegisterFunction<void, &QuickSave>("QuickSave");
     scriptInterface.RegisterFunction<void, &QuickLoad>("QuickLoad");
 
     // Misc functions
     scriptInterface.RegisterFunction<std::wstring, std::wstring, &SetCursor>("SetCursor");
     scriptInterface.RegisterFunction<int, &GetPlayerID>("GetPlayerID");
     scriptInterface.RegisterFunction<void, int, &SetPlayerID>("SetPlayerID");
     scriptInterface.RegisterFunction<void, std::string, &OpenURL>("OpenURL");
     scriptInterface.RegisterFunction<std::wstring, &GetMatchID>("GetMatchID");
     scriptInterface.RegisterFunction<void, &RestartInAtlas>("RestartInAtlas");
     scriptInterface.RegisterFunction<bool, &AtlasIsAvailable>("AtlasIsAvailable");

source/network/NetClient.cpp

@@ -98 +98 @@
 
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CHAT, NCS_JOIN_SYNCING, (void*)&OnChat, context);
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_GAME_SETUP, NCS_JOIN_SYNCING, (void*)&OnGameSetup, context);
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_PLAYER_ASSIGNMENT, NCS_JOIN_SYNCING, (void*)&OnPlayerAssignment, context);
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_GAME_START, NCS_JOIN_SYNCING, (void*)&OnGameStart, context);
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_SIMULATION_COMMAND, NCS_JOIN_SYNCING, (void*)&OnInGame, context);
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_END_COMMAND_BATCH, NCS_JOIN_SYNCING, (void*)&OnJoinSyncEndCommandBatch, context);
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_LOADED_GAME, NCS_INGAME, (void*)&OnLoadedGame, context);
 
     AddTransition(NCS_LOADING, (uint)NMT_CHAT, NCS_LOADING, (void*)&OnChat, context);
     AddTransition(NCS_LOADING, (uint)NMT_GAME_SETUP, NCS_LOADING, (void*)&OnGameSetup, context);
     AddTransition(NCS_LOADING, (uint)NMT_PLAYER_ASSIGNMENT, NCS_LOADING, (void*)&OnPlayerAssignment, context);
     AddTransition(NCS_LOADING, (uint)NMT_LOADED_GAME, NCS_INGAME, (void*)&OnLoadedGame, context);
 
     AddTransition(NCS_INGAME, (uint)NMT_CHAT, NCS_INGAME, (void*)&OnChat, context);
     AddTransition(NCS_INGAME, (uint)NMT_GAME_SETUP, NCS_INGAME, (void*)&OnGameSetup, context);
     AddTransition(NCS_INGAME, (uint)NMT_PLAYER_ASSIGNMENT, NCS_INGAME, (void*)&OnPlayerAssignment, context);
     AddTransition(NCS_INGAME, (uint)NMT_SIMULATION_COMMAND, NCS_INGAME, (void*)&OnInGame, context);
     AddTransition(NCS_INGAME, (uint)NMT_SYNC_ERROR, NCS_INGAME, (void*)&OnInGame, context);
     AddTransition(NCS_INGAME, (uint)NMT_END_COMMAND_BATCH, NCS_INGAME, (void*)&OnInGame, context);
+    AddTransition(NCS_INGAME, (uint)NMT_REJOINED, NCS_INGAME, (void*)&OnRejoined, context);
 
     // Set first state
     SetFirstState(NCS_UNCONNECTED);
 }
 
 CNetClient::~CNetClient()
 {
     DestroyConnection();
     JS_RemoveExtraGCRootsTracer(GetScriptInterface().GetJSRuntime(), CNetClient::Trace, this);
 }
 
 void CNetClient::TraceMember(JSTracer *trc)
 {
     std::deque<JS::Heap<JS::Value> >::iterator itr;
     for (itr=m_GuiMessageQueue.begin(); itr != m_GuiMessageQueue.end(); ++itr)
         JS_CallHeapValueTracer(trc, &*itr, "m_GuiMessageQueue");
 }
 
 void CNetClient::SetUserName(const CStrW& username)
 {
@@ -269 +270 @@
 
     // Update the state immediately to UNCONNECTED (don't bother with FSM transitions since
     // we'd need one for every single state, and we don't need to use per-state actions)
     SetCurrState(NCS_UNCONNECTED);
 }
 
 void CNetClient::SendChatMessage(const std::wstring& text)
 {
     CChatMessage chat;
     chat.m_Message = text;
     SendMessage(&chat);
 }
 
 void CNetClient::SendReadyMessage(const int status)
 {
     CReadyMessage readyStatus;
     readyStatus.m_Status = status;
     SendMessage(&readyStatus);
 }
 
+void CNetClient::SendRejoinedMessage()
+{
+    CRejoinedMessage rejoinedMessage;
+    SendMessage(&rejoinedMessage);
+}
+
 bool CNetClient::HandleMessage(CNetMessage* message)
 {
     // Handle non-FSM messages first
 
     Status status = m_Session->GetFileTransferer().HandleMessageReceive(message);
     if (status == INFO::OK)
         return true;
     if (status != INFO::SKIPPED)
         return false;
 
     if (message->GetType() == NMT_FILE_TRANSFER_REQUEST)
     {
         CFileTransferRequestMessage* reqMessage = (CFileTransferRequestMessage*)message;
 
         // TODO: we should support different transfer request types, instead of assuming
         // it's always requesting the simulation state
 
         std::stringstream stream;
 
         LOGMESSAGERENDER("Serializing game at turn %u for rejoining player", m_ClientTurnManager->GetCurrentTurn());
@@ -567 +574 @@
 
     return true;
 }
 
 bool CNetClient::OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_END_COMMAND_BATCH);
 
     CNetClient* client = (CNetClient*)context;
 
     CEndCommandBatchMessage* endMessage = (CEndCommandBatchMessage*)event->GetParamRef();
 
     client->m_ClientTurnManager->FinishedAllCommands(endMessage->m_Turn, endMessage->m_TurnLength);
 
     // Execute all the received commands for the latest turn
     client->m_ClientTurnManager->UpdateFastForward();
 
     return true;
 }
 
+bool CNetClient::OnRejoined(void *context, CFsmEvent* event)
+{
+    ENSURE(event->GetType() == (uint)NMT_REJOINED);
+
+    CNetClient* client = (CNetClient*)context;
+    JSContext* cx = client->GetScriptInterface().GetContext();
+
+    CRejoinedMessage* message = (CRejoinedMessage*)event->GetParamRef();
+    JS::RootedValue msg(cx);
+    client->GetScriptInterface().Eval("({'type':'rejoined'})", &msg);
+    client->GetScriptInterface().SetProperty(msg, "guid", std::string(message->m_GUID), false);
+    client->PushGuiMessage(msg);
+
+    return true;
+}
+
 bool CNetClient::OnLoadedGame(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
     CNetClient* client = (CNetClient*)context;
     JSContext* cx = client->GetScriptInterface().GetContext();
     JSAutoRequest rq(cx);
 
     // All players have loaded the game - start running the turn manager
     // so that the game begins
     client->m_Game->SetTurnManager(client->m_ClientTurnManager);
 
     JS::RootedValue msg(cx);
     client->GetScriptInterface().Eval("({'type':'netstatus','status':'active'})", &msg);
     client->PushGuiMessage(msg);
 
     return true;
 }
 
 bool CNetClient::OnInGame(void *context, CFsmEvent* event)
@@ -614 +637 @@
     {
         if (message->GetType() == NMT_SIMULATION_COMMAND)
         {
             CSimulationMessage* simMessage = static_cast<CSimulationMessage*> (message);
             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);
         }
         else if (message->GetType() == NMT_END_COMMAND_BATCH)
         {
             CEndCommandBatchMessage* endMessage = static_cast<CEndCommandBatchMessage*> (message);
             client->m_ClientTurnManager->FinishedAllCommands(endMessage->m_Turn, endMessage->m_TurnLength);
         }
     }
 
     return true;
 }
+

source/network/NetClient.h

@@ -163 +163 @@
     /**
      * 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.
      */
     void LoadFinished();
 
     void SendChatMessage(const std::wstring& text);
     
     void SendReadyMessage(const int status);
 
+    /**
+     * Call when the client has rejoined a running match and finished
+     * the loading screen.
+     */
+    void SendRejoinedMessage();
+
+
 private:
     // Net message / FSM transition handlers
     static bool OnConnect(void* context, CFsmEvent* event);
     static bool OnHandshake(void* context, CFsmEvent* event);
     static bool OnHandshakeResponse(void* context, CFsmEvent* event);
     static bool OnAuthenticate(void* context, CFsmEvent* event);
     static bool OnChat(void* context, CFsmEvent* event);
     static bool OnReady(void* context, CFsmEvent* event);
     static bool OnGameSetup(void* context, CFsmEvent* event);
     static bool OnPlayerAssignment(void* context, CFsmEvent* event);
     static bool OnInGame(void* context, CFsmEvent* event);
     static bool OnGameStart(void* context, CFsmEvent* event);
     static bool OnJoinSyncStart(void* context, CFsmEvent* event);
     static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
     static bool OnLoadedGame(void* context, CFsmEvent* event);
+    static bool OnRejoined(void* context, CFsmEvent* event);
 
     /**
      * Take ownership of a session object, and use it for all network communication.
      */
     void SetAndOwnSession(CNetClientSession* session);
 
     /**
      * Push a message onto the GUI queue listing the current player assignments.
      */
     void PostPlayerAssignmentsToScript();
 
     CGame *m_Game;
     CStrW m_UserName;
 
     /// Current network session (or NULL if not connected)
     CNetClientSession* m_Session;
 
     /// Turn manager associated with the current game (or NULL if we haven't started the game yet)
     CNetClientTurnManager* m_ClientTurnManager;
 

source/network/NetMessage.cpp

@@ -114 +114 @@
     case NMT_FILE_TRANSFER_REQUEST:
         pNewMessage = new CFileTransferRequestMessage;
         break;
 
     case NMT_FILE_TRANSFER_RESPONSE:
         pNewMessage = new CFileTransferResponseMessage;
         break;
 
     case NMT_FILE_TRANSFER_DATA:
         pNewMessage = new CFileTransferDataMessage;
         break;
 
     case NMT_FILE_TRANSFER_ACK:
         pNewMessage = new CFileTransferAckMessage;
         break;
 
     case NMT_JOIN_SYNC_START:
         pNewMessage = new CJoinSyncStartMessage;
         break;
 
+    case NMT_REJOINED:
+        pNewMessage = new CRejoinedMessage;
+        break;
+
     case NMT_LOADED_GAME:
         pNewMessage = new CLoadedGameMessage;
         break;
 
     case NMT_SERVER_HANDSHAKE:
         pNewMessage = new CSrvHandshakeMessage;
         break;
 
     case NMT_SERVER_HANDSHAKE_RESPONSE:
         pNewMessage = new CSrvHandshakeResponseMessage;
         break;
 
     case NMT_CLIENT_HANDSHAKE:
         pNewMessage = new CCliHandshakeMessage;
         break;
 
     case NMT_AUTHENTICATE:
         pNewMessage = new CAuthenticateMessage;
         break;
 
@@ -157 +161 @@
 
     case NMT_GAME_START:
         pNewMessage = new CGameStartMessage;
         break;
 
     case NMT_END_COMMAND_BATCH:
         pNewMessage = new CEndCommandBatchMessage;
         break;
 
     case NMT_SYNC_CHECK:
         pNewMessage = new CSyncCheckMessage;
         break;
 
     case NMT_SYNC_ERROR:
         pNewMessage = new CSyncErrorMessage;
         break;
 
     case NMT_CHAT:
         pNewMessage = new CChatMessage;
         break;
-    
+
     case NMT_READY:
         pNewMessage = new CReadyMessage;
         break;
 
     case NMT_SIMULATION_COMMAND:
         pNewMessage = new CSimulationMessage(scriptInterface);
         break;
 
     default:
         LOGERROR("CNetMessageFactory::CreateMessage(): Unknown message type '%d' received", header.GetType());
         break;
     }
 
     if (pNewMessage)
         pNewMessage->Deserialize((const u8*)pData, (const u8*)pData + dataSize);
 
     return pNewMessage;
 }

source/network/NetMessages.h

@@ -30 +30 @@
 #define PS_PROTOCOL_MAGIC_RESPONSE      0x50630121      // 'P', 'c', 0x01, '!'
 #define PS_PROTOCOL_VERSION             0x01010005      // Arbitrary protocol
 #define PS_DEFAULT_PORT                 0x5073          // 'P', 's'
 
 // Defines the list of message types. The order of the list must not change.
 // The message types having a negative value are used internally and not sent
 // over the network. The message types used for network communication have 
 // positive values.
 enum NetMessageType
 {
     NMT_CONNECT_COMPLETE = -256,    // Connection is complete
     NMT_CONNECTION_LOST,
     NMT_INVALID = 0,        // Invalid message
     NMT_SERVER_HANDSHAKE,   // Handshake stage
     NMT_CLIENT_HANDSHAKE,
     NMT_SERVER_HANDSHAKE_RESPONSE,
     NMT_AUTHENTICATE,       // Authentication stage
     NMT_AUTHENTICATE_RESULT,
     NMT_CHAT,       // Common chat message
     NMT_READY,
+    NMT_REJOINED,
     NMT_GAME_SETUP,
     NMT_PLAYER_ASSIGNMENT,
 
     NMT_FILE_TRANSFER_REQUEST,
     NMT_FILE_TRANSFER_RESPONSE,
     NMT_FILE_TRANSFER_DATA,
     NMT_FILE_TRANSFER_ACK,
 
     NMT_JOIN_SYNC_START,
 
     NMT_LOADED_GAME,
     NMT_GAME_START,
     NMT_END_COMMAND_BATCH,
     NMT_SYNC_CHECK, // OOS-detection hash checking
     NMT_SYNC_ERROR, // OOS-detection error
     NMT_SIMULATION_COMMAND,
     NMT_LAST                // Last message in the list
 };
 
 // Authentication result codes
@@ -138 +139 @@
 END_NMT_CLASS()
 
 START_NMT_CLASS_(FileTransferResponse, NMT_FILE_TRANSFER_RESPONSE)
     NMT_FIELD_INT(m_RequestID, u32, 4)
     NMT_FIELD_INT(m_Length, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(FileTransferData, NMT_FILE_TRANSFER_DATA)
     NMT_FIELD_INT(m_RequestID, u32, 4)
     NMT_FIELD(CStr8, m_Data)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(FileTransferAck, NMT_FILE_TRANSFER_ACK)
     NMT_FIELD_INT(m_RequestID, u32, 4)
     NMT_FIELD_INT(m_NumPackets, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(JoinSyncStart, NMT_JOIN_SYNC_START)
 END_NMT_CLASS()
 
+START_NMT_CLASS_(Rejoined, NMT_REJOINED)
+    NMT_FIELD(CStr8, m_GUID)
+END_NMT_CLASS()
+
 START_NMT_CLASS_(LoadedGame, NMT_LOADED_GAME)
     NMT_FIELD_INT(m_CurrentTurn, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(GameStart, NMT_GAME_START)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(EndCommandBatch, NMT_END_COMMAND_BATCH)
     NMT_FIELD_INT(m_Turn, u32, 4)
     NMT_FIELD_INT(m_TurnLength, u32, 2)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(SyncCheck, NMT_SYNC_CHECK)
     NMT_FIELD_INT(m_Turn, u32, 4)
     NMT_FIELD(CStr, m_Hash)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(SyncError, NMT_SYNC_ERROR)
     NMT_FIELD_INT(m_Turn, u32, 4)
     NMT_FIELD(CStr, m_HashExpected)

source/network/NetServer.cpp

@@ -581 +581 @@
 
     session->AddTransition(NSS_HANDSHAKE, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED);
     session->AddTransition(NSS_HANDSHAKE, (uint)NMT_CLIENT_HANDSHAKE, NSS_AUTHENTICATE, (void*)&OnClientHandshake, context);
 
     session->AddTransition(NSS_AUTHENTICATE, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED);
     session->AddTransition(NSS_AUTHENTICATE, (uint)NMT_AUTHENTICATE, NSS_PREGAME, (void*)&OnAuthenticate, context);
 
     session->AddTransition(NSS_PREGAME, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
     session->AddTransition(NSS_PREGAME, (uint)NMT_CHAT, NSS_PREGAME, (void*)&OnChat, context);
     session->AddTransition(NSS_PREGAME, (uint)NMT_READY, NSS_PREGAME, (void*)&OnReady, context);
     session->AddTransition(NSS_PREGAME, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnLoadedGame, context);
 
     session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
     session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnJoinSyncingLoadedGame, context);
 
     session->AddTransition(NSS_INGAME, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
     session->AddTransition(NSS_INGAME, (uint)NMT_CHAT, NSS_INGAME, (void*)&OnChat, context);
     session->AddTransition(NSS_INGAME, (uint)NMT_SIMULATION_COMMAND, NSS_INGAME, (void*)&OnInGame, context);
     session->AddTransition(NSS_INGAME, (uint)NMT_SYNC_CHECK, NSS_INGAME, (void*)&OnInGame, context);
     session->AddTransition(NSS_INGAME, (uint)NMT_END_COMMAND_BATCH, NSS_INGAME, (void*)&OnInGame, context);
+    session->AddTransition(NSS_INGAME, (uint)NMT_REJOINED, NSS_INGAME, (void*)&OnRejoined, context);
 
     // Set first state
     session->SetFirstState(NSS_HANDSHAKE);
 }
 
 bool CNetServerWorker::HandleConnect(CNetServerSession* session)
 {
     CSrvHandshakeMessage handshake;
     handshake.m_Magic = PS_PROTOCOL_MAGIC;
     handshake.m_ProtocolVersion = PS_PROTOCOL_VERSION;
     handshake.m_SoftwareVersion = PS_PROTOCOL_VERSION;
     return session->SendMessage(&handshake);
 }
 
 void CNetServerWorker::OnUserJoin(CNetServerSession* session)
 {
     AddPlayer(session->GetGUID(), session->GetUserName());
 
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data = m_GameAttributes.get();
@@ -905 +906 @@
 
     return true;
 }
 
 bool CNetServerWorker::OnReady(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_READY);
 
     CNetServerSession* session = (CNetServerSession*)context;
     CNetServerWorker& server = session->GetServer();
 
     CReadyMessage* message = (CReadyMessage*)event->GetParamRef();
 
     message->m_GUID = session->GetGUID();
 
     server.Broadcast(message);
 
     return true;
 }
 
+
 bool CNetServerWorker::OnLoadedGame(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
     CNetServerSession* session = (CNetServerSession*)context;
     CNetServerWorker& server = session->GetServer();
 
     // We're in the loading state, so wait until every player has loaded before
     // starting the game
     ENSURE(server.m_State == SERVER_STATE_LOADING);
     server.CheckGameLoadStatus(session);
 
     return true;
 }
 
 bool CNetServerWorker::OnJoinSyncingLoadedGame(void* context, CFsmEvent* event)
 {
     // A client rejoining an in-progress game has now finished loading the
     // map and deserialized the initial state.
     // The simulation may have progressed since then, so send any subsequent
@@ -971 +973 @@
         if (i <= readyTurn)
         {
             CEndCommandBatchMessage endMessage;
             endMessage.m_Turn = i;
             endMessage.m_TurnLength = server.m_ServerTurnManager->GetSavedTurnLength(i);
             session->SendMessage(&endMessage);
         }
     }
 
     // Tell the turn manager to expect commands from this new client
     server.m_ServerTurnManager->InitialiseClient(session->GetHostID(), readyTurn);
 
     // Tell the client that everything has finished loading and it should start now
     CLoadedGameMessage loaded;
     loaded.m_CurrentTurn = readyTurn;
     session->SendMessage(&loaded);
 
     return true;
 }
 
+bool CNetServerWorker::OnRejoined(void* context, CFsmEvent* event)
+{
+
+    // A client has finished rejoining and his/her loading screen disappeared.
+
+    ENSURE(event->GetType() == (uint)NMT_REJOINED);
+
+    CNetServerSession* session = (CNetServerSession*)context;
+    CNetServerWorker& server = session->GetServer();
+
+    CRejoinedMessage* message = (CRejoinedMessage*)event->GetParamRef();
+
+    message->m_GUID = session->GetGUID();
+
+    server.Broadcast(message);
+
+    return true;
+}
+
 bool CNetServerWorker::OnDisconnect(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_CONNECTION_LOST);
 
     CNetServerSession* session = (CNetServerSession*)context;
     CNetServerWorker& server = session->GetServer();
 
     server.OnUserLeave(session);
 
     return true;
 }
 
 void CNetServerWorker::CheckGameLoadStatus(CNetServerSession* changedSession)
 {
     for (size_t i = 0; i < m_Sessions.size(); ++i)
     {
         if (m_Sessions[i] != changedSession && m_Sessions[i]->GetCurrState() != NSS_INGAME)
             return;
     }
 

source/network/NetServer.h

@@ -245 +245 @@
 
     void AddPlayer(const CStr& guid, const CStrW& name);
     void RemovePlayer(const CStr& guid);
     void SetPlayerReady(const CStr& guid, const int ready); 
     void SendPlayerAssignments();
     void ClearAllPlayerReady();
 
     void SetupSession(CNetServerSession* session);
     bool HandleConnect(CNetServerSession* session);
 
     void OnUserJoin(CNetServerSession* session);
     void OnUserLeave(CNetServerSession* session);
 
     static bool OnClientHandshake(void* context, CFsmEvent* event);
     static bool OnAuthenticate(void* context, CFsmEvent* event);
     static bool OnInGame(void* context, CFsmEvent* event);
     static bool OnChat(void* context, CFsmEvent* event);
     static bool OnReady(void* context, CFsmEvent* event);
     static bool OnLoadedGame(void* context, CFsmEvent* event);
     static bool OnJoinSyncingLoadedGame(void* context, CFsmEvent* event);
+    static bool OnRejoined(void* context, CFsmEvent* event);
     static bool OnDisconnect(void* context, CFsmEvent* event);
 
     void CheckGameLoadStatus(CNetServerSession* changedSession);
 
     void ConstructPlayerAssignmentMessage(CPlayerAssignmentMessage& message);
 
     void HandleMessageReceive(const CNetMessage* message, CNetServerSession* session);
 
 
     /**
      * Internal script context for (de)serializing script messages,
      * and for storing game attributes.
      * (TODO: we shouldn't bother deserializing (except for debug printing of messages),
      * we should just forward messages blindly and efficiently.)
      */
     ScriptInterface* m_ScriptInterface;
 
     PlayerAssignmentMap m_PlayerAssignments;
 
     /**

source/ps/Game.cpp

@@ -218 +218 @@
             m_Simulation2->PreInitGame();
 
         JS::RootedValue settings(cx);
         JS::RootedValue tmpInitAttributes(cx, m_Simulation2->GetInitAttributes());
         m_Simulation2->GetScriptInterface().GetProperty(tmpInitAttributes, "settings", &settings);
         m_Simulation2->InitGame(settings);
     }
 
     // We need to do an initial Interpolate call to set up all the models etc,
     // because Update might never interpolate (e.g. if the game starts paused)
     // and we could end up rendering before having set up any models (so they'd
     // all be invisible)
     Interpolate(0, 0);
 
     m_GameStarted=true;
     
     // Render a frame to begin loading assets
     if (CRenderer::IsInitialised())
         Render();
 
+    if (g_NetClient)
+        g_NetClient->LoadFinished();
+
     // Call the reallyStartGame GUI function, but only if it exists
     if (g_GUI && g_GUI->HasPages())
     {
         JS::RootedValue global(cx, g_GUI->GetActiveGUI()->GetGlobalObject());
         if (g_GUI->GetActiveGUI()->GetScriptInterface()->HasProperty(global, "reallyStartGame"))
             g_GUI->GetActiveGUI()->GetScriptInterface()->CallFunctionVoid(global, "reallyStartGame");
     }
 
-    if (g_NetClient)
-        g_NetClient->LoadFinished();
-
     debug_printf("GAME STARTED, ALL INIT COMPLETE\n");
 
     // The call tree we've built for pregame probably isn't useful in-game.
     if (CProfileManager::IsInitialised())
         g_Profiler.StructuralReset();
 
     // Mark terrain as modified so the minimap can repaint (is there a cleaner way of handling this?)
     g_GameRestarted = true;
 
     return 0;
 }
 
 int CGame::GetPlayerID()
 {
     return m_PlayerID;
 }
 
 void CGame::SetPlayerID(int playerID)
 {
     m_PlayerID = playerID;