Notify: show server count at startup, tell user if lobby can be reached

Author: emoose

src/game_addrs.hpp

@@ -101,6 +101,8 @@ namespace Game
 
 	inline fn_stdcall_1arg_int Sumo_CheckRacerUnlocked = nullptr;
 
+	inline const char* SumoNet_OnlineUserName = nullptr;
+
 	// 2d sprite drawing
 	inline fn_1arg sprSetFontPriority = nullptr;
 	inline fn_1arg sprSetPrintFont = nullptr;
@@ -225,6 +227,8 @@ namespace Game
 
 		Sumo_CheckRacerUnlocked = Module::fn_ptr<fn_stdcall_1arg_int>(0xE8410);
 
+		SumoNet_OnlineUserName = Module::exe_ptr<const char>(0x430C20);
+
 		sprSetFontPriority = Module::fn_ptr<fn_1arg>(0x2CCB0);
 		sprSetPrintFont = Module::fn_ptr<fn_1arg>(0x2CA60);
 		sprSetFontColor = Module::fn_ptr<fn_1arg>(0x2CCA0);

src/overlay/notifications.hpp

@@ -7,6 +7,7 @@ inline std::chrono::seconds displayDuration = std::chrono::seconds(7);
 
 inline ImVec2 notificationSize = { 600, 100 };
 inline float notificationSpacing = 10.0f;
+inline float notificationTextScale = 1.5f;
 
 class Notifications
 {
@@ -15,16 +16,17 @@ class Notifications
 	{
 		std::string message;
 		std::chrono::time_point<std::chrono::steady_clock> timestamp;
+		int minDisplaySeconds;
 	};
 
 	std::deque<Notification> notifications;
 	std::mutex notificationsMutex;
 
 public:
-	void add(const std::string& message)
+	void add(const std::string& message, int minDisplaySeconds = 0)
 	{
 		std::lock_guard<std::mutex> lock(notificationsMutex);
-		notifications.push_back({ message, std::chrono::steady_clock::now() });
+		notifications.push_back({ message, std::chrono::steady_clock::now(), minDisplaySeconds });
 
 		if (notifications.size() > maxNotifications)
 			notifications.pop_front();
@@ -36,8 +38,20 @@ class Notifications
 		auto now = std::chrono::steady_clock::now();
 		{
 			std::lock_guard<std::mutex> lock(notificationsMutex);
-			while (!notifications.empty() && now - notifications.front().timestamp > displayDuration)
+
+			while (!notifications.empty())
+			{
+				auto& front = notifications.front();
+
+				auto duration = displayDuration;
+				if (front.minDisplaySeconds > 0)
+					duration = std::chrono::seconds(front.minDisplaySeconds);
+
+				if (now - front.timestamp <= duration) // notif time hasn't elapsed yet?
+					break;
+
 				notifications.pop_front();
+			}
 		}
 
 		ImVec2 screenSize = ImGui::GetIO().DisplaySize;
@@ -50,39 +64,43 @@ class Notifications
 			borderWidth = 0;
 
 		float startX = screenSize.x - notificationSize.x - borderWidth - 10.f;  // 10px padding from the right
-		float startY = (screenSize.y / 4.0f) - (notifications.size() * (notificationSize.y + notificationSpacing) / 2.0f);
+		float curY = (screenSize.y / 4.0f) - (notifications.size() * (notificationSize.y + notificationSpacing) / 2.0f);
 
 		std::lock_guard<std::mutex> lock(notificationsMutex);
 
 		for (size_t i = 0; i < notifications.size(); ++i)
 		{
+			auto windowSize = notificationSize;
 			const auto& notification = notifications[i];
 
-			float posY = startY + i * (notificationSize.y + notificationSpacing);
-			ImGui::SetNextWindowPos(ImVec2(startX, posY));
-			ImGui::SetNextWindowSize(notificationSize);
+			ImGui::SetNextWindowPos(ImVec2(startX, curY));
+
+			curY += windowSize.y + notificationSpacing;
 
 			std::string windowName = "Notification " + std::to_string(i);
 			ImGui::Begin(windowName.c_str(), nullptr, ImGuiWindowFlags_NoDecoration |
 				ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoInputs |
 				ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing);
 
-			ImGui::SetWindowFontScale(1.5f);
+			ImGui::SetWindowFontScale(notificationTextScale);
+			ImVec2 textSize = ImGui::CalcTextSize(notification.message.c_str(), nullptr, true, windowSize.x - 20.0f); // Account for padding
+
+			// Adjust window height if text is larger than current window height
+			if (textSize.y + 40.0f > windowSize.y)
+				windowSize.y = textSize.y + 40.0f;
 
-			// Calculate offsets to center text
-			ImVec2 textSize = ImGui::CalcTextSize(notification.message.c_str());
-			float offsetX = (notificationSize.x - textSize.x) / 2.0f;
-			float offsetY = (notificationSize.y - textSize.y) / 2.0f;
+			ImGui::SetWindowSize(windowSize);
 
-			// Padding
-			float paddingX = 10.0f;
-			float paddingY = 5.0f;
+			// Center text with padding
+			float paddingX = 10.0f, paddingY = 5.0f;
+			float offsetX = (windowSize.x - textSize.x) / 2.0f;
+			float offsetY = (windowSize.y - textSize.y) / 2.0f;
 			offsetX = max(offsetX, paddingX);
 			offsetY = max(offsetY, paddingY);
 
-			// Position cursor for centered text
 			ImGui::SetCursorPos(ImVec2(offsetX, offsetY));
 			ImGui::TextWrapped("%s", notification.message.c_str());
+
 			ImGui::End();
 		}
 	}

src/overlay/server_notifications.cpp

@@ -37,6 +37,8 @@ class ServerUpdater
 	Json::Value previousServers;
 	std::mutex dataMutex;
 
+	int numServerUpdates = 0;
+
 	void monitorServers()
 	{
 		while (running)
@@ -57,6 +59,8 @@ class ServerUpdater
 					// Save the current state as the previous state for the next check
 					std::lock_guard<std::mutex> lock(dataMutex);
 					previousServers = currentServers;
+
+					numServerUpdates++;
 				}
 			}
 			catch (const std::exception& e)
@@ -149,25 +153,48 @@ class ServerUpdater
 			}
 		}
 
+		int numValid = 0;
+
 		// Compare current servers to previous identifiers
 		for (const auto& server : currentServers)
 		{
 			if (server.isMember("HostName") && server.isMember("Platform") && server.isMember("Reachable"))
 			{
-				if (server["Reachable"].asBool())
+				bool reachable = server["Reachable"].asBool();
+				if (reachable)
+				{
+					numValid++;
+				}
+
+				if (numServerUpdates > 0) // have we fetched server info before?
 				{
-					std::string identifier = server["HostName"].asString() + "_" + server["Platform"].asString();
+					auto hostName = server["HostName"].asString();
 
-					if (previousIdentifiers.find(identifier) == previousIdentifiers.end())
-						newServer(server);
+					if (!hostName.empty())
+					{
+						std::string identifier = hostName + "_" + server["Platform"].asString();
+						bool ourLobby = !strncmp(hostName.c_str(), Game::SumoNet_OnlineUserName, 16);
+						if (!ourLobby)
+						{
+							if (reachable && previousIdentifiers.find(identifier) == previousIdentifiers.end())
+								Notifications::instance.add(hostName + " started hosting a lobby!");
+						}
+						else
+						{
+							Notifications::instance.add(reachable ?
+								"Your lobby is active & accessible!" :
+								"Your lobby cannot be reached by the master server!\nYou may need to setup port-forwarding for UDP ports 41455/41456/41457.", reachable ? 0 : 20);
+						}
+					}
 				}
 			}
 		}
-	}
 
-	void newServer(const Json::Value& server)
-	{
-		Notifications::instance.add(server["HostName"].asString() + " started hosting a lobby!");
+		if (numServerUpdates == 0 && numValid > 0)
+		{
+			// First update since game launch and we have some servers, write a notify about it
+			Notifications::instance.add("There are " + std::to_string(numValid) + " online lobbies active!");
+		}
 	}
 
 public: