Ticket #3264: t3264_show_network_warnings_v1.patch

binaries/data/config/default.cfg

@@ -350 +350 @@
 enabledmods = "mod public"
 
 [overlay]
 fps = "false"                     ; Show frames per second in top right corner
 realtime = "false"                ; Show current system time in top right corner
+netwarnings = "true"              ; Show warnings if the network connection is bad
 
 [profiler2]
 autoenable = false                ; Enable HTTP server output at startup (default off for security/performance)
 script.enable = false             ; Enable Javascript profiling. Needs to be set before startup and can't be changed later. (default off for performance)
 gpu.arb.enable = true             ; Allow GL_ARB_timer_query timing mode when available

binaries/data/mods/public/gui/common/functions_global_object.js

@@ -1 @@
-/*
-    DESCRIPTION : Contains global GUI functions, which will later be accessible from every GUI script/file.
-    NOTES       : So far, only the message box-related functions are implemented.
-*/
+/**
+ * Contains global GUI functions accessible from every GUI script/file.
+ * File will be reloaded when switching pages or showing message boxes!
+ */
+
+/**
+ * Number of milliseconds to display network warnings.
+ */
+var g_NetworkWarningTimeout = 3000;
+
+/**
+ * Currently displayed network warnings. At most one message per user.
+ */
+var g_NetworkWarnings = {};
+
+/**
+ * Update GUI object once per second.
+ */
+var g_NetworkWarningsLastUpdate = 0;
+
+/**
+ * Message-types to be displayed.
+ */
+var g_NetworkWarningTexts = {
+
+    "server-timeout": (msg, username) =>
+        sprintf(translate("Losing connection to server (%(seconds)s)"), {
+            "seconds": Math.ceil(msg.lastReceivedTime / 1000)
+        }),
+
+    "client-timeout": (msg, username) =>
+        sprintf(translate("%(player)s losing connection (%(seconds)s)"), {
+            "player": username,
+            "seconds": Math.ceil(msg.lastReceivedTime / 1000)
+        }),
+
+    "server-latency": (msg, username) =>
+        sprintf(translate("Bad connection to server (%(milliseconds)sms)"), {
+            "milliseconds": msg.meanRTT
+        }),
+
+    "client-latency": (msg, username) =>
+        sprintf(translate("Bad connection to %(player)s (%(milliseconds)sms)"), {
+            "player": username,
+            "milliseconds": msg.meanRTT
+        })
+};
 
 // *******************************************
 // messageBox
 // *******************************************
 // @params:     int mbWidth, int mbHeight, string mbMessage, string mbTitle, int mbMode, arr mbButtonCaptions, function mbBtnCode, var mbCallbackArgs
@@ -138 +181 @@
 
     var dataCounter = Engine.GetGUIObjectByName("dataCounter");
     dataCounter.caption = caption;
     dataCounter.size = sprintf("100%%-100 40 100%%-5 %(bottom)s", { bottom: 40 + 14 * linesCount });
 }
+
+/**
+ * @param msg - GUI message sent by NetServer or NetClient
+ */
+function addNetworkWarning(msg)
+{
+    if (Engine.ConfigDB_GetValue("user", "overlay.netwarnings") != "true")
+        return;
+
+    if (!g_NetworkWarningTexts[msg.warntype])
+    {
+        warn("Unknown network warning type received: " + JSON.stringify(msg));
+        return;
+    }
+
+    // Remember this message for few seconds.
+    // Overwrite previous messages for this user.
+    g_NetworkWarnings[msg.guid || "server"] = {
+        "added": Date.now(),
+        "msg": msg
+    };
+}
+
+/**
+ * Displays the most recent network warning of each client onscreen.
+ */
+function displayNetworkWarnings()
+{
+    // Update once per second
+    let now = Date.now();
+    if (now <= g_NetworkWarningsLastUpdate)
+        return;
+
+    // Hide GUI object if disabled
+    let showWarnings = Engine.ConfigDB_GetValue("user", "overlay.netwarnings") == "true";
+
+    let networkWarnings = Engine.GetGUIObjectByName("networkWarnings");
+    networkWarnings.hidden = !showWarnings;
+
+    if (!showWarnings)
+        return;
+
+    // Remove outdated messages
+    for (let guid in g_NetworkWarnings)
+        if (now - g_NetworkWarnings[guid].added > g_NetworkWarningTimeout || !g_PlayerAssignments[guid])
+            delete g_NetworkWarnings[guid];
+
+    // Sort messages to show local ones first
+    let guids = Object.keys(g_NetworkWarnings).sort(guid => guid != "server");
+
+    // Get text and width
+    let formattedMessages = [];
+    let maxTextWidth = 0;
+    for (let guid of guids)
+    {
+        let msg = g_NetworkWarnings[guid].msg;
+
+        // Colorize message
+        formattedMessages.push(g_NetworkWarningTexts[msg.warntype](msg, colorizePlayernameByGUID(guid)));
+
+        // Get width of unformatted text
+        let textWidth = Engine.GetTextWidth("mono-stroke-10", g_NetworkWarningTexts[msg.warntype](msg, g_PlayerAssignments[guid].name));
+        maxTextWidth = Math.max(textWidth, maxTextWidth);
+    }
+
+    // Update textbox size
+    let width = maxTextWidth + 20;
+    let height = 14 * formattedMessages.length;
+
+    let top = "40";
+    let right = "100%-110";
+    let bottom = top + "+" + height;
+    let left = right + "-" + width;
+
+    networkWarnings.caption = formattedMessages.join("\n");
+    networkWarnings.size = left + " " + top + " " + right + " " + bottom;
+}

binaries/data/mods/public/gui/common/global.xml

@@ -12 +12 @@
 
     <object>
 
         <!--
         ==========================================
+        - NETWORK WARNINGS
+        ==========================================
+        -->
+        <object name="networkWarnings"
+            type="text"
+            ghost="true"
+            z="199"
+            size="100%-110 40 100%-110 40"
+            font="mono-stroke-10"
+            textcolor="255 219 77"
+            text_align="center"
+            text_valign="top"
+            sprite="color: 0 0 0 100"
+            >
+            <action on="Tick">
+                displayNetworkWarnings();
+            </action>
+        </object>
+
+        <!--
+        ==========================================
         - FPS & REAL TIME & GAME TIME COUNTER
         ==========================================
         -->
         <object name="dataCounter"
             type="text"

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

@@ -26 +26 @@
 /**
  * Processes a CNetMessage (see NetMessage.h, NetMessages.h) sent by the CNetServer.
  */
 const g_NetMessageTypes = {
     "netstatus": msg => handleNetStatusMessage(msg),
+    "netwarn": msg => addNetworkWarning(msg),
     "gamesetup": msg => handleGamesetupMessage(msg),
     "players": msg => handlePlayerAssignmentMessage(msg),
     "ready": msg => handleReadyMessage(msg),
     "start": msg => handleGamestartMessage(msg),
     "kicked": msg => addChatMessage({ "type": "kicked", "username": msg.username }),

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

@@ -124 +124 @@
                     "playerAssignments": g_PlayerAssignments
                 });
                 break;
 
             case "chat":
-                // Ignore, since we have nowhere to display chat messages
+                break;
+
+            case "netwarn":
                 break;
 
             default:
                 error(sprintf("Unrecognised net message type %(messageType)s", { messageType: message.type }));
             }
@@ -167 +169 @@
                 default:
                     error(sprintf("Unrecognised netstatus type %(netType)s", { netType: message.status }));
                     break;
                 }
                 break;
+
+            case "netwarn":
+                break;
+
             default:
                 error(sprintf("Unrecognised net message type %(messageType)s", { messageType: message.type }));
                 break;
             }
         }

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

@@ -25 +25 @@
             "tooltip": "Show detailed tooltips for trainable units in unit-producing buildings.",
             "parameters": { "config": "showdetailedtooltips" }
         },
         {
             "type": "boolean",
+            "label": "Network Warnings",
+            "tooltip": "Show which player has a bad connection in multiplayer games.",
+            "parameters": { "config": "overlay.netwarnings" }
+        },
+        {
+            "type": "boolean",
             "label": "FPS Overlay",
             "tooltip": "Show frames per second in top right corner.",
             "parameters": { "config": "overlay.fps" }
         },
         {

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

@@ -27 +27 @@
 /**
  * Handle all netmessage types that can occur.
  */
 var g_NetMessageTypes = {
     "netstatus": msg => handleNetStatusMessage(msg),
+    "netwarn": msg => addNetworkWarning(msg),
     "players": msg => handlePlayerAssignmentsMessage(msg),
     "rejoined": msg => addChatMessage({ "type": "rejoined", "guid": msg.guid }),
     "kicked": msg => addChatMessage({ "type": "system", "text": sprintf(translate("%(username)s has been kicked"), { "username": msg.username }) }),
     "banned": msg => addChatMessage({ "type": "system", "text": sprintf(translate("%(username)s has been banned"), { "username": msg.username }) }),
     "chat": msg => addChatMessage({ "type": "message", "guid": msg.guid, "text": msg.text }),

source/gui/scripting/ScriptFunctions.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "scriptinterface/ScriptInterface.h"
 
 #include "graphics/Camera.h"
+#include "graphics/FontMetrics.h"
 #include "graphics/GameView.h"
 #include "graphics/MapReader.h"
 #include "graphics/scripting/JSInterface_GameView.h"
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
@@ -873 +874 @@
 CParamNode GetTemplate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& templateName)
 {
     return g_GUI->GetTemplate(templateName);
 }
 
+int GetTextWidth(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& fontName, const std::wstring& text)
+{
+    int width = 0;
+    int height = 0;
+    CStrIntern _fontName (fontName);
+    CFontMetrics fontMetrics(_fontName);
+    fontMetrics.CalculateStringSize(text.c_str(), width, height);
+    return width;
+}
+
 //-----------------------------------------------------------------------------
 // Timer
 //-----------------------------------------------------------------------------
 
 
@@ -1047 +1058 @@
     scriptInterface.RegisterFunction<std::wstring, int, &GetBuildTimestamp>("GetBuildTimestamp");
     scriptInterface.RegisterFunction<JS::Value, std::wstring, &ReadJSONFile>("ReadJSONFile");
     scriptInterface.RegisterFunction<void, std::wstring, JS::HandleValue, &WriteJSONFile>("WriteJSONFile");
     scriptInterface.RegisterFunction<bool, std::string, &TemplateExists>("TemplateExists");
     scriptInterface.RegisterFunction<CParamNode, std::string, &GetTemplate>("GetTemplate");
+    scriptInterface.RegisterFunction<int, std::string, std::wstring, &GetTextWidth>("GetTextWidth");
 
     // User report functions
     scriptInterface.RegisterFunction<bool, &IsUserReportEnabled>("IsUserReportEnabled");
     scriptInterface.RegisterFunction<void, bool, &SetUserReportEnabled>("SetUserReportEnabled");
     scriptInterface.RegisterFunction<std::string, &GetUserReportStatus>("GetUserReportStatus");

source/network/NetClient.cpp

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -68 +68 @@
 
 CNetClient::CNetClient(CGame* game) :
     m_Session(NULL),
     m_UserName(L"anonymous"),
     m_GUID(ps_generate_guid()), m_HostID((u32)-1), m_ClientTurnManager(NULL), m_Game(game),
-    m_GameAttributes(game->GetSimulation2()->GetScriptInterface().GetContext())
+    m_GameAttributes(game->GetSimulation2()->GetScriptInterface().GetContext()),
+    m_LastConnectionCheck(0)
 {
     m_Game->SetTurnManager(NULL); // delete the old local turn manager so we don't accidentally use it
 
     void* context = this;
 
@@ -92 +93 @@
     AddTransition(NCS_PREGAME, (uint)NMT_CHAT, NCS_PREGAME, (void*)&OnChat, context);
     AddTransition(NCS_PREGAME, (uint)NMT_READY, NCS_PREGAME, (void*)&OnReady, context);
     AddTransition(NCS_PREGAME, (uint)NMT_GAME_SETUP, NCS_PREGAME, (void*)&OnGameSetup, context);
     AddTransition(NCS_PREGAME, (uint)NMT_PLAYER_ASSIGNMENT, NCS_PREGAME, (void*)&OnPlayerAssignment, context);
     AddTransition(NCS_PREGAME, (uint)NMT_KICKED, NCS_PREGAME, (void*)&OnKicked, context);
+    AddTransition(NCS_PREGAME, (uint)NMT_CLIENT_TIMEOUT, NCS_PREGAME, (void*)&OnClientTimeout, context);
+    AddTransition(NCS_PREGAME, (uint)NMT_CLIENT_PERFORMANCE, NCS_PREGAME, (void*)&OnClientPerformance, context);
     AddTransition(NCS_PREGAME, (uint)NMT_GAME_START, NCS_LOADING, (void*)&OnGameStart, context);
     AddTransition(NCS_PREGAME, (uint)NMT_JOIN_SYNC_START, NCS_JOIN_SYNCING, (void*)&OnJoinSyncStart, context);
 
     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_CLIENT_TIMEOUT, NCS_JOIN_SYNCING, (void*)&OnClientTimeout, context);
+    AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CLIENT_PERFORMANCE, NCS_JOIN_SYNCING, (void*)&OnClientPerformance, 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_CLIENT_TIMEOUT, NCS_LOADING, (void*)&OnClientTimeout, context);
+    AddTransition(NCS_LOADING, (uint)NMT_CLIENT_PERFORMANCE, NCS_LOADING, (void*)&OnClientPerformance, context);
     AddTransition(NCS_LOADING, (uint)NMT_LOADED_GAME, NCS_INGAME, (void*)&OnLoadedGame, context);
 
     AddTransition(NCS_INGAME, (uint)NMT_REJOINED, NCS_INGAME, (void*)&OnRejoined, context);
     AddTransition(NCS_INGAME, (uint)NMT_KICKED, NCS_INGAME, (void*)&OnKicked, context);
+    AddTransition(NCS_INGAME, (uint)NMT_CLIENT_TIMEOUT, NCS_INGAME, (void*)&OnClientTimeout, context);
+    AddTransition(NCS_INGAME, (uint)NMT_CLIENT_PERFORMANCE, NCS_INGAME, (void*)&OnClientPerformance, 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);
@@ -168 +177 @@
     SAFE_DELETE(m_Session);
 }
 
 void CNetClient::Poll()
 {
-    if (m_Session)
-        m_Session->Poll();
+    if (!m_Session)
+        return;
+
+    CheckServerConnection();
+    m_Session->Poll();
+}
+
+void CNetClient::CheckServerConnection()
+{
+    // Trigger local warnings if the connection to the server is bad.
+    // At most once per second.
+    std::time_t now = std::time(nullptr);
+    if (now <= m_LastConnectionCheck)
+        return;
+
+    m_LastConnectionCheck = now;
+
+    JSContext* cx = GetScriptInterface().GetContext();
+
+    // Report if we are losing the connection to the server
+    u32 lastReceived = m_Session->GetLastReceivedTime();
+    if (lastReceived > NETWORK_WARNING_TIMEOUT)
+    {
+        JS::RootedValue msg(cx);
+        GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'server-timeout' })", &msg);
+        GetScriptInterface().SetProperty(msg, "lastReceivedTime", lastReceived);
+        PushGuiMessage(msg);
+        return;
+    }
+
+    // Report if we have a bad ping to the server
+    u32 meanRTT = m_Session->GetMeanRTT();
+    if (meanRTT > DEFAULT_TURN_LENGTH_MP * NETWORK_WARNING_LATENCY)
+    {
+        JS::RootedValue msg(cx);
+        GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'server-latency' })", &msg);
+        GetScriptInterface().SetProperty(msg, "meanRTT", meanRTT);
+        PushGuiMessage(msg);
+    }
 }
 
 void CNetClient::Flush()
 {
     if (m_Session)
@@ -625 +671 @@
     client->PushGuiMessage(msg);
 
     return true;
 }
 
+bool CNetClient::OnClientTimeout(void *context, CFsmEvent* event)
+{
+    // Report the timeout of some other client
+
+    ENSURE(event->GetType() == (uint)NMT_CLIENT_TIMEOUT);
+
+    CNetClient* client = (CNetClient*)context;
+    JSContext* cx = client->GetScriptInterface().GetContext();
+
+    if (client->GetCurrState() == NCS_LOADING)
+        return true;
+
+    CClientTimeoutMessage* message = (CClientTimeoutMessage*)event->GetParamRef();
+    JS::RootedValue msg(cx);
+
+    client->GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'client-timeout' })", &msg);
+    client->GetScriptInterface().SetProperty(msg, "guid", std::string(message->m_GUID));
+    client->GetScriptInterface().SetProperty(msg, "lastReceivedTime", message->m_LastReceivedTime);
+    client->PushGuiMessage(msg);
+
+    return true;
+}
+
+bool CNetClient::OnClientPerformance(void *context, CFsmEvent* event)
+{
+    // Performance statistics for one or multiple clients
+
+    ENSURE(event->GetType() == (uint)NMT_CLIENT_PERFORMANCE);
+
+    CNetClient* client = (CNetClient*)context;
+    JSContext* cx = client->GetScriptInterface().GetContext();
+
+    if (client->GetCurrState() == NCS_LOADING)
+        return true;
+
+    CClientPerformanceMessage* message = (CClientPerformanceMessage*)event->GetParamRef();
+    std::vector<CClientPerformanceMessage::S_m_Clients> &clients = message->m_Clients;
+
+    // Display warnings for other clients with bad ping
+    for (size_t i = 0; i < clients.size(); ++i)
+    {
+        u32 meanRTT = clients[i].m_MeanRTT;
+
+        if (meanRTT < DEFAULT_TURN_LENGTH_MP * NETWORK_WARNING_LATENCY || clients[i].m_GUID == client->m_GUID)
+            continue;
+
+        JS::RootedValue msg(cx);
+        client->GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'client-latency' })", &msg);
+        client->GetScriptInterface().SetProperty(msg, "guid", clients[i].m_GUID);
+        client->GetScriptInterface().SetProperty(msg, "meanRTT", meanRTT);
+        client->PushGuiMessage(msg);
+    }
+
+    return true;
+}
+
 bool CNetClient::OnLoadedGame(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
     CNetClient* client = (CNetClient*)context;

source/network/NetClient.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -107 +107 @@
      * This must be called frequently (i.e. once per frame).
      */
     void Poll();
 
     /**
+     * Locally triggers a GUI message if the connection to the server is being lost or has bad latency.
+     */
+    void CheckServerConnection();
+
+    /**
      * Flush any queued outgoing network messages.
      * This should be called soon after sending a group of messages that may be batched together.
      */
     void Flush();
 
@@ -200 +205 @@
     static bool OnGameStart(void* context, CFsmEvent* event);
     static bool OnJoinSyncStart(void* context, CFsmEvent* event);
     static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
     static bool OnRejoined(void* context, CFsmEvent* event);
     static bool OnKicked(void* context, CFsmEvent* event);
+    static bool OnClientTimeout(void* context, CFsmEvent* event);
+    static bool OnClientPerformance(void* context, CFsmEvent* event);
     static bool OnLoadedGame(void* context, CFsmEvent* event);
 
     /**
      * Take ownership of a session object, and use it for all network communication.
      */
@@ -238 +245 @@
     /// Queue of messages for GuiPoll
     std::deque<JS::Heap<JS::Value> > m_GuiMessageQueue;
 
     /// Serialized game state received when joining an in-progress game
     std::string m_JoinSyncBuffer;
+
+    /// Time when the server was last checked for timeout
+    std::time_t m_LastConnectionCheck;
 };
 
 /// Global network client for the standard game
 extern CNetClient *g_NetClient;
 

source/network/NetMessage.cpp

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -137 +137 @@
 
     case NMT_KICKED:
         pNewMessage = new CKickedMessage;
         break;
 
+    case NMT_CLIENT_TIMEOUT:
+        pNewMessage = new CClientTimeoutMessage;
+        break;
+
+    case NMT_CLIENT_PERFORMANCE:
+        pNewMessage = new CClientPerformanceMessage;
+        break;
+
     case NMT_LOADED_GAME:
         pNewMessage = new CLoadedGameMessage;
         break;
 
     case NMT_SERVER_HANDSHAKE:

source/network/NetMessages.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -26 +26 @@
 #include "ps/CStr.h"
 #include "scriptinterface/ScriptVal.h"
 
 #define PS_PROTOCOL_MAGIC               0x5073013f      // 'P', 's', 0x01, '?'
 #define PS_PROTOCOL_MAGIC_RESPONSE      0x50630121      // 'P', 'c', 0x01, '!'
-#define PS_PROTOCOL_VERSION             0x01010008      // Arbitrary protocol
+#define PS_PROTOCOL_VERSION             0x01010009      // 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
@@ -58 +58 @@
     NMT_JOIN_SYNC_START,
 
     NMT_REJOINED,
     NMT_KICKED,
 
+    NMT_CLIENT_TIMEOUT,
+    NMT_CLIENT_PERFORMANCE,
+
     NMT_LOADED_GAME,
     NMT_GAME_START,
     NMT_END_COMMAND_BATCH,
     NMT_SYNC_CHECK, // OOS-detection hash checking
     NMT_SYNC_ERROR, // OOS-detection error
@@ -165 +168 @@
 START_NMT_CLASS_(Kicked, NMT_KICKED)
     NMT_FIELD(CStrW, m_Name)
     NMT_FIELD_INT(m_Ban, u8, 1)
 END_NMT_CLASS()
 
+START_NMT_CLASS_(ClientTimeout, NMT_CLIENT_TIMEOUT)
+    NMT_FIELD(CStr8, m_GUID)
+    NMT_FIELD_INT(m_LastReceivedTime, u32, 4)
+END_NMT_CLASS()
+
+START_NMT_CLASS_(ClientPerformance, NMT_CLIENT_PERFORMANCE)
+    NMT_START_ARRAY(m_Clients)
+        NMT_FIELD(CStr8, m_GUID)
+        NMT_FIELD_INT(m_MeanRTT, u32, 4)
+    NMT_END_ARRAY()
+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)

source/network/NetServer.cpp

@@ -119 +119 @@
 
 CNetServerWorker::CNetServerWorker(int autostartPlayers) :
     m_AutostartPlayers(autostartPlayers),
     m_Shutdown(false),
     m_ScriptInterface(NULL),
-    m_NextHostID(1), m_Host(NULL), m_HostGUID(), m_Stats(NULL)
+    m_NextHostID(1), m_Host(NULL), m_HostGUID(), m_Stats(NULL),
+    m_LastConnectionCheck(0)
 {
     m_State = SERVER_STATE_UNCONNECTED;
 
     m_ServerTurnManager = NULL;
 
@@ -449 +450 @@
 
     // Perform file transfers
     for (size_t i = 0; i < m_Sessions.size(); ++i)
         m_Sessions[i]->GetFileTransferer().Poll();
 
+    CheckClientConnections();
+
     // Process network events:
 
     ENetEvent event;
     int status = enet_host_service(m_Host, &event, HOST_SERVICE_TIMEOUT);
     if (status < 0)
@@ -547 +550 @@
     }
 
     return true;
 }
 
+void CNetServerWorker::CheckClientConnections()
+{
+    if (m_State == SERVER_STATE_LOADING)
+        return;
+
+    // Send messages at most once per second
+    std::time_t now = std::time(nullptr);
+    if (now <= m_LastConnectionCheck)
+        return;
+
+    m_LastConnectionCheck = now;
+
+    for (size_t i = 0; i < m_Sessions.size(); ++i)
+    {
+        u32 lastReceived = m_Sessions[i]->GetLastReceivedTime();
+        u32 meanRTT = m_Sessions[i]->GetMeanRTT();
+
+        CNetMessage* message = nullptr;
+
+        // Report if we didn't hear from the client since few seconds
+        if (lastReceived > NETWORK_WARNING_TIMEOUT)
+        {
+            CClientTimeoutMessage* msg = new CClientTimeoutMessage();
+            msg->m_GUID = m_Sessions[i]->GetGUID();
+            msg->m_LastReceivedTime = lastReceived;
+            message = msg;
+        }
+        // Report if the client has bad ping
+        else if (meanRTT > DEFAULT_TURN_LENGTH_MP * NETWORK_WARNING_LATENCY)
+        {
+            CClientPerformanceMessage* msg = new CClientPerformanceMessage();
+            CClientPerformanceMessage::S_m_Clients client;
+            client.m_GUID = m_Sessions[i]->GetGUID();
+            client.m_MeanRTT = meanRTT;
+            msg->m_Clients.push_back(client);
+            message = msg;
+        }
+
+        // Send to all clients except the affected one
+        // (since that will show the locally triggered warning instead)
+        if (message)
+            for (size_t j = 0; j < m_Sessions.size(); ++j)
+                if (i != j)
+                    m_Sessions[j]->SendMessage(message);
+
+        SAFE_DELETE(message);
+    }
+}
+
 void CNetServerWorker::HandleMessageReceive(const CNetMessage* message, CNetServerSession* session)
 {
     // Handle non-FSM messages first
     Status status = session->GetFileTransferer().HandleMessageReceive(message);
     if (status != INFO::SKIPPED)

source/network/NetServer.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -279 +279 @@
 
     void ConstructPlayerAssignmentMessage(CPlayerAssignmentMessage& message);
 
     void HandleMessageReceive(const CNetMessage* message, CNetServerSession* session);
 
+    /**
+     * Send a network warning if the connection to a client is being lost or has bad latency.
+     */
+    void CheckClientConnections();
 
     /**
      * 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),
@@ -329 +333 @@
      * The latest copy of the simulation state, received from an existing
      * client when a new client has asked to rejoin the game.
      */
     std::string m_JoinSyncFile;
 
+    /**
+     *  Time when the clients connections were last checked for timeouts and latency.
+     */
+    std::time_t m_LastConnectionCheck;
+
 private:
     // Thread-related stuff:
 
 #if CONFIG2_MINIUPNPC
     /**

source/network/NetSession.cpp

@@ -23 +23 @@
 #include "NetStats.h"
 #include "lib/external_libraries/enet.h"
 #include "ps/CLogger.h"
 #include "scriptinterface/ScriptInterface.h"
 
+const u32 NETWORK_WARNING_TIMEOUT = 4000;
+const float NETWORK_WARNING_LATENCY = 1.1f;
+
 static const int CHANNEL_COUNT = 1;
 
 CNetClientSession::CNetClientSession(CNetClient& client) :
     m_Client(client), m_FileTransferer(this), m_Host(NULL), m_Server(NULL), m_Stats(NULL)
 {
@@ -166 +169 @@
     ENSURE(m_Host && m_Server);
 
     return CNetHost::SendMessage(message, m_Server, "server");
 }
 
+u32 CNetClientSession::GetLastReceivedTime() const
+{
+    if (!m_Server)
+        return 0;
+
+    return enet_time_get() - m_Server->lastReceiveTime;
+}
+
+u32 CNetClientSession::GetMeanRTT() const
+{
+    if (!m_Server)
+        return 0;
+
+    return m_Server->roundTripTime;
+}
+
 
 
 CNetServerSession::CNetServerSession(CNetServerWorker& server, ENetPeer* peer) :
     m_Server(server), m_FileTransferer(this), m_Peer(peer)
 {
@@ -182 +201 @@
         LOGMESSAGE("Could not get IP address of a client!");
 
     return ipAddress;
 }
 
+u32 CNetServerSession::GetLastReceivedTime() const
+{
+    if (!m_Peer)
+        return 0;
+
+    return enet_time_get() - m_Peer->lastReceiveTime;
+}
+
+u32 CNetServerSession::GetMeanRTT() const
+{
+    if (!m_Peer)
+        return 0;
+
+    return m_Peer->roundTripTime;
+}
+
 void CNetServerSession::Disconnect(u32 reason)
 {
     Update((uint)NMT_CONNECTION_LOST, NULL);
 
     enet_peer_disconnect(m_Peer, reason);

source/network/NetSession.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -22 +22 @@
 #include "network/NetFileTransfer.h"
 #include "network/NetHost.h"
 #include "ps/CStr.h"
 #include "scriptinterface/ScriptVal.h"
 
+/**
+ * Report the peer if we didn't receive a packet after this time (milliseconds).
+ */
+extern const u32 NETWORK_WARNING_TIMEOUT;
+
+/**
+ * Report the peer if the mean RTT takes longer than this multiple of a turnlength.
+ */
+extern const float NETWORK_WARNING_LATENCY;
+
 class CNetClient;
 class CNetServerWorker;
 
 class CNetStatsTable;
 
@@ -81 +91 @@
     /**
      * Send a message to the server.
      */
     virtual bool SendMessage(const CNetMessage* message);
 
+    /**
+     * Number of milliseconds since the most recent packet of the server was received.
+     */
+    u32 GetLastReceivedTime() const;
+
+    /**
+     * Average round trip time to the server.
+     */
+    u32 GetMeanRTT() const;
+
     CNetFileTransferer& GetFileTransferer() { return m_FileTransferer; }
 
 private:
     CNetClient& m_Client;
 
@@ -123 +143 @@
     void SetHostID(u32 id) { m_HostID = id; }
 
     CStr GetIPAddress() const;
 
     /**
+     * Number of milliseconds since the latest packet of that client was received.
+     */
+    u32 GetLastReceivedTime() const;
+
+    /**
+     * Average round trip time to the client.
+     */
+    u32 GetMeanRTT() const;
+
+    /**
      * Sends a disconnection notification to the client,
      * and sends a NMT_CONNECTION_LOST message to the session FSM.
      * The server will receive a disconnection notification after a while.
      * The server will not receive any further messages sent via this session.
      */

source/network/NetTurnManager.cpp

@@ -36 +36 @@
 
 #include <sstream>
 #include <fstream>
 #include <iomanip>
 
-static const int DEFAULT_TURN_LENGTH_MP = 500;
-static const int DEFAULT_TURN_LENGTH_SP = 200;
+const int DEFAULT_TURN_LENGTH_MP = 500;
+const int DEFAULT_TURN_LENGTH_SP = 200;
 
 static const int COMMAND_DELAY = 2;
 
 #if 0
 #define NETTURN_LOG(args) debug_printf args

source/network/NetTurnManager.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -24 +24 @@
 
 #include <list>
 #include <map>
 #include <vector>
 
+extern const int DEFAULT_TURN_LENGTH_MP;
+extern const int DEFAULT_TURN_LENGTH_SP;
+
 class CNetServerWorker;
 class CNetClient;
 class CSimulationMessage;
 class CSimulation2;
 class IReplayLogger;