Add workflows

Update Premake5, fix git modules.

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+- package-ecosystem: gitsubmodule
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

.github/workflows/build.yml

@@ -0,0 +1,45 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - "*"
+  pull_request:
+    branches:
+      - "*"
+    types: [opened, synchronize, reopened]
+jobs:
+  build:
+    name: Build binaries
+    runs-on: windows-2022
+    strategy:
+      matrix:
+        configuration:
+          - Debug
+          - Release
+    steps:
+      - name: Check out files
+        uses: actions/checkout@v3
+        with:
+          submodules: true
+          fetch-depth: 0
+          lfs: false
+
+      - name: Add msbuild to PATH
+        uses: microsoft/setup-msbuild@v1.1.3
+
+      - name: Generate project files
+        run: tools/premake5 vs2022
+
+      - name: Set up problem matching
+        uses: ammaraskar/msvc-problem-matcher@master
+
+      - name: Build ${{matrix.configuration}} binaries
+        run: msbuild /m /v:minimal /p:Configuration=${{matrix.configuration}} /p:PlatformTarget=x86 build/iw5-gsc-utils.sln
+
+      - name: Upload ${{matrix.configuration}} binaries
+        uses: actions/upload-artifact@v3.1.0
+        with:
+          name: ${{matrix.configuration}} binaries
+          path: |
+            build/bin/${{matrix.configuration}}/iw5-gsc-utils.dll

.gitmodules

@@ -4,12 +4,13 @@
 [submodule "deps/GSL"]
 	path = deps/GSL
 	url = https://github.com/microsoft/GSL.git
-[submodule "deps/sol2"]
-	path = deps/sol2
-	url = https://github.com/ThePhD/sol2.git
-[submodule "deps/lua"]
-	path = deps/lua
-	url = https://github.com/lua/lua.git
 [submodule "deps/json"]
 	path = deps/json
 	url = https://github.com/nlohmann/json.git
+	branch = develop
+[submodule "deps/gsc-tool"]
+	path = deps/gsc-tool
+	url = https://github.com/xensik/gsc-tool.git
+[submodule "deps/zlib"]
+	path = deps/zlib
+	url = https://github.com/madler/zlib.git

README.md

@@ -10,7 +10,7 @@ This plugin adds some useful functions/methods to IW5's GSC VM
   ```c
   init()
   {
-    replaceFunc(maps\mp\gametypes\_damage::Callback_PlayerDamage, ::callbackPlayerDamage);
+      replaceFunc(maps\mp\gametypes\_damage::Callback_PlayerDamage, ::callbackPlayerDamage);
   }
 
   callbackPlayerDamage(eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, timeOffset)
@@ -43,7 +43,19 @@ This plugin adds some useful functions/methods to IW5's GSC VM
       }
   }
   ```
+# Player
+* `say(message)`: Prints a message to all players' chat.
+
+* `self tell(message)`: Prints a message to the player's chat.
+* `self setName(name)`: Sets a player's name.
+* `self resetName(name)`: Resets a player's name to its original.
+* `self setClantag(name)`: Sets a player's clantag.
+* `self resetClantag(name)`: Resets a player's clantag to its original.
+* `self removeClantag(name)`: Removes a player's clantag.
 # IO
+
+The basepath for all IO functions is `Plutonium/storage/iw5`
+
 * `fopen(path, mode)`: Opens a file of given name with given mode, returns a file stream.
 * `fwrite(stream, text)`: Writes a string to a stream.
 * `fread(stream)`: Reads entire file.
@@ -64,6 +76,15 @@ This plugin adds some useful functions/methods to IW5's GSC VM
       fclose(file);
   }
   ```
+ * `fileExists(path)`: Returns true if the file exists.
+ * `writeFile(path, data[, append])`: Creates a file if it doesn't exist and writes/appends text to it.
+ * `readFile(path)`: Reads a file.
+ * `fileSize(path)`: Returns file size in bytes.
+ * `createDirectory(path)`: Creates a directory.
+ * `directoryExists(path)`: Returns true if the directory exists.
+ * `directoryIsEmpty(path)`: Returns true if the directory is empty.
+ * `listFiles(path)`: Returns the list of files in the directory as an array.
+ * `copyFolder(source, target)`: Copies a folder.
 
 # JSON
 
@@ -205,6 +226,6 @@ This plugin adds some useful functions/methods to IW5's GSC VM
       */
   }
   ```
- 
+ * `jsonPrint(...)`: Prints values as json.
  # Credits
  * [xensik](https://github.com/xensik)

deps/premake/gsc-tool.lua

@@ -0,0 +1,62 @@
+gsc_tool = {
+	source = path.join(dependencies.basePath, "gsc-tool"),
+}
+
+function gsc_tool.import()
+	links { "xsk-gsc-iw5-pc", "xsk-gsc-utils" }
+	gsc_tool.includes()
+end
+
+function gsc_tool.includes()
+	includedirs {
+		path.join(gsc_tool.source, "include"),
+	}
+end
+
+function gsc_tool.project()
+	project "xsk-gsc-utils"
+		kind "StaticLib"
+		language "C++"
+
+		files {
+			path.join(gsc_tool.source, "include/xsk/utils/*.hpp"),
+			path.join(gsc_tool.source, "src/utils/*.cpp"),
+		}
+
+		includedirs {
+			path.join(gsc_tool.source, "include"),
+		}
+
+		zlib.includes()
+
+	project "xsk-gsc-iw5-pc"
+		kind "StaticLib"
+		language "C++"
+
+		filter "action:vs*"
+			buildoptions "/Zc:__cplusplus"
+		filter {}
+
+		files {
+			path.join(gsc_tool.source, "include/xsk/stdinc.hpp"),
+
+			path.join(gsc_tool.source, "include/xsk/gsc/engine/iw5_pc.hpp"),
+			path.join(gsc_tool.source, "src/gsc/engine/iw5_pc.cpp"),
+
+			path.join(gsc_tool.source, "src/gsc/engine/iw5_pc_code.cpp"),
+			path.join(gsc_tool.source, "src/gsc/engine/iw5_pc_func.cpp"),
+			path.join(gsc_tool.source, "src/gsc/engine/iw5_pc_meth.cpp"),
+			path.join(gsc_tool.source, "src/gsc/engine/iw5_pc_token.cpp"),
+
+			path.join(gsc_tool.source, "src/gsc/*.cpp"),
+
+			path.join(gsc_tool.source, "src/gsc/common/*.cpp"),
+			path.join(gsc_tool.source, "include/xsk/gsc/common/*.hpp"),
+		}
+
+		includedirs {
+			path.join(gsc_tool.source, "include"),
+		}
+end
+
+table.insert(dependencies, gsc_tool)

deps/premake/zlib.lua

@@ -0,0 +1,39 @@
+zlib = {
+	source = path.join(dependencies.basePath, "zlib"),
+}
+
+function zlib.import()
+	links { "zlib" }
+	zlib.includes()
+end
+
+function zlib.includes()
+	includedirs {
+		zlib.source
+	}
+
+	defines {
+		"ZLIB_CONST",
+	}
+end
+
+function zlib.project()
+	project "zlib"
+		language "C"
+
+		zlib.includes()
+
+		files {
+			path.join(zlib.source, "*.h"),
+			path.join(zlib.source, "*.c"),
+		}
+
+		defines {
+			"_CRT_SECURE_NO_DEPRECATE",
+		}
+
+		warnings "Off"
+		kind "StaticLib"
+end
+
+table.insert(dependencies, zlib)

generate.bat

@@ -1,2 +1,4 @@
 @echo off
-tools\windows\premake5.exe vs2019
+call git submodule update --init --recursive
+tools\windows\premake5.exe vs2022
+pause

premake5.lua

@@ -36,32 +36,35 @@ workspace "iw5-gsc-utils"
 	targetdir "%{wks.location}/bin/%{cfg.buildcfg}"
 	targetname "%{prj.name}"
 
+	configurations { "Debug", "Release", }
+
 	language "C++"
+	cppdialect "C++20"
 
 	architecture "x86"
 
-	buildoptions "/std:c++latest"
 	systemversion "latest"
+	symbols "On"
+	staticruntime "On"
+	editandcontinue "Off"
+	warnings "Extra"
+	characterset "ASCII"
 
 	flags
 	{
 		"NoIncrementalLink",
 		"MultiProcessorCompile",
 	}
-
-	configurations { "Debug", "Release", }
-
-	symbols "On"
 	
-	configuration "Release"
+	filter "configurations:Release"
 		optimize "Full"
 		defines { "NDEBUG" }
-	configuration{}
+	filter {}
 
-	configuration "Debug"
+	filter "configurations:Debug"
 		optimize "Debug"
 		defines { "DEBUG", "_DEBUG" }
-	configuration {}
+	filter {}
 
 	startproject "iw5-gsc-utils"
 

src/component/command.cpp

@@ -49,6 +49,7 @@ namespace command
 			if (i > index) result.append(" ");
 			result.append(this->get(i));
 		}
+
 		return result;
 	}
 
@@ -96,7 +97,6 @@ namespace command
 	public:
 		void post_unpack() override
 		{
-
 		}
 	};
 }

src/component/gsc.cpp

@@ -8,37 +8,12 @@
 #include "game/scripting/execution.hpp"
 #include "game/scripting/functions.hpp"
 #include "game/scripting/array.hpp"
+#include "game/scripting/function.hpp"
 
 #include "gsc.hpp"
 
 namespace gsc
 {
-	function_args::function_args(std::vector<scripting::script_value> values)
-		: values_(values)
-	{
-	}
-
-	unsigned int function_args::size() const
-	{
-		return this->values_.size();
-	}
-
-	std::vector<scripting::script_value> function_args::get_raw() const
-	{
-		return this->values_;
-	}
-
-	scripting::script_value function_args::get(const int index) const
-	{
-		if (index >= this->values_.size())
-		{
-			throw std::runtime_error(utils::string::va("Insufficient arguments, got %i expected %i", 
-				this->values_.size(), index + 1));
-		}
-		
-		return this->values_[index];
-	}
-
 	std::unordered_map<unsigned, script_function> functions;
 	std::unordered_map<unsigned, script_method> methods;
 
@@ -46,13 +21,13 @@ namespace gsc
 	{
 		std::string method_name(unsigned int id)
 		{
-			const auto map = *game::plutonium::method_map_rev;
+			const auto& map = (*game::plutonium::gsc_ctx)->meth_map();
 
 			for (const auto& function : map)
 			{
 				if (function.second == id)
 				{
-					return function.first;
+					return function.first.data();
 				}
 			}
 
@@ -61,13 +36,13 @@ namespace gsc
 
 		std::string function_name(unsigned int id)
 		{
-			const auto map = *game::plutonium::function_map_rev;
+			const auto& map = (*game::plutonium::gsc_ctx)->func_map();
 
 			for (const auto& function : map)
 			{
 				if (function.second == id)
 				{
-					return function.first;
+					return function.first.data();
 				}
 			}
 
@@ -78,8 +53,6 @@ namespace gsc
 		{
 			std::vector<scripting::script_value> args;
 
-			const auto top = game::scr_VmPub->top;
-
 			for (auto i = 0; i < game::scr_VmPub->outparamcount; i++)
 			{
 				const auto value = game::scr_VmPub->top[-i];
@@ -101,12 +74,24 @@ namespace gsc
 
 		auto function_map_start = 0x200;
 		auto method_map_start = 0x8400;
+		auto token_map_start = 0x8000;
+		auto field_offset_start = 0xA000;
+
+		struct entity_field
+		{
+			std::string name;
+			std::function<scripting::script_value(unsigned int entnum)> getter;
+			std::function<void(unsigned int entnum, scripting::script_value)> setter;
+		};
+
+		std::vector<std::function<void()>> post_load_callbacks;
+		std::unordered_map<unsigned int, std::unordered_map<unsigned int, entity_field>> custom_fields;
 
 		void call_function(unsigned int id)
 		{
 			if (id < 0x200)
 			{
-				return reinterpret_cast<builtin_function*>(0x1D6EB34)[id]();
+				return reinterpret_cast<builtin_function*>(game::plutonium::function_table.get())[id]();
 			}
 
 			try
@@ -119,11 +104,11 @@ namespace gsc
 					return_value(result);
 				}
 			}
-			catch (std::exception e)
+			catch (const std::exception& e)
 			{
 				printf("************** Script execution error **************\n");
-				printf("Error executing function %s\n", function_name(id).data());
+				printf("Error executing function %s:\n", function_name(id).data());
-				printf("%s\n", e.what());
+				printf("    %s\n", e.what());
 				printf("****************************************************\n");
 			}
 		}
@@ -132,7 +117,7 @@ namespace gsc
 		{
 			if (id < 0x8400)
 			{
-				return reinterpret_cast<builtin_method*>(0x1D4F258)[id](ent);
+				return reinterpret_cast<builtin_method*>(game::plutonium::method_table.get())[id - 0x8000](ent);
 			}
 
 			try
@@ -145,11 +130,11 @@ namespace gsc
 					return_value(result);
 				}
 			}
-			catch (std::exception e)
+			catch (const std::exception& e)
 			{
 				printf("************** Script execution error **************\n");
-				printf("Error executing method %s\n", method_name(id).data());
+				printf("Error executing method %s:\n", method_name(id).data());
-				printf("%s\n", e.what());
+				printf("    %s\n", e.what());
 				printf("****************************************************\n");
 			}
 		}
@@ -199,60 +184,63 @@ namespace gsc
 			}
 		}
 
-		unsigned int replaced_pos = 0;
+		utils::hook::detour scr_get_object_field_hook;
-
+		void scr_get_object_field_stub(unsigned int classnum, int entnum, unsigned int offset)
-		void get_replaced_pos(unsigned int pos)
 		{
-			if (scripting::replaced_functions.find(pos) != scripting::replaced_functions.end())
+			if (custom_fields[classnum].find(offset) == custom_fields[classnum].end())
 			{
-				replaced_pos = scripting::replaced_functions[pos];
+				return scr_get_object_field_hook.invoke<void>(classnum, entnum, offset);
+			}
+
+			const auto& field = custom_fields[classnum][offset];
+
+			try
+			{
+				const auto result = field.getter(entnum);
+				return_value(result);
+			}
+			catch (const std::exception& e)
+			{
+				printf("************** Script execution error **************\n");
+				printf("Error getting field %s:\n", field.name.data());
+				printf("    %s\n", e.what());
+				printf("****************************************************\n");
 			}
 		}
 
-		__declspec(naked) void vm_execute_stub()
+		utils::hook::detour scr_set_object_field_hook;
+		void scr_set_object_field_stub(unsigned int classnum, int entnum, unsigned int offset)
 		{
-			__asm
+			if (custom_fields[classnum].find(offset) == custom_fields[classnum].end())
 			{
-				pushad
+				return scr_set_object_field_hook.invoke<void>(classnum, entnum, offset);
-				push esi
-				call get_replaced_pos
-				pop esi
-				popad
-
-				cmp replaced_pos, 0
-				jne set_pos
-
-				movzx eax, byte ptr[esi]
-				inc esi
-
-				jmp loc_1
-			loc_1:
-				mov [ebp - 0x18], eax
-				mov [ebp - 0x8], esi
-
-				push ecx
-
-				mov ecx, 0x20B8E28
-				mov [ecx], eax
-
-				mov ecx, 0x20B4A5C
-				mov[ecx], esi
-
-				pop ecx
-
-				cmp eax, 0x98
-
-				push 0x56B740
-				retn
-			set_pos:
-				mov esi, replaced_pos
-				mov replaced_pos, 0
-
-				movzx eax, byte ptr[esi]
-				inc esi
-
-				jmp loc_1
 			}
+
+			const auto args = get_arguments();
+			const auto& field = custom_fields[classnum][offset];
+
+			try
+			{
+				field.setter(entnum, args[0]);
+			}
+			catch (const std::exception& e)
+			{
+				printf("************** Script execution error **************\n");
+				printf("Error setting field %s:\n", field.name.data());
+				printf("    %s\n", e.what());
+				printf("****************************************************\n");
+			}
+		}
+
+		utils::hook::detour scr_post_load_scripts_hook;
+		void scr_post_load_scripts_stub()
+		{
+			for (const auto& callback : post_load_callbacks)
+			{
+				callback();
+			}
+
+			return scr_post_load_scripts_hook.invoke<void>();
 		}
 	}
 
@@ -260,10 +248,16 @@ namespace gsc
 	{
 		void add(const std::string& name, const script_function& func)
 		{
-			const auto index = function_map_start++;
+			try
-
+			{
-			functions[index] = func;
+				const auto index = function_map_start++;
-			(*game::plutonium::function_map_rev)[name] = index;
+				functions[index] = func;
+				(*game::plutonium::gsc_ctx)->func_add(name, index);
+			}
+			catch (const std::exception& e)
+			{
+				printf("[iw5-gsc-utils] failed to add function \"%s\": %s\n", name.data(), e.what());
+			}
 		}
 	}
 
@@ -271,51 +265,107 @@ namespace gsc
 	{
 		void add(const std::string& name, const script_method& func)
 		{
-			const auto index = method_map_start++;
+			try
-
+			{
-			methods[index] = func;
+				const auto index = method_map_start++;
-			(*game::plutonium::method_map_rev)[name] = index;
+				methods[index] = func;
+				(*game::plutonium::gsc_ctx)->meth_add(name, index);
+			}
+			catch (const std::exception& e)
+			{
+				printf("[iw5-gsc-utils] failed to add method \"%s\": %s\n", name.data(), e.what());
+			}
 		}
 	}
 
+	namespace field
+	{
+		void add(const classid classnum, const std::string& name,
+			const std::function<scripting::script_value(unsigned int entnum)>& getter,
+			const std::function<void(unsigned int entnum, const scripting::script_value&)>& setter)
+		{
+			const auto offset = field_offset_start++;
+			custom_fields[classnum][offset] = {name, getter, setter};
+
+			post_load_callbacks.push_back([=]()
+			{
+				const auto name_str = game::SL_GetString(name.data(), 0);
+				game::Scr_AddClassField(classnum, name_str, game::SL_GetCanonicalString(name.data()), offset);
+			});
+		}
+	}
+
+	function_args::function_args(std::vector<scripting::script_value> values)
+		: values_(values)
+	{
+	}
+
+	unsigned int function_args::size() const
+	{
+		return this->values_.size();
+	}
+
+	std::vector<scripting::script_value> function_args::get_raw() const
+	{
+		return this->values_;
+	}
+
+	scripting::value_wrap function_args::get(const int index) const
+	{
+		if (index >= this->values_.size())
+		{
+			throw std::runtime_error(utils::string::va("parameter %d does not exist", index));
+		}
+
+		return {this->values_[index], index};
+	}
+
 	class component final : public component_interface
 	{
 	public:
 		void post_unpack() override
 		{
-			function::add("executecommand", [](function_args args) -> scripting::script_value
+			scr_get_object_field_hook.create(0x52BDB0, scr_get_object_field_stub);
+			scr_set_object_field_hook.create(0x52BCC0, scr_set_object_field_stub);
+			scr_post_load_scripts_hook.create(0x628B50, scr_post_load_scripts_stub);
+
+			field::add(classid::entity, "entityflags",
+				[](unsigned int entnum) -> scripting::script_value
+				{
+					const auto entity = &game::g_entities[entnum];
+					return entity->flags;
+				},
+				[](unsigned int entnum, const scripting::script_value& value)
+				{
+					const auto entity = &game::g_entities[entnum];
+					entity->flags = value.as<int>();
+				}
+			);
+
+			field::add(classid::entity, "clientflags",
+				[](unsigned int entnum) -> scripting::script_value
+				{
+					const auto entity = &game::g_entities[entnum];
+					return entity->client->flags;
+				},
+				[](unsigned int entnum, const scripting::script_value& value)
+				{
+					const auto entity = &game::g_entities[entnum];
+					entity->client->flags = value.as<int>();
+				}
+			);
+
+			function::add("executecommand", [](const function_args& args) -> scripting::script_value
 			{
 				game::Cbuf_AddText(0, args[0].as<const char*>());
 				return {};
 			});
 
-			function::add("replacefunc", [](function_args args) -> scripting::script_value
+			function::add("addcommand", [](const function_args& args) -> scripting::script_value
-			{
-				const auto what = args[0].get_raw();
-				const auto with = args[1].get_raw();
-
-				if (what.type != game::SCRIPT_FUNCTION || with.type != game::SCRIPT_FUNCTION)
-				{
-					throw std::runtime_error("Invalid type");
-				}
-
-				scripting::replaced_functions[what.u.uintValue] = with.u.uintValue;
-
-				return {};
-			});
-
-			function::add("addcommand", [](function_args args) -> scripting::script_value
 			{
 				const auto name = args[0].as<std::string>();
-				const auto function = args[1].get_raw();
+				const auto function = args[1].as<scripting::function>();
-
+				command::add_script_command(name, [function](const command::params& params)
-				if (function.type != game::SCRIPT_FUNCTION)
-				{
-					throw std::runtime_error("Invalid type");
-				}
-
-				const auto pos = function.u.codePosValue;
-				command::add_script_command(name, [pos](const command::params& params)
 				{
 					scripting::array array;
 					for (auto i = 0; i < params.size(); i++)
@@ -323,13 +373,13 @@ namespace gsc
 						array.push(params[i]);
 					}
 
-					scripting::exec_ent_thread(*game::levelEntityId, pos, {array.get_raw()});
+					function({array.get_raw()});
 				});
 
 				return {};
 			});
 
-			function::add("say", [](function_args args) -> scripting::script_value
+			function::add("say", [](const function_args& args) -> scripting::script_value
 			{
 				const auto message = args[0].as<std::string>();
 				game::SV_GameSendServerCommand(-1, 0, utils::string::va("%c \"%s\"", 84, message.data()));
@@ -337,26 +387,105 @@ namespace gsc
 				return {};
 			});
 
-			method::add("tell", [](game::scr_entref_t ent, function_args args) -> scripting::script_value
+			function::add("dropallbots", [](const function_args&) -> scripting::script_value
+			{
+				for (auto i = 0; i < *game::svs_clientCount; i++)
+				{
+					if (game::svs_clients[i].header.state != game::CS_FREE
+						&& game::svs_clients[i].header.netchan.remoteAddress.type == game::NA_BOT)
+					{
+						game::SV_GameDropClient(i, "GAME_GET_TO_COVER");
+					}
+				}
+
+				return {};
+			});
+
+			method::add("tell", [](const game::scr_entref_t ent, const function_args& args) -> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
-					throw std::runtime_error("Invalid type");
+					throw std::runtime_error("Invalid entity");
 				}
 
 				const auto client = ent.entnum;
-				const auto message = args[0].as<std::string>();
 
+				if (game::g_entities[client].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				const auto message = args[0].as<std::string>();
 				game::SV_GameSendServerCommand(client, 0, utils::string::va("%c \"%s\"", 84, message.data()));
 
 				return {};
 			});
 
-			utils::hook::jump(0x56C8EB, call_builtin_stub);
+			method::add("specialtymarathon", [](const game::scr_entref_t ent, const function_args& args) -> scripting::script_value
-			utils::hook::jump(0x56CBDC, call_builtin_method_stub);
+			{
-			utils::hook::jump(0x56B726, vm_execute_stub);
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				const auto client = ent.entnum;
+
+				if (game::g_entities[client].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				const auto toggle = args[0].as<int>();
+				auto flags = game::g_entities[client].client->ps.perks[0];
+
+				game::g_entities[client].client->ps.perks[0] = toggle
+					? flags | 0x4000u : flags & ~0x4000u;
+
+				return {};
+			});
+
+			method::add("isbot", [](const game::scr_entref_t ent, const function_args&) -> scripting::script_value
+			{
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				const auto client = ent.entnum;
+
+				if (game::g_entities[client].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				return game::svs_clients[client].bIsTestClient;
+			});
+
+			method::add("arecontrolsfrozen", [](const game::scr_entref_t ent, const function_args&) -> scripting::script_value
+			{
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				const auto client = ent.entnum;
+
+				if (game::g_entities[client].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				return {(game::g_entities[client].client->flags & 4) != 0};
+			});
+
+			// let other plugins read the pointers
+			post_load_callbacks.push_back([]()
+			{
+				utils::hook::jump(0x56C8EB, call_builtin_stub);
+				utils::hook::jump(0x56CBDC, call_builtin_method_stub);
+			});
 		}
 	};
 }
 
-REGISTER_COMPONENT(gsc::component)
+REGISTER_COMPONENT(gsc::component)

src/component/gsc.hpp

@@ -1,17 +1,28 @@
 #pragma once
+#include "game/scripting/array.hpp"
+#include "game/scripting/execution.hpp"
 
 namespace gsc
 {
+	enum classid
+	{
+		entity,
+		hudelem,
+		pathnode,
+		node,
+		count
+	};
+
 	class function_args
 	{
 	public:
 		function_args(std::vector<scripting::script_value>);
 
-		unsigned int function_args::size() const;
+		unsigned int size() const;
-		std::vector<scripting::script_value> function_args::get_raw() const;
+		std::vector<scripting::script_value> get_raw() const;
-		scripting::script_value get(const int index) const;
+		scripting::value_wrap get(const int index) const;
 
-		scripting::script_value operator[](const int index) const
+		scripting::value_wrap operator[](const int index) const
 		{
 			return this->get(index);
 		}
@@ -22,8 +33,8 @@ namespace gsc
 	using builtin_function = void(*)();
 	using builtin_method = void(*)(game::scr_entref_t);
 
-	using script_function = std::function<scripting::script_value(function_args)>;
+	using script_function = std::function<scripting::script_value(const function_args&)>;
-	using script_method = std::function<scripting::script_value(game::scr_entref_t, function_args)>;
+	using script_method = std::function<scripting::script_value(const game::scr_entref_t, const function_args&)>;
 
 	namespace function
 	{
@@ -34,4 +45,11 @@ namespace gsc
 	{
 		void add(const std::string& name, const script_method& func);
 	}
+
+	namespace field
+	{
+		void add(const classid classnum, const std::string& name,
+			const std::function<scripting::script_value(unsigned int entnum)>& getter,
+			const std::function<void(unsigned int entnum, const scripting::script_value&)>& setter);
+	}
 }

src/component/io.cpp

@@ -2,13 +2,8 @@
 #include "loader/component_loader.hpp"
 
 #include "scheduler.hpp"
-
-#include "game/scripting/event.hpp"
-#include "game/scripting/execution.hpp"
-#include "game/scripting/functions.hpp"
-#include "game/scripting/array.hpp"
-
 #include "gsc.hpp"
+#include "json.hpp"
 
 namespace io
 {
@@ -20,13 +15,27 @@ namespace io
 			const auto path = game::Dvar_FindVar("fs_basegame")->current.string;
 			std::filesystem::current_path(path);
 
-			gsc::function::add("fremove", [](gsc::function_args args)
+			gsc::function::add("jsonprint", [](const gsc::function_args& args) -> scripting::script_value
+			{
+				std::string buffer;
+
+				for (const auto arg : args.get_raw())
+				{
+					buffer.append(json::gsc_to_string(arg));
+					buffer.append("\t");
+				}
+
+				printf("%s\n", buffer.data());
+				return {};
+			});
+
+			gsc::function::add("fremove", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<const char*>();
 				return std::remove(path);
 			});
 
-			gsc::function::add("fopen", [](gsc::function_args args)
+			gsc::function::add("fopen", [](const gsc::function_args& args)
 			{
 				const auto* path = args[0].as<const char*>();
 				const auto* mode = args[1].as<const char*>();
@@ -41,13 +50,13 @@ namespace io
 				return handle;
 			});
 
-			gsc::function::add("fclose", [](gsc::function_args args)
+			gsc::function::add("fclose", [](const gsc::function_args& args)
 			{
 				const auto handle = args[0].as_ptr<FILE>();
 				return fclose(handle);
 			});
 
-			gsc::function::add("fwrite", [](gsc::function_args args)
+			gsc::function::add("fwrite", [](const gsc::function_args& args)
 			{
 				const auto handle = args[0].as_ptr<FILE>();
 				const auto text = args[1].as<const char*>();
@@ -55,7 +64,7 @@ namespace io
 				return fprintf(handle, text);
 			});
 
-			gsc::function::add("fread", [](gsc::function_args args)
+			gsc::function::add("fread", [](const gsc::function_args& args)
 			{
 				const auto handle = args[0].as_ptr<FILE>();
 
@@ -74,13 +83,13 @@ namespace io
 				return result;
 			});
 
-			gsc::function::add("fileexists", [](gsc::function_args args)
+			gsc::function::add("fileexists", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::file_exists(path);
 			});
 
-			gsc::function::add("writefile", [](gsc::function_args args)
+			gsc::function::add("writefile", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				const auto data = args[1].as<std::string>();
@@ -94,37 +103,37 @@ namespace io
 				return utils::io::write_file(path, data, append);
 			});
 
-			gsc::function::add("readfile", [](gsc::function_args args)
+			gsc::function::add("readfile", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::read_file(path);
 			});
 
-			gsc::function::add("filesize", [](gsc::function_args args)
+			gsc::function::add("filesize", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::file_size(path);
 			});
 
-			gsc::function::add("createdirectory", [](gsc::function_args args)
+			gsc::function::add("createdirectory", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::create_directory(path);
 			});
 
-			gsc::function::add("directoryexists", [](gsc::function_args args)
+			gsc::function::add("directoryexists", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::directory_exists(path);
 			});
 
-			gsc::function::add("directoryisempty", [](gsc::function_args args)
+			gsc::function::add("directoryisempty", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::directory_is_empty(path);
 			});
 
-			gsc::function::add("listfiles", [](gsc::function_args args)
+			gsc::function::add("listfiles", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				const auto files = utils::io::list_files(path);
@@ -135,10 +144,10 @@ namespace io
 					array.push(file);
 				}
 
-				return array.get_raw();
+				return array;
 			});
 
-			gsc::function::add("copyfolder", [](gsc::function_args args)
+			gsc::function::add("copyfolder", [](const gsc::function_args& args)
 			{
 				const auto source = args[0].as<std::string>();
 				const auto target = args[1].as<std::string>();
@@ -146,6 +155,26 @@ namespace io
 
 				return scripting::script_value{};
 			});
+
+			gsc::function::add("httpget", [](const gsc::function_args& args) -> scripting::script_value
+			{
+				const auto url = args[0].as<std::string>();
+				const auto object = scripting::entity(scripting::make_object());
+
+				scheduler::once([object, url]()
+				{
+					const auto result = utils::http::get_data(url.data());
+					scheduler::once([object, result]()
+					{
+						const auto value = result.has_value()
+							? result.value().substr(0, 0x5000)
+							: "";
+						scripting::notify(object, "done", {value});
+					});
+				}, scheduler::pipeline::async);
+			
+				return object;
+			});
 		}
 	};
 }

src/component/json.cpp

@@ -2,13 +2,8 @@
 #include "loader/component_loader.hpp"
 
 #include "scheduler.hpp"
-
-#include "game/scripting/event.hpp"
-#include "game/scripting/execution.hpp"
-#include "game/scripting/functions.hpp"
-#include "game/scripting/array.hpp"
-
 #include "gsc.hpp"
+#include "json.hpp"
 
 #include <json.hpp>
 
@@ -27,18 +22,23 @@ namespace json
 			const auto keys = array.get_keys();
 			for (auto i = 0; i < keys.size(); i++)
 			{
+				const auto is_int = keys[i].is<int>();
+				const auto is_string = keys[i].is<std::string>();
+
 				if (string_indexed == -1)
 				{
-					string_indexed = keys[i].is_string;
+					string_indexed = is_string;
 				}
 
-				if (!string_indexed && keys[i].is_integer)
+				if (!string_indexed && is_int)
 				{
-					obj[keys[i].index] = gsc_to_json(array[keys[i].index]);
+					const auto index = keys[i].as<int>();
+					obj[index] = gsc_to_json(array[index]);
 				}
-				else if (string_indexed && keys[i].is_string)
+				else if (string_indexed && is_string)
 				{
-					obj.emplace(keys[i].key, gsc_to_json(array[keys[i].key]));
+					const auto key = keys[i].as<std::string>();
+					obj.emplace(key, gsc_to_json(array[key]));
 				}
 			}
 
@@ -136,18 +136,23 @@ namespace json
 		}
 	}
 
+	std::string gsc_to_string(const scripting::script_value& value)
+	{
+		return gsc_to_json(value).dump();
+	}
+
 	class component final : public component_interface
 	{
 	public:
 		void post_unpack() override
 		{
-			gsc::function::add("array", [](gsc::function_args args)
+			gsc::function::add("array", [](const gsc::function_args& args)
 			{
 				scripting::array array(args.get_raw());
 				return array.get_raw();
 			});
 
-			gsc::function::add("map", [](gsc::function_args args)
+			gsc::function::add("map", [](const gsc::function_args& args)
 			{
 				scripting::array array;
 
@@ -162,10 +167,10 @@ namespace json
 					array[key] = args[i + 1];
 				}
 
-				return array.get_raw();
+				return array;
 			});
 
-			gsc::function::add("jsonparse", [](gsc::function_args args)
+			gsc::function::add("jsonparse", [](const gsc::function_args& args)
 			{
 				const auto json = args[0].as<std::string>();
 				const auto obj = nlohmann::json::parse(json);
@@ -173,7 +178,7 @@ namespace json
 				return json_to_gsc(obj);
 			});
 
-			gsc::function::add("jsonserialize", [](gsc::function_args args)
+			gsc::function::add("jsonserialize", [](const gsc::function_args& args)
 			{
 				const auto value = args[0];
 				auto indent = -1;

src/component/json.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace json
+{
+	std::string gsc_to_string(const scripting::script_value& _value);
+}

src/component/notifies.cpp

@@ -1,35 +1,51 @@
 #include <stdinc.hpp>
 #include "loader/component_loader.hpp"
-#include "scheduler.hpp"
 
-#include "game/scripting/entity.hpp"
+#include "scheduler.hpp"
-#include "game/scripting/execution.hpp"
+#include "gsc.hpp"
+#include "scripting.hpp"
 
 namespace notifies
 {
 	namespace
 	{
+		std::vector<scripting::function> say_callbacks;
 		utils::hook::detour client_command_hook;
 
 		void client_command_stub(int clientNum)
 		{
-			char cmd[1024] = { 0 };
+			char cmd[1024] = {0};
+			const auto* entity = &game::g_entities[clientNum];
+
+			if (entity->client == nullptr)
+			{
+				return; // Client is not fully in game yet
+			}
 
 			game::SV_Cmd_ArgvBuffer(0, cmd, 1024);
 
+			auto hidden = false;
 			if (cmd == "say"s || cmd == "say_team"s)
 			{
 				std::string message = game::ConcatArgs(1);
 				message.erase(0, 1);
 
-				const scripting::entity level{*game::levelEntityId};
+				for (const auto& callback : say_callbacks)
-				const auto player = scripting::call("getEntByNum", {clientNum}).as<scripting::entity>();
+				{
+					const auto entity_id = game::Scr_GetEntityId(clientNum, 0);
+					const auto result = callback(entity_id, {message, cmd == "say_team"s});
 
-				scripting::notify(level, cmd, {player, message});
+					if (result.is<int>() && !hidden)
-				scripting::notify(player, cmd, {message});
+					{
+						hidden = result.as<int>() == 0;
+					}
+				}
 			}
 
-			return client_command_hook.invoke<void>(clientNum);
+			if (!hidden)
+			{
+				client_command_hook.invoke<void>(clientNum);
+			}
 		}
 	}
 
@@ -39,6 +55,18 @@ namespace notifies
 		void post_unpack() override
 		{
 			client_command_hook.create(0x502CB0, client_command_stub);
+
+			scripting::on_shutdown([]()
+			{
+				say_callbacks.clear();
+			});
+
+			gsc::function::add("onplayersay", [](const gsc::function_args& args) -> scripting::script_value
+			{
+				const auto function = args[0].as<scripting::function>();
+				say_callbacks.push_back(function);
+				return {};
+			});
 		}
 	};
 }

src/component/scheduler.cpp

@@ -1,73 +1,128 @@
 #include <stdinc.hpp>
 #include "loader/component_loader.hpp"
+#include "scheduler.hpp"
+#include "game/game.hpp"
 
 namespace scheduler
 {
 	namespace
 	{
-		std::queue<std::function<void()>> tasks;
-
 		struct task
 		{
-			std::function<bool()> handler;
+			std::function<bool()> handler{};
 			std::chrono::milliseconds interval{};
 			std::chrono::high_resolution_clock::time_point last_call{};
 		};
 
-		utils::concurrent_list<task> callbacks;
+		using task_list = std::vector<task>;
 
-		void execute()
+		class task_pipeline
 		{
-			for (auto callback : callbacks)
+		public:
+			void add(task&& task)
 			{
-				const auto now = std::chrono::high_resolution_clock::now();
+				new_callbacks_.access([&task](task_list& tasks)
-				const auto diff = now - callback->last_call;
-
-				if (diff < callback->interval) continue;
-
-				callback->last_call = now;
-
-				const auto res = callback->handler();
-				if (res)
 				{
-					callbacks.remove(callback);
+					tasks.emplace_back(std::move(task));
-				}
+				});
 			}
+
+			void execute()
+			{
+				callbacks_.access([&](task_list& tasks)
+				{
+					this->merge_callbacks();
+
+					for (auto i = tasks.begin(); i != tasks.end();)
+					{
+						const auto now = std::chrono::high_resolution_clock::now();
+						const auto diff = now - i->last_call;
+
+						if (diff < i->interval)
+						{
+							++i;
+							continue;
+						}
+
+						i->last_call = now;
+
+						const auto res = i->handler();
+						if (res == cond_end)
+						{
+							i = tasks.erase(i);
+						}
+						else
+						{
+							++i;
+						}
+					}
+				});
+			}
+
+		private:
+			utils::concurrency::container<task_list> new_callbacks_;
+			utils::concurrency::container<task_list, std::recursive_mutex> callbacks_;
+
+			void merge_callbacks()
+			{
+				callbacks_.access([&](task_list& tasks)
+				{
+					new_callbacks_.access([&](task_list& new_tasks)
+					{
+						tasks.insert(tasks.end(), std::move_iterator<task_list::iterator>(new_tasks.begin()), std::move_iterator<task_list::iterator>(new_tasks.end()));
+						new_tasks = {};
+					});
+				});
+			}
+		};
+
+		std::thread thread;
+		task_pipeline pipelines[pipeline::count];
+
+		void execute(const pipeline type)
+		{
+			assert(type >= 0 && type < pipeline::count);
+			pipelines[type].execute();
 		}
 
-		void server_frame()
+		void server_frame_stub()
 		{
-			execute();
 			reinterpret_cast<void (*)()>(0x50C1E0)();
+			execute(pipeline::server);
 		}
 	}
 
-	void schedule(const std::function<bool()>& callback, const std::chrono::milliseconds delay)
+	void schedule(const std::function<bool()>& callback, const pipeline type,
+		const std::chrono::milliseconds delay)
 	{
+		assert(type >= 0 && type < pipeline::count);
+
 		task task;
 		task.handler = callback;
 		task.interval = delay;
 		task.last_call = std::chrono::high_resolution_clock::now();
 
-		callbacks.add(task);
+		pipelines[type].add(std::move(task));
 	}
 
-	void loop(const std::function<void()>& callback, const std::chrono::milliseconds delay)
+	void loop(const std::function<void()>& callback, const pipeline type,
+		const std::chrono::milliseconds delay)
 	{
 		schedule([callback]()
 		{
 			callback();
-			return false;
+			return cond_continue;
-		}, delay);
+		}, type, delay);
 	}
 
-	void once(const std::function<void()>& callback, const std::chrono::milliseconds delay)
+	void once(const std::function<void()>& callback, const pipeline type,
+		const std::chrono::milliseconds delay)
 	{
 		schedule([callback]()
 		{
 			callback();
-			return true;
+			return cond_end;
-		}, delay);
+		}, type, delay);
 	}
 
 	class component final : public component_interface
@@ -75,9 +130,18 @@ namespace scheduler
 	public:
 		void post_unpack() override
 		{
-			utils::hook::call(0x50CEDC, server_frame);
+			thread = std::thread([]()
+			{
+				while (true)
+				{
+					execute(pipeline::async);
+					std::this_thread::sleep_for(10ms);
+				}
+			});
+
+			utils::hook::call(0x50CEDC, server_frame_stub);
 		}
 	};
 }
 
-REGISTER_COMPONENT(scheduler::component)
+REGISTER_COMPONENT(scheduler::component)

src/component/scheduler.hpp

@@ -2,9 +2,20 @@
 
 namespace scheduler
 {
-	void schedule(const std::function<bool()>& callback, std::chrono::milliseconds delay = 0ms);
+	enum pipeline
-	void loop(const std::function<void()>& callback, std::chrono::milliseconds delay = 0ms);
+	{
-	void once(const std::function<void()>& callback, std::chrono::milliseconds delay = 0ms);
+		server,
+		async,
+		count,
+	};
 
-	void init();
+	static const bool cond_continue = false;
+	static const bool cond_end = true;
+
+	void schedule(const std::function<bool()>& callback, pipeline type = pipeline::server,
+		std::chrono::milliseconds delay = 0ms);
+	void loop(const std::function<void()>& callback, pipeline type = pipeline::server,
+		std::chrono::milliseconds delay = 0ms);
+	void once(const std::function<void()>& callback, pipeline type = pipeline::server,
+		std::chrono::milliseconds delay = 0ms);
 }

src/component/scripting.cpp

@@ -3,17 +3,18 @@
 
 #include "scheduler.hpp"
 #include "command.hpp"
+#include "userinfo.hpp"
 
 #include "game/scripting/event.hpp"
 #include "game/scripting/execution.hpp"
 #include "game/scripting/functions.hpp"
 
+#include "gsc.hpp"
+
 namespace scripting
 {
 	std::unordered_map<int, std::unordered_map<std::string, int>> fields_table;
-	std::unordered_map<std::string, std::unordered_map<std::string, char*>> script_function_table;
+	std::unordered_map<std::string, std::unordered_map<std::string, const char*>> script_function_table;
-
-	std::unordered_map<unsigned, unsigned> replaced_functions;
 
 	namespace
 	{
@@ -23,8 +24,12 @@ namespace scripting
 		utils::hook::detour scr_load_level_hook;
 		utils::hook::detour g_shutdown_game_hook;
 
-		utils::hook::detour scr_emit_function_hook;
+		utils::hook::detour scr_set_thread_position_hook;
-		utils::hook::detour scr_end_load_scripts_hook;
+		utils::hook::detour process_script_hook;
+
+		std::string current_file;
+
+		std::vector<std::function<void()>> shutdown_callbacks;
 
 		void vm_notify_stub(const unsigned int notify_list_owner_id, const unsigned int string_value,
 			                game::VariableValue* top)
@@ -44,7 +49,9 @@ namespace scripting
 
 				if (e.name == "connected")
 				{
-					scripting::clear_entity_fields(e.entity);
+					const auto player = e.arguments[0].as<scripting::entity>();
+					const auto client = player.call("getentitynumber").as<int>();
+					userinfo::clear_client_overrides(client);
 				}
 			}
 
@@ -70,61 +77,48 @@ namespace scripting
 
 		void g_shutdown_game_stub(const int free_scripts)
 		{
+			userinfo::clear_overrides();
 			command::clear_script_commands();
-			replaced_functions.clear();
+
+			for (const auto& callback : shutdown_callbacks)
+			{
+				callback();
+			}
+
 			g_shutdown_game_hook.invoke<void>(free_scripts);
 		}
 
-		char* function_pos(unsigned int filename, unsigned int name)
+		void process_script_stub(const char* filename)
 		{
-			const auto scripts_pos = *reinterpret_cast<int*>(0x1D6EB14);
+			current_file = filename;
 
-			const auto v2 = game::FindVariable(scripts_pos, filename);
+			const auto file_id = atoi(filename);
-
+			if (file_id)
-			const auto v3 = game::FindObject(scripts_pos, v2);
-			const auto v4 = game::FindVariable(v3, name);
-
-			if (!v2 || !v3 || !v4)
 			{
-				return 0;
+				current_file = scripting::find_file(file_id);
 			}
 
-			return utils::hook::invoke<char*>(0x5659C0, v3, v4);
+			process_script_hook.invoke<void>(filename);
 		}
 
-		void scr_emit_function_stub(unsigned int filename, unsigned int threadName, char* codePos)
+		void scr_set_thread_position_stub(unsigned int threadName, const char* codePos)
 		{
-			const auto* name = game::SL_ConvertToString(filename);
+			const auto function_name = scripting::find_token(threadName);
-			const auto filename_id = atoi(name);
 
-			for (const auto& entry : scripting::file_list)
+			if (!function_name.empty())
 			{
-				if (entry.first == filename_id)
+				script_function_table[current_file][function_name] = codePos;
-				{
-					if (script_function_table.find(entry.second) == script_function_table.end())
-					{
-						script_function_table[entry.second] = {};
-					}
-
-					for (const auto& token : scripting::token_map)
-					{
-						if (token.second == threadName)
-						{
-							const auto pos = function_pos(filename, threadName);
-
-							if (pos)
-							{
-								script_function_table[entry.second][token.first] = pos;
-							}
-						}
-					}
-				}
 			}
 
-			scr_emit_function_hook.invoke<void>(filename, threadName, codePos);
+			scr_set_thread_position_hook.invoke<void>(threadName, codePos);
 		}
 	}
 
+	void on_shutdown(const std::function<void()>& callback)
+	{
+		shutdown_callbacks.push_back(callback);
+	}
+
 	class component final : public component_interface
 	{
 	public:
@@ -134,6 +128,10 @@ namespace scripting
 			g_shutdown_game_hook.create(0x50C100, g_shutdown_game_stub);
 
 			scr_add_class_field_hook.create(0x567CD0, scr_add_class_field_stub);
+			vm_notify_hook.create(0x569720, vm_notify_stub);
+
+			scr_set_thread_position_hook.create(0x5616D0, scr_set_thread_position_stub);
+			process_script_hook.create(0x56B130, process_script_stub);
 		}
 	};
 }

src/component/scripting.hpp

@@ -2,8 +2,8 @@
 
 namespace scripting
 {
-	extern std::unordered_map<unsigned, unsigned> replaced_functions;
-
 	extern std::unordered_map<int, std::unordered_map<std::string, int>> fields_table;
-	extern std::unordered_map<std::string, std::unordered_map<std::string, char*>> script_function_table;
+	extern std::unordered_map<std::string, std::unordered_map<std::string, const char*>> script_function_table;
+
+	void on_shutdown(const std::function<void()>& callback);
 }

src/component/signatures.cpp

@@ -0,0 +1,96 @@
+#include <stdinc.hpp>
+#include "signatures.hpp"
+#include <utils/hook.hpp>
+
+namespace signatures
+{
+	size_t load_image_size()
+	{
+		MODULEINFO info{};
+		GetModuleInformation(GetCurrentProcess(),
+			GetModuleHandle("plutonium-bootstrapper-win32.exe"), &info, sizeof(MODULEINFO));
+		return info.SizeOfImage;
+	}
+
+	size_t get_image_size()
+	{
+		static const auto image_size = load_image_size();
+		return image_size;
+	}
+
+	void load_function_tables()
+	{
+		static const auto ptr = *reinterpret_cast<size_t*>(0x56CBDC + 0x1) + 0x56CBDC + 0x5;
+		static const auto function_table = *reinterpret_cast<size_t*>(0x56C8EB + 0x3);
+		static const auto method_table = *reinterpret_cast<size_t*>(ptr + 0xA);
+
+		game::plutonium::function_table.set(function_table);
+		game::plutonium::method_table.set(method_table);
+	}
+
+	size_t find_string_ptr(const std::string& string)
+	{
+		const char* string_ptr = nullptr;
+		std::string mask(string.size(), 'x');
+		const auto base = reinterpret_cast<size_t>(GetModuleHandle("plutonium-bootstrapper-win32.exe"));
+		utils::hook::signature signature(base, get_image_size() - base);
+
+		signature.add({
+			string,
+			mask,
+			[&](char* address)
+			{
+				string_ptr = address;
+			}
+		});
+
+		signature.process();
+		return reinterpret_cast<size_t>(string_ptr);
+	}
+
+	size_t find_string_ref(const std::string& string)
+	{
+		char bytes[4] = {0};
+		const auto string_ptr = find_string_ptr(string);
+		if (!string_ptr)
+		{
+			return 0;
+		}
+
+		std::memcpy(bytes, &string_ptr, sizeof(bytes));
+		return find_string_ptr({bytes, 4});
+	}
+
+	bool process_gsc_ctx()
+	{
+		const auto string_ref = find_string_ref("in call to builtin %s");
+		if (!string_ref)
+		{
+			return false;
+		}
+		
+		const auto gsc_ctx_ptr = *reinterpret_cast<size_t*>(string_ref - 0x8C);
+		game::plutonium::gsc_ctx.set(gsc_ctx_ptr);
+		return true;
+	}
+
+	bool process_printf()
+	{
+		const auto string_ref = find_string_ref("A critical exception occured!\n");
+		if (!string_ref)
+		{
+			return false;
+		}
+
+		const auto offset = *reinterpret_cast<size_t*>(string_ref + 5);
+		game::plutonium::printf.set(string_ref + 4 + 5 + offset);
+
+		return true;
+	}
+
+	bool process()
+	{
+		load_function_tables();
+		return process_printf() && process_gsc_ctx();
+	}
+}

src/component/signatures.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace signatures
+{
+	bool process();
+}

src/component/string.cpp

@@ -0,0 +1,46 @@
+#include <stdinc.hpp>
+#include "loader/component_loader.hpp"
+
+#include "gsc.hpp"
+
+#include <utils/string.hpp>
+
+namespace string
+{
+	class component final : public component_interface
+	{
+	public:
+		void post_unpack() override
+		{
+			gsc::function::add("toupper", [](const gsc::function_args& args)
+			{
+				return utils::string::to_upper(args[0].as<std::string>());
+			});
+
+			gsc::function::add("getchar", [](const gsc::function_args& args)
+			{
+				auto index = 0;
+				if (args.size() > 1)
+				{
+					index = args[1].as<int>();
+				}
+
+				const auto string = args[0].as<std::string>();
+				if (index >= static_cast<int>(string.size()))
+				{
+					throw std::runtime_error("Char index out of bounds");
+				}
+
+				return static_cast<int>(string[index]);
+			});
+
+			gsc::function::add("chartostring", [](const gsc::function_args& args)
+			{
+				const auto char_ = static_cast<char>(args[0].as<int>());
+				return std::string(1, char_);
+			});
+		}
+	};
+}
+
+REGISTER_COMPONENT(string::component)

src/component/userinfo.cpp

@@ -0,0 +1,196 @@
+#include <stdinc.hpp>
+#include "loader/component_loader.hpp"
+
+#include "scheduler.hpp"
+#include "gsc.hpp"
+
+namespace userinfo
+{
+	using userinfo_map = std::unordered_map<std::string, std::string>;
+	std::unordered_map<int, userinfo_map> userinfo_overrides;
+
+	namespace
+	{
+		utils::hook::detour sv_getuserinfo_hook;
+
+		userinfo_map userinfo_to_map(std::string userinfo)
+		{
+			userinfo_map map{};
+
+			if (userinfo[0] == '\\')
+			{
+				userinfo = userinfo.substr(1);
+			}
+
+			const auto args = utils::string::split(userinfo, '\\');
+			for (size_t i = 0; !args.empty() && i < (args.size() - 1); i += 2)
+			{
+				map[args[i]] = args[i + 1];
+			}
+
+			return map;
+		}
+
+		std::string map_to_userinfo(const userinfo_map& map)
+		{
+			std::string buffer{};
+
+			for (const auto& value : map)
+			{
+				buffer.append("\\");
+				buffer.append(value.first);
+				buffer.append("\\");
+				buffer.append(value.second);
+			}
+
+			return buffer;
+		}
+
+		void sv_getuserinfo_stub(int index, char* buffer, int bufferSize)
+		{
+			sv_getuserinfo_hook.invoke<void>(index, buffer, bufferSize);
+			auto map = userinfo_to_map(buffer);
+
+			if (userinfo_overrides.find(index) == userinfo_overrides.end())
+			{
+				userinfo_overrides[index] = {};
+			}
+
+			for (const auto& values : userinfo_overrides[index])
+			{
+				if (values.second.empty())
+				{
+					map.erase(values.first);
+				}
+				else
+				{
+					map[values.first] = values.second;
+				}
+			}
+
+			const auto userinfo = map_to_userinfo(map);
+			strcpy_s(buffer, 1024, userinfo.data());
+		}
+	}
+
+	void clear_client_overrides(int client)
+	{
+		userinfo_overrides[client].clear();
+	}
+
+	void clear_overrides()
+	{
+		userinfo_overrides.clear();
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void post_unpack() override
+		{
+			sv_getuserinfo_hook.create(0x573E00, sv_getuserinfo_stub);
+
+			gsc::method::add("setname", [](const game::scr_entref_t ent, const gsc::function_args& args) -> scripting::script_value
+			{
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				if (game::g_entities[ent.entnum].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				const auto name = args[0].as<std::string>();
+
+				userinfo_overrides[ent.entnum]["name"] = name;
+				game::ClientUserinfoChanged(ent.entnum);
+
+				return {};
+			});
+
+			gsc::method::add("resetname", [](const game::scr_entref_t ent, const gsc::function_args&) -> scripting::script_value
+			{
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				if (game::g_entities[ent.entnum].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				userinfo_overrides[ent.entnum].erase("name");
+				game::ClientUserinfoChanged(ent.entnum);
+
+				return {};
+			});
+
+			gsc::method::add("setclantag", [](const game::scr_entref_t ent, const gsc::function_args& args) -> scripting::script_value
+			{
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				if (game::g_entities[ent.entnum].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				const auto name = args[0].as<std::string>();
+
+				userinfo_overrides[ent.entnum]["clantag"] = name;
+				userinfo_overrides[ent.entnum]["ec_TagText"] = name;
+				userinfo_overrides[ent.entnum]["ec_usingTag"] = "1";
+				game::ClientUserinfoChanged(ent.entnum);
+
+				return {};
+			});
+
+			gsc::method::add("resetclantag", [](const game::scr_entref_t ent, const gsc::function_args&) -> scripting::script_value
+			{
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				if (game::g_entities[ent.entnum].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				userinfo_overrides[ent.entnum].erase("clantag");
+				userinfo_overrides[ent.entnum].erase("ec_TagText");
+				userinfo_overrides[ent.entnum].erase("ec_usingTag");
+				game::ClientUserinfoChanged(ent.entnum);
+
+				return {};
+			});
+
+			gsc::method::add("removeclantag", [](const game::scr_entref_t ent, const gsc::function_args&) -> scripting::script_value
+			{
+				if (ent.classnum != 0)
+				{
+					throw std::runtime_error("Invalid entity");
+				}
+
+				if (game::g_entities[ent.entnum].client == nullptr)
+				{
+					throw std::runtime_error("Not a player entity");
+				}
+
+				userinfo_overrides[ent.entnum]["clantag"] = "";
+				userinfo_overrides[ent.entnum]["ec_TagText"] = "";
+				userinfo_overrides[ent.entnum]["ec_usingTag"] = "0";
+				game::ClientUserinfoChanged(ent.entnum);
+
+				return {};
+			});
+		}
+	};
+}
+
+REGISTER_COMPONENT(userinfo::component)

src/component/userinfo.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace userinfo
+{
+	void clear_client_overrides(int client);
+	void clear_overrides();
+}

src/dllmain.cpp

@@ -1,10 +1,27 @@
 #include <stdinc.hpp>
 #include "loader/component_loader.hpp"
 
-BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
+#include "component/signatures.hpp"
+
+BOOL APIENTRY DllMain(HMODULE /*hModule*/, DWORD ul_reason_for_call, LPVOID /*lpReserved*/)
 {
     if (ul_reason_for_call == DLL_PROCESS_ATTACH)
     {
+        if (!signatures::process())
+        {
+            MessageBoxA(NULL,
+                "This version of iw5-gsc-utils is outdated.\n" \
+                "Download the latest dll from here: https://github.com/fedddddd/iw5-gsc-utils/releases",
+                "ERROR", MB_ICONERROR);
+
+            return FALSE;
+        }
+
+        if (game::plutonium::printf.get() != nullptr)
+        {
+            utils::hook::jump(reinterpret_cast<uintptr_t>(&printf), game::plutonium::printf);
+        }
+
         component_loader::post_unpack();
     }
 

src/game/game.cpp

@@ -2,5 +2,11 @@
 
 namespace game
 {
-
+	void SV_GameDropClient(int clientNum, const char* reason)
+	{
+		if (clientNum >= 0 && clientNum < sv_maxclients->current.integer)
+		{
+			SV_DropClient(&svs_clients[clientNum], reason, true);
+		}
+	}
 }

src/game/game.hpp

@@ -16,6 +16,11 @@ namespace game
 			return dedi_;
 		}
 
+		void set(const size_t dedi)
+		{
+			this->dedi_ = reinterpret_cast<T*>(dedi);
+		}
+
 		operator T* () const
 		{
 			return this->get();
@@ -29,6 +34,8 @@ namespace game
 	private:
 		T* dedi_;
 	};
+
+	void SV_GameDropClient(int clientNum, const char* reason);
 }
 
 #include "symbols.hpp"

src/game/scripting/array.cpp

@@ -1,5 +1,6 @@
 #include <stdinc.hpp>
 #include "array.hpp"
+#include "script_value.hpp"
 #include "execution.hpp"
 
 namespace scripting
@@ -40,9 +41,20 @@ namespace scripting
 		this->value_ = value;
 	}
 
-	array::array(unsigned int id)
+	array::array(const unsigned int id)
 		: id_(id)
 	{
+		this->add();
+	}
+
+	array::array(const array& other) : array(other.id_)
+	{
+	}
+
+	array::array(array&& other) noexcept
+	{
+		this->id_ = other.id_;
+		other.id_ = 0;
 	}
 
 	array::array()
@@ -70,9 +82,54 @@ namespace scripting
 		}
 	}
 
-	std::vector<array_key> array::get_keys() const
+	array::~array()
 	{
-		std::vector<array_key> result;
+		this->release();
+	}
+
+	array& array::operator=(const array& other)
+	{
+		if (&other != this)
+		{
+			this->release();
+			this->id_ = other.id_;
+			this->add();
+		}
+
+		return *this;
+	}
+
+	array& array::operator=(array&& other) noexcept
+	{
+		if (&other != this)
+		{
+			this->release();
+			this->id_ = other.id_;
+			other.id_ = 0;
+		}
+
+		return *this;
+	}
+
+	void array::add() const
+	{
+		if (this->id_)
+		{
+			game::AddRefToValue(game::SCRIPT_OBJECT, {static_cast<int>(this->id_)});
+		}
+	}
+
+	void array::release() const
+	{
+		if (this->id_)
+		{
+			game::RemoveRefToValue(game::SCRIPT_OBJECT, {static_cast<int>(this->id_)});
+		}
+	}
+
+	std::vector<script_value> array::get_keys() const
+	{
+		std::vector<script_value> result;
 
 		const auto offset = 0xC800 * (this->id_ & 1);
 		auto current = game::scr_VarGlob->objectVariableChildren[this->id_].firstChild;
@@ -90,16 +147,14 @@ namespace scripting
 			const auto string_value = (unsigned int)((unsigned __int8)var.name_lo + (var.k.keys.name_hi << 8));
 			const auto* str = game::SL_ConvertToString(string_value);
 
-			array_key key;
+			script_value key;
 			if (string_value < 0x40000 && str)
 			{
-				key.is_string = true;
+				key = str;
-				key.key = str;
 			}
 			else
 			{
-				key.is_integer = true;
+				key = (string_value - 0x800000) & 0xFFFFFF;
-				key.index = (string_value - 0x800000) & 0xFFFFFF;
 			}
 
 			result.push_back(key);
@@ -110,20 +165,61 @@ namespace scripting
 		return result;
 	}
 
-	int array::size() const
+	unsigned int array::size() const
 	{
 		return game::Scr_GetSelf(this->id_);
 	}
 
-	void array::push(script_value value) const
+	unsigned int array::push(script_value value) const
 	{
 		this->set(this->size(), value);
+		return this->size();
+	}
+
+	void array::erase(const unsigned int index) const
+	{
+		const auto variable_id = game::FindVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
+		if (variable_id)
+		{
+			game::RemoveVariableValue(this->id_, variable_id);
+		}
+	}
+
+	void array::erase(const std::string& key) const
+	{
+		const auto string_value = game::SL_GetString(key.data(), 0);
+		const auto variable_id = game::FindVariable(this->id_, string_value);
+		if (variable_id)
+		{
+			game::RemoveVariableValue(this->id_, variable_id);
+		}
+	}
+
+	script_value array::pop() const
+	{
+		const auto value = this->get(this->size() - 1);
+		this->erase(this->size() - 1);
+		return value;
+	}
+
+	script_value array::get(const script_value& key) const
+	{
+		if (key.is<int>())
+		{
+			return this->get(key.as<int>());
+		}
+		else
+		{
+			return this->get(key.as<std::string>());
+		}
+
+		return {};
 	}
 
 	script_value array::get(const std::string& key) const
 	{
 		const auto string_value = game::SL_GetString(key.data(), 0);
-		const auto variable_id = game::GetVariable(this->id_, string_value);
+		const auto variable_id = game::FindVariable(this->id_, string_value);
 
 		if (!variable_id)
 		{
@@ -140,7 +236,7 @@ namespace scripting
 
 	script_value array::get(const unsigned int index) const
 	{
-		const auto variable_id = game::GetVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
+		const auto variable_id = game::FindVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
 
 		if (!variable_id)
 		{
@@ -155,40 +251,21 @@ namespace scripting
 		return variable;
 	}
 
-	unsigned int array::get_entity_id() const
+	void array::set(const script_value& key, const script_value& value) const
 	{
-		return this->id_;
+		if (key.is<int>())
-	}
-
-	unsigned int array::get_value_id(const std::string& key) const
-	{
-		const auto string_value = game::SL_GetString(key.data(), 0);
-		const auto variable_id = game::GetVariable(this->id_, string_value);
-
-		if (!variable_id)
 		{
-			return game::GetNewVariable(this->id_, string_value);
+			this->set(key.as<int>(), value);
 		}
-
+		else
-		return variable_id;
-	}
-
-	unsigned int array::get_value_id(const unsigned int index) const
-	{
-		const auto variable_id = game::GetVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
-		if (!variable_id)
 		{
-			return game::GetNewArrayVariable(this->id_, index);
+			this->set(key.as<std::string>(), value);
 		}
-
-		return variable_id;
 	}
 
-	void array::set(const std::string& key, const script_value& _value) const
+	void array::set(const std::string& key, const script_value& value_) const
 	{
-		const auto value = _value.get_raw();
+		const auto value = value_.get_raw();
-
-		const auto string_value = game::SL_GetString(key.data(), 0);
 		const auto variable_id = this->get_value_id(key);
 
 		if (!variable_id)
@@ -205,9 +282,9 @@ namespace scripting
 		variable->u.u = value.u;
 	}
 
-	void array::set(const unsigned int index, const script_value& _value) const
+	void array::set(const unsigned int index, const script_value& value_) const
 	{
-		const auto value = _value.get_raw();
+		const auto value = value_.get_raw();
 		const auto variable_id = this->get_value_id(index);
 
 		if (!variable_id)
@@ -224,6 +301,35 @@ namespace scripting
 		variable->u.u = value.u;
 	}
 
+	unsigned int array::get_entity_id() const
+	{
+		return this->id_;
+	}
+
+	unsigned int array::get_value_id(const std::string& key) const
+	{
+		const auto string_value = game::SL_GetString(key.data(), 0);
+		const auto variable_id = game::FindVariable(this->id_, string_value);
+
+		if (!variable_id)
+		{
+			return game::GetNewVariable(this->id_, string_value);
+		}
+
+		return variable_id;
+	}
+
+	unsigned int array::get_value_id(const unsigned int index) const
+	{
+		const auto variable_id = game::FindVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
+		if (!variable_id)
+		{
+			return game::GetNewArrayVariable(this->id_, index);
+		}
+
+		return variable_id;
+	}
+
 	entity array::get_raw() const
 	{
 		return entity(this->id_);

src/game/scripting/array.hpp

@@ -1,21 +1,14 @@
 #pragma once
+#include "game/game.hpp"
 #include "script_value.hpp"
 
 namespace scripting
 {
-	struct array_key
-	{
-		bool is_string = false;
-		bool is_integer = false;
-		int index{};
-		std::string key{};
-	};
-
 	class array_value : public script_value
 	{
 	public:
-		array_value(unsigned int parent_id, unsigned int id);
+		array_value(unsigned int, unsigned int);
-		void array_value::operator=(const script_value& value);
+		void operator=(const script_value&);
 	private:
 		unsigned int id_;
 		unsigned int parent_id_;
@@ -25,38 +18,70 @@ namespace scripting
 	{
 	public:
 		array();
-		array(unsigned int);
+		array(const unsigned int);
+
 		array(std::vector<script_value>);
 		array(std::unordered_map<std::string, script_value>);
 
-		std::vector<array_key> get_keys() const;
+		array(const array& other);
+		array(array&& other) noexcept;
 
-		int size() const;
+		~array();
-		void push(script_value) const;
 
+		array& operator=(const array& other);
+		array& operator=(array&& other) noexcept;
+
+		std::vector<script_value> get_keys() const;
+		unsigned int size() const;
+
+		unsigned int push(script_value) const;
+		void erase(const unsigned int) const;
+		void erase(const std::string&) const;
+		script_value pop() const;
+
+		script_value get(const script_value&) const;
 		script_value get(const std::string&) const;
 		script_value get(const unsigned int) const;
 
+		void set(const script_value&, const script_value&) const;
+		void set(const std::string&, const script_value&) const;
+		void set(const unsigned int, const script_value&) const;
+
 		unsigned int get_entity_id() const;
 
 		unsigned int get_value_id(const std::string&) const;
 		unsigned int get_value_id(const unsigned int) const;
 
-		void set(const std::string&, const script_value&) const;
-		void set(const unsigned int, const script_value&) const;
-
 		entity get_raw() const;
 
-		array_value array::operator[](const int index) const
+		array_value operator[](const int index) const
 		{
 			return {this->id_, this->get_value_id(index)};
 		}
 
-		array_value array::operator[](const std::string& key) const
+		array_value operator[](const std::string& key) const
 		{
 			return {this->id_, this->get_value_id(key)};
 		}
+
+		template <typename I = int, typename S = std::string>
+		array_value operator[](const script_value& key) const
+		{
+			if (key.is<I>())
+			{
+				return { this->id_, this->get_value_id(key.as<I>()) };
+			}
+
+			if (key.is<S>())
+			{
+				return { this->id_, this->get_value_id(key.as<S>()) };
+			}
+		}
+
 	private:
+		void add() const;
+		void release() const;
+
 		unsigned int id_;
 	};
 }

src/game/scripting/execution.cpp

@@ -155,8 +155,7 @@ namespace scripting
 		return get_return_value();
 	}
 
-	script_value call_script_function(const entity& entity, const std::string& filename,
+	const char* get_function_pos(const std::string& filename, const std::string& function)
-		const std::string& function, const std::vector<script_value>& arguments)
 	{
 		if (scripting::script_function_table.find(filename) == scripting::script_function_table.end())
 		{
@@ -164,14 +163,18 @@ namespace scripting
 		};
 
 		const auto functions = scripting::script_function_table[filename];
-
 		if (functions.find(function) == functions.end())
 		{
 			throw std::runtime_error("Function '" + function + "' in file '" + filename + "' not found");
 		}
 
-		const auto pos = functions.at(function);
+		return functions.at(function);
+	}
 
+	script_value call_script_function(const entity& entity, const std::string& filename,
+		const std::string& function, const std::vector<script_value>& arguments)
+	{
+		const auto pos = get_function_pos(filename, function);
 		return exec_ent_thread(entity, pos, arguments);
 	}
 
@@ -266,8 +269,6 @@ namespace scripting
 		{
 			return get_custom_field(entity, field);
 		}
-
-		return {};
 	}
 
 	unsigned int make_array()
@@ -280,4 +281,14 @@ namespace scripting
 
 		return index;
 	}
+
+	unsigned int make_object()
+	{
+		unsigned int index = 0;
+		const auto variable = game::AllocVariable(&index);
+		variable->w.type = game::SCRIPT_STRUCT;
+		variable->u.f.prev = 0;
+
+		return index;
+	}
 }

src/game/scripting/execution.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include "game/game.hpp"
 #include "entity.hpp"
+#include "array.hpp"
+#include "function.hpp"
 #include "script_value.hpp"
 
 namespace scripting
@@ -36,4 +38,5 @@ namespace scripting
 	void notify(const entity& entity, const std::string& event, const std::vector<script_value>& arguments);
 
 	unsigned int make_array();
+	unsigned int make_object();
 }

src/game/scripting/function.cpp

@@ -0,0 +1,30 @@
+#include <stdinc.hpp>
+#include "function.hpp"
+#include "execution.hpp"
+
+namespace scripting
+{
+	function::function(const char* pos)
+		: pos_(pos)
+	{
+	}
+
+	script_value function::get_raw() const
+	{
+		game::VariableValue value;
+		value.type = game::SCRIPT_FUNCTION;
+		value.u.codePosValue = this->pos_;
+
+		return value;
+	}
+
+	const char* function::get_pos() const
+	{
+		return this->pos_;
+	}
+
+	script_value function::call(const entity& self, std::vector<script_value> arguments) const
+	{
+		return exec_ent_thread(self, this->pos_, arguments);
+	}
+}

src/game/scripting/function.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include "entity.hpp"
+#include "script_value.hpp"
+
+namespace scripting
+{
+	class function
+	{
+	public:
+		function(const char*);
+
+		script_value get_raw() const;
+		const char* get_pos() const;
+
+		script_value call(const entity& self, std::vector<script_value> arguments) const;
+
+		script_value operator()(const entity& self, std::vector<script_value> arguments) const
+		{
+			return this->call(self, arguments);
+		}
+
+		script_value operator()(std::vector<script_value> arguments) const
+		{
+			return this->call(*game::levelEntityId, arguments);
+		}
+
+		script_value operator()() const
+		{
+			return this->call(*game::levelEntityId, {});
+		}
+	private:
+		const char* pos_;
+	};
+}

src/game/scripting/functions.cpp

@@ -7,51 +7,20 @@ namespace scripting
 {
 	namespace
 	{
-		std::unordered_map<std::string, unsigned> lowercase_map(
+		int find_function_index(const std::string& name, [[maybe_unused]] const bool prefer_global)
-			const std::unordered_map<std::string, unsigned>& old_map)
-		{
-			std::unordered_map<std::string, unsigned> new_map{};
-			for (auto& entry : old_map)
-			{
-				new_map[utils::string::to_lower(entry.first)] = entry.second;
-			}
-
-			return new_map;
-		}
-
-		const std::unordered_map<std::string, unsigned>& get_methods()
-		{
-			static auto methods = lowercase_map(method_map);
-			return methods;
-		}
-
-		const std::unordered_map<std::string, unsigned>& get_functions()
-		{
-			static auto function = lowercase_map(function_map);
-			return function;
-		}
-
-		int find_function_index(const std::string& name, const bool prefer_global)
 		{
 			const auto target = utils::string::to_lower(name);
+			auto const& first = (*game::plutonium::gsc_ctx)->func_map();
+			auto const& second = (*game::plutonium::gsc_ctx)->meth_map();
 
-			const auto& primary_map = prefer_global
+			if (const auto itr = first.find(name); itr != first.end())
-				                          ? get_functions()
-				                          : get_methods();
-			const auto& secondary_map = !prefer_global
-				                            ? get_functions()
-				                            : get_methods();
-
-			auto function_entry = primary_map.find(target);
-			if (function_entry != primary_map.end())
 			{
-				return function_entry->second;
+				return static_cast<int>(itr->second);
 			}
 
-			function_entry = secondary_map.find(target);
+			if (const auto itr = second.find(name); itr != second.end())
-			if (function_entry != secondary_map.end())
 			{
-				return function_entry->second;
+				return static_cast<int>(itr->second);
 			}
 
 			return -1;
@@ -59,34 +28,40 @@ namespace scripting
 
 		script_function get_function_by_index(const unsigned index)
 		{
-			static const auto function_table = 0x1D6EB34;
+			static const auto function_table = game::plutonium::function_table.get();
-			static const auto method_table = 0x1D4F258;
+			static const auto method_table = game::plutonium::method_table.get();
 
 			if (index < 0x1C7)
 			{
 				return reinterpret_cast<script_function*>(function_table)[index];
 			}
 
-			return reinterpret_cast<script_function*>(method_table)[index];
+			return reinterpret_cast<script_function*>(method_table)[index - 0x8000];
 		}
 	}
 
+	std::string find_token(unsigned int id)
+	{
+		return (*game::plutonium::gsc_ctx)->token_name(id);
+	}
+
+	std::string find_file(unsigned int id)
+	{
+		return find_token(id);
+	}
+
 	int find_token_id(const std::string& name)
 	{
-		const auto result = token_map.find(name);
+		return (*game::plutonium::gsc_ctx)->token_id(name);
-
-		if (result != token_map.end())
-		{
-			return result->second;
-		}
-
-		return -1;
 	}
 
 	script_function find_function(const std::string& name, const bool prefer_global)
 	{
 		const auto index = find_function_index(name, prefer_global);
-		if (index < 0) return nullptr;
+		if (index < 0)
+		{
+			return nullptr;
+		}
 
 		return get_function_by_index(index);
 	}

src/game/scripting/functions.hpp

@@ -3,13 +3,10 @@
 
 namespace scripting
 {
-	extern std::unordered_map<std::string, unsigned> method_map;
-	extern std::unordered_map<std::string, unsigned> function_map;
-	extern std::unordered_map<std::string, unsigned> token_map;
-	extern std::unordered_map<unsigned, std::string> file_list;
-
 	using script_function = void(*)(game::scr_entref_t);
 
 	script_function find_function(const std::string& name, const bool prefer_global);
 	int find_token_id(const std::string& name);
+	std::string find_token(unsigned int id);
+	std::string find_file(unsigned int id);
 }

src/game/scripting/safe_execution.cpp

@@ -25,7 +25,7 @@ namespace scripting::safe_execution
 	bool call(const script_function function, const game::scr_entref_t& entref)
 	{
 		*game::g_script_error_level += 1;
-		if (game::_setjmp(&game::g_script_error[*game::g_script_error_level]))
+		if (game::_setjmp(&game::g_script_error[*game::g_script_error_level], 0, 0, 0))
 		{
 			*game::g_script_error_level -= 1;
 			return false;
@@ -39,7 +39,7 @@ namespace scripting::safe_execution
 	bool set_entity_field(const game::scr_entref_t& entref, const int offset)
 	{
 		*game::g_script_error_level += 1;
-		if (game::_setjmp(&game::g_script_error[*game::g_script_error_level]))
+		if (game::_setjmp(&game::g_script_error[*game::g_script_error_level], 0, 0, 0))
 		{
 			*game::g_script_error_level -= 1;
 			return false;
@@ -54,7 +54,7 @@ namespace scripting::safe_execution
 	bool get_entity_field(const game::scr_entref_t& entref, const int offset, game::VariableValue* value)
 	{
 		*game::g_script_error_level += 1;
-		if (game::_setjmp(&game::g_script_error[*game::g_script_error_level]))
+		if (game::_setjmp(&game::g_script_error[*game::g_script_error_level], 0, 0, 0))
 		{
 			value->type = game::SCRIPT_NONE;
 			value->u.intValue = 0;

src/game/scripting/script_value.cpp

@@ -2,6 +2,7 @@
 #include "script_value.hpp"
 #include "entity.hpp"
 #include "array.hpp"
+#include "function.hpp"
 
 namespace scripting
 {
@@ -14,6 +15,11 @@ namespace scripting
 	{
 	}
 
+	script_value::script_value(const value_wrap& value)
+		: value_(value.get_raw())
+	{
+	}
+
 	script_value::script_value(void* value)
 	{
 		game::VariableValue variable{};
@@ -102,6 +108,24 @@ namespace scripting
 		this->value_ = variable;
 	}
 
+	script_value::script_value(const array& value)
+	{
+		game::VariableValue variable{};
+		variable.type = game::SCRIPT_OBJECT;
+		variable.u.pointerValue = value.get_entity_id();
+
+		this->value_ = variable;
+	}
+
+	script_value::script_value(const function& value)
+	{
+		game::VariableValue variable{};
+		variable.type = game::SCRIPT_OBJECT;
+		variable.u.codePosValue = value.get_pos();
+
+		this->value_ = variable;
+	}
+
 	/***************************************************************
 	 * Integer
 	 **************************************************************/
@@ -261,11 +285,17 @@ namespace scripting
 	 **************************************************************/
 
 	template <>
-	bool script_value::is<std::function<void()>>() const
+	bool script_value::is<function>() const
 	{
 		return this->get_raw().type == game::SCRIPT_FUNCTION;
 	}
 
+	template <>
+	function script_value::get() const
+	{
+		return function(this->get_raw().u.codePosValue);
+	}
+
 	/***************************************************************
 	 * Vector
 	 **************************************************************/
@@ -290,4 +320,10 @@ namespace scripting
 	{
 		return this->value_.get();
 	}
+
+	value_wrap::value_wrap(const scripting::script_value& value, int argument_index)
+		: value_(value)
+		, argument_index_(argument_index)
+	{
+	}
 }

src/game/scripting/script_value.hpp

@@ -6,12 +6,102 @@
 namespace scripting
 {
 	class entity;
+	class array;
+	class function;
+	class value_wrap;
+
+	namespace
+	{
+		std::unordered_map<int, std::string> typenames =
+		{
+			{0, "undefined"},
+			{1, "object"},
+			{2, "string"},
+			{3, "localized string"},
+			{4, "vector"},
+			{5, "float"},
+			{6, "integer"},
+			{7, "codepos"},
+			{8, "precodepos"},
+			{9, "function"},
+			{10, "builtin function"},
+			{11, "builtin method"},
+			{12, "stack"},
+			{13, "animation"},
+			{14, "pre animation"},
+			{15, "thread"},
+			{16, "thread"},
+			{17, "thread"},
+			{18, "thread"},
+			{19, "struct"},
+			{20, "removed entity"},
+			{21, "entity"},
+			{22, "array"},
+			{23, "removed thread"},
+			{24, "count"},
+			{25, "<free>"},
+			{26, "thread list"},
+			{27, "endon list"},
+		};
+
+		std::string get_typename(const game::VariableValue& value)
+		{
+			if (value.type == game::SCRIPT_OBJECT)
+			{
+				const auto type = game::scr_VarGlob->objectVariableValue[value.u.uintValue].w.type;
+				return typenames[type];
+			}
+			else
+			{
+				return typenames[value.type];
+			}
+		}
+
+		template <typename T, typename A = array>
+		std::string get_c_typename()
+		{
+			auto& info = typeid(T);
+
+			if (info == typeid(std::string))
+			{
+				return "string";
+			}
+
+			if (info == typeid(const char*))
+			{
+				return "string";
+			}
+
+			if (info == typeid(entity))
+			{
+				return "entity";
+			}
+
+			if (info == typeid(array))
+			{
+				return "array";
+			}
+
+			if (info == typeid(function))
+			{
+				return "function";
+			}
+
+			if (info == typeid(vector))
+			{
+				return "vector";
+			}
+
+			return info.name();
+		}
+	}
 
 	class script_value
 	{
 	public:
 		script_value() = default;
 		script_value(const game::VariableValue& value);
+		script_value(const value_wrap& value);
 
 		script_value(void* value);
 
@@ -29,6 +119,10 @@ namespace scripting
 
 		script_value(const vector& value);
 
+		script_value(const array& value);
+
+		script_value(const function& value);
+
 		template <typename T>
 		bool is() const;
 
@@ -37,25 +131,23 @@ namespace scripting
 		{
 			if (!this->is<T>())
 			{
-				throw std::runtime_error("Invalid type");
+				const auto type = get_typename(this->get_raw());
+				const auto c_type = get_c_typename<T>();
+				throw std::runtime_error(std::string("has type '" + type + "' but should be '" + c_type + "'"));
 			}
 
 			return get<T>();
 		}
 
-		template <typename T>
+		template <typename T, typename I = int>
 		T* as_ptr()
 		{
-			if (!this->is<int>())
-			{
-				throw std::runtime_error("Invalid type");
-			}
 
-			const auto value = this->get<int>();
+			const auto value = this->as<I>();
 
 			if (!value)
 			{
-				throw std::runtime_error("Null pointer");
+				throw std::runtime_error("is null");
 			}
 
 			return reinterpret_cast<T*>(value);
@@ -68,4 +160,50 @@ namespace scripting
 		template <typename T>
 		T get() const;
 	};
+
+	class value_wrap
+	{
+	public:
+		value_wrap(const scripting::script_value& value, int argument_index);
+
+		template <typename T>
+		T as() const
+		{
+			try
+			{
+				return this->value_.as<T>();
+			}
+			catch (const std::exception& e)
+			{
+				throw std::runtime_error(utils::string::va("parameter %d %s", this->argument_index_, e.what()));
+			}
+		}
+
+		template <typename T, typename I = int>
+		T* as_ptr()
+		{
+			try
+			{
+				return this->value_.as_ptr<T>();
+			}
+			catch (const std::exception& e)
+			{
+				throw std::runtime_error(utils::string::va("parameter %d %s", this->argument_index_, e.what()));
+			}
+		}
+
+		template <typename T>
+		T is() const
+		{
+			return this->value_.is<T>();
+		}
+
+		const game::VariableValue& get_raw() const
+		{
+			return this->value_.get_raw();
+		}
+
+		int argument_index_{};
+		scripting::script_value value_;
+	};
 }

src/game/structs.hpp

@@ -26,20 +26,35 @@ namespace game
 		const char** argv[8];
 	};
 
+	enum netsrc_t
+	{
+		NS_CLIENT1 = 0x0,
+		NS_CLIENT2 = 0x1,
+		NS_CLIENT3 = 0x2,
+		NS_CLIENT4 = 0x3,
+		NS_MAXCLIENTS = 0x4,
+		NS_SERVER = 0x4,
+		NS_PACKET = 0x5,
+		NS_INVALID_NETSRC = 0x6
+	};
+
 	struct msg_t
 	{
 		int overflowed;
 		int readOnly;
-		char* data;
+		unsigned char* data;
-		char* splitData;
+		unsigned char* splitData;
 		int maxsize;
 		int cursize;
 		int splitSize;
 		int readcount;
 		int bit;
 		int lastEntityRef;
+		netsrc_t targetLocalNetID;
 	};
 
+	static_assert(sizeof(msg_t) == 0x2C);
+
 	struct XZoneInfo
 	{
 		const char* name;
@@ -303,8 +318,112 @@ namespace game
 		dvar_t* hashNext;
 	};
 
+	struct playerState_s
+	{
+		char __pad0[0x4EC];
+		unsigned int perks[0x2];
+		unsigned int perkSlots[0x9];
+		char __pad1[0x2DE8];
+	};
+
+	struct gclient_s
+	{
+		playerState_s ps;
+		char __pad0[0x2CC];
+		int flags;
+	};
+
 	struct gentity_s
 	{
 		int entnum;
+		char __pad0[0x154];
+		gclient_s* client;
+		char __pad1[0x28];
+		int flags;
+		char __pad2[0xEC];
 	};
+
+	enum netadrtype_t
+	{
+		NA_BOT = 0x0,
+		NA_BAD = 0x1,
+		NA_LOOPBACK = 0x2,
+		NA_BROADCAST = 0x3,
+		NA_IP = 0x4
+	};
+
+	struct netadr_s
+	{
+		netadrtype_t type;
+		unsigned char ip[4];
+		unsigned __int16 port;
+		unsigned char ipx[10];
+		unsigned int addrHandleIndex;
+	};
+
+	static_assert(sizeof(netadr_s) == 24);
+
+	struct netchan_t
+	{
+		int outgoingSequence;
+		netsrc_t sock;
+		int dropped;
+		int incomingSequence;
+		netadr_s remoteAddress;
+		int qport;
+		int fragmentSequence;
+		int fragmentLength;
+		unsigned char* fragmentBuffer;
+		int fragmentBufferSize;
+		int unsentFragments;
+		int unsentFragmentStart;
+		int unsentLength;
+		unsigned char* unsentBuffer;
+		int unsentBufferSize;
+		unsigned char __pad0[0x5E0];
+	};
+
+	static_assert(sizeof(netchan_t) == 0x630);
+
+	enum clientState_t
+	{
+		CS_FREE = 0,
+		CS_ZOMBIE = 1,
+		CS_RECONNECTING = 2,
+		CS_CONNECTED = 3,
+		CS_CLIENTLOADING = 4,
+		CS_ACTIVE = 5
+	};
+
+	struct clientHeader_t
+	{
+		clientState_t state; // 0
+		int sendAsActive; // 4
+		int deltaMessage; // 8
+		int rateDealyed; // 12
+		int hasAckedBaselineData; // 16
+		int hugeSnapshotSent; // 20
+		netchan_t netchan; // 24
+		vec3_t predictedOrigin;
+		int predictedOriginServerTime;
+		int migrationState;
+		vec3_t predictedVehicleOrigin;
+		int predictedVehicleServerTime;
+	};
+
+	static_assert(sizeof(clientHeader_t) == 0x66C);
+
+	struct client_s
+	{
+		clientHeader_t header;
+		const char* dropReason;
+		char userinfo[1024];
+		char __pad0[0x41242];
+		unsigned __int16 scriptId; // 269490
+		int bIsTestClient; // 269492
+		int serverId; // 269496
+		char __pad1[0x369DC];
+	};
+
+	static_assert(sizeof(client_s) == 0x78698);
 }

src/game/symbols.hpp

@@ -16,6 +16,7 @@ namespace game
 
 	WEAK symbol<void(unsigned int weapon, bool isAlternate, char* output, unsigned int maxStringLen)> BG_GetWeaponNameComplete{0x42F760};
 
+	WEAK symbol<void(int client)> ClientUserinfoChanged{0x4FADB0};
 	WEAK symbol<const char*(int index)> ConcatArgs{0x502150};
 	WEAK symbol<void(int localClientNum, const char* text)> Cbuf_AddText{0x545680};
 	WEAK symbol<void(const char* cmdName, void(), cmd_function_t* allocedCmd)> Cmd_AddCommandInternal{0x545DF0};
@@ -33,6 +34,7 @@ namespace game
 	WEAK symbol<unsigned int(unsigned int parentId, unsigned int name)> GetNewVariable{0x566390};
 	WEAK symbol<unsigned int(unsigned int parentId, unsigned int unsignedValue)> GetNewArrayVariable{0x5668C0};
 	WEAK symbol<void(unsigned int parentId, unsigned int id, VariableValue* value)> SetNewVariableValue{0x5658D0};
+	WEAK symbol<void(unsigned int parentId, unsigned int index)> RemoveVariableValue{0x566500};
 
 	WEAK symbol<const float* (const float* v)> Scr_AllocVector{0x565680};
 	WEAK symbol<void()> Scr_ClearOutParams{0x569010};
@@ -47,18 +49,21 @@ namespace game
 	WEAK symbol<unsigned int(unsigned int threadId)> Scr_GetSelf{0x5655E0};
 	WEAK symbol<void()> Scr_MakeArray{0x56ADE0};
 	WEAK symbol<void(unsigned int stringValue)> Scr_AddArrayStringIndexed{0x56AE70};
+	WEAK symbol<void(unsigned int classnum, unsigned int name, unsigned int canonicalString, unsigned int offset)> Scr_AddClassField{0x567CD0};
 
 	WEAK symbol<unsigned int(const char* str, unsigned int user)> SL_GetString{0x5649E0};
+	WEAK symbol<unsigned int(const char* str)> SL_GetCanonicalString{0x5619A0};
 	WEAK symbol<const char*(unsigned int stringValue)> SL_ConvertToString{0x564270};
 
 	WEAK symbol<void(int clientNum, int type, const char* command)> SV_GameSendServerCommand{0x573220};
 	WEAK symbol<void(int arg, char* buffer, int bufferLength)> SV_Cmd_ArgvBuffer{0x5459F0};
+	WEAK symbol<void(client_s* drop, const char* reason, bool tellThem)> SV_DropClient{0x570980};
 
 	WEAK symbol<void(unsigned int notifyListOwnerId, unsigned int stringValue, VariableValue* top)> VM_Notify{0x569720};
 	WEAK symbol<unsigned int(unsigned int localId, const char* pos, unsigned int paramcount)> VM_Execute{0x56DFE0};
 
 	WEAK symbol<void* (jmp_buf* Buf, int Value)> longjmp{0x7363BC};
-	WEAK symbol<int(jmp_buf* Buf)> _setjmp{0x734CF8};
+	WEAK symbol<int(jmp_buf* Buf, int a2, int a3, int a4)> _setjmp{0x734CF8};
 
 	// Variables
 
@@ -72,13 +77,18 @@ namespace game
 
 	WEAK symbol<scr_classStruct_t*> g_classMap{0x8B4300};
 
-	WEAK symbol<gentity_s> g_entities{0x0};
+	WEAK symbol<gentity_s> g_entities{0x1A66E28};
 	WEAK symbol<unsigned int> levelEntityId{0x208E1A4};
 
+	WEAK symbol<dvar_t> sv_maxclients{0x1BA0E4C};
+	WEAK symbol<int> svs_clientCount{0x4B5CF8C};
+	WEAK symbol<client_s> svs_clients{0x4B5CF90};
+
 	namespace plutonium
 	{
-		WEAK symbol<std::unordered_map<std::string, std::uint16_t>> function_map_rev{0x20589F68};
+		WEAK symbol<std::unique_ptr<xsk::gsc::iw5_pc::context>> gsc_ctx{0};
-		WEAK symbol<std::unordered_map<std::string, std::uint16_t>> method_map_rev{0x20589F88};
+		WEAK symbol<int(const char* fmt, ...)> printf{0};
-		WEAK symbol<std::unordered_map<std::string, std::uint16_t>> token_map_rev{0x20589FC8};
+		WEAK symbol<void*> function_table{0};
+		WEAK symbol<void*> method_table{0};
 	}
-}
+}

src/stdinc.hpp

@@ -2,10 +2,14 @@
 
 #pragma warning(disable: 4018)
 #pragma warning(disable: 4146)
+#pragma warning(disable: 4129)
 #pragma warning(disable: 4244)
 #pragma warning(disable: 4267)
+#pragma warning(disable: 4996)
 #pragma warning(disable: 26812)
 
+#include <xsk/gsc/engine/iw5_pc.hpp>
+
 #define DLL_EXPORT extern "C" __declspec(dllexport)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
@@ -25,17 +29,24 @@
 #include <filesystem>
 #include <map>
 #include <csetjmp>
+#include <atlcomcli.h>
+#include <Psapi.h>
+
+#pragma comment(lib, "urlmon.lib")
 
 using namespace std::literals;
 
 #include <gsl/gsl>
 #include <MinHook.h>
 
+
 #include "utils/memory.hpp"
 #include "utils/string.hpp"
 #include "utils/hook.hpp"
 #include "utils/concurrent_list.hpp"
 #include "utils/io.hpp"
+#include "utils/concurrency.hpp"
+#include "utils/http.hpp"
 
 #include "game/structs.hpp"
-#include "game/game.hpp"
+#include "game/game.hpp"

src/utils/concurrency.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <mutex>
+
+namespace utils::concurrency
+{
+	template <typename T, typename MutexType = std::mutex>
+	class container
+	{
+	public:
+		template <typename R = void, typename F>
+		R access(F&& accessor) const
+		{
+			std::lock_guard<MutexType> _{mutex_};
+			return accessor(object_);
+		}
+
+		template <typename R = void, typename F>
+		R access(F&& accessor)
+		{
+			std::lock_guard<MutexType> _{mutex_};
+			return accessor(object_);
+		}
+
+		template <typename R = void, typename F>
+		R access_with_lock(F&& accessor) const
+		{
+			std::unique_lock<MutexType> lock{mutex_};
+			return accessor(object_, lock);
+		}
+
+		template <typename R = void, typename F>
+		R access_with_lock(F&& accessor)
+		{
+			std::unique_lock<MutexType> lock{mutex_};
+			return accessor(object_, lock);
+		}
+
+		T& get_raw() { return object_; }
+		const T& get_raw() const { return object_; }
+
+	private:
+		mutable MutexType mutex_{};
+		T object_{};
+	};
+}

src/utils/hook.cpp

@@ -4,6 +4,48 @@
 
 namespace utils::hook
 {
+	// open-iw5
+
+	void signature::process()
+	{
+		if (this->signatures_.empty()) return;
+
+		const auto start = static_cast<char*>(this->start_);
+
+		const unsigned int sig_count = this->signatures_.size();
+		const auto containers = this->signatures_.data();
+
+		for (size_t i = 0; i < this->length_; ++i)
+		{
+			const auto address = start + i;
+
+			for (unsigned int k = 0; k < sig_count; ++k)
+			{
+				const auto container = &containers[k];
+
+				unsigned int j;
+				for (j = 0; j < static_cast<unsigned int>(container->mask.size()); ++j)
+				{
+					if (container->mask[j] != '?' && container->signature[j] != address[j])
+					{
+						break;
+					}
+				}
+
+				if (j == container->mask.size())
+				{
+					container->callback(address);
+				}
+			}
+		}
+	}
+
+	void signature::add(const container& container)
+	{
+		signatures_.push_back(container);
+	}
+
+
 	namespace
 	{
 		[[maybe_unused]] class _

src/utils/hook.hpp

@@ -4,6 +4,37 @@
 
 namespace utils::hook
 {
+	class signature final
+	{
+	public:
+		struct container final
+		{
+			std::string signature;
+			std::string mask;
+			std::function<void(char*)> callback;
+		};
+
+		signature(void* start, const size_t length) : start_(start), length_(length)
+		{
+		}
+
+		signature(const DWORD start, const size_t length) : signature(reinterpret_cast<void*>(start), length)
+		{
+		}
+
+		signature() : signature(0x400000, 0x800000)
+		{
+		}
+
+		void process();
+		void add(const container& container);
+
+	private:
+		void* start_;
+		size_t length_;
+		std::vector<container> signatures_;
+	};
+
 	class detour
 	{
 	public:

src/utils/http.cpp

@@ -0,0 +1,47 @@
+#include <stdinc.hpp>
+#include "http.hpp"
+
+namespace utils::http
+{
+	std::optional<std::string> get_data(const std::string& url)
+	{
+		CComPtr<IStream> stream;
+
+		if (FAILED(URLOpenBlockingStreamA(nullptr, url.data(), &stream, 0, nullptr)))
+		{
+			return {};
+		}
+
+		char buffer[0x1000];
+		std::string result;
+
+		HRESULT status{};
+
+		do
+		{
+			DWORD bytes_read = 0;
+			status = stream->Read(buffer, sizeof(buffer), &bytes_read);
+
+			if (bytes_read > 0)
+			{
+				result.append(buffer, bytes_read);
+			}
+		}
+		while (SUCCEEDED(status) && status != S_FALSE);
+
+		if (FAILED(status))
+		{
+			return {};
+		}
+
+		return {result};
+	}
+
+	std::future<std::optional<std::string>> get_data_async(const std::string& url)
+	{
+		return std::async(std::launch::async, [url]()
+		{
+			return get_data(url);
+		});
+	}
+}

src/utils/http.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+#include <optional>
+#include <future>
+
+namespace utils::http
+{
+	std::optional<std::string> get_data(const std::string& url);
+	std::future<std::optional<std::string>> get_data_async(const std::string& url);
+}

src/utils/io.cpp

@@ -1,8 +1,14 @@
 #include <stdinc.hpp>
 #include <fstream>
+#include "io.hpp"
 
 namespace utils::io
 {
+	bool remove_file(const std::string& file)
+	{
+		return DeleteFileA(file.data()) == TRUE;
+	}
+
 	bool file_exists(const std::string& file)
 	{
 		return std::ifstream(file).good();

src/utils/io.hpp

@@ -6,6 +6,7 @@
 
 namespace utils::io
 {
+	bool remove_file(const std::string& file);
 	bool file_exists(const std::string& file);
 	bool write_file(const std::string& file, const std::string& data, bool append = false);
 	bool read_file(const std::string& file, std::string* data);