#include "pch.h" #include "rpakfilesystem.h" #include "modmanager.h" #include "dedicated.h" #include "tier0.h" AUTOHOOK_INIT() // there are more i'm just too lazy to add struct PakLoadFuncs { void* unk0[3]; int (*LoadPakAsync)(const char* pPath, void* unknownSingleton, int flags, void* callback0, void* callback1); void* unk1[2]; void* (*UnloadPak)(int iPakHandle, void* callback); void* unk2[6]; void* (*LoadFile)(const char* path); // unsure void* unk3[10]; void* (*ReadFileAsync)(const char* pPath, void* a2); }; PakLoadFuncs* g_pakLoadApi; PakLoadManager* g_pPakLoadManager; void** pUnknownPakLoadSingleton; int PakLoadManager::LoadPakAsync(const char* pPath, const ePakLoadSource nLoadSource) { int nHandle = g_pakLoadApi->LoadPakAsync(pPath, *pUnknownPakLoadSingleton, 2, nullptr, nullptr); // set the load source of the pak we just loaded if (nHandle != -1) GetPakInfo(nHandle)->m_nLoadSource = nLoadSource; return nHandle; } void PakLoadManager::UnloadPak(const int nPakHandle) { g_pakLoadApi->UnloadPak(nPakHandle, nullptr); } void PakLoadManager::UnloadMapPaks() { for (auto& pair : m_vLoadedPaks) if (pair.second.m_nLoadSource == ePakLoadSource::MAP) UnloadPak(pair.first); } LoadedPak* PakLoadManager::TrackLoadedPak(ePakLoadSource nLoadSource, int nPakHandle, size_t nPakNameHash) { LoadedPak pak; pak.m_nLoadSource = nLoadSource; pak.m_nPakHandle = nPakHandle; pak.m_nPakNameHash = nPakNameHash; m_vLoadedPaks.insert(std::make_pair(nPakHandle, pak)); return &m_vLoadedPaks.at(nPakHandle); } void PakLoadManager::RemoveLoadedPak(int nPakHandle) { m_vLoadedPaks.erase(nPakHandle); } LoadedPak* PakLoadManager::GetPakInfo(const int nPakHandle) { return &m_vLoadedPaks.at(nPakHandle); } int PakLoadManager::GetPakHandle(const size_t nPakNameHash) { for (auto& pair : m_vLoadedPaks) if (pair.second.m_nPakNameHash == nPakNameHash) return pair.first; return -1; } int PakLoadManager::GetPakHandle(const char* pPath) { return GetPakHandle(STR_HASH(pPath)); } void* PakLoadManager::LoadFile(const char* path) { return g_pakLoadApi->LoadFile(path); } void HandlePakAliases(char** map) { // convert the pak being loaded to it's aliased one, e.g. aliasing mp_hub_timeshift => sp_hub_timeshift for (int64_t i = g_pModManager->m_LoadedMods.size() - 1; i > -1; i--) { Mod* mod = &g_pModManager->m_LoadedMods[i]; if (!mod->m_bEnabled) continue; if (mod->RpakAliases.find(*map) != mod->RpakAliases.end()) { *map = &mod->RpakAliases[*map][0]; return; } } } void LoadPreloadPaks() { // note, loading from ./ is necessary otherwise paks will load from gamedir/r2/paks for (Mod& mod : g_pModManager->m_LoadedMods) { if (!mod.m_bEnabled) continue; // need to get a relative path of mod to mod folder fs::path modPakPath("./" / mod.m_ModDirectory / "paks"); for (ModRpakEntry& pak : mod.Rpaks) if (pak.m_bAutoLoad) g_pPakLoadManager->LoadPakAsync((modPakPath / pak.m_sPakName).string().c_str(), ePakLoadSource::CONSTANT); } } void LoadPostloadPaks(const char* pPath) { // note, loading from ./ is necessary otherwise paks will load from gamedir/r2/paks for (Mod& mod : g_pModManager->m_LoadedMods) { if (!mod.m_bEnabled) continue; // need to get a relative path of mod to mod folder fs::path modPakPath("./" / mod.m_ModDirectory / "paks"); for (ModRpakEntry& pak : mod.Rpaks) if (pak.m_sLoadAfterPak == pPath) g_pPakLoadManager->LoadPakAsync((modPakPath / pak.m_sPakName).string().c_str(), ePakLoadSource::CONSTANT); } } void LoadCustomMapPaks(char** pakName, bool* bNeedToFreePakName) { // whether the vanilla game has this rpak bool bHasOriginalPak = fs::exists(fs::path("r2/paks/Win64/") / *pakName); // note, loading from ./ is necessary otherwise paks will load from gamedir/r2/paks for (Mod& mod : g_pModManager->m_LoadedMods) { if (!mod.m_bEnabled) continue; // need to get a relative path of mod to mod folder fs::path modPakPath("./" / mod.m_ModDirectory / "paks"); for (ModRpakEntry& pak : mod.Rpaks) { if (!pak.m_bAutoLoad && !pak.m_sPakName.compare(*pakName)) { // if the game doesn't have the original pak, let it handle loading this one as if it was the one it was loading originally if (!bHasOriginalPak) { std::string path = (modPakPath / pak.m_sPakName).string(); *pakName = new char[path.size() + 1]; strcpy(*pakName, &path[0]); (*pakName)[path.size()] = '\0'; bHasOriginalPak = true; *bNeedToFreePakName = true; // we can't free this memory until we're done with the pak, so let whatever's calling this deal with it } else g_pPakLoadManager->LoadPakAsync((modPakPath / pak.m_sPakName).string().c_str(), ePakLoadSource::MAP); } } } } // clang-format off HOOK(LoadPakAsyncHook, LoadPakAsync, int, __fastcall, (char* pPath, void* unknownSingleton, int flags, void* pCallback0, void* pCallback1)) // clang-format on { HandlePakAliases(&pPath); // dont load the pak if it's currently loaded already size_t nPathHash = STR_HASH(pPath); if (g_pPakLoadManager->GetPakHandle(nPathHash) != -1) return -1; bool bNeedToFreePakName = false; static bool bShouldLoadPaks = true; if (bShouldLoadPaks) { // make a copy of the path for comparing to determine whether we should load this pak on dedi, before it could get overwritten by // LoadCustomMapPaks std::string originalPath(pPath); // disable preloading while we're doing this bShouldLoadPaks = false; LoadPreloadPaks(); LoadCustomMapPaks(&pPath, &bNeedToFreePakName); bShouldLoadPaks = true; // do this after custom paks load and in bShouldLoadPaks so we only ever call this on the root pakload call // todo: could probably add some way to flag custom paks to not be loaded on dedicated servers in rpak.json // dedicated only needs common, common_mp, common_sp, and sp_<map> rpaks // sp_<map> rpaks contain tutorial ghost data // sucks to have to load the entire rpak for that but sp was never meant to be done on dedi if (IsDedicatedServer() && (Tier0::CommandLine()->CheckParm("-nopakdedi") || strncmp(&originalPath[0], "common", 6) && strncmp(&originalPath[0], "sp_", 3))) { if (bNeedToFreePakName) delete[] pPath; NS::log::rpak->info("Not loading pak {} for dedicated server", originalPath); return -1; } } int iPakHandle = LoadPakAsync(pPath, unknownSingleton, flags, pCallback0, pCallback1); NS::log::rpak->info("LoadPakAsync {} {}", pPath, iPakHandle); // trak the pak g_pPakLoadManager->TrackLoadedPak(ePakLoadSource::UNTRACKED, iPakHandle, nPathHash); LoadPostloadPaks(pPath); if (bNeedToFreePakName) delete[] pPath; return iPakHandle; } // clang-format off HOOK(UnloadPakHook, UnloadPak, void*, __fastcall, (int nPakHandle, void* pCallback)) // clang-format on { // stop tracking the pak g_pPakLoadManager->RemoveLoadedPak(nPakHandle); static bool bShouldUnloadPaks = true; if (bShouldUnloadPaks) { bShouldUnloadPaks = false; g_pPakLoadManager->UnloadMapPaks(); bShouldUnloadPaks = true; } NS::log::rpak->info("UnloadPak {}", nPakHandle); return UnloadPak(nPakHandle, pCallback); } // we hook this exclusively for resolving stbsp paths, but seemingly it's also used for other stuff like vpk, rpak, mprj and starpak loads // tbh this actually might be for memory mapped files or something, would make sense i think // clang-format off HOOK(ReadFileAsyncHook, ReadFileAsync, void*, __fastcall, (const char* pPath, void* pCallback)) // clang-format on { fs::path path(pPath); std::string newPath = ""; fs::path filename = path.filename(); if (path.extension() == ".stbsp") { NS::log::rpak->info("LoadStreamBsp: {}", filename.string()); // resolve modded stbsp path so we can load mod stbsps auto modFile = g_pModManager->m_ModFiles.find(g_pModManager->NormaliseModFilePath(fs::path("maps" / filename))); if (modFile != g_pModManager->m_ModFiles.end()) { newPath = (modFile->second.m_pOwningMod->m_ModDirectory / "mod" / modFile->second.m_Path).string(); pPath = newPath.c_str(); } } else if (path.extension() == ".starpak") { // code for this is mostly stolen from above // unfortunately I can't find a way to get the rpak that is causing this function call, so I have to // store them on mod init and then compare the current path with the stored paths // game adds r2\ to every path, so assume that a starpak path that begins with r2\paks\ is a vanilla one // modded starpaks will be in the mod's paks folder (but can be in folders within the paks folder) // this might look a bit confusing, but its just an iterator over the various directories in a path. // path.begin() being the first directory, r2 in this case, which is guaranteed anyway, // so increment the iterator with ++ to get the first actual directory, * just gets the actual value // then we compare to "paks" to determine if it's a vanilla rpak or not if (*++path.begin() != "paks") { // remove the r2\ from the start used for path lookups std::string starpakPath = path.string().substr(3); // hash the starpakPath to compare with stored entries size_t hashed = STR_HASH(starpakPath); // loop through all loaded mods for (Mod& mod : g_pModManager->m_LoadedMods) { // ignore non-loaded mods if (!mod.m_bEnabled) continue; // loop through the stored starpak paths for (size_t hash : mod.StarpakPaths) { if (hash == hashed) { // construct new path newPath = (mod.m_ModDirectory / "paks" / starpakPath).string(); // set path to the new path pPath = newPath.c_str(); goto LOG_STARPAK; } } } } LOG_STARPAK: NS::log::rpak->info("LoadStreamPak: {}", filename.string()); } return ReadFileAsync(pPath, pCallback); } ON_DLL_LOAD("engine.dll", RpakFilesystem, (CModule module)) { AUTOHOOK_DISPATCH(); g_pPakLoadManager = new PakLoadManager; g_pakLoadApi = module.Offset(0x5BED78).Deref().As<PakLoadFuncs*>(); pUnknownPakLoadSingleton = module.Offset(0x7C5E20).As<void**>(); LoadPakAsyncHook.Dispatch(g_pakLoadApi->LoadPakAsync); UnloadPakHook.Dispatch(g_pakLoadApi->UnloadPak); ReadFileAsyncHook.Dispatch(g_pakLoadApi->ReadFileAsync); }