feat(zones): auto-load patch fastfiles with override priority

also disabled gamepad + xlive for stability

Author: ujicos

src/component/engine/zones/fastfiles.cpp

@@ -4,15 +4,151 @@
 #include "game/game.hpp"
 
 #include "fastfiles.hpp"
-#include "component/engine/console/command.hpp"
-#include "component/engine/console/console.hpp"
 
 #include <utils/hook.hpp>
-#include <utils/memory.hpp>
-#include <utils/io.hpp>
+#include <utils/nt.hpp>
 
 namespace fastfiles
 {
+	namespace
+	{
+		utils::hook::detour db_load_xassets_hook;
+
+		bool patch_consolation_loaded = false;
+		bool patch_mp_loaded = false;
+		bool patch_consolation_attempted = false;
+		bool patch_mp_attempted = false;
+
+		bool zone_name_equals(const char* lhs, const char* rhs)
+		{
+			return lhs != nullptr && rhs != nullptr && _stricmp(lhs, rhs) == 0;
+		}
+
+		bool has_zone(const game::XZoneInfo* zone_info, const int zone_count, const char* name)
+		{
+			if (zone_info == nullptr || zone_count <= 0 || name == nullptr)
+			{
+				return false;
+			}
+
+			for (auto index = 0; index < zone_count; ++index)
+			{
+				if (zone_name_equals(zone_info[index].name, name))
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		bool zone_file_exists(const char* zone_name)
+		{
+			if (zone_name == nullptr || zone_name[0] == '\0')
+			{
+				return false;
+			}
+
+			const auto zone_file_name = std::string(zone_name) + ".ff";
+			const std::array roots
+			{
+				std::filesystem::path(utils::nt::get_host_module().get_folder()) / "zone",
+				std::filesystem::current_path() / "zone",
+			};
+
+			for (const auto& root : roots)
+			{
+				std::error_code ec{};
+				if (!std::filesystem::exists(root, ec))
+				{
+					continue;
+				}
+
+				if (std::filesystem::exists(root / zone_file_name, ec))
+				{
+					return true;
+				}
+
+				for (std::filesystem::recursive_directory_iterator it(root, ec), end; it != end && !ec; it.increment(ec))
+				{
+					if (!it->is_regular_file(ec))
+					{
+						continue;
+					}
+
+					const auto filename = it->path().filename().string();
+					if (_stricmp(filename.c_str(), zone_file_name.c_str()) == 0)
+					{
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+
+		game::XZoneInfo make_override_zone(const char* zone_name)
+		{
+			game::XZoneInfo zone_info{};
+			zone_info.name = zone_name;
+			zone_info.allocFlags = 2;
+			zone_info.freeFlags = 0;
+
+			return zone_info;
+		}
+
+		int db_load_xassets_stub(game::XZoneInfo* zone_info, const int zone_count, const int sync)
+		{
+			patch_consolation_loaded = patch_consolation_loaded || has_zone(zone_info, zone_count, "patch_consolation");
+			patch_mp_loaded = patch_mp_loaded || has_zone(zone_info, zone_count, "patch_mp");
+
+			const auto loading_common_fastfiles = has_zone(zone_info, zone_count, "common_mp");
+			const auto should_load_patch_consolation = loading_common_fastfiles
+				&& !patch_consolation_attempted
+				&& !patch_consolation_loaded;
+
+			const auto should_load_patch_mp = loading_common_fastfiles
+				&& !patch_mp_attempted
+				&& !patch_mp_loaded;
+
+			const auto result = db_load_xassets_hook.invoke<int>(zone_info, zone_count, sync);
+			if (!result)
+			{
+				return result;
+			}
+
+			std::vector<game::XZoneInfo> patch_zones{};
+			if (should_load_patch_mp)
+			{
+				patch_mp_attempted = true;
+				patch_zones.push_back(make_override_zone("patch_mp"));
+				patch_mp_loaded = true;
+			}
+
+			if (should_load_patch_consolation)
+			{
+				patch_consolation_attempted = true;
+				if (zone_file_exists("patch_consolation"))
+				{
+					patch_zones.push_back(make_override_zone("patch_consolation"));
+					patch_consolation_loaded = true;
+				}
+				else
+				{
+					game::Com_Printf(16, "Skipping override fastfile 'patch_consolation' because it was not found\n");
+				}
+			}
+
+			if (!patch_zones.empty())
+			{
+				game::Com_Printf(16, "Loading patch fastfiles with override priority\n");
+				db_load_xassets_hook.invoke<int>(patch_zones.data(), static_cast<int>(patch_zones.size()), sync);
+			}
+
+			return result;
+		}
+	}
+
 	void enum_assets(const game::XAssetType type, const std::function<void(game::XAssetHeader)>& callback, const bool include_override)
 	{
 		game::DB_EnumXAssets_FastFile(type, static_cast<void(*)(game::XAssetHeader, void*)>([](game::XAssetHeader header, void* data)
@@ -24,11 +160,11 @@ namespace fastfiles
 
 	class component final : public component_interface
 	{
-		/*public:
-			void post_unpack() override
-			{
-				//Placeholder for now, so it builds
-			}*/
+	public:
+		void post_load() override
+		{
+			db_load_xassets_hook.create(game::DB_LoadXAssets, db_load_xassets_stub);
+		}
 	};
 }
 

src/component/gamepad/sdl_input.cpp

@@ -16,4 +16,4 @@ namespace sdl_input
 	};
 }
 
-REGISTER_COMPONENT(sdl_input::component)
+//REGISTER_COMPONENT(sdl_input::component)

src/component/gamepad/xinput.cpp

@@ -1449,4 +1449,4 @@ namespace gamepad
 	}
 }
 
-REGISTER_COMPONENT(xinput::component)
+//REGISTER_COMPONENT(xinput::component)

src/game/structs.hpp

@@ -640,6 +640,14 @@ namespace game
 		XAssetHeader header;
 	};
 
+	struct XZoneInfo
+	{
+		const char* name;
+		int allocFlags;
+		int freeFlags;
+	};
+	static_assert(sizeof(XZoneInfo) == 12);
+
 	struct XAssetEntry
 	{
 		XAsset asset;

src/game/symbols.hpp

@@ -21,6 +21,7 @@ namespace game
 	WEAK symbol<void()> ConDrawInput_DrawInput{ game_offset(0x103175D0) };
 	WEAK symbol<Font_s*> con_font{ game_offset(0x1125C5B4) };
 
+	WEAK symbol<int(XZoneInfo* zoneInfo, int zoneCount, int sync)> DB_LoadXAssets{ game_offset(0x103E1CF0) };
 	WEAK symbol<void(XAssetType type, void(*)(XAssetHeader, void*), const void* userdata, bool overrides)> DB_EnumXAssets_FastFile{ game_offset(0x103DFCA0) };
 	WEAK symbol<XAssetHeader(XAssetType type, const char* name)> DB_FindXAssetHeader{ game_offset(0x103E2260) };
 	WEAK symbol<XAssetHeader(XAssetType type, const char* name, int create_default)> DB_FindXAssetHeader_Internal{ game_offset(0x103E1EE0) };