add spt forced linker

src/acts/tools/ff/linkers/bo4/linker_bo4_rawfile.cpp

@@ -36,14 +36,15 @@ namespace fastfile::linker::bo4 {
 
 				RawFile& rf{ utils::Allocate<RawFile>(ctx.assetData) };
 
-				rf.name.hash = HashPathName(rfpath);
+				uint64_t hash = HashPathName(rfpath);
+				rf.name.hash = hash;
 				rf.buffer = fastfile::ALLOC_PTR;
 				rf.len = (uint32_t)buffer.size();
 
 				// write header
 				utils::WriteValue(ctx.assetData, buffer.data(), buffer.length() + 1); // add \0
 				ctx.assets.emplace_back(games::bo4::pool::ASSET_TYPE_RAWFILE, fastfile::ALLOC_PTR);
-				LOG_INFO("Added asset rawfile {} (hash_{:x})", path.string(), rf.name.hash);
+				LOG_INFO("Added asset rawfile {} (hash_{:x})", path.string(), hash);
 			}
 		}
 	};

src/acts/tools/ff/linkers/bo4/linker_bo4_scriptparsetree.cpp

@@ -31,7 +31,7 @@ namespace fastfile::linker::bo4 {
 			buffer.push_back(0); // the game is reading (len + 1) so we add a byte at the end
 			utils::WriteValue(ctx.assetData, buffer.data(), buffer.size());
 			ctx.assets.emplace_back(games::bo4::pool::ASSET_TYPE_SCRIPTPARSETREE, fastfile::ALLOC_PTR);
-			LOG_INFO("Added asset scriptparsetree {} (hash_{:x})", path.string(), spt.name.hash);
+			LOG_INFO("Added asset scriptparsetree {} (hash_{:x})", path.string(), obj.name);
 		}
 
 		void Compute(BO4LinkContext& ctx) override {

src/acts/tools/ff/linkers/bo4/linker_bo4_scriptparsetree_forced.cpp

@@ -0,0 +1,66 @@
+#include <includes.hpp>
+#include <tools/ff/linkers/linker_bo4.hpp>
+
+namespace fastfile::linker::bo4 {
+	class ScriptParseTreeForcedWorker : public LinkerWorker {
+	public:
+		ScriptParseTreeForcedWorker() : LinkerWorker("ScriptParseTreeForced") {}
+
+		void Compute(BO4LinkContext& ctx) override {
+
+			std::filesystem::path forcedConfigPath{ ctx.linkCtx.input / "sptforced.json" };
+			core::config::Config forcedConfig{ forcedConfigPath };
+			forcedConfig.SyncConfig(false);
+			if (forcedConfig.main.Empty()) return; // nothing to force
+
+			std::vector<XHash> serverScripts{};
+			std::vector<XHash> clientScripts{};
+
+			if (forcedConfig.main.HasMember("server")) {
+				for (auto& e : forcedConfig.main["server"].GetArray()) {
+					if (!e.IsString()) {
+						LOG_WARNING("Invalid entry in sptforced.json: {}", e.GetString());
+						continue;
+					}
+					serverScripts.emplace_back(hash::Hash64Pattern(e.GetString()), 0);
+				}
+			}
+			if (forcedConfig.main.HasMember("client")) {
+				for (auto& e : forcedConfig.main["client"].GetArray()) {
+					if (!e.IsString()) {
+						LOG_WARNING("Invalid entry in sptforced.json: {}", e.GetString());
+						continue;
+					}
+					clientScripts.emplace_back(hash::Hash64Pattern(e.GetString()), 0);
+				}
+			}
+
+			if (clientScripts.empty() && serverScripts.empty()) {
+				LOG_INFO("Nothing to compile for spt forced: {}", forcedConfigPath.string());
+				return; // nothing to compile
+			}
+
+			struct ScriptParseTreeForced {
+				XHash name;
+				uint32_t gscCount;
+				uint32_t cscCount;
+				uintptr_t gscScripts; // XHash*
+				uintptr_t cscScripts; // XHash*
+			};
+
+			ScriptParseTreeForced& header{ utils::Allocate<ScriptParseTreeForced>(ctx.assetData) };
+			header.name.hash = ctx.ffnameHash;
+			header.gscCount = (uint32_t)serverScripts.size();
+			header.cscCount = (uint32_t)clientScripts.size();
+			if (serverScripts.size()) header.gscScripts = fastfile::ALLOC_PTR;
+			if (clientScripts.size()) header.cscScripts = fastfile::ALLOC_PTR;
+
+			utils::WriteValue(ctx.assetData, serverScripts.data(), serverScripts.size() * sizeof(serverScripts[0]));
+			utils::WriteValue(ctx.assetData, clientScripts.data(), clientScripts.size() * sizeof(clientScripts[0]));
+			ctx.assets.emplace_back(games::bo4::pool::ASSET_TYPE_SCRIPTPARSETREEFORCED, fastfile::ALLOC_PTR);
+			LOG_INFO("Added asset scriptparsetreeforced {} (hash_{:x})", forcedConfigPath.string(), ctx.ffnameHash);
+		}
+	};
+
+	utils::ArrayAdder<ScriptParseTreeForcedWorker, LinkerWorker> impl{ GetWorkers() };
+}

src/acts/tools/ff/linkers/linker_bo4.cpp

@@ -44,6 +44,7 @@ namespace fastfile::linker::bo4 {
 			}
 
 			BO4LinkContext bo4ctx{ ctx, cfg };
+			bo4ctx.ffnameHash = hash::Hash64Pattern(ctx.ffname);
 
 
 			// load files into bo4ctx.assetData

src/acts/tools/ff/linkers/linker_bo4.hpp

@@ -31,6 +31,7 @@ namespace fastfile::linker::bo4 {
 		std::vector<const char*> strings{};
 		std::vector<XAsset> assets{};
 		bool error{};
+		uint64_t ffnameHash{};
 	};
 
 	class LinkerWorker {

test/ff-linker/core_test/sptforced.json

@@ -0,0 +1,8 @@
+{
+    "server": [
+        "scripts/core_common/acts/test_shared.gsc"
+    ],
+    "client": [
+        "scripts/core_common/acts/test_shared.csc"
+    ]
+}