reenable improved reconnecting

rts/Game/Game.cpp

@@ -139,6 +139,7 @@
 #include "System/Exceptions.h"
 #include "System/Sync/FPUCheck.h"
 #include "System/GlobalConfig.h"
+#include "System/myMath.h"
 #include "System/NetProtocol.h"
 #include "System/SpringApp.h"
 #include "System/Util.h"
@@ -919,7 +920,6 @@ bool CGame::UpdateUnsynced()
 
 	// Update simFPS
 	{
-		const bool newSimFrame_ = (lastSimFrame != gs->frameNum);
 		static int lsf = gs->frameNum;
 		static spring_time lsft = currentTime;
 		const float diffsecs_ = spring_diffsecs(currentTime, lsft);
@@ -1296,6 +1296,8 @@ bool CGame::Draw() {
 
 	CTeamHighlight::Disable();
 
+	gu->avgDrawFrameTime = mix(gu->avgDrawFrameTime, float(spring_tomsecs(spring_gettime() - currentTime)), 0.1f);
+
 	return true;
 }
 
@@ -1500,6 +1502,8 @@ void CGame::SimFrame() {
 
 	DumpState(-1, -1, 1);
 
+	gu->avgSimFrameTime = mix(gu->avgSimFrameTime, float(spring_tomsecs(spring_gettime() - lastFrameTime)), 0.1f);
+
 	LEAVE_SYNCED_CODE();
 }
 

rts/Game/GlobalUnsynced.cpp

@@ -54,6 +54,9 @@ CGlobalUnsynced::CGlobalUnsynced()
 
 	simFPS = 0.0f;
 
+	avgSimFrameTime = 0.0f;
+	avgDrawFrameTime = 0.0f;
+
 	modGameTime = 0;
 	gameTime = 0;
 	startTime = 0;

rts/Game/GlobalUnsynced.h

@@ -45,11 +45,11 @@ class CGlobalUnsynced {
 	 * for simulation is minimum spend for
 	 * drawing.
 	 * This is important when reconnecting,
-	 * i.e. it means that 20% of the total
-	 * cpu time is spend for drawing and 80%
+	 * i.e. it means that 15% of the total
+	 * cpu time is spend for drawing and 85%
 	 * for reconnecting/simulation.
 	 */
-	static const float simDrawBalance = 0.2f;
+	static const float reconnectSimDrawBalance = 0.15f;
 
 	/**
 	 * @brief simulation frames per second
@@ -60,6 +60,12 @@ class CGlobalUnsynced {
 	 */
 	float simFPS;
 
+	/**
+	 * @brief average frame time (in ms)
+	 */
+	float avgSimFrameTime;
+	float avgDrawFrameTime;
+
 	/**
 	 * @brief mod game time
 	 *

rts/Game/NetCommands.cpp

@@ -109,17 +109,17 @@ void CGame::ClientReadNet()
 
 	// balance the time spend in simulation & drawing (esp. when reconnecting)
 	// always render at least 2FPS (will otherwise be highly unresponsive when catching up after a reconnection)
-	//const float curSimFPS = gs->userSpeedFactor * GAME_SPEED; FIXME this returns incorrect data when reconnecting
-	//const float msPerDrawFrame = 1000.0f * profiler.GetPercent("GameController::Draw") / std::max(1.0f, globalRendering->FPS); FIXME this returns incorrect data when reconnecting (>60ms per frame during reconnect, and <6ms normally)
-	//const float msPerSimFrame = 1000.0f * profiler.GetPercent("Game::SimFrame") / std::max(1.0f, curSimFPS);
-	//const float wantedDrawFPS = (msPerSimFrame * gu->simDrawBalance) / std::max(1.0f, msPerDrawFrame);
-	//const float wantedFPS = std::max(float(gu->minFPS), wantedDrawFPS);
-	const float wantedFPS = gu->minFPS;
+	// else use the following algo: i.e. with gu->reconnectSimDrawBalance = 0.2f
+	//  -> try to spend minimum 20% of the time in drawing
+	//  -> use remaining 80% for reconnecting
+	const float maxSimFPS  = (1.0f - gu->reconnectSimDrawBalance) * 1000.0f / std::max(0.01f, gu->avgSimFrameTime);
+	const float minDrawFPS =         gu->reconnectSimDrawBalance  * 1000.0f / std::max(0.01f, gu->avgDrawFrameTime);
+	const float drawMinimumEachMS = std::min(1000.0f / gu->minFPS, (maxSimFPS / minDrawFPS) * gu->avgSimFrameTime);
 
 	// really process the messages
 	while (
 		timeLeft > 0.0f // smooths simframes across the full second
-		&& spring_tomsecs(spring_gettime() - procstarttime) < (1000.0f / wantedFPS) // balance the time spend in sim & drawing
+		&& spring_tomsecs(spring_gettime() - procstarttime) < drawMinimumEachMS // balance the time spend in sim & drawing
 		&& (packet = net->GetData(gs->frameNum)) // get netpacket from the stack
 	){
 		const unsigned char* inbuf = packet->data;