Feat/improve exceptions

src/Components/Modules/Events.hpp

@@ -35,6 +35,7 @@ namespace Components
 		static void OnSVInit(const std::function<void()>& callback);
 
 		// Client & Server (triggered once)
+		// Required for String Dvars (game will crash if the dvar subsystem wasn't initialised)
 		static void OnDvarInit(const std::function<void()>& callback);
 
 		// Client & Server (triggered once)

src/Components/Modules/Exception.cpp

@@ -3,11 +3,17 @@
 #include "Console.hpp"
 #include "Exception.hpp"
 #include "Window.hpp"
+#include "Party.hpp"
+#include "TextRenderer.hpp"
 
+#include <cwctype>
 #include <version.hpp>
 
 namespace Components
 {
+	constexpr auto CLIPBOARD_MSG = "Do you want to copy this message to the clipboard?";
+	constexpr auto DISCORD_LINK = "https://discord.gg/2ETE8engZM";
+
 	Utils::Hook Exception::SetFilterHook;
 	int Exception::MiniDumpType;
 
@@ -53,6 +59,148 @@ namespace Components
 		Game::Sys_SuspendOtherThreads();
 	}
 
+	std::wstring Exception::GetErrorMessage()
+	{
+		const auto clientVersion = (*Game::shortversion)->current.string;
+		const auto osVersion = Utils::IsWineEnvironment() ? "Wine" : Utils::GetWindowsVersion();
+		const auto launchParams = Utils::String::Convert(Utils::GetLaunchParameters());
+
+		std::string clientInfo = std::format(R"(
+			Client Info:
+			IW4x Version: {}
+			OS Version: {}
+			Parameters: {})",
+			clientVersion, osVersion, launchParams);
+
+		if (!Game::CL_IsCgameInitialized())
+		{
+			std::string msg = std::format("{}\n\n{}", clientInfo, CLIPBOARD_MSG);
+			std::wstring message(msg.begin(), msg.end());
+			return message;
+		}
+
+		const auto* gameType = (*Game::sv_gametype)->current.string;
+		const auto* mapName = (*Game::sv_mapname)->current.string;
+
+		// Get info for a private match
+		{
+			if (std::strcmp(Game::cls->servername, "localhost") == 0)
+			{
+				std::string privateMatchInfo = std::format(R"(
+					Host Info:
+					Type: Private Match
+					Gametype: {}
+					Map Name: {})",
+					gameType, mapName);
+
+				std::string msg = std::format("{}\n{}\n\n{}", clientInfo, privateMatchInfo, CLIPBOARD_MSG);
+				std::wstring message(msg.begin(), msg.end());
+				return message;
+			}
+		}
+
+		// Get info for a dedicated server
+		{
+			const auto serverVersion = Dvar::Var("sv_version").get<std::string>();
+			const auto ipAddress = Network::Address(*Game::connectedHost).getString();
+
+			char serverName[256]{ 0 };
+			TextRenderer::StripColors(Party::GetHostName().data(), serverName, sizeof(serverName));
+			TextRenderer::StripAllTextIcons(serverName, serverName, sizeof(serverName));
+
+			std::string serverInfo = std::format(R"(
+				Server Info:
+				Type: Dedicated Server							
+				IW4x Version: {}
+				Server Name: {}
+				IP Address: {}					
+				Gametype: {}
+				Map Name: {})",
+				serverVersion, serverName, ipAddress, gameType, mapName);
+
+			std::string msg = std::format("{}\n{}\n\n{}", clientInfo, serverInfo, CLIPBOARD_MSG);
+			std::wstring message(msg.begin(), msg.end());
+			return message;
+		}
+	}
+
+	std::string Exception::FormatMessageForClipboard(const std::wstring& message)
+	{
+		std::wstringstream ss(message);
+		std::wstring line;
+		std::wostringstream result;
+
+		// Trim all the whitespaces from the message
+		auto trim = [](std::wstring& s)
+		{
+			s.erase(s.begin(), std::find_if_not(s.begin(), s.end(), [](wchar_t ch) { return std::iswspace(ch); })); // trim left
+			s.erase(std::find_if_not(s.rbegin(), s.rend(), [](wchar_t ch) { return std::iswspace(ch); }).base());	// trim right
+		};
+
+		// Construct a corrected version and get rid of the last line
+		while (std::getline(ss, line))
+		{
+			trim(line);
+
+			if (line != Utils::String::Convert(CLIPBOARD_MSG))
+			{
+				if (!line.empty())
+				{
+					result << line << L'\n';
+				}
+			}
+		}
+
+		// Enough wide strings for today
+		return Utils::String::Convert(result.str());
+	}
+
+	void Exception::DisplayErrorMessage(const std::wstring& title, const std::wstring& message)
+	{
+		const std::wstring footerText = std::format(
+			L"Join the official <a href=\"{}\">Discord Server</a> for additional support.",
+			Utils::String::Convert(DISCORD_LINK));
+
+		TASKDIALOGCONFIG taskDialogConfig = { 0 };
+		taskDialogConfig.cbSize				= sizeof(taskDialogConfig);
+		taskDialogConfig.hInstance			= GetModuleHandleA(nullptr);
+		taskDialogConfig.hwndParent			= Window::GetWindow();
+		taskDialogConfig.pszWindowTitle		= L"Unhandled Exception";
+		taskDialogConfig.pszMainIcon		= MAKEINTRESOURCEW(-7); // Red bar with a shield icon
+		taskDialogConfig.pszMainInstruction = title.c_str();
+		taskDialogConfig.pszContent			= message.c_str();
+		taskDialogConfig.dwCommonButtons	= TDCBF_YES_BUTTON | TDCBF_NO_BUTTON;
+		taskDialogConfig.nDefaultButton		= IDYES;
+		taskDialogConfig.pszFooterIcon		= TD_INFORMATION_ICON;
+        taskDialogConfig.pszFooter			= footerText.c_str();
+		taskDialogConfig.dwFlags			= TDF_ENABLE_HYPERLINKS | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT;
+		taskDialogConfig.lpCallbackData		= reinterpret_cast<LONG_PTR>(&message);
+		taskDialogConfig.pfCallback			= Exception::TaskDialogCallbackProc;
+
+		::TaskDialogIndirect(&taskDialogConfig, nullptr, nullptr, nullptr);
+	}
+
+	HRESULT CALLBACK Exception::TaskDialogCallbackProc(HWND, UINT notification, WPARAM clickedButton, LPARAM, LONG_PTR data)
+	{
+		const auto* msg = reinterpret_cast<const std::wstring*>(data);
+
+		if (notification == TDN_HYPERLINK_CLICKED)
+		{
+			Utils::OpenUrl(DISCORD_LINK);
+		}
+
+		if (notification == TDN_BUTTON_CLICKED)
+		{
+			if (clickedButton == IDYES)
+			{
+				std::string formattedMessage = Exception::FormatMessageForClipboard(*msg);
+				Exception::CopyMessageToClipboard(formattedMessage.c_str());
+			}
+		}
+
+		return S_OK;
+	}
+
 	void Exception::CopyMessageToClipboard(const char* error)
 	{
 		const auto hWndNewOwner = GetDesktopWindow();
@@ -98,20 +246,25 @@ namespace Components
 			return EXCEPTION_CONTINUE_EXECUTION;
 		}
 
-		const char* error;
 		if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)
 		{
-			error = "Termination because of a stack overflow.\nCopy exception address to clipboard?";
+			const auto error = std::format("Termination because of a stack overflow.\n{}", CLIPBOARD_MSG);
+
+			// Message should be copied to the clipboard if no button is pressed
+			if (MessageBoxA(nullptr, error.c_str(), nullptr, MB_YESNO | MB_ICONERROR) == IDYES)
+			{
+				CopyMessageToClipboard(Utils::String::VA("0x%08X", ExceptionInfo->ExceptionRecord->ExceptionAddress));
+			}
 		}
 		else
 		{
-			error = Utils::String::VA("Fatal error (0x%08X) at 0x%08X.\nCopy exception address to clipboard?", ExceptionInfo->ExceptionRecord->ExceptionCode, ExceptionInfo->ExceptionRecord->ExceptionAddress);
-		}
+			const auto code	   = ExceptionInfo->ExceptionRecord->ExceptionCode;
+			const auto address = reinterpret_cast<std::uintptr_t>(ExceptionInfo->ExceptionRecord->ExceptionAddress);
 
-		// Message should be copied to the keyboard if no button is pressed
-		if (MessageBoxA(nullptr, error, nullptr, MB_YESNO | MB_ICONERROR) == IDYES)
-		{
-			CopyMessageToClipboard(Utils::String::VA("0x%08X", ExceptionInfo->ExceptionRecord->ExceptionAddress));
+			std::wstring title   = Utils::String::Convert(std::format("Fatal error (0x{:X}) at 0x{:X}", code, address));
+			std::wstring message = Exception::GetErrorMessage();
+
+			Exception::DisplayErrorMessage(title, message);	
 		}
 
 		if (Flags::HasFlag("bigminidumps"))

src/Components/Modules/Exception.hpp

@@ -17,9 +17,14 @@ namespace Components
 		static LONG WINAPI ExceptionFilter(LPEXCEPTION_POINTERS ExceptionInfo);
 		static __declspec(noreturn) void LongJmp_Internal_Stub(jmp_buf env, int status);
 
+		static std::wstring GetErrorMessage();
+		static std::string FormatMessageForClipboard(const std::wstring& message);
+
+		static void DisplayErrorMessage(const std::wstring& title, const std::wstring& message);
 		static void CopyMessageToClipboard(const char* error);
 
 		static LPTOP_LEVEL_EXCEPTION_FILTER WINAPI SetUnhandledExceptionFilter_Stub(LPTOP_LEVEL_EXCEPTION_FILTER);
+		static HRESULT CALLBACK TaskDialogCallbackProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, LONG_PTR lpRefData);
 
 		static int MiniDumpType;
 		static Utils::Hook SetFilterHook;

src/Components/Modules/Party.cpp

@@ -12,6 +12,7 @@
 #include "Stats.hpp"
 #include "TextRenderer.hpp"
 #include "Voice.hpp"
+#include "Events.hpp"
 
 #include <version.hpp>
 
@@ -40,6 +41,7 @@ namespace Components
 	std::map<std::uint64_t, Network::Address> Party::LobbyMap;
 
 	Dvar::Var Party::PartyEnable;
+	Dvar::Var Party::ServerVersion;
 
 	SteamID Party::GenerateLobbyId()
 	{
@@ -208,8 +210,12 @@ namespace Components
 			return;
 		}
 
-		PartyEnable = Dvar::Register<bool>("party_enable", Dedicated::IsEnabled(), Game::DVAR_NONE, "Enable party system");
-		Dvar::Register<bool>("xblive_privatematch", true, Game::DVAR_INIT, "");
+		Events::OnDvarInit([]
+		{
+			ServerVersion = Dvar::Register<const char*>("sv_version", "", Game::DVAR_SERVERINFO | Game::DVAR_INIT, "Server version");
+			PartyEnable = Dvar::Register<bool>("party_enable", Dedicated::IsEnabled(), Game::DVAR_NONE, "Enable party system");
+			Dvar::Register<bool>("xblive_privatematch", true, Game::DVAR_INIT, "");
+		});
 
 		// Kill the party migrate handler - it's not necessary and has apparently been used in the past for trickery?
 		Utils::Hook(0x46AB70, PartyMigrate_HandlePacket, HOOK_JUMP).install()->quick();
@@ -563,11 +569,13 @@ namespace Components
 						{
 							int clients;
 							int maxClients;
+							std::string version;
 
 							try
 							{
 								clients = std::stoi(Container.info.get("clients"));
 								maxClients = std::stoi(Container.info.get("sv_maxclients"));
+								version = Container.info.get("version");
 							}
 							catch ([[maybe_unused]] const std::exception& ex)
 							{
@@ -582,7 +590,7 @@ namespace Components
 							else
 							{
 								Dvar::Var("xblive_privateserver").set(true);
-
+								ServerVersion.set(version.c_str());
 								Game::Menus_CloseAll(Game::uiContext);
 
 								Game::_XSESSION_INFO hostInfo;

src/Components/Modules/Party.hpp

@@ -31,6 +31,7 @@ namespace Components
 		static std::map<std::uint64_t, Network::Address> LobbyMap;
 
 		static Dvar::Var PartyEnable;
+		static Dvar::Var ServerVersion;
 
 		static SteamID GenerateLobbyId();
 

src/Components/Modules/QuickPatch.cpp

@@ -388,9 +388,9 @@ namespace Components
 		// disable bind protection
 		Utils::Hook::Set<BYTE>(0x4DACA2, 0xEB);
 
-		// require Windows 5
-		Utils::Hook::Set<BYTE>(0x467ADF, 5);
-		Utils::Hook::Set<char>(0x6DF5D6, '5');
+		// require Windows 6 (Vista)
+		Utils::Hook::Set<BYTE>(0x467ADF, 6);
+		Utils::Hook::Set<char>(0x6DF5D6, '6');
 
 		// disable 'ignoring asset' notices
 		Utils::Hook::Nop(0x5BB902, 5);

src/Game/Dvars.cpp

@@ -80,6 +80,7 @@ namespace Game
 	const dvar_t** cg_scoreboardWidth = reinterpret_cast<const dvar_t**>(0x9FD0AC);
 
 	const dvar_t** version = reinterpret_cast<const dvar_t**>(0x1AD7930);
+	const dvar_t** shortversion = reinterpret_cast<const dvar_t**>(0x01AD79D0);
 
 	const dvar_t** viewposNow = reinterpret_cast<const dvar_t**>(0x9FD30C);
 

src/Game/Dvars.hpp

@@ -132,6 +132,10 @@ namespace Game
 	extern const dvar_t** cg_scoreboardWidth;
 
 	extern const dvar_t** version;
+	/// <summary>
+	/// Client Revision
+	/// </summary>
+	extern const dvar_t** shortversion;
 
 	extern const dvar_t** viewposNow;
 

src/Game/Functions.cpp

@@ -194,6 +194,7 @@ namespace Game
 	UI_ReplaceConversions_t UI_ReplaceConversions = UI_ReplaceConversions_t(0x4E9740);
 	UI_ParseInfos_t UI_ParseInfos = UI_ParseInfos_t(0x4027A0);
 	UI_GetMapDisplayName_t UI_GetMapDisplayName = UI_GetMapDisplayName_t(0x420700);
+	UI_GetGameTypeDisplayName_t UI_GetGameTypeDisplayName = UI_GetGameTypeDisplayName_t(0x4EB0B0);
 	ParseConfigStringToStruct_t ParseConfigStringToStruct = ParseConfigStringToStruct_t(0x403B60);
 
 	Win_GetLanguage_t Win_GetLanguage = Win_GetLanguage_t(0x45CBA0);

src/Game/Functions.hpp

@@ -221,6 +221,9 @@ namespace Game
 	typedef const char*(*UI_GetMapDisplayName_t)(const char* pszMap);
 	extern UI_GetMapDisplayName_t UI_GetMapDisplayName;
 
+	typedef const char* (*UI_GetGameTypeDisplayName_t)(const char* pszGameType);
+	extern UI_GetGameTypeDisplayName_t UI_GetGameTypeDisplayName;
+
 	typedef int(*ParseConfigStringToStruct_t)(void* pStruct, const Game::cspField_t* pFieldList, const int iNumFields, const char* pszBuffer, const int iMaxFieldTypes, int(__cdecl* parseSpecialFieldType)(char*, const char*, const int), void(__cdecl* parseStrcpy)(char*, char*));
 	extern ParseConfigStringToStruct_t ParseConfigStringToStruct;
 

src/STDInclude.hpp

@@ -65,6 +65,8 @@
 #include <hidsdi.h>
 #pragma comment(lib, "Hid.lib")
 
+#include <CommCtrl.h>
+#pragma comment(lib, "Comctl32.lib")
 
 // Ignore the warnings
 #pragma warning(push)

src/Utils/Utils.cpp

@@ -50,6 +50,51 @@ namespace Utils
 		return (GetProcAddress(hntdll, "wine_get_version") != nullptr);
 	}
 
+	std::string GetWindowsVersion()
+	{
+		const auto ntdll = Utils::Library("ntdll.dll");
+		const auto rtlGetVersion = ntdll.getProc<LONG(WINAPI*)(PRTL_OSVERSIONINFOW)>("RtlGetVersion");
+
+		if (rtlGetVersion)
+		{
+			LONG STATUS_SUCCESS = 0;
+			RTL_OSVERSIONINFOW versionInfo = {};
+			versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
+
+			if (rtlGetVersion(&versionInfo) == STATUS_SUCCESS)
+			{
+				const auto major = versionInfo.dwMajorVersion;
+				const auto minor = versionInfo.dwMinorVersion;
+				const auto build = versionInfo.dwBuildNumber;
+				const auto arch  = Utils::GetWindowsArchitecture();
+
+				if (major == 10 && build >= 22000) return std::format("Windows 11 (Build {}) {}", build, arch);
+				if (major == 10)				   return std::format("Windows 10 (Build {}) {}", build, arch);
+				if (major == 6 && minor == 3)	   return std::format("Windows 8.1 (Build {}) {}", build, arch);
+				if (major == 6 && minor == 2)	   return std::format("Windows 8.0 (Build {}) {}", build, arch);
+				if (major == 6 && minor == 1)	   return std::format("Windows 7 (Build {}) {}", build, arch);
+				if (major == 6 && minor == 0)	   return std::format("Windows Vista (Build {}) {}", build, arch);
+				if (major == 5 && minor == 1)	   return std::format("Windows XP (Build {}) {}", build, arch);
+			}
+		}
+
+		return "Unknown Version";
+	}
+
+	std::string GetWindowsArchitecture()
+	{
+		SYSTEM_INFO sysInfo;
+		::GetNativeSystemInfo(&sysInfo);
+
+		switch (sysInfo.wProcessorArchitecture)
+		{
+			case PROCESSOR_ARCHITECTURE_AMD64: return "64 Bit";
+			case PROCESSOR_ARCHITECTURE_INTEL: return "32 Bit";
+			case PROCESSOR_ARCHITECTURE_ARM:   return "ARM";
+			default: return "Unknown Architecture";
+		}
+	}
+
 	unsigned long GetParentProcessId()
 	{
 		HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);