Merge pull request #528 from cortex-command-community/NetworkInputLagFix

Fix Server Input lag

Author: garethyr

Main.cpp

@@ -255,17 +255,15 @@ namespace RTE {
 		while (!System::IsSetToQuit()) {
 			bool serverUpdated = false;
 			updateStartTime = g_TimerMan.GetAbsoluteTime();
+			PollSDLEvents();
+			g_WindowMan.Update();
 
 			g_TimerMan.Update();
 
 			// Simulation update, as many times as the fixed update step allows in the span since last frame draw.
 			while (g_TimerMan.TimeForSimUpdate()) {
 				serverUpdated = false;
 
-				PollSDLEvents();
-
-				g_WindowMan.Update();
-
 				g_PerformanceMan.NewPerformanceSample();
 				g_PerformanceMan.UpdateMSPSU();
 				g_TimerMan.UpdateSim();
@@ -378,6 +376,10 @@ int main(int argc, char **argv) {
 
 	HandleMainArgs(argc, argv);
 
+	if (g_NetworkServer.IsServerModeEnabled()) {
+		SDL_ShowCursor(SDL_ENABLE);
+	}
+
 	g_PresetMan.LoadAllDataModules();
 
 	if (!System::IsInExternalModuleValidationMode()) {

Managers/NetworkClient.cpp

@@ -228,17 +228,10 @@ namespace RTE {
 		msg.MouseY = static_cast<int>(mouse.GetY());
 
 		// Those are update in Update every frame to catch short events like clicks and releases
-		msg.MouseButtonPressed[MOUSE_LEFT] = m_MouseButtonPressedState[MOUSE_LEFT] == 1 ? true : false;
-		msg.MouseButtonPressed[MOUSE_MIDDLE] = m_MouseButtonPressedState[MOUSE_MIDDLE] == 1 ? true : false;
-		msg.MouseButtonPressed[MOUSE_RIGHT] = m_MouseButtonPressedState[MOUSE_RIGHT] == 1 ? true : false;
 
-		msg.MouseButtonReleased[MOUSE_LEFT] = m_MouseButtonReleasedState[MOUSE_LEFT] == 1 ? true : false;
-		msg.MouseButtonReleased[MOUSE_MIDDLE] = m_MouseButtonReleasedState[MOUSE_MIDDLE] == 1 ? true : false;
-		msg.MouseButtonReleased[MOUSE_RIGHT] = m_MouseButtonReleasedState[MOUSE_RIGHT] == 1 ? true : false;
-
-		msg.MouseButtonHeld[MOUSE_LEFT] = g_UInputMan.MouseButtonHeld(MOUSE_LEFT, -1);
-		msg.MouseButtonHeld[MOUSE_MIDDLE] = g_UInputMan.MouseButtonHeld(MOUSE_MIDDLE, -1);
-		msg.MouseButtonHeld[MOUSE_RIGHT] = g_UInputMan.MouseButtonHeld(MOUSE_RIGHT, -1);
+		msg.MouseButtonState[MOUSE_LEFT] = g_UInputMan.MouseButtonHeld(MOUSE_LEFT, -1);
+		msg.MouseButtonState[MOUSE_MIDDLE] = g_UInputMan.MouseButtonHeld(MOUSE_MIDDLE, -1);
+		msg.MouseButtonState[MOUSE_RIGHT] = g_UInputMan.MouseButtonHeld(MOUSE_RIGHT, -1);
 
 		for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) {
 			m_MouseButtonPressedState[i] = -1;
@@ -251,20 +244,16 @@ namespace RTE {
 			msg.MouseWheelMoved = 0;
 		}
 
-		msg.InputElementHeld = 0;
-		msg.InputElementPressed = 0;
-		msg.InputElementReleased = 0;
+		msg.InputElementState = 0;
 
-		msg.ResetActivityVote = g_UInputMan.KeyHeld(KEY_BACKSPACE) ? true : false;
-		msg.RestartActivityVote = g_UInputMan.KeyHeld(KEY_BACKSLASH) ? true : false;
+		msg.ResetActivityVote = g_UInputMan.KeyHeld(SDLK_BACKSPACE) ? true : false;
+		msg.RestartActivityVote = g_UInputMan.KeyHeld(SDLK_BACKSLASH) ? true : false;
 
 		unsigned int bitMask = 0x1;
 
 		// Store element states as bit flags
 		for (int i = 0; i < INPUT_COUNT; i++) {
-			if (g_UInputMan.ElementHeld(0, i)) { msg.InputElementHeld = msg.InputElementHeld | bitMask; }
-			if (g_UInputMan.NetworkAccumulatedElementPressed(i)) { msg.InputElementPressed = msg.InputElementPressed | bitMask; }
-			if (g_UInputMan.NetworkAccumulatedElementReleased(i)) { msg.InputElementReleased = msg.InputElementReleased | bitMask; }
+			if (g_UInputMan.ElementHeld(0, i)) { msg.InputElementState = msg.InputElementState | bitMask; }
 
 			bitMask <<= 1;
 		}

Managers/NetworkClient.h

@@ -191,8 +191,8 @@ namespace RTE {
 		int m_SceneWidth; //!<
 		int m_SceneHeight; //!<
 
-		int m_MouseButtonPressedState[3]; //!<
-		int m_MouseButtonReleasedState[3]; //!<
+		int m_MouseButtonPressedState[MAX_MOUSE_BUTTONS]; //!<
+		int m_MouseButtonReleasedState[MAX_MOUSE_BUTTONS]; //!<
 		int m_MouseWheelMoved; //!< Whether the mouse wheel was moved this Update. Used to make mouse wheel detection better.
 
 	private:

Managers/NetworkServer.cpp

@@ -500,18 +500,14 @@ namespace RTE {
 			msg.MouseX = m->MouseX;
 			msg.MouseY = m->MouseY;
 			for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) {
-				msg.MouseButtonPressed[i] = m->MouseButtonPressed[i];
-				msg.MouseButtonReleased[i] = m->MouseButtonReleased[i];
-				msg.MouseButtonHeld[i] = m->MouseButtonHeld[i];
+				msg.MouseButtonState[i] = m->MouseButtonState[i];
 			}
 			msg.ResetActivityVote = m->ResetActivityVote;
 			msg.RestartActivityVote = m->RestartActivityVote;
 
 			msg.MouseWheelMoved = m->MouseWheelMoved;
 
-			msg.InputElementPressed = m->InputElementPressed;
-			msg.InputElementReleased = m->InputElementReleased;
-			msg.InputElementHeld = m->InputElementHeld;
+			msg.InputElementState = m->InputElementState;
 
 			bool skip = true;
 
@@ -522,23 +518,19 @@ namespace RTE {
 				if (msg.MouseY != lastmsg.MouseY) { skip = false; }
 
 				for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) {
-					if (msg.MouseButtonPressed[i] != lastmsg.MouseButtonPressed[i]) { skip = false; }
-					if (msg.MouseButtonReleased[i] != lastmsg.MouseButtonReleased[i]) { skip = false; }
-					if (msg.MouseButtonHeld[i] != lastmsg.MouseButtonHeld[i]) { skip = false; }
+					if (msg.MouseButtonState[i] != lastmsg.MouseButtonState[i]) { skip = false; }
 				}
 				if (msg.ResetActivityVote != lastmsg.ResetActivityVote) { skip = false; }
 				if (msg.RestartActivityVote != lastmsg.RestartActivityVote) { skip = false; }
 
 				if (msg.MouseWheelMoved != lastmsg.MouseWheelMoved) { skip = false; }
 
-				if (msg.InputElementPressed != lastmsg.InputElementPressed) { skip = false; }
-				if (msg.InputElementReleased != lastmsg.InputElementReleased) { skip = false; }
-				if (msg.InputElementHeld != lastmsg.InputElementHeld) { skip = false; }
+				if (msg.InputElementState != lastmsg.InputElementState) { skip = false; }
 			} else {
 				skip = false;
 			}
 
-			if (!skip) { m_InputMessages[player].push(msg); }
+			if (!skip) { m_InputMessages[player].push_back(msg); }
 		}
 	}
 
@@ -551,19 +543,13 @@ namespace RTE {
 			input.m_Y = msg.MouseY;
 			g_UInputMan.SetNetworkMouseMovement(player, input);
 
-			g_UInputMan.SetNetworkMouseButtonHeldState(player, MOUSE_LEFT, msg.MouseButtonHeld[MOUSE_LEFT]);
-			g_UInputMan.SetNetworkMouseButtonPressedState(player, MOUSE_LEFT, msg.MouseButtonPressed[MOUSE_LEFT]);
-			g_UInputMan.SetNetworkMouseButtonReleasedState(player, MOUSE_LEFT, msg.MouseButtonReleased[MOUSE_LEFT]);
+			g_UInputMan.SetNetworkMouseButtonHeldState(player, MOUSE_LEFT, msg.MouseButtonState[MOUSE_LEFT]);
 
-			m_MouseState1[player] = (msg.MouseButtonPressed[MOUSE_LEFT] || msg.MouseButtonHeld[MOUSE_LEFT]) ? 1 : 0;
+			m_MouseState1[player] = (msg.MouseButtonState[MOUSE_LEFT]) ? 1 : 0;
 
-			g_UInputMan.SetNetworkMouseButtonHeldState(player, MOUSE_RIGHT, msg.MouseButtonHeld[MOUSE_RIGHT]);
-			g_UInputMan.SetNetworkMouseButtonPressedState(player, MOUSE_RIGHT, msg.MouseButtonPressed[MOUSE_RIGHT]);
-			g_UInputMan.SetNetworkMouseButtonReleasedState(player, MOUSE_RIGHT, msg.MouseButtonReleased[MOUSE_RIGHT]);
+			g_UInputMan.SetNetworkMouseButtonHeldState(player, MOUSE_RIGHT, msg.MouseButtonState[MOUSE_RIGHT]);
 
-			g_UInputMan.SetNetworkMouseButtonHeldState(player, MOUSE_MIDDLE, msg.MouseButtonHeld[MOUSE_MIDDLE]);
-			g_UInputMan.SetNetworkMouseButtonPressedState(player, MOUSE_MIDDLE, msg.MouseButtonPressed[MOUSE_MIDDLE]);
-			g_UInputMan.SetNetworkMouseButtonReleasedState(player, MOUSE_MIDDLE, msg.MouseButtonReleased[MOUSE_MIDDLE]);
+			g_UInputMan.SetNetworkMouseButtonHeldState(player, MOUSE_MIDDLE, msg.MouseButtonState[MOUSE_MIDDLE]);
 
 			GUIInput::SetNetworkMouseButton(player, m_MouseState1[player], m_MouseState2[player], m_MouseState3[player]);
 
@@ -573,11 +559,9 @@ namespace RTE {
 
 			// Store element states as bit flags
 			for (int i = 0; i < INPUT_COUNT; i++) {
-				bool val = (msg.InputElementHeld & bitMask) > 0;
+				bool val = (msg.InputElementState & bitMask) > 0;
 
-				g_UInputMan.SetNetworkInputElementHeldState(player, i, val);
-				g_UInputMan.SetNetworkInputElementPressedState(player, i, (msg.InputElementPressed & bitMask) > 0);
-				g_UInputMan.SetNetworkInputElementReleasedState(player, i, (msg.InputElementReleased & bitMask) > 0);
+				g_UInputMan.SetNetworkInputElementState(player, i, val);
 
 				bitMask <<= 1;
 			}
@@ -596,9 +580,7 @@ namespace RTE {
 
 	void NetworkServer::ClearInputMessages(short player) {
 		if (player >= 0 && player < c_MaxClients) {
-			while (!m_InputMessages[player].empty()) {
-				m_InputMessages[player].pop();
-			}
+			m_InputMessages[player].clear();
 		}
 	}
 
@@ -1739,7 +1721,10 @@ namespace RTE {
 			double compressionRatio = (m_DataUncompressedTotal[i] > 0) ? static_cast<double>(m_DataSentTotal[i]) / static_cast<double>(m_DataUncompressedTotal[i]) : 0;
 			double emptyRatio = (m_EmptyBlocks[i] > 0) ? static_cast<double>(m_FullBlocks[i]) / static_cast<double>(m_EmptyBlocks[i]) : 0;
 
-			std::string playerName = IsPlayerConnected(i) ? GetPlayerName(i) : "- NO PLAYER -";
+			std::string playerName = " - NO PLAYER - ";
+			if (IsPlayerConnected(i)) {
+				playerName = GetPlayerName(i);
+			}
 
 			// Jesus christ
 			std::snprintf(buf, sizeof(buf),
@@ -1749,18 +1734,18 @@ namespace RTE {
 				"R : % .2f\n"
 				"Full Blck %lu (%.1f Kb)\n"
 				"Empty Blck %lu (%.1f Kb)\n"
-				"Frame Kb : % lu\n"
-				"Glow Kb : % lu\n"
-				"Sound Kb : % lu\n"
-				"Scene Kb : % lu\n"
-				"Frames sent : % uK\n"
-				"Frame skipped : % uK\n"
-				"Blocks full : % uK\n"
-				"Blocks empty : % uK\n"
+				"Frame Kb : %lu\n"
+				"Glow Kb : %lu\n"
+				"Sound Kb : %lu\n"
+				"Scene Kb : %lu\n"
+				"Frames sent : %uK\n"
+				"Frame skipped : %uK\n"
+				"Blocks full : %uK\n"
+				"Blocks empty : %uK\n"
 				"Blk Ratio : % .2f\n"
 				"Frames ms : % d\n"
 				"Send ms % d\n"
-				"Total Data % lu MB",
+				"Total Data %lu MB",
 
 				(i == c_MaxClients) ? "- TOTALS - " : playerName.c_str(),
 				(i < c_MaxClients) ? m_Ping[i] : 0,
@@ -1825,9 +1810,10 @@ namespace RTE {
 		if (processInput) {
 			for (short player = 0; player < c_MaxClients; player++) {
 				if (!m_InputMessages[player].empty()) {
-					MsgInput msg = m_InputMessages[player].front();
-					m_InputMessages[player].pop();
-					ProcessInputMsg(player, msg);
+					for (const MsgInput &msg: m_InputMessages[player]) {
+						ProcessInputMsg(player, msg);
+					}
+					m_InputMessages[player].clear();
 				}
 			}
 

Managers/NetworkServer.h

@@ -219,7 +219,7 @@ namespace RTE {
 
 		std::string m_ServerPort; //!<
 
-		ClientConnection m_ClientConnections[c_MaxClients]; //!<
+		std::array<ClientConnection, c_MaxClients> m_ClientConnections; //!<
 
 		bool m_UseNATService; //!< Whether a NAT service is used for punch-through.
 		RakNet::NatPunchthroughClient m_NATPunchthroughClient; //!<
@@ -276,12 +276,12 @@ namespace RTE {
 
 		std::mutex m_Mutex[c_MaxClients]; //!<
 
-		std::queue<MsgInput> m_InputMessages[c_MaxClients]; //!<
+		std::vector<MsgInput> m_InputMessages[c_MaxClients]; //!< Message Queue for received input events to be processed this frame.
 
 		unsigned char m_SceneID; //!<
 
-		bool m_EndActivityVotes[c_MaxClients]; //!< Votes from each player required to return to the Multiplayer Lobby.
-		bool m_RestartActivityVotes[c_MaxClients]; //!< Votes from each player required to restart the current activity.
+		std::array<bool, c_MaxClients> m_EndActivityVotes; //!< Votes from each player required to return to the Multiplayer Lobby.
+		std::array<bool, c_MaxClients> m_RestartActivityVotes; //!< Votes from each player required to restart the current activity.
 
 		long long m_LatestRestartTime; //!< The time, in ticks, that the last activity restart took place on the server.
 

Managers/TimerMan.h

@@ -46,7 +46,7 @@ namespace RTE {
 		/// This also clears the accumulator, to avoid the case where the sim may update while paused when behind schedule.
 		/// </summary>
 		/// <param name="pause">Whether the sim should be paused or not.</param>
-		void PauseSim(bool pause = false) { m_SimPaused = pause; m_SimAccumulator = 0.0F; }
+		void PauseSim(bool pause = false) { m_SimPaused = pause; if(pause) m_SimAccumulator = 0.0F; }
 
 		/// <summary>
 		/// Tells whether there is enough sim time accumulated to do at least one physics update.