From 0a59aec1ba38a528ffabf90d7dd2ad245d76d581 Mon Sep 17 00:00:00 2001
From: tintinhamans <5984296+tintinhamans@users.noreply.github.com>
Date: Wed, 7 Oct 2026 22:37:40 +0200
Subject: [PATCH 1/3] perf(screenshot): Avoid redundant buffers and copies in
 screenshot uploads

---
 .../GeneralsOnline/OnlineServices_Init.h      |   4 +-
 .../GeneralsOnline/HTTP/HTTPManager.cpp       |   2 +-
 .../GeneralsOnline/OnlineServices_Init.cpp    | 203 ++++++++----------
 3 files changed, 88 insertions(+), 121 deletions(-)

diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
index 7d1419d2ee1..27d5fffdfcd 100644
--- a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
+++ b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
@@ -586,10 +586,10 @@ class NGMP_OnlineServicesManager
 	ServiceConfig& GetServiceConfig() { return m_ServiceConfig; }
 
 public:
-	void CacheScreenshotBytes_StartMatch(std::vector<uint8_t>& vecData)
+	void CacheScreenshotBytes_StartMatch(std::vector<uint8_t> vecData)
 	{
 		std::scoped_lock<std::mutex> ssLock(m_ScreenshotMutex);
-        m_vecCachedScreenshotBytes_MatchStart = vecData;
+        m_vecCachedScreenshotBytes_MatchStart = std::move(vecData);
 	}
 
 	void CacheScreenshotBytes_EndMatch(uint64_t matchID, std::vector<uint8_t> data);
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp
index a420a04cda6..9b6d94eca4c 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp
@@ -49,7 +49,7 @@ void HTTPManager::SendS3PUTRequest(const char* szURI, EIPProtocolVersion protove
 
     HTTPRequest* pRequest = PlatformCreateRequest(EHTTPVerb::HTTP_VERB_PUT, protover, szURI, inHeaders, completionCallback, progressCallback, timeoutMS);
 	pRequest->DisableServiceAuth();
-    pRequest->SetPostDataBuffer(vecBuffer);
+    pRequest->SetPostDataBuffer(std::move(vecBuffer));
 
     m_vecRequestsPendingStart.push_back(pRequest);
 }
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
index cfe0835efd4..951c40f6dd2 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
@@ -127,7 +127,7 @@ void NGMP_OnlineServicesManager::CaptureScreenshotForProbe(EScreenshotType scree
                         // certain screenshots require caching for later upload when we have a valid match id, so we store them
 						if (screenshotType == EScreenshotType::SCREENSHOT_TYPE_LOADSCREEN)
 						{
-							NGMP_OnlineServicesManager::GetInstance()->CacheScreenshotBytes_StartMatch(vecData);
+							NGMP_OnlineServicesManager::GetInstance()->CacheScreenshotBytes_StartMatch(std::move(vecData));
 						}
                         else if (screenshotType == EScreenshotType::SCREENSHOT_TYPE_SCORESCREEN)
                         {
@@ -143,7 +143,7 @@ void NGMP_OnlineServicesManager::CaptureScreenshotForProbe(EScreenshotType scree
                             newEntry.vecBytes = std::move(vecData);
                             newEntry.strSignedURI = strURI;
                             newEntry.screenshotType = screenshotType;
-                            m_vecGuardedSSData.push_back(newEntry);
+                            m_vecGuardedSSData.push_back(std::move(newEntry));
 						}
 					});
 			}
@@ -579,7 +579,6 @@ void NGMP_OnlineServicesManager::CaptureScreenshot(bool bResizeForTransmit, std:
 	}
 
 	SurfaceClass* surface = DX8Wrapper::_Get_DX8_Back_Buffer();
-	LPDIRECT3DSURFACE8 surf = nullptr;
 	SurfaceClass* surfaceCopy = nullptr;
 	void* pBits = nullptr;
 	IDirect3DSurface8* pDXsurf = nullptr;
@@ -599,119 +598,96 @@ void NGMP_OnlineServicesManager::CaptureScreenshot(bool bResizeForTransmit, std:
 			{
 				DX8Wrapper::_Copy_DX8_Rects(surface->Peek_D3D_Surface(), NULL, 0, surfaceCopy->Peek_D3D_Surface(), NULL);
 
-				HRESULT hr;
+				// gather all our data
+				int pitch = 0;
+				pBits = surfaceCopy->Lock(&pitch);
 
-				D3DDISPLAYMODE mode;
-				if (SUCCEEDED(hr = DX8Wrapper::_Get_D3D_Device8()->GetDisplayMode(&mode)))
+				if (pBits != nullptr)
 				{
-					if (SUCCEEDED(hr = DX8Wrapper::_Get_D3D_Device8()->CreateImageSurface(mode.Width, mode.Height,
-						D3DFMT_A8R8G8B8, &surf)))
-					{
-						if (SUCCEEDED(hr = DX8Wrapper::_Get_D3D_Device8()->GetFrontBuffer(surf)))
+					int width = surfaceDesc.Width;
+					int height = surfaceDesc.Height;
+
+					// Copy pixel data into an owned buffer before spawning the thread so
+					// the surface can be safely unlocked on the main thread immediately after.
+					const uint8_t* pSurfaceBytes = static_cast<const uint8_t*>(pBits);
+					std::vector<uint8_t> pixelData(pSurfaceBytes, pSurfaceBytes + height * pitch);
+
+					// process on thread - track the thread so we can join it during shutdown
+					std::thread* pNewThread = new std::thread([cbOnDataAvailable, width, height, pixelData = std::move(pixelData), pitch, bResizeForTransmit]() mutable
 						{
-							// gather all our data
-							int pitch = 0;
-							pBits = surfaceCopy->Lock(&pitch);
+							CHECK_WORKER_THREAD;
 
-							if (pBits != nullptr)
-							{
-								int width = surfaceDesc.Width;
-								int height = surfaceDesc.Height;
-
-								// Copy pixel data into an owned buffer before spawning the thread so
-								// the surface can be safely unlocked on the main thread immediately after.
-								std::vector<uint8_t> pixelData(height * pitch);
-								memcpy(pixelData.data(), pBits, height * pitch);
-
-								// process on thread - track the thread so we can join it during shutdown
-								std::thread* pNewThread = new std::thread([cbOnDataAvailable, width, height, pixelData = std::move(pixelData), pitch, bResizeForTransmit]()
-									{
-										CHECK_WORKER_THREAD;
-
-										unsigned char* rgbData = new unsigned char[width * height * 3];
-
-										std::vector<unsigned char> vecData;
-
-										int finalWidth = width;
-										int finalHeight = height;
-
-										for (int y = 0; y < height; ++y) {
-											const uint8_t* row = pixelData.data() + y * pitch;
-											int rowOffset = y * width * 3;
-											int srcOffset = 0;
-											for (int x = 0; x < width; ++x, srcOffset += 4)
-											{
-												int dstIndex = rowOffset + x * 3;
-												rgbData[dstIndex + 0] = row[srcOffset + 2]; // R
-												rgbData[dstIndex + 1] = row[srcOffset + 1]; // G
-												rgbData[dstIndex + 2] = row[srcOffset + 0]; // B
-											}
-										}
-
-										// resize
-										unsigned char* pBufferToWrite = rgbData;
-										if (bResizeForTransmit)
-										{
-											ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
-											int new_width = serviceConf.screenshot_width;
-											int new_height = serviceConf.screenshot_height;
-											int channels = 3;
-											unsigned char* resized = new unsigned char[new_width * new_height * channels];
-
-											stbir_resize_uint8(rgbData, width, height, 0,
-												resized, new_width, new_height, 0,
-												channels
-											);
-
-											// update data
-											finalWidth = new_width;
-											finalHeight = new_height;
-											pBufferToWrite = resized;
-										}
-										// end resize
-
-										stbi_write_jpg_to_func([](void* context, void* data, int size)
-											{
-												std::vector<unsigned char>* buffer = static_cast<std::vector<unsigned char>*>(context);
-												buffer->insert(buffer->end(), (unsigned char*)data, (unsigned char*)data + size);
-											}, &vecData, finalWidth, finalHeight, 3, pBufferToWrite, bResizeForTransmit ? 0 : 90);
-
-										// cleanup
-										if (bResizeForTransmit)
-										{
-											delete[] pBufferToWrite; // This is 'resized'
-											pBufferToWrite = nullptr;
-										}
-
-										delete[] rgbData;
-										rgbData = nullptr;
-
-										// invoke cb
-										if (cbOnDataAvailable != nullptr)
-										{
-											cbOnDataAvailable(vecData);
-										}
-									}
-								);
+							const int channels = 3;
+							int finalWidth = width;
+							int finalHeight = height;
 
-							// Store the thread so we can join it during shutdown
-							// SECURITY FIX: Capture manager pointer before spawning thread to avoid TOCTOU race
-							NGMP_OnlineServicesManager* pMgr = NGMP_OnlineServicesManager::GetInstance();
-							if (pMgr != nullptr)
+							// Pack the BGRA rows to tight RGB in place. The write position never passes the read position.
+							uint8_t* pixels = pixelData.data();
+							for (int y = 0; y < height; ++y)
 							{
-								std::scoped_lock<std::mutex> lock(pMgr->m_mutexScreenshotThreads);
-								pMgr->m_vecScreenshotThreads.push_back(pNewThread);
+								const uint8_t* src = pixels + y * pitch;
+								uint8_t* dst = pixels + y * width * channels;
+								for (int x = 0; x < width; ++x, src += 4, dst += channels)
+								{
+									const uint8_t blue = src[0];
+									dst[0] = src[2]; // R
+									dst[1] = src[1]; // G
+									dst[2] = blue;   // B
+								}
 							}
-							else
+
+							// resize
+							std::vector<uint8_t> resized;
+							if (bResizeForTransmit)
 							{
-								// Manager was destroyed, cannot store thread. Thread will leak but won't crash.
-								NetworkLog(ELogVerbosity::LOG_RELEASE, "[Screenshot] Manager destroyed before thread could be registered");
+								ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
+								finalWidth = serviceConf.screenshot_width;
+								finalHeight = serviceConf.screenshot_height;
+								resized.resize(finalWidth * finalHeight * channels);
+
+								stbir_resize_uint8(pixels, width, height, 0,
+									resized.data(), finalWidth, finalHeight, 0,
+									channels
+								);
+
+								// the capture is no longer needed
+								std::vector<uint8_t>().swap(pixelData);
 							}
+							// end resize
+
+							// room for a typical JPEG, so the write callback rarely has to grow it
+							std::vector<unsigned char> vecData;
+							vecData.reserve(256 * 1024);
+
+							stbi_write_jpg_to_func([](void* context, void* data, int size)
+								{
+									std::vector<unsigned char>* buffer = static_cast<std::vector<unsigned char>*>(context);
+									buffer->insert(buffer->end(), (unsigned char*)data, (unsigned char*)data + size);
+								}, &vecData, finalWidth, finalHeight, channels, bResizeForTransmit ? resized.data() : pixelData.data(), bResizeForTransmit ? 0 : 90);
 
-								bSucceeded = true;
+							// invoke cb
+							if (cbOnDataAvailable != nullptr)
+							{
+								cbOnDataAvailable(std::move(vecData));
 							}
 						}
+					);
+
+					// Store the thread so we can join it during shutdown
+					// SECURITY FIX: Capture manager pointer before spawning thread to avoid TOCTOU race
+					NGMP_OnlineServicesManager* pMgr = NGMP_OnlineServicesManager::GetInstance();
+					if (pMgr != nullptr)
+					{
+						std::scoped_lock<std::mutex> lock(pMgr->m_mutexScreenshotThreads);
+						pMgr->m_vecScreenshotThreads.push_back(pNewThread);
+					}
+					else
+					{
+						// Manager was destroyed, cannot store thread. Thread will leak but won't crash.
+						NetworkLog(ELogVerbosity::LOG_RELEASE, "[Screenshot] Manager destroyed before thread could be registered");
 					}
+
+					bSucceeded = true;
 				}
 			}
 		}
@@ -719,18 +695,9 @@ void NGMP_OnlineServicesManager::CaptureScreenshot(bool bResizeForTransmit, std:
 
 	// clean everything up, whether we succeeded or not
 
-	// release the image surface
-	if (surf != nullptr)
-	{
-		surf->Release();
-		//delete surf;
-		surf = nullptr;
-	}
-
 	// unlock
 	if (surface != nullptr)
 	{
-		surface->Unlock();
 		surface->Release_Ref();
  		surface = nullptr;
 	}
@@ -954,7 +921,7 @@ void NGMP_OnlineServicesManager::Tick()
 
 
 		// screenshot types that already have a presigned URL
-		for (S3ScreenshotEntry screenshotEntry : m_vecGuardedSSData)
+		for (S3ScreenshotEntry& screenshotEntry : m_vecGuardedSSData)
 		{
 			// NOTE: Screenshot types start and end of match are captures and cached in memory until the server tells us where to upload them, so we need to wait for the upload URI
 
@@ -966,7 +933,7 @@ void NGMP_OnlineServicesManager::Tick()
 			{
                 std::map<std::string, std::string> mapHeaders;
                 mapHeaders["Content-Type"] = "image/jpeg";
-                NGMP_OnlineServicesManager::GetInstance()->GetHTTPManager()->SendS3PUTRequest(screenshotEntry.strSignedURI.c_str(), EIPProtocolVersion::DONT_CARE, mapHeaders, screenshotEntry.vecBytes, [=](bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)
+                NGMP_OnlineServicesManager::GetInstance()->GetHTTPManager()->SendS3PUTRequest(screenshotEntry.strSignedURI.c_str(), EIPProtocolVersion::DONT_CARE, mapHeaders, std::move(screenshotEntry.vecBytes), [=](bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)
                     {
 #if _DEBUG
                         if (statusCode != 200)
@@ -990,9 +957,9 @@ void NGMP_OnlineServicesManager::Tick()
 				// queue it
 				S3ScreenshotEntry newEntry;
 				newEntry.screenshotType = EScreenshotType::SCREENSHOT_TYPE_LOADSCREEN;
-				newEntry.vecBytes = m_vecCachedScreenshotBytes_MatchStart;
-				newEntry.strSignedURI = m_strCachedScreenshot_MatchStart_S3URI;
-				m_vecGuardedSSData.push_back(newEntry);
+				newEntry.vecBytes = std::move(m_vecCachedScreenshotBytes_MatchStart);
+				newEntry.strSignedURI = std::move(m_strCachedScreenshot_MatchStart_S3URI);
+				m_vecGuardedSSData.push_back(std::move(newEntry));
 
 				// clear data
                 m_vecCachedScreenshotBytes_MatchStart = std::vector<uint8_t>();
@@ -1023,7 +990,7 @@ void NGMP_OnlineServicesManager::Tick()
 				// do the upload
                 std::map<std::string, std::string> mapHeaders;
                 mapHeaders["Content-Type"] = "application/octet-stream";
-                NGMP_OnlineServicesManager::GetInstance()->GetHTTPManager()->SendS3PUTRequest(m_cachedReplayUpload.signedURI.c_str(), EIPProtocolVersion::DONT_CARE, mapHeaders, m_cachedReplayUpload.bytes, [=](bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)
+                NGMP_OnlineServicesManager::GetInstance()->GetHTTPManager()->SendS3PUTRequest(m_cachedReplayUpload.signedURI.c_str(), EIPProtocolVersion::DONT_CARE, mapHeaders, std::move(m_cachedReplayUpload.bytes), [=](bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)
                     {
 #if _DEBUG
                         if (statusCode != 200)

From 4e21dabadfc6e22df9d19667e2bc7f9d05e22e6d Mon Sep 17 00:00:00 2001
From: tintinhamans <5984296+tintinhamans@users.noreply.github.com>
Date: Tue, 27 Oct 2026 14:32:41 +0100
Subject: [PATCH 2/3] perf(screenshot): Upload probe screenshots one slot at a
 time at a capped rate

---
 .../GeneralsOnline/HTTP/HTTPManager.h         |  2 +-
 .../GeneralsOnline/HTTP/HTTPRequest.h         |  7 +++
 .../GeneralsOnline/OnlineServices_Init.h      |  6 +-
 .../GeneralsOnline/HTTP/HTTPManager.cpp       |  3 +-
 .../GeneralsOnline/HTTP/HTTPRequest.cpp       |  5 ++
 .../GeneralsOnline/OnlineServices_Init.cpp    | 60 +++++++++++++++++--
 6 files changed, 74 insertions(+), 9 deletions(-)

diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPManager.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPManager.h
index 57a4c498928..d2d5c80f753 100644
--- a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPManager.h
+++ b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPManager.h
@@ -54,7 +54,7 @@ class HTTPManager
 	// NOTE: set bDisableServiceAuth for endpoints that must be called with something other than the session token (e.g. the refresh endpoint, which needs the refresh token), otherwise the session token overwrites any Authorization header passed in inHeaders
 	void SendPOSTRequest(const char* szURI, EIPProtocolVersion protover, std::map<std::string, std::string>& inHeaders, const char* szPostData, std::function<void(bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)> completionCallback, std::function<void(size_t bytesReceived)> progressCallback = nullptr, int timeoutMS = -1, bool bDisableServiceAuth = false);
 	void SendPUTRequest(const char* szURI, EIPProtocolVersion protover, std::map<std::string, std::string>& inHeaders, const char* szData, std::function<void(bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)> completionCallback, std::function<void(size_t bytesReceived)> progressCallback = nullptr, int timeoutMS = -1);
-	void SendS3PUTRequest(const char* szURI, EIPProtocolVersion protover, std::map<std::string, std::string>& inHeaders, std::vector<uint8_t> vecBuffer, std::function<void(bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)> completionCallback, std::function<void(size_t bytesReceived)> progressCallback = nullptr, int timeoutMS = -1);
+	void SendS3PUTRequest(const char* szURI, EIPProtocolVersion protover, std::map<std::string, std::string>& inHeaders, std::vector<uint8_t> vecBuffer, std::function<void(bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)> completionCallback, std::function<void(size_t bytesReceived)> progressCallback = nullptr, int timeoutMS = -1, int maxSendBytesPerSec = 0);
 	void SendDELETERequest(const char* szURI, EIPProtocolVersion protover, std::map<std::string, std::string>& inHeaders, const char* szData, std::function<void(bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)> completionCallback, std::function<void(size_t bytesReceived)> progressCallback = nullptr, int timeoutMS = -1);
 
 	void Shutdown();
diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.h
index f5b901aade5..7dbf977a136 100644
--- a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.h
+++ b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.h
@@ -36,6 +36,11 @@ class HTTPRequest
 		m_bAppendAuthIfPresent = false;
 	}
 
+	void SetMaxSendSpeed(int bytesPerSec)
+	{
+		m_maxSendBytesPerSec = bytesPerSec;
+	}
+
 	void OnResponsePartialWrite(std::uint8_t* pBuffer, size_t numBytes);
 
 	bool HasStarted() const { return m_bIsStarted; }
@@ -77,6 +82,8 @@ class HTTPRequest
 
 	bool m_bAppendAuthIfPresent = true;
 
+	int m_maxSendBytesPerSec = 0; // 0 = unlimited
+
 	EIPProtocolVersion m_protover;
 
 	int m_timeoutMS = 5000;
diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
index 27d5fffdfcd..2096e7b3623 100644
--- a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
+++ b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
@@ -4,6 +4,7 @@
 
 #include <thread>
 #include <memory>
+#include <chrono>
 
 class HTTPManager;
 
@@ -28,6 +29,7 @@ struct S3ScreenshotEntry
     std::vector<uint8_t> vecBytes;
     std::string strSignedURI;
 	EScreenshotType screenshotType;
+	std::chrono::steady_clock::time_point notBefore; // upload is held back until this time
 
     bool operator==(const S3ScreenshotEntry& other) const
 	{
@@ -341,6 +343,8 @@ struct ServiceConfig
 
 	int screenshot_width = 557;
 	int screenshot_height = 333;
+	int screenshot_upload_bytes_per_sec = 131072; // 128 KB/s
+	int screenshot_slot_offset_ms = 2000;
 
 	// ICE client used for P2P NAT traversal: 0 = library default, 1 = native, 2 = WebRTC.
 	int ice_implementation = 2;
@@ -351,7 +355,7 @@ struct ServiceConfig
 		ra_slack_percent, frame_grouping_frames, enable_host_migration, network_do_immediate_flush_per_frame, network_send_flags, network_latency_logic_model,
 		use_default_config, ra_slack_override_percent_in_default, do_probes, do_replay_upload, network_mesh_histogram_duration,
 		ibra_ra_tweaks, ibra_minslack_default, ibra_maxslack_default, ibra_minslack_greaterthan300ms, ibra_maxslack_greaterthan300ms, ibra_minslack_greaterthan200ms, ibra_maxslack_greaterthan200ms,
-		screenshot_width, screenshot_height, ice_implementation, use_new_networking)
+		screenshot_width, screenshot_height, screenshot_upload_bytes_per_sec, screenshot_slot_offset_ms, ice_implementation, use_new_networking)
 };
 
 class NGMP_OnlineServicesManager
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp
index 9b6d94eca4c..e476ced3bb7 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPManager.cpp
@@ -43,12 +43,13 @@ void HTTPManager::SendPUTRequest(const char* szURI, EIPProtocolVersion protover,
 }
 
 
-void HTTPManager::SendS3PUTRequest(const char* szURI, EIPProtocolVersion protover, std::map<std::string, std::string>& inHeaders, std::vector<uint8_t> vecBuffer, std::function<void(bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)> completionCallback, std::function<void(size_t bytesReceived)> progressCallback /*= nullptr*/, int timeoutMS /*= -1*/)
+void HTTPManager::SendS3PUTRequest(const char* szURI, EIPProtocolVersion protover, std::map<std::string, std::string>& inHeaders, std::vector<uint8_t> vecBuffer, std::function<void(bool bSuccess, int statusCode, std::string strBody, HTTPRequest* pReq)> completionCallback, std::function<void(size_t bytesReceived)> progressCallback /*= nullptr*/, int timeoutMS /*= -1*/, int maxSendBytesPerSec /*= 0*/)
 {
     CHECK_MAIN_THREAD;
 
     HTTPRequest* pRequest = PlatformCreateRequest(EHTTPVerb::HTTP_VERB_PUT, protover, szURI, inHeaders, completionCallback, progressCallback, timeoutMS);
 	pRequest->DisableServiceAuth();
+	pRequest->SetMaxSendSpeed(maxSendBytesPerSec);
     pRequest->SetPostDataBuffer(std::move(vecBuffer));
 
     m_vecRequestsPendingStart.push_back(pRequest);
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.cpp
index 02786d7f3d9..3c77e8f4039 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/HTTP/HTTPRequest.cpp
@@ -298,6 +298,11 @@ void HTTPRequest::PlatformStartRequest()
 			}
 		}
 
+		if (m_maxSendBytesPerSec > 0)
+		{
+			curl_easy_setopt(m_pCURL, CURLOPT_MAX_SEND_SPEED_LARGE, (curl_off_t)m_maxSendBytesPerSec);
+		}
+
 		// needed for PUT etc
 		if (m_httpVerb == EHTTPVerb::HTTP_VERB_PUT)
 		{
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
index 951c40f6dd2..b2fa378fdb1 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
@@ -23,7 +23,10 @@
 #include "GameNetwork/GeneralsOnline/Vendor/stb_image/stb_image_write.h"
 #include "GameNetwork/GeneralsOnline/Vendor/stb_image/stb_image_resize.h"
 #include "GameClient/GameText.h"
+#include "GameLogic/GameLogic.h"
 #include <unordered_set>
+#include <random>
+#include <algorithm>
 
 extern "C"
 {
@@ -99,6 +102,34 @@ void NGMP_OnlineServicesManager::GetAndParseServiceConfig(std::function<void(voi
 		});
 }
 
+// time this client may upload its screenshot, staggered by match slot so players do not saturate their links at once
+static std::chrono::steady_clock::time_point GetScreenshotUploadTime()
+{
+	int slotIndex = 0;
+
+	NGMP_OnlineServices_AuthInterface* pAuthInterface = NGMP_OnlineServicesManager::GetInterface<NGMP_OnlineServices_AuthInterface>();
+	NGMP_OnlineServices_LobbyInterface* pLobbyInterface = NGMP_OnlineServicesManager::GetInterface<NGMP_OnlineServices_LobbyInterface>();
+	if (pAuthInterface != nullptr && pLobbyInterface != nullptr)
+	{
+		const int64_t localUserID = pAuthInterface->GetUserID();
+		for (const LobbyMemberEntry& lobbyMember : pLobbyInterface->GetMembersListForCurrentRoom())
+		{
+			if (lobbyMember.user_id == localUserID)
+			{
+				slotIndex = lobbyMember.m_SlotIndex < MAX_SLOTS ? lobbyMember.m_SlotIndex : 0;
+				break;
+			}
+		}
+	}
+
+	const int slotOffsetMS = std::clamp(NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig().screenshot_slot_offset_ms, 0, 10000);
+
+	static thread_local std::mt19937 rng{ std::random_device{}() };
+	const int jitterMS = std::uniform_int_distribution<int>(0, 500)(rng);
+
+	return std::chrono::steady_clock::now() + std::chrono::milliseconds(slotIndex * slotOffsetMS + jitterMS);
+}
+
 void NGMP_OnlineServicesManager::CaptureScreenshotForProbe(EScreenshotType screenshotType, std::string strURI)
 {
 	NGMP_OnlineServicesManager* pOnlineServicesMgr = NGMP_OnlineServicesManager::GetInstance();
@@ -114,7 +145,8 @@ void NGMP_OnlineServicesManager::CaptureScreenshotForProbe(EScreenshotType scree
 			if (pLobbyInterface != nullptr)
 			{
 				const uint64_t matchID = pLobbyInterface->GetCurrentMatchID();
-				NGMP_OnlineServicesManager::GetInstance()->CaptureScreenshot(true, [strURI = std::move(strURI), screenshotType, matchID](std::vector<uint8_t> vecData)
+				const std::chrono::steady_clock::time_point uploadTime = GetScreenshotUploadTime();
+				NGMP_OnlineServicesManager::GetInstance()->CaptureScreenshot(true, [strURI = std::move(strURI), screenshotType, matchID, uploadTime](std::vector<uint8_t> vecData)
 					{
 						CHECK_WORKER_THREAD;
 
@@ -143,6 +175,7 @@ void NGMP_OnlineServicesManager::CaptureScreenshotForProbe(EScreenshotType scree
                             newEntry.vecBytes = std::move(vecData);
                             newEntry.strSignedURI = strURI;
                             newEntry.screenshotType = screenshotType;
+                            newEntry.notBefore = uploadTime;
                             m_vecGuardedSSData.push_back(std::move(newEntry));
 						}
 					});
@@ -920,13 +953,28 @@ void NGMP_OnlineServicesManager::Tick()
 		std::scoped_lock<std::mutex> ssLock(m_ScreenshotMutex);
 
 
+		const int uploadBytesPerSec = std::clamp(m_ServiceConfig.screenshot_upload_bytes_per_sec, 16384, 10485760);
+		const std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
+		const bool bMatchOver = TheGameLogic == nullptr || !TheGameLogic->isInMultiplayerGame(); // uploads no longer compete with game traffic
+
 		// screenshot types that already have a presigned URL
-		for (S3ScreenshotEntry& screenshotEntry : m_vecGuardedSSData)
+		for (auto it = m_vecGuardedSSData.begin(); it != m_vecGuardedSSData.end();)
 		{
+			S3ScreenshotEntry& screenshotEntry = *it;
+			const bool bUnthrottled = bMatchOver || screenshotEntry.screenshotType == EScreenshotType::SCREENSHOT_TYPE_SCORESCREEN;
+
+			// not this client's turn to upload yet
+			if (!bUnthrottled && screenshotEntry.notBefore > now)
+			{
+				++it;
+				continue;
+			}
+
 			// NOTE: Screenshot types start and end of match are captures and cached in memory until the server tells us where to upload them, so we need to wait for the upload URI
 
 			if ((screenshotEntry.screenshotType == EScreenshotType::SCREENSHOT_TYPE_LOADSCREEN || screenshotEntry.screenshotType == EScreenshotType::SCREENSHOT_TYPE_SCORESCREEN) && screenshotEntry.strSignedURI.empty())
 			{
+				it = m_vecGuardedSSData.erase(it);
 				continue;
 			}
 			else // we have the data we need, send away
@@ -942,12 +990,11 @@ void NGMP_OnlineServicesManager::Tick()
                         }
 #endif
                         NetworkLog(ELogVerbosity::LOG_RELEASE, "Screenshot upload, result: %d", statusCode);
-                    }, nullptr, HTTP_UPLOAD_TIMEOUT);
+                    }, nullptr, HTTP_UPLOAD_TIMEOUT, bUnthrottled ? 0 : uploadBytesPerSec);
 			}
-            
-		}
 
-		m_vecGuardedSSData.clear();
+			it = m_vecGuardedSSData.erase(it);
+		}
 
 		// screenshots and replays that are cached and awaiting S3 url, and now have said URL
 		if (!m_vecCachedScreenshotBytes_MatchStart.empty()) // we have data waiting
@@ -959,6 +1006,7 @@ void NGMP_OnlineServicesManager::Tick()
 				newEntry.screenshotType = EScreenshotType::SCREENSHOT_TYPE_LOADSCREEN;
 				newEntry.vecBytes = std::move(m_vecCachedScreenshotBytes_MatchStart);
 				newEntry.strSignedURI = std::move(m_strCachedScreenshot_MatchStart_S3URI);
+				newEntry.notBefore = GetScreenshotUploadTime();
 				m_vecGuardedSSData.push_back(std::move(newEntry));
 
 				// clear data

From 3580bf4bf28a4c404b26cefe46e634a79f7ddbe8 Mon Sep 17 00:00:00 2001
From: tintinhamans <5984296+tintinhamans@users.noreply.github.com>
Date: Thu, 22 Oct 2026 06:59:06 +0200
Subject: [PATCH 3/3] feat(network): Share the game network settings between
 LAN and online

---
 .../Include/GameNetwork/ConnectionManager.h   |   8 +
 .../Include/GameNetwork/FrameMetrics.h        |   3 +
 .../Include/GameNetwork/NetworkDefs.h         |   2 +-
 .../Include/GameNetwork/NetworkSettings.h     |  35 ++++
 .../Source/GameNetwork/Connection.cpp         |   2 +-
 .../Source/GameNetwork/ConnectionManager.cpp  |  29 ++-
 .../Source/GameNetwork/DisconnectManager.cpp  |   2 +-
 .../Source/GameNetwork/FrameMetrics.cpp       |  30 ++-
 .../GeneralsOnline/NextGenMP_defines.h        |   6 +-
 .../GeneralsOnline/OnlineServices_Init.h      | 190 ++++++++++++++----
 .../GUICallbacks/Menus/WOLGameSetupMenu.cpp   |   2 +-
 .../GameNetwork/GeneralsOnline/NGMPGame.cpp   |  34 +---
 .../GeneralsOnline/NetworkMesh.cpp            |  14 +-
 .../GeneralsOnline/OnlineServices_Init.cpp    |  12 +-
 .../GeneralsOnline/PluginInterfaces.cpp       |   2 +-
 15 files changed, 277 insertions(+), 94 deletions(-)
 create mode 100644 Core/GameEngine/Include/GameNetwork/NetworkSettings.h

diff --git a/Core/GameEngine/Include/GameNetwork/ConnectionManager.h b/Core/GameEngine/Include/GameNetwork/ConnectionManager.h
index 4e1693455b5..1b1d3e2731b 100644
--- a/Core/GameEngine/Include/GameNetwork/ConnectionManager.h
+++ b/Core/GameEngine/Include/GameNetwork/ConnectionManager.h
@@ -37,6 +37,9 @@
 #include "GameNetwork/FrameMetrics.h"
 #include "GameNetwork/NetworkDefs.h"
 #include "GameNetwork/DisconnectManager.h"
+#if defined(GENERALS_ONLINE)
+#include "GameNetwork/NetworkSettings.h"
+#endif
 
 class GameInfo;
 class NetCommandWrapperList;
@@ -56,6 +59,7 @@ class ConnectionManager
 	virtual void update(Bool isInGame);			///< Service the Connections being managed by this instance.
 
 #if defined(GENERALS_ONLINE)
+	const NetworkSettings &getNetworkSettings() const { return m_networkSettings; }
 	void SeedLatencyData(int highestLatency)
 	{
 		for (int i = 0; i < MAX_SLOTS; ++i) {
@@ -165,6 +169,10 @@ class ConnectionManager
 	Int getPingsReceived();
 
 private:
+#if defined(GENERALS_ONLINE)
+	NetworkSettings m_networkSettings;
+#endif
+
 	void doRelay();
 	void doKeepAlive();
 	void sendRemoteCommand(NetCommandRef *msg);
diff --git a/Core/GameEngine/Include/GameNetwork/FrameMetrics.h b/Core/GameEngine/Include/GameNetwork/FrameMetrics.h
index 13967e49164..fdf4edca419 100644
--- a/Core/GameEngine/Include/GameNetwork/FrameMetrics.h
+++ b/Core/GameEngine/Include/GameNetwork/FrameMetrics.h
@@ -59,6 +59,9 @@ class FrameMetrics {
 	Real *m_fpsList;								///< A record of how many game logic frames per second there were for the last 60 seconds.
 	time_t m_lastFpsTimeThing;																///< The time when the last fps entry started being recorded.
 	Int m_fpsListIndex;																				///< Index into the array of the current fps list entry being measured.
+#if defined(GENERALS_ONLINE)
+	UnsignedInt m_fpsListLength;																						///< Entries m_fpsList holds, the history length can change after construction.
+#endif
 	Real m_averageFps;																				///< The current average logic fps, computed just like m_averageLatency below but with the fps numbers.
 
 	// round trip time to packet router variables.
diff --git a/Core/GameEngine/Include/GameNetwork/NetworkDefs.h b/Core/GameEngine/Include/GameNetwork/NetworkDefs.h
index 6295493ea7d..330477fdcc5 100644
--- a/Core/GameEngine/Include/GameNetwork/NetworkDefs.h
+++ b/Core/GameEngine/Include/GameNetwork/NetworkDefs.h
@@ -38,7 +38,7 @@ static constexpr const Int MIN_LOGIC_FRAMES = 5;
 static constexpr const Int MAX_FRAMES_AHEAD = 128;
 
 #if defined(GENERALS_ONLINE)
-static Int MIN_RUNAHEAD = 6;
+extern Int MIN_RUNAHEAD;
 #else
 static constexpr const Int MIN_RUNAHEAD = 4;
 #endif
diff --git a/Core/GameEngine/Include/GameNetwork/NetworkSettings.h b/Core/GameEngine/Include/GameNetwork/NetworkSettings.h
new file mode 100644
index 00000000000..f09f5c1d644
--- /dev/null
+++ b/Core/GameEngine/Include/GameNetwork/NetworkSettings.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#if defined(GENERALS_ONLINE)
+
+#include <string>
+
+// Per-match game networking policy, independent of online-service lifetime.
+struct NetworkSettings
+{
+	struct Send
+	{
+		int frames_per_packet = 2;      // send interval in frames
+		bool flush_every_frame = true;  // flush GNS after each frame
+		int flags = -1;                 // GNS send flags tried after a failed reliable send, -1 = none
+	} send;
+	struct InputDelay
+	{
+		int min_frames = 4;
+		int decision_interval_ms = 5000;
+		int fps_history_samples = 30;   // per-second FPS samples averaged
+		int slack_percent = 30;         // percent added to the measured round trip, also sets the start run ahead and the rating
+
+		struct Formula
+		{
+			int latency_history_samples = 200; // in-band ping samples averaged
+		} formula;
+	} input_delay;
+
+	static NetworkSettings LocalDefaults()
+	{
+		return NetworkSettings();
+	}
+};
+
+#endif
diff --git a/Core/GameEngine/Source/GameNetwork/Connection.cpp b/Core/GameEngine/Source/GameNetwork/Connection.cpp
index 8ba8a3e2dcd..d81ede4a504 100644
--- a/Core/GameEngine/Source/GameNetwork/Connection.cpp
+++ b/Core/GameEngine/Source/GameNetwork/Connection.cpp
@@ -271,7 +271,7 @@ UnsignedInt Connection::doSend() {
 
 	if ((curtime - m_lastTimeSent) < m_frameGrouping) {
 //		DEBUG_LOG(("not sending packet, time = %d, m_lastFrameSent = %d, m_frameGrouping = %d", curtime, m_lastTimeSent, m_frameGrouping));
-		NetworkLog(ELogVerbosity::LOG_DEBUG, "not sending packet, time = %d, m_lastFrameSent = %d, m_frameGrouping = %d", curtime, m_lastTimeSent, m_frameGrouping);
+		NetworkLog(ELogVerbosity::LOG_DEBUG, "not sending packet, time = %I64d, m_lastFrameSent = %I64d, m_frameGrouping = %I64d", (Int64)curtime, (Int64)m_lastTimeSent, (Int64)m_frameGrouping);
 		return 0;
 	}
 
diff --git a/Core/GameEngine/Source/GameNetwork/ConnectionManager.cpp b/Core/GameEngine/Source/GameNetwork/ConnectionManager.cpp
index f347db5a83f..504fa1362c3 100644
--- a/Core/GameEngine/Source/GameNetwork/ConnectionManager.cpp
+++ b/Core/GameEngine/Source/GameNetwork/ConnectionManager.cpp
@@ -59,6 +59,10 @@
 #include "../NetworkMesh.h"
 #include "../ngmp_interfaces.h"
 
+#if defined(GENERALS_ONLINE)
+Int MIN_RUNAHEAD = 4;
+#endif
+
 static Bool hasValidTransferFileExtension(const AsciiString& filePath)
 {
 	static const char* const validExtensions[] = {
@@ -272,6 +276,23 @@ ConnectionManager::ConnectionManager()
  */
 void ConnectionManager::init()
 {
+#if defined(GENERALS_ONLINE)
+	m_networkSettings = NetworkSettings::LocalDefaults();
+	NGMP_OnlineServicesManager *services = NGMP_OnlineServicesManager::GetInstance();
+	if (TheLAN == nullptr && TheNGMPGame != nullptr && services != nullptr) {
+		const ServiceConfig &overrides = services->GetServiceConfig();
+		m_networkSettings.send = overrides.send;
+		m_networkSettings.input_delay = overrides.input_delay;
+	}
+	const NetworkSettings::InputDelay &runAhead = m_networkSettings.input_delay;
+	TheWritableGlobalData->m_networkFPSHistoryLength = (std::max)(1, runAhead.fps_history_samples);
+	TheWritableGlobalData->m_networkLatencyHistoryLength = (std::max)(1, runAhead.formula.latency_history_samples);
+	TheWritableGlobalData->m_networkRunAheadSlack = runAhead.slack_percent;
+	TheWritableGlobalData->m_networkRunAheadMetricsTime = runAhead.decision_interval_ms;
+	MIN_RUNAHEAD = runAhead.min_frames;
+	FRAME_GROUPING_CAP = (int)(m_networkSettings.send.frames_per_packet * (float)(1000.f / GENERALS_ONLINE_HIGH_FPS_LIMIT));
+#endif
+
 //	if (m_transport == nullptr) {
 //		m_transport = new Transport;
 //	}
@@ -389,10 +410,10 @@ void ConnectionManager::reset()
 #endif
 	m_packetRouterSlot = -1;
 
-	for (i = 0; i < TheGlobalData->m_networkFPSHistoryLength; ++i) {
+	for (i = 0; i < (UnsignedInt)MAX_SLOTS; ++i) {
 		m_fpsAverages[i] = -1;
 	}
-	for (i = 0; i < TheGlobalData->m_networkLatencyHistoryLength; ++i) {
+	for (i = 0; i < (UnsignedInt)MAX_SLOTS; ++i) {
 		m_latencyAverages[i] = 0.0;
 	}
 
@@ -1995,7 +2016,7 @@ void ConnectionManager::setFrameGrouping(time_t frameGrouping) {
 	// This is probably ok since the packet router should have the fastest connection of all
 	// the players in the game.
 
-	NetworkLog(ELogVerbosity::LOG_DEBUG, "ConnectionManager::setFrameGrouping Frame grouping is %d, is packet router %d", frameGrouping, m_localSlot == m_packetRouterSlot);
+	NetworkLog(ELogVerbosity::LOG_DEBUG, "ConnectionManager::setFrameGrouping Frame grouping is %I64d, is packet router %d", (Int64)frameGrouping, m_localSlot == m_packetRouterSlot);
 
 	if (m_localSlot == m_packetRouterSlot) {
 		frameGrouping = frameGrouping / 2;
@@ -2785,7 +2806,7 @@ void ConnectionManager::sendFrameDataToPlayer(UnsignedInt playerID, UnsignedInt
 }
 
 void ConnectionManager::sendSingleFrameToPlayer(UnsignedInt playerID, UnsignedInt frame) {
-	if ((TheGameLogic->getFrame() - FRAMES_TO_KEEP) > frame) {
+	if (frame + FRAMES_TO_KEEP < TheGameLogic->getFrame()) {
 		DEBUG_LOG_LEVEL(DEBUG_LEVEL_NET, ("ConnectionManager::sendSingleFrameToPlayer - player %d requested frame %d when we are on frame %d, this is too far in the past.", playerID, frame, TheGameLogic->getFrame()));
 		return;
 	}
diff --git a/Core/GameEngine/Source/GameNetwork/DisconnectManager.cpp b/Core/GameEngine/Source/GameNetwork/DisconnectManager.cpp
index 9d2f1b58574..a59a6fcbc7c 100644
--- a/Core/GameEngine/Source/GameNetwork/DisconnectManager.cpp
+++ b/Core/GameEngine/Source/GameNetwork/DisconnectManager.cpp
@@ -214,7 +214,7 @@ void DisconnectManager::updateDisconnectStatus(ConnectionManager *conMgr) {
 						m_haveNotifiedOtherPlayersOfCurrentFrame = TRUE;
 					}
 
-					DEBUG_LOG(("DisconnectManager::updateDisconnectStatus - curTime = %d, m_timeOfDisconnectScreenOn = %d, curTime - m_timeOfDisconnectScreenOn = %d", curTime, m_timeOfDisconnectScreenOn, curTime - m_timeOfDisconnectScreenOn));
+					DEBUG_LOG(("DisconnectManager::updateDisconnectStatus - curTime = %I64d, m_timeOfDisconnectScreenOn = %I64d, curTime - m_timeOfDisconnectScreenOn = %I64d", (Int64)curTime, (Int64)m_timeOfDisconnectScreenOn, (Int64)(curTime - m_timeOfDisconnectScreenOn)));
 
 					if (m_timeOfDisconnectScreenOn != 0) {
 						if ((curTime - m_timeOfDisconnectScreenOn) > TheGlobalData->m_networkDisconnectScreenNotifyTime) {
diff --git a/Core/GameEngine/Source/GameNetwork/FrameMetrics.cpp b/Core/GameEngine/Source/GameNetwork/FrameMetrics.cpp
index 0de0dd2096c..abc805ddb71 100644
--- a/Core/GameEngine/Source/GameNetwork/FrameMetrics.cpp
+++ b/Core/GameEngine/Source/GameNetwork/FrameMetrics.cpp
@@ -61,14 +61,17 @@ FrameMetrics::FrameMetrics()
 
 
 	m_fpsList = NEW Real[TheGlobalData->m_networkFPSHistoryLength];
+#if defined(GENERALS_ONLINE)
+	m_fpsListLength = TheGlobalData->m_networkFPSHistoryLength;
+#endif
 }
 
 FrameMetrics::~FrameMetrics() {
-	delete m_fpsList;
+	delete[] m_fpsList;
 	m_fpsList = NULL;
 
 #if !defined(USE_NEW_FRAMEMETRIC_LOGIC)
-    delete m_latencyList;
+    delete[] m_latencyList;
     m_latencyList = NULL;
 
     delete[] m_pendingLatencies;
@@ -115,6 +118,15 @@ void FrameMetrics::init() {
 #endif
 	m_minimumCushion = -1;
 
+#if defined(GENERALS_ONLINE)
+	// the game network settings can change the history length after construction
+	if (m_fpsListLength != TheGlobalData->m_networkFPSHistoryLength) {
+		delete[] m_fpsList;
+		m_fpsList = NEW Real[TheGlobalData->m_networkFPSHistoryLength];
+		m_fpsListLength = TheGlobalData->m_networkFPSHistoryLength;
+	}
+#endif
+
 	UnsignedInt i = 0;
 	for (; i < TheGlobalData->m_networkFPSHistoryLength; ++i) {
 #if defined(GENERALS_ONLINE_HIGH_FPS_SERVER)
@@ -228,8 +240,8 @@ void FrameMetrics::processLatencyResponse(UnsignedInt frame)
     {
         m_averageLatency += kvPaAir.second;
     }
-	NetworkLog(ELogVerbosity::LOG_DEBUG, "Avg latency is: %f / %d = %f", m_averageLatency, m_mapLatenciesLookup.size(), m_averageLatency /= m_mapLatenciesLookup.size());
     m_averageLatency /= m_mapLatenciesLookup.size();
+	NetworkLog(ELogVerbosity::LOG_DEBUG, "Avg latency is: %f over %d samples", m_averageLatency, (int)m_mapLatenciesLookup.size());
 
 
     if (timeDiff > 1000)
@@ -280,4 +292,16 @@ void FrameMetrics::SeedLatencyData(int latency)
 {
 	m_averageFps = GENERALS_ONLINE_HIGH_FPS_LIMIT;
 	m_averageLatency = latency / 1000.f;
+
+#if defined(USE_NEW_FRAMEMETRIC_LOGIC)
+	// the next response recomputes the average from these maps, so they must carry the seed too
+	for (std::unordered_map<UnsignedInt, Real>::iterator it = m_mapLatenciesLookup.begin(); it != m_mapLatenciesLookup.end(); ++it)
+	{
+		it->second = m_averageLatency;
+	}
+	for (std::map<UnsignedInt, Real>::iterator it = m_mapLatenciesSorted.begin(); it != m_mapLatenciesSorted.end(); ++it)
+	{
+		it->second = m_averageLatency;
+	}
+#endif
 }
diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/NextGenMP_defines.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/NextGenMP_defines.h
index b78109bc4c4..d7ac3365899 100644
--- a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/NextGenMP_defines.h
+++ b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/NextGenMP_defines.h
@@ -89,11 +89,7 @@ void showNotificationBox(AsciiString nick, UnicodeString message, bool bPlaySoun
 	#define GENERALS_ONLINE_HIGH_FPS_RENDER 1 // This is optional on 30fps, but will boost/unlock the framerate, similar to gentool
 #endif
 
-#if defined(GENERALS_ONLINE_HIGH_FPS_SERVER)
-static int FRAME_GROUPING_CAP = 32;
-#else
-static int FRAME_GROUPING_CAP = 64;
-#endif
+extern int FRAME_GROUPING_CAP;
 
 //#define GENERALS_ONLINE_ENABLE_CONTROVERSIAL_NON_RETAIL_CHANGES 1
 
diff --git a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
index 2096e7b3623..6b4169bb152 100644
--- a/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
+++ b/GeneralsMD/Code/GameEngine/Include/GameNetwork/GeneralsOnline/OnlineServices_Init.h
@@ -1,7 +1,10 @@
 #pragma once
 
+#include "GameNetwork/NetworkSettings.h"
 #include "NGMP_include.h"
 
+#include <algorithm>
+#include <stdexcept>
 #include <thread>
 #include <memory>
 #include <chrono>
@@ -310,53 +313,168 @@ struct RegionResponse
 
 struct ServiceConfig
 {
-	bool retry_signalling = false;
-	bool use_mapped_port = true;
-	int min_run_ahead_frames = 4;
-	int ra_update_frequency_frames = 10;
-	bool relay_all_traffic = false;
-	int ra_slack_percent = 20;
-	int frame_grouping_frames = 2;
-	bool enable_host_migration = true;
-
-	bool network_do_immediate_flush_per_frame = true;
-	int network_send_flags = -1;
-
-	int network_latency_logic_model = 0;
-
-	bool use_default_config = false;
-	int ra_slack_override_percent_in_default = 10;
-	bool do_probes = true;
-	bool do_replay_upload = true;
-
-	int network_mesh_histogram_duration = 20000;
-
+	// Peer connections: signalling, NAT traversal, and the per-connection ping history
+	struct Connection
+	{
+		bool relay_only = false;
+		int ice_engine = 2;             // ICE library: 0 = library default, 1 = native, 2 = WebRTC; the key also takes "default", "native" or "webrtc"
+		bool use_mapped_port = true;
+		bool retry_signalling = true;
+		bool anticheat_transport = false; // game traffic through the anticheat plugin's transport
+		int latency_history_ms = 20000;
+	} connection;
+
+	// Not read from the service: the live values
+	int network_latency_logic_model = 2;
 	bool ibra_ra_tweaks = false;
 	float ibra_minslack_default = 0.25f;
 	float ibra_maxslack_default = 1.f;
-
     float ibra_minslack_greaterthan300ms = 0.35f;
     float ibra_maxslack_greaterthan300ms = 1.f;
-
     float ibra_minslack_greaterthan200ms = 0.3f;
     float ibra_maxslack_greaterthan200ms = 1.f;
+	using Send = NetworkSettings::Send;
+	using InputDelay = NetworkSettings::InputDelay;
+	Send send;
+	InputDelay input_delay;
 
-	int screenshot_width = 557;
-	int screenshot_height = 333;
-	int screenshot_upload_bytes_per_sec = 131072; // 128 KB/s
-	int screenshot_slot_offset_ms = 2000;
+	struct Lobby
+	{
+		bool host_migration = false;
+	} lobby;
 
-	// ICE client used for P2P NAT traversal: 0 = library default, 1 = native, 2 = WebRTC.
-	int ice_implementation = 2;
+	struct Telemetry
+	{
+		bool screenshot_probes = true;
+		bool replay_upload = true;
+		int screenshot_width = 960;
+		int screenshot_height = 600;
+		int screenshot_upload_bytes_per_sec = 131072; // 128 KB/s
+		int screenshot_slot_offset_ms = 2000;
+	} telemetry;
+};
 
-	bool use_new_networking = false;
+// Reads key into value when present; a missing key keeps the default
+template <typename T>
+inline void ReadServiceConfigValue(const nlohmann::json& j, const char* key, T& value)
+{
+	if (!j.is_object())
+	{
+		throw std::invalid_argument("Service config sections must be objects");
+	}
+	const auto it = j.find(key);
+	if (it != j.end() && !it->is_null())
+	{
+		value = it->get<T>();
+	}
+}
 
-	NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(ServiceConfig, retry_signalling, use_mapped_port, min_run_ahead_frames, ra_update_frequency_frames, relay_all_traffic,
-		ra_slack_percent, frame_grouping_frames, enable_host_migration, network_do_immediate_flush_per_frame, network_send_flags, network_latency_logic_model,
-		use_default_config, ra_slack_override_percent_in_default, do_probes, do_replay_upload, network_mesh_histogram_duration,
-		ibra_ra_tweaks, ibra_minslack_default, ibra_maxslack_default, ibra_minslack_greaterthan300ms, ibra_maxslack_greaterthan300ms, ibra_minslack_greaterthan200ms, ibra_maxslack_greaterthan200ms,
-		screenshot_width, screenshot_height, screenshot_upload_bytes_per_sec, screenshot_slot_offset_ms, ice_implementation, use_new_networking)
-};
+// The ICE library by name or by number
+inline void ReadIceEngine(const nlohmann::json& j, int& value)
+{
+	if (!j.is_object())
+	{
+		throw std::invalid_argument("Service config sections must be objects");
+	}
+	const auto it = j.find("ice_engine");
+	if (it == j.end() || it->is_null())
+	{
+		return;
+	}
+	if (it->is_string())
+	{
+		const std::string name = it->get<std::string>();
+		if (name == "default")
+		{
+			value = 0;
+		}
+		else if (name == "native")
+		{
+			value = 1;
+		}
+		else if (name == "webrtc")
+		{
+			value = 2;
+		}
+		return;
+	}
+	value = it->get<int>();
+}
+
+// A key the service sets replaces the compiled default, a missing key keeps it
+inline void ReadServiceConfig(const nlohmann::json& j, ServiceConfig& c)
+{
+	if (j.contains("connection"))
+	{
+		const nlohmann::json& s = j["connection"];
+		ReadServiceConfigValue(s, "relay_only", c.connection.relay_only);
+		ReadIceEngine(s, c.connection.ice_engine);
+		ReadServiceConfigValue(s, "use_mapped_port", c.connection.use_mapped_port);
+		ReadServiceConfigValue(s, "retry_signalling", c.connection.retry_signalling);
+		ReadServiceConfigValue(s, "anticheat_transport", c.connection.anticheat_transport);
+		ReadServiceConfigValue(s, "latency_history_ms", c.connection.latency_history_ms);
+	}
+	if (j.contains("send"))
+	{
+		const nlohmann::json& s = j["send"];
+		ReadServiceConfigValue(s, "frames_per_packet", c.send.frames_per_packet);
+		ReadServiceConfigValue(s, "flush_every_frame", c.send.flush_every_frame);
+		ReadServiceConfigValue(s, "flags", c.send.flags);
+	}
+	if (j.contains("input_delay"))
+	{
+		const nlohmann::json& s = j["input_delay"];
+		ReadServiceConfigValue(s, "min_frames", c.input_delay.min_frames);
+		ReadServiceConfigValue(s, "decision_interval_ms", c.input_delay.decision_interval_ms);
+		ReadServiceConfigValue(s, "fps_history_samples", c.input_delay.fps_history_samples);
+		ReadServiceConfigValue(s, "slack_percent", c.input_delay.slack_percent);
+		if (s.contains("formula"))
+		{
+			const nlohmann::json& f = s["formula"];
+			ReadServiceConfigValue(f, "latency_history_samples", c.input_delay.formula.latency_history_samples);
+		}
+	}
+	if (j.contains("lobby"))
+	{
+		ReadServiceConfigValue(j["lobby"], "host_migration", c.lobby.host_migration);
+	}
+	if (j.contains("telemetry"))
+	{
+		const nlohmann::json& s = j["telemetry"];
+		ReadServiceConfigValue(s, "screenshot_probes", c.telemetry.screenshot_probes);
+		ReadServiceConfigValue(s, "replay_upload", c.telemetry.replay_upload);
+		ReadServiceConfigValue(s, "screenshot_width", c.telemetry.screenshot_width);
+		ReadServiceConfigValue(s, "screenshot_height", c.telemetry.screenshot_height);
+		ReadServiceConfigValue(s, "screenshot_upload_bytes_per_sec", c.telemetry.screenshot_upload_bytes_per_sec);
+		ReadServiceConfigValue(s, "screenshot_slot_offset_ms", c.telemetry.screenshot_slot_offset_ms);
+	}
+}
+
+// Keeps values from the service inside the ranges the game can run with
+inline void ClampServiceConfig(ServiceConfig& c)
+{
+	c.connection.latency_history_ms = std::clamp(c.connection.latency_history_ms, 1000, 120000);
+
+	c.input_delay.min_frames = std::clamp(c.input_delay.min_frames, 1, 64);
+	c.input_delay.slack_percent = std::clamp(c.input_delay.slack_percent, 0, 200);
+	c.input_delay.decision_interval_ms = std::clamp(c.input_delay.decision_interval_ms, 100, 60000);
+	c.input_delay.fps_history_samples = std::clamp(c.input_delay.fps_history_samples, 1, 128);
+	c.input_delay.formula.latency_history_samples = std::clamp(c.input_delay.formula.latency_history_samples, 128, 3600); // FrameMetrics drops pending acks when the window is smaller than the frames in flight
+	c.send.frames_per_packet = std::clamp(c.send.frames_per_packet, 1, 16);
+
+	c.telemetry.screenshot_width = std::clamp(c.telemetry.screenshot_width, 16, 4096);
+	c.telemetry.screenshot_height = std::clamp(c.telemetry.screenshot_height, 16, 4096);
+}
+
+inline void from_json(const nlohmann::json& j, ServiceConfig& c)
+{
+	if (!j.is_object())
+	{
+		throw std::invalid_argument("Service config must be an object");
+	}
+	ReadServiceConfig(j, c);
+	ClampServiceConfig(c);
+}
 
 class NGMP_OnlineServicesManager
 {
diff --git a/GeneralsMD/Code/GameEngine/Source/GameClient/GUI/GUICallbacks/Menus/WOLGameSetupMenu.cpp b/GeneralsMD/Code/GameEngine/Source/GameClient/GUI/GUICallbacks/Menus/WOLGameSetupMenu.cpp
index d8c0b2c2eba..739367b2894 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameClient/GUI/GUICallbacks/Menus/WOLGameSetupMenu.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameClient/GUI/GUICallbacks/Menus/WOLGameSetupMenu.cpp
@@ -2510,7 +2510,7 @@ void WOLGameSetupMenuUpdate( WindowLayout * layout, void *userData)
 		if (pLobbyInterface != nullptr)
 		{
 			ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
-			bool bHostMigrationEnabledOnService = serviceConf.enable_host_migration;
+			bool bHostMigrationEnabledOnService = serviceConf.lobby.host_migration;
 
 			if (bHostMigrationEnabledOnService)
 			{
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NGMPGame.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NGMPGame.cpp
index 62f7b703cba..490bfcf0e33 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NGMPGame.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NGMPGame.cpp
@@ -13,6 +13,12 @@
 #include "GameClient/View.h"
 #include "../NextGenMP_defines.h"
 
+#if defined(GENERALS_ONLINE_HIGH_FPS_SERVER)
+int FRAME_GROUPING_CAP = 32;
+#else
+int FRAME_GROUPING_CAP = 64;
+#endif
+
 NGMPGameSlot::NGMPGameSlot()
 {
 	GameSlot();
@@ -411,34 +417,6 @@ void NGMPGame::launchGame(void)
 	//TheWritableGlobalData->m_networkPlayerTimeoutTime = 60000;
 	//TheWritableGlobalData->m_networkDisconnectScreenNotifyTime = 2500;
 
-	// process service config
-	NGMP_OnlineServicesManager* pOnlineServicesMgr = NGMP_OnlineServicesManager::GetInstance();
-	if (pOnlineServicesMgr != nullptr)
-	{
-		ServiceConfig& serviceConf = pOnlineServicesMgr->GetServiceConfig();
-
-		if (serviceConf.use_default_config)
-		{
-			TheWritableGlobalData->m_networkFPSHistoryLength = 30;
-			TheWritableGlobalData->m_networkLatencyHistoryLength = 200;
-			TheWritableGlobalData->m_networkRunAheadSlack = serviceConf.ra_slack_override_percent_in_default; // normally 10
-			TheWritableGlobalData->m_networkRunAheadMetricsTime = 5000;
-		}
-		else
-		{
-			TheWritableGlobalData->m_networkFPSHistoryLength = 10;
-			TheWritableGlobalData->m_networkLatencyHistoryLength = 10;
-
-			MIN_RUNAHEAD = serviceConf.min_run_ahead_frames;
-
-			TheWritableGlobalData->m_networkRunAheadSlack = serviceConf.ra_slack_percent;
-			TheWritableGlobalData->m_networkRunAheadMetricsTime = serviceConf.ra_update_frequency_frames * (float)(1000.f / GENERALS_ONLINE_HIGH_FPS_LIMIT);
-
-			FRAME_GROUPING_CAP = serviceConf.frame_grouping_frames * (float)(1000.f / GENERALS_ONLINE_HIGH_FPS_LIMIT);
-		}
-	}
-	
-
 #if defined(GENERALS_ONLINE_HIGH_FPS_RENDER)
 	TheWritableGlobalData->m_horizontalScrollSpeedFactor = NGMP_OnlineServicesManager::Settings.Camera_MoveSpeedRatio();
 	TheWritableGlobalData->m_verticalScrollSpeedFactor = NGMP_OnlineServicesManager::Settings.Camera_MoveSpeedRatio();
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NetworkMesh.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NetworkMesh.cpp
index 5957924e4c2..94cbb787e1e 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NetworkMesh.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/NetworkMesh.cpp
@@ -114,7 +114,7 @@ void OnSteamNetConnectionStatusChanged(SteamNetConnectionStatusChangedCallback_t
 			const bool bPeerLeft = pJoinOrderLobby != nullptr && pJoinOrderLobby->IsJoinOrderKnown() && !pJoinOrderLobby->IsLobbyMember(userID);
 			// a match can't leave its lobby, so keep repairing the link until the service drops the player
 			const bool bInMatch = TheGameLogic != nullptr && TheGameLogic->isInInternetGame();
-			bool bShouldRetry = serviceConf.retry_signalling && ((bInMatch && !bPeerLeft) || (!bWeJoinedLater && !bPeerLeft) || signallingAttemptsBeforeDisconnect < numSignallingAttempts);
+			bool bShouldRetry = serviceConf.connection.retry_signalling && ((bInMatch && !bPeerLeft) || (!bWeJoinedLater && !bPeerLeft) || signallingAttemptsBeforeDisconnect < numSignallingAttempts);
 
 			bool bWasError = pInfo->m_info.m_eState == k_ESteamNetworkingConnectionState_ProblemDetectedLocally || pInfo->m_info.m_eEndReason != k_ESteamNetConnectionEnd_App_Generic;
 			plrConnection.SetDisconnected(bWasError, pMesh, bShouldRetry && bWasError);
@@ -716,12 +716,12 @@ NetworkMesh::NetworkMesh()
 	m_strTurnTokenString = std::format("{},{}", m_strTurnToken.c_str(), m_strTurnToken.c_str());
 
 	ServiceConfig& serviceConf = pOnlineServicesMgr->GetServiceConfig();
-	m_iceEnable = (g_bForceRelay || serviceConf.relay_all_traffic)
+	m_iceEnable = (g_bForceRelay || serviceConf.connection.relay_only)
 		? k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Relay
 		: k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_All;
 
 	// 0 = library default, 1 = native, 2 = WebRTC
-	m_iceImplementation = (serviceConf.ice_implementation >= 0 && serviceConf.ice_implementation <= 2) ? serviceConf.ice_implementation : 2;
+	m_iceImplementation = (serviceConf.connection.ice_engine >= 0 && serviceConf.connection.ice_engine <= 2) ? serviceConf.connection.ice_engine : 2;
 	NetworkLog(ELogVerbosity::LOG_RELEASE, "NetworkMesh: using ICE implementation %d (0=default, 1=native, 2=WebRTC)", m_iceImplementation);
 
 	m_pSignaling = new CSignalingClient(SteamNetworkingSockets());
@@ -772,7 +772,7 @@ NetworkMesh::NetworkMesh()
 void NetworkMesh::Flush()
 {
 	ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
-	bool bDoImmediateFlushPerFrame = serviceConf.network_do_immediate_flush_per_frame;
+	bool bDoImmediateFlushPerFrame = serviceConf.send.flush_every_frame;
 
 	if (bDoImmediateFlushPerFrame)
 	{
@@ -952,7 +952,7 @@ void NetworkMesh::StartConnectionSignalling(const char* szMiddlewareID, int64_t
 
         int g_nLocalPort = 0;
 
-        int g_nVirtualPortRemote = serviceConf.use_mapped_port ? preferredPort : 0;
+        int g_nVirtualPortRemote = serviceConf.connection.use_mapped_port ? preferredPort : 0;
 
         // Our remote and local port don't match, so we need to set it explicitly
         if (g_nVirtualPortRemote != g_nLocalPort)
@@ -1336,7 +1336,7 @@ int PlayerConnection::SendGamePacket(void* pBuffer, uint32_t totalDataSize)
 		int sendFlags = k_nSteamNetworkingSend_Reliable | k_nSteamNetworkingSend_AutoRestartBrokenSession; // default from last patch
 
 		ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
-		int netSendFlags = serviceConf.network_send_flags;
+		int netSendFlags = serviceConf.send.flags;
 
 		NetworkLog(ELogVerbosity::LOG_DEBUG, "[GAME PACKET] Sending msg of size %ld to user %lld\n", totalDataSize, m_userID);
 		EResult r = SteamNetworkingSockets()->SendMessageToConnection(
@@ -1424,7 +1424,7 @@ void PlayerConnection::UpdateLatencyHistogram()
 	if (NGMP_OnlineServicesManager::GetInstance() != nullptr)
 	{
 		ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
-		histogram_duration = serviceConf.network_mesh_histogram_duration;
+		histogram_duration = serviceConf.connection.latency_history_ms;
 	}
 
 
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
index b2fa378fdb1..46a35dfed6f 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/OnlineServices_Init.cpp
@@ -122,7 +122,7 @@ static std::chrono::steady_clock::time_point GetScreenshotUploadTime()
 		}
 	}
 
-	const int slotOffsetMS = std::clamp(NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig().screenshot_slot_offset_ms, 0, 10000);
+	const int slotOffsetMS = std::clamp(NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig().telemetry.screenshot_slot_offset_ms, 0, 10000);
 
 	static thread_local std::mt19937 rng{ std::random_device{}() };
 	const int jitterMS = std::uniform_int_distribution<int>(0, 500)(rng);
@@ -137,7 +137,7 @@ void NGMP_OnlineServicesManager::CaptureScreenshotForProbe(EScreenshotType scree
 	{
 		ServiceConfig& serviceConf = pOnlineServicesMgr->GetServiceConfig();
 
-		if (serviceConf.do_probes)
+		if (serviceConf.telemetry.screenshot_probes)
 		{
 			CHECK_MAIN_THREAD;
 
@@ -275,7 +275,7 @@ void NGMP_OnlineServicesManager::CommitReplay(AsciiString absoluteReplayPath)
 	{
 		ServiceConfig& serviceConf = pOnlineServicesMgr->GetServiceConfig();
 
-		if (serviceConf.do_replay_upload)
+		if (serviceConf.telemetry.replay_upload)
 		{
 			NGMP_OnlineServices_LobbyInterface* pLobbyInterface = NGMP_OnlineServicesManager::GetInterface<NGMP_OnlineServices_LobbyInterface>();
 			const uint64_t matchID = pLobbyInterface == nullptr ? 0 : pLobbyInterface->GetCurrentMatchID();
@@ -674,8 +674,8 @@ void NGMP_OnlineServicesManager::CaptureScreenshot(bool bResizeForTransmit, std:
 							if (bResizeForTransmit)
 							{
 								ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
-								finalWidth = serviceConf.screenshot_width;
-								finalHeight = serviceConf.screenshot_height;
+								finalWidth = serviceConf.telemetry.screenshot_width;
+								finalHeight = serviceConf.telemetry.screenshot_height;
 								resized.resize(finalWidth * finalHeight * channels);
 
 								stbir_resize_uint8(pixels, width, height, 0,
@@ -953,7 +953,7 @@ void NGMP_OnlineServicesManager::Tick()
 		std::scoped_lock<std::mutex> ssLock(m_ScreenshotMutex);
 
 
-		const int uploadBytesPerSec = std::clamp(m_ServiceConfig.screenshot_upload_bytes_per_sec, 16384, 10485760);
+		const int uploadBytesPerSec = std::clamp(m_ServiceConfig.telemetry.screenshot_upload_bytes_per_sec, 16384, 10485760);
 		const std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
 		const bool bMatchOver = TheGameLogic == nullptr || !TheGameLogic->isInMultiplayerGame(); // uploads no longer compete with game traffic
 
diff --git a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/PluginInterfaces.cpp b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/PluginInterfaces.cpp
index 7d60712e8cc..c62f5f7fcf9 100644
--- a/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/PluginInterfaces.cpp
+++ b/GeneralsMD/Code/GameEngine/Source/GameNetwork/GeneralsOnline/PluginInterfaces.cpp
@@ -507,7 +507,7 @@ bool AnticheatPlugInterface::DoesACPluginProvideSecureGameTransport()
 {
 #if defined(AC_ENABLED)
     ServiceConfig& serviceConf = NGMP_OnlineServicesManager::GetInstance()->GetServiceConfig();
-    const bool bEnabledByConfig = serviceConf.use_new_networking;
+    const bool bEnabledByConfig = serviceConf.connection.anticheat_transport;
 
     // The plugin makes this same decision internally in places the game cannot
     // reach - notably inside the EOS anti-cheat OnMessageToPeer callback, which