Ticket #3907: rangebasedfornetwork_v1.patch

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

@@ -170 +170 @@
  */
 function getNetworkWarnings()
 {
     // Remove outdated messages
     for (let guid in g_NetworkWarnings)
-    {
-        if (Date.now() > g_NetworkWarnings[guid].added + g_NetworkWarningTimeout)
+        if (Date.now() > g_NetworkWarnings[guid].added + g_NetworkWarningTimeout ||
+            guid != "server" && !g_PlayerAssignments[guid])
             delete g_NetworkWarnings[guid];
 
-        if (guid != "server" && !g_PlayerAssignments[guid])
-            delete g_NetworkWarnings[guid];
-    }
-
     // Show local messages first
     let guids = Object.keys(g_NetworkWarnings).sort(guid => guid != "server");
 
     let font = Engine.GetGUIObjectByName("gameStateNotifications").font;
 

source/network/NetClient.cpp

@@ -564 +564 @@
 
     CPlayerAssignmentMessage* message = (CPlayerAssignmentMessage*)event->GetParamRef();
 
     // Unpack the message
     PlayerAssignmentMap newPlayerAssignments;
-    for (size_t i = 0; i < message->m_Hosts.size(); ++i)
+    for (CPlayerAssignmentMessage::S_m_Hosts& host : message->m_Hosts)
     {
         PlayerAssignment assignment;
         assignment.m_Enabled = true;
-        assignment.m_Name = message->m_Hosts[i].m_Name;
-        assignment.m_PlayerID = message->m_Hosts[i].m_PlayerID;
-        assignment.m_Status = message->m_Hosts[i].m_Status;
-        newPlayerAssignments[message->m_Hosts[i].m_GUID] = assignment;
+        assignment.m_Name = host.m_Name;
+        assignment.m_PlayerID = host.m_PlayerID;
+        assignment.m_Status = host.m_Status;
+        newPlayerAssignments[host.m_GUID] = assignment;
     }
 
     client->m_PlayerAssignments.swap(newPlayerAssignments);
 
     client->PostPlayerAssignmentsToScript();
@@ -707 +707 @@
 
     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)
+    for (CClientPerformanceMessage::S_m_Clients& other_client : message->m_Clients)
     {
-        if (clients[i].m_MeanRTT < DEFAULT_TURN_LENGTH_MP || clients[i].m_GUID == client->m_GUID)
+        if (other_client.m_MeanRTT < DEFAULT_TURN_LENGTH_MP || other_client.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", clients[i].m_MeanRTT);
+        client->GetScriptInterface().SetProperty(msg, "guid", other_client.m_GUID);
+        client->GetScriptInterface().SetProperty(msg, "meanRTT", other_client.m_MeanRTT);
         client->PushGuiMessage(msg);
     }
 
     return true;
 }

source/network/NetServer.cpp

@@ -88 +88 @@
         // We've received the game state from an existing player - now
         // we need to send it onwards to the newly rejoining player
 
         // Find the session corresponding to the rejoining host (if any)
         CNetServerSession* session = NULL;
-        for (size_t i = 0; i < m_Server.m_Sessions.size(); ++i)
+        for (CNetServerSession* sess : m_Server.m_Sessions)
         {
-            if (m_Server.m_Sessions[i]->GetHostID() == m_RejoinerHostID)
+            if (sess->GetHostID() == m_RejoinerHostID)
             {
-                session = m_Server.m_Sessions[i];
+                session = sess;
                 break;
             }
         }
 
         if (!session)
@@ -155 +155 @@
 
     // Clean up resources
 
     delete m_Stats;
 
-    for (size_t i = 0; i < m_Sessions.size(); ++i)
+    for (CNetServerSession* session : m_Sessions)
     {
-        m_Sessions[i]->DisconnectNow(NDR_SERVER_SHUTDOWN);
-        delete m_Sessions[i];
+        session->DisconnectNow(NDR_SERVER_SHUTDOWN);
+        SAFE_DELETE(session);
     }
 
     if (m_Host)
     {
         enet_host_destroy(m_Host);
@@ -344 +344 @@
     ENSURE(m_Host);
 
     bool ok = true;
 
     // Send to all sessions that are active and has finished authentication
-    for (size_t i = 0; i < m_Sessions.size(); ++i)
+    for (CNetServerSession* session : m_Sessions)
     {
-        if (m_Sessions[i]->GetCurrState() == NSS_PREGAME || m_Sessions[i]->GetCurrState() == NSS_INGAME)
+        if (session->GetCurrState() == NSS_PREGAME || session->GetCurrState() == NSS_INGAME)
         {
-            if (!m_Sessions[i]->SendMessage(message))
+            if (!session->SendMessage(message))
                 ok = false;
 
             // TODO: this does lots of repeated message serialisation if we have lots
             // of remote peers; could do it more efficiently if that's a real problem
         }
@@ -430 +430 @@
         newAssignPlayer.swap(m_AssignPlayerQueue);
         newGameAttributes.swap(m_GameAttributesQueue);
         newTurnLength.swap(m_TurnLengthQueue);
     }
 
-    for (size_t i = 0; i < newAssignPlayer.size(); ++i)
-        AssignPlayer(newAssignPlayer[i].first, newAssignPlayer[i].second);
+    for (std::pair<int, CStr> player : newAssignPlayer)
+        AssignPlayer(player.first, player.second);
 
-    for (size_t i = 0; i < newPlayerReady.size(); ++i)
-        SetPlayerReady(newPlayerReady[i].first, newPlayerReady[i].second);
+    for (std::pair<CStr, int> player : newPlayerReady)
+        SetPlayerReady(player.first, player.second);
 
     if (!newPlayerResetReady.empty())
         ClearAllPlayerReady();
 
     if (!newGameAttributes.empty())
@@ -454 +454 @@
     // Do StartGame last, so we have the most up-to-date game attributes when we start
     if (!newStartGame.empty())
         StartGame();
 
     // Perform file transfers
-    for (size_t i = 0; i < m_Sessions.size(); ++i)
-        m_Sessions[i]->GetFileTransferer().Poll();
+    for (CNetServerSession* session : m_Sessions)
+        session->GetFileTransferer().Poll();
 
     CheckClientConnections();
 
     // Process network events:
 
@@ -575 +575 @@
     if (now <= m_LastConnectionCheck)
         return;
 
     m_LastConnectionCheck = now;
 
-    for (size_t i = 0; i < m_Sessions.size(); ++i)
+    for (CNetServerSession* session : m_Sessions)
     {
-        u32 lastReceived = m_Sessions[i]->GetLastReceivedTime();
-        u32 meanRTT = m_Sessions[i]->GetMeanRTT();
+        u32 lastReceived = session->GetLastReceivedTime();
+        u32 meanRTT = session->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_GUID = session->GetGUID();
             msg->m_LastReceivedTime = lastReceived;
             message = msg;
         }
         // Report if the client has bad ping
         else if (meanRTT > DEFAULT_TURN_LENGTH_MP)
         {
             CClientPerformanceMessage* msg = new CClientPerformanceMessage();
             CClientPerformanceMessage::S_m_Clients client;
-            client.m_GUID = m_Sessions[i]->GetGUID();
+            client.m_GUID = session->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);
+            for (CNetServerSession* session2 : m_Sessions)
+                if (session != session2)
+                    session2->SendMessage(message);
 
         SAFE_DELETE(message);
     }
 }
 
@@ -1206 +1206 @@
     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)
+    for (CNetServerSession* session : m_Sessions)
+        if (session != changedSession && session->GetCurrState() != NSS_INGAME)
             return;
-    }
 
     CLoadedGameMessage loaded;
     loaded.m_CurrentTurn = 0;
     Broadcast(&loaded);
 
@@ -1223 +1221 @@
 
 void CNetServerWorker::StartGame()
 {
     m_ServerTurnManager = new CNetServerTurnManager(*this);
 
-    for (size_t i = 0; i < m_Sessions.size(); ++i)
-        m_ServerTurnManager->InitialiseClient(m_Sessions[i]->GetHostID(), 0); // TODO: only for non-observers
+    for (CNetServerSession* session : m_Sessions)
+        m_ServerTurnManager->InitialiseClient(session->GetHostID(), 0); // TODO: only for non-observers
 
     m_State = SERVER_STATE_LOADING;
 
     // Send the final setup state to all clients
     UpdateGameAttributes(&m_GameAttributes.get());
@@ -1287 +1285 @@
     // Try names "Foo", "Foo (2)", "Foo (3)", etc
     size_t id = 2;
     while (true)
     {
         bool unique = true;
-        for (size_t i = 0; i < m_Sessions.size(); ++i)
+        for (CNetServerSession* session : m_Sessions)
         {
-            if (m_Sessions[i]->GetUserName() == name)
+            if (session->GetUserName() == name)
             {
                 unique = false;
                 break;
             }
         }