Cache Updates (#34)

* Header updates
Automated cache downloading
Added new RCON command `map.setserverid <id>` to allow changing the ServerID

* Updated SaveWorld

* Made auto cache config more readable, fixed save world bool missing

* Set cdn enabled by default

* Updated cache refresh message for a realistic timeframe if cache is being built by the server itself.

* Removed debug processor used for detecting bad offsets in favor of always showing bad offsets instead of just mysteriously crashing with no info.

---------

Co-authored-by: Pelayori <[email protected]>

Author: Lethalinjectionx

AsaApi/AsaApi.vcxproj

@@ -324,7 +324,7 @@ copy  /Y "$(SolutionDir)AsaApi\Core\Private\PDBReader\pdbignores.txt" "E:\ASA\Te
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>API_DEBUG;NDEBUG;ASAAPI_EXPORTS;ARK_EXPORTS;_WINDOWS;_USRDLL;POCO_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;ASAAPI_EXPORTS;ARK_EXPORTS;_WINDOWS;_USRDLL;POCO_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
@@ -343,9 +343,7 @@ copy  /Y "$(SolutionDir)AsaApi\Core\Private\PDBReader\pdbignores.txt" "E:\ASA\Te
       <AdditionalDependencies>$(CoreLibraryDependencies);crypt32.lib;Ws2_32.lib;iphlpapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <PostBuildEvent>
-      <Command>xcopy /I  /Y "$(TargetDir)$(ProjectName).lib" "$(SolutionDir)out_lib\"
-xcopy /I  /Y "$(TargetDir)$(ProjectName).lib" "$(SolutionDir)..\ARK-API-Stable-Libs\"
-xcopy /I  /Y "$(TargetDir)$(ProjectName).lib" "$(SolutionDir)..\ARK-API-Stable-Libs\1.02\"
+      <Command>xcopy /I  /Y "$(TargetDir)$(ProjectName).lib" "$(SolutionDir)..\ARK-API-Stable-Libs\dev-latest\"
 
 copy "$(SolutionDir)$(PlatformName)\$(ConfigurationName)\$(ProjectName).dll" "F:\ASA-Dedicated\asa-server\ShooterGame\Binaries\Win64\ArkApi\" /y
 copy "$(SolutionDir)$(PlatformName)\$(ConfigurationName)\$(ProjectName).pdb" "F:\ASA-Dedicated\asa-server\ShooterGame\Binaries\Win64\ArkApi\" /y</Command>

AsaApi/Core/Private/Ark/ArkBaseApi.cpp

@@ -10,10 +10,12 @@
 #include "HooksImpl.h"
 #include "ApiUtils.h"
 #include <filesystem>
+#include "Requests.h"
+#include <minizip/unzip.h>
 
 namespace API
 {
-	constexpr float api_version = 1.12f;
+	constexpr float api_version = 1.13f;
 
 	ArkBaseApi::ArkBaseApi()
 		: commands_(std::make_unique<AsaApi::Commands>()),
@@ -24,8 +26,10 @@ namespace API
 
 	bool ArkBaseApi::Init()
 	{
+		nlohmann::json apiConfig = ArkBaseApi::GetConfig();
+		const nlohmann::json autoCacheConfig = apiConfig.value("settings", nlohmann::json::object()).value("AutomaticCacheDownload", nlohmann::json::object());
 		namespace fs = std::filesystem;
-
+		
 		Log::GetLog()->info("-----------------------------------------------");
 		Log::GetLog()->info("ARK:SA Api V{:.2f}", GetVersion());
 		Log::GetLog()->info("Loading...\n");
@@ -58,14 +62,28 @@ namespace API
 			const fs::path bitfieldsCacheFile = fs::path(exe_path).append(ArkBaseApi::GetApiName()+"/Cache/cached_bitfields.cache");
 			const fs::path offsetsCacheFilePlain = fs::path(exe_path).append(ArkBaseApi::GetApiName() + "/Cache/cached_offsets.txt");
 			const std::string fileHash = Cache::calculateSHA256(filepath);
-			const std::string storedHash = Cache::readFromFile(keyCacheFile);
+			std::string storedHash = Cache::readFromFile(keyCacheFile);
 			std::unordered_set<std::string> pdbIgnoreSet = Cache::readFileIntoSet(pdbIgnoreFile);
 
-			if (fileHash != storedHash
-				|| !fs::exists(offsetsCacheFile)
-				|| !fs::exists(bitfieldsCacheFile))
+			if (autoCacheConfig.value("Enable", true)
+				&& autoCacheConfig.value("DownloadCacheURL", "https://cdn.pelayori.com/cache/") != ""
+				&& (fileHash != storedHash || !fs::exists(offsetsCacheFile) || !fs::exists(bitfieldsCacheFile)))
 			{
-				Log::GetLog()->info("Cache refresh required this will take several minutes to complete");
+				const fs::path downloadFile = autoCacheConfig.value("DownloadCacheURL", "") + fileHash + ".zip";
+				const fs::path localFile = fs::path(exe_path).append(ArkBaseApi::GetApiName() + "/Cache/" + fileHash + ".zip");
+
+				if (ArkBaseApi::DownloadCacheFiles(downloadFile, localFile))
+					storedHash = Cache::readFromFile(keyCacheFile);
+				else
+					Log::GetLog()->error("Failed to download the Cache files.");
+
+				if (fs::exists(localFile))
+					fs::remove(localFile);
+			}
+
+			if (fileHash != storedHash || !fs::exists(offsetsCacheFile) || !fs::exists(bitfieldsCacheFile))
+			{
+				Log::GetLog()->info("Cache refresh required this will take 10-20 minutes to complete");
 				pdb_reader.Read(filepath, &offsets_dump, &bitfields_dump, pdbIgnoreSet);
 
 				Log::GetLog()->info("Caching offsets for faster loading next time");
@@ -92,8 +110,6 @@ namespace API
 			return false;
 		}
 
-
-
 		Offsets::Get().Init(move(offsets_dump), move(bitfields_dump));
 		Sleep(10);
 		AsaApi::InitHooks();
@@ -103,6 +119,106 @@ namespace API
 		return true;
 	}
 
+	nlohmann::json ArkBaseApi::GetConfig()
+	{
+		const std::string config_path = AsaApi::Tools::GetCurrentDir() + "/config.json";
+		std::ifstream file{ config_path };
+		if (!file.is_open())
+			return false;
+
+		nlohmann::json config;
+		file >> config;
+		file.close();
+
+		return config;
+	}
+
+	bool ArkBaseApi::DownloadCacheFiles(const std::filesystem::path downloadFile, const std::filesystem::path localFile)
+	{
+		if (API::Requests::DownloadFile(downloadFile.string(), localFile.string()))
+		{
+			std::string outputFolder = localFile.parent_path().string();
+			unzFile zf = unzOpen(localFile.string().c_str());
+			if (zf == nullptr)
+				return false;
+
+			unz_global_info globalInfo;
+			if (unzGetGlobalInfo(zf, &globalInfo) != UNZ_OK)
+			{
+				unzClose(zf);
+				return false;
+			}
+
+			char readBuffer[8192];
+
+			for (uLong i = 0; i < globalInfo.number_entry; ++i)
+			{
+				unz_file_info fileInfo;
+				char filename[256];
+				if (unzGetCurrentFileInfo(zf, &fileInfo, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK)
+				{
+					unzClose(zf);
+					return false;
+				}
+
+				const size_t filenameLength = strlen(filename);
+				if (filename[filenameLength - 1] == '/')
+					continue;
+				else
+				{
+					if (unzOpenCurrentFile(zf) != UNZ_OK)
+					{
+						unzClose(zf);
+						return false;
+					}
+
+					std::string fullPath = outputFolder + "/" + filename;
+					std::ofstream out(fullPath, std::ios::binary);
+
+					if (!out) 
+					{
+						unzCloseCurrentFile(zf);
+						unzClose(zf);
+						return false;
+					}
+
+					int bytesRead;
+					do {
+						bytesRead = unzReadCurrentFile(zf, readBuffer, sizeof(readBuffer));
+						if (bytesRead < 0) 
+						{
+							unzCloseCurrentFile(zf);
+							unzClose(zf);
+							return false;
+						}
+
+						if (bytesRead > 0)
+							out.write(readBuffer, bytesRead);
+					} while (bytesRead > 0);
+
+					unzCloseCurrentFile(zf);
+					out.close();
+				}
+
+				if ((i + 1) < globalInfo.number_entry)
+				{
+					if (unzGoToNextFile(zf) != UNZ_OK)
+					{
+						unzClose(zf);
+						return false;
+					}
+				}
+			}
+
+			unzClose(zf);
+		}
+		else
+			return false;
+
+		Log::GetLog()->info("Cache files downloaded and processed successfully");
+		return true;
+	}
+
 	float ArkBaseApi::GetVersion()
 	{
 		return api_version;
@@ -134,6 +250,7 @@ namespace API
 		GetCommands()->AddConsoleCommand("plugins.unload", &UnloadPluginCmd);
 		GetCommands()->AddRconCommand("plugins.load", &LoadPluginRcon);
 		GetCommands()->AddRconCommand("plugins.unload", &UnloadPluginRcon);
+		GetCommands()->AddRconCommand("map.setserverid", &SetServerID);
 	}
 
 	FString ArkBaseApi::LoadPlugin(FString* cmd)
@@ -216,4 +333,48 @@ namespace API
 		FString reply = UnloadPlugin(&rcon_packet->Body);
 		rcon_connection->SendMessageW(rcon_packet->Id, 0, &reply);
 	}
+
+	void ArkBaseApi::SetServerID(RCONClientConnection* rcon_connection, RCONPacket* rcon_packet,
+		UWorld* /*unused*/)
+	{
+		FString reply = "Set new server id";
+		TArray<FString> parsed;
+		rcon_packet->Body.ParseIntoArray(parsed, L" ", true);
+
+		if (parsed.IsValidIndex(1))
+		{
+			int new_server_id = std::stoi(parsed[1].ToString());
+
+			try
+			{
+				const auto& actors = AsaApi::GetApiUtils().GetWorld()->PersistentLevelField().Get()->ActorsField();
+				for (auto actor : actors)
+				{
+					FString bp = AsaApi::GetApiUtils().GetBlueprint(actor);
+					if (bp.Equals("Blueprint'/Script/ShooterGame.PrimalPersistentWorldData'"))
+					{
+						actor->TargetingTeamField() = new_server_id;
+
+						AsaApi::GetApiUtils().GetShooterGameMode()->MyServerIdField() = FString(std::to_string(new_server_id));
+						AsaApi::GetApiUtils().GetShooterGameMode()->ServerIDField() = new_server_id;
+						Log::GetLog()->info("SERVER ID: {}", new_server_id);
+						Log::GetLog()->info("Forcing world save to lock-in new server id");
+						AsaApi::GetApiUtils().GetShooterGameMode()->SaveWorld(false, true);
+
+						break;
+					}
+				}
+			}
+			catch (const std::exception& error)
+			{
+				Log::GetLog()->warn("({}) {}", __FUNCTION__, error.what());
+				reply = FString::Format("Failed to set server id - {}", error.what());
+			}
+		}
+		else
+			reply = L"You must specify a unique server id.";
+
+		
+		rcon_connection->SendMessageW(rcon_packet->Id, 0, &reply);
+	}
 } // namespace API

AsaApi/Core/Private/Ark/ArkBaseApi.h

@@ -3,6 +3,8 @@
 #include "../IBaseApi.h"
 #include <IApiUtils.h>
 #include "Containers/UnrealString.h"
+#include <filesystem>
+#include <json.hpp>
 
 namespace API
 {
@@ -22,6 +24,9 @@ namespace API
 		std::unique_ptr<AsaApi::IApiUtils>& GetApiUtils() override;
 
 	private:
+		nlohmann::json GetConfig();
+		bool DownloadCacheFiles(const std::filesystem::path downloadFile, const std::filesystem::path localFile);
+
 		// Callbacks
 		static FString LoadPlugin(FString* cmd);
 		static FString UnloadPlugin(FString* cmd);
@@ -34,6 +39,9 @@ namespace API
 		static void UnloadPluginRcon(RCONClientConnection* /*rcon_connection*/, RCONPacket* /*rcon_packet*/,
 			UWorld* /*unused*/);
 
+		static void SetServerID(RCONClientConnection* /*rcon_connection*/, RCONPacket* /*rcon_packet*/,
+			UWorld* /*unused*/);
+
 		std::unique_ptr<AsaApi::ICommands> commands_;
 		std::unique_ptr<AsaApi::IHooks> hooks_;
 		std::unique_ptr<AsaApi::IApiUtils> api_utils_;

AsaApi/Core/Private/Offsets.cpp

@@ -49,45 +49,39 @@ namespace API
 
 	DWORD64 Offsets::GetAddress(const void* base, const std::string& name)
 	{
-#ifdef API_DEBUG
 		if (!offsets_dump_.contains(name))
 		{
 			Log::GetLog()->critical("Failed to get the offset of {}.", name);
 			Log::GetLog()->flush();
 			Sleep(10000);
 			throw;
 		}
-#endif
 
 		return reinterpret_cast<DWORD64>(base) + static_cast<DWORD64>(offsets_dump_[name]);
 	}
 
 	LPVOID Offsets::GetAddress(const std::string& name)
 	{
-#ifdef API_DEBUG
 		if (!offsets_dump_.contains(name))
 		{
 			Log::GetLog()->critical("Failed to get the offset of {}.", name);
 			Log::GetLog()->flush();
 			Sleep(10000);
 			throw;
 		}
-#endif
 
 		return reinterpret_cast<LPVOID>(module_base_ + static_cast<DWORD64>(offsets_dump_[name]));
 	}
 
 	LPVOID Offsets::GetDataAddress(const std::string& name)
 	{
-#ifdef API_DEBUG
 		if (!offsets_dump_.contains(name))
 		{
 			Log::GetLog()->critical("Failed to get the offset of {}.", name);
 			Log::GetLog()->flush();
 			Sleep(10000);
 			throw;
 		}
-#endif
 
 		return reinterpret_cast<LPVOID>(data_base_ + static_cast<DWORD64>(offsets_dump_[name]));
 	}
@@ -104,15 +98,13 @@ namespace API
 
 	BitField Offsets::GetBitFieldInternal(const void* base, const std::string& name)
 	{
-#ifdef API_DEBUG
 		if (!bitfields_dump_.contains(name))
 		{
 			Log::GetLog()->critical("Failed to get the bitfield address of {}.", name);
 			Log::GetLog()->flush();
 			Sleep(10000);
 			throw;
 		}
-#endif
 
 		const auto bf = bitfields_dump_[name];
 		auto cf = BitField();

AsaApi/Core/Private/PluginManager/PluginManager.cpp

@@ -297,7 +297,7 @@ namespace API
 				if (save_world)
 				{
 					Log::GetLog()->info("Saving world before reloading plugins");
-					AsaApi::GetApiUtils().GetShooterGameMode()->SaveWorld(true);
+					AsaApi::GetApiUtils().GetShooterGameMode()->SaveWorld(true, true);
 					Log::GetLog()->info("World saved.");
 
 					save_world = false; // do not save again if multiple plugins are reloaded in this loop