add settextunlimited()

direct_connect notify, string_format(), parsehex()
add mysql & http funcs
2026-08-01 12:50:33 +00:00 · 2026-07-31 00:38:28 +02:00 · 2026-07-29 01:05:51 +02:00 · 2026-07-28 23:44:07 +02:00 · 2026-07-27 03:57:20 +02:00 · 2026-07-27 03:32:32 +02:00
58 changed files with 3596 additions and 390 deletions
@@ -148,3 +148,5 @@ user*.bat

 # Premake binary
 #premake5.exe
+
+deps/mysql
@@ -17,3 +17,18 @@
 [submodule "deps/plutonium-sdk"]
 	path = deps/plutonium-sdk
 	url = https://github.com/plutoniummod/plutonium-sdk.git
+[submodule "deps/libtommath"]
+	path = deps/libtommath
+	url = https://github.com/libtom/libtommath.git
+[submodule "deps/libtomcrypt"]
+	path = deps/libtomcrypt
+	url = https://github.com/libtom/libtomcrypt.git
+[submodule "deps/sqlpp11"]
+	path = deps/sqlpp11
+	url = https://github.com/rbock/sqlpp11.git
+[submodule "deps/date"]
+	path = deps/date
+	url = https://github.com/HowardHinnant/date
+[submodule "deps/curl"]
+	path = deps/curl
+	url = https://github.com/curl/curl.git
@@ -0,0 +1,73 @@
+curl = {
+	source = path.join(dependencies.basePath, "curl"),
+}
+
+function curl.import()
+	links { "curl" }
+
+	filter "toolset:msc*"
+	links { "Crypt32.lib" }
+	filter {}
+
+	curl.includes()
+end
+
+function curl.includes()
+filter "toolset:msc*"
+	includedirs {
+		path.join(curl.source, "include"),
+	}
+
+	defines {
+		"CURL_STRICTER",
+		"CURL_STATICLIB",
+		"CURL_DISABLE_LDAP",
+	}
+filter {}
+end
+
+function curl.project()
+	if not os.istarget("windows") then
+		return
+	end
+
+	project "curl"
+		language "C"
+
+		curl.includes()
+
+		includedirs {
+			path.join(curl.source, "lib"),
+		}
+
+		files {
+			path.join(curl.source, "lib/**.c"),
+			path.join(curl.source, "lib/**.h"),
+		}
+
+		defines {
+			"BUILDING_LIBCURL",
+		}
+
+		filter "toolset:msc*"
+
+		defines {
+			"USE_SCHANNEL",
+			"USE_WINDOWS_SSPI",
+			"USE_THREADS_WIN32",
+		}
+
+		filter "toolset:not msc*"
+
+		defines {
+			"USE_GNUTLS",
+			"USE_THREADS_POSIX",
+		}
+
+		filter {}
+
+		warnings "Off"
+		kind "StaticLib"
+end
+
+table.insert(dependencies, curl) 
@@ -0,0 +1,61 @@
+libtomcrypt = {
+	source = path.join(dependencies.basePath, "libtomcrypt"),
+}
+
+function libtomcrypt.import()
+	links {
+		"libtomcrypt"
+	}
+
+	libtomcrypt.includes()
+end
+
+function libtomcrypt.includes()
+	includedirs {
+		path.join(libtomcrypt.source, "src/headers")
+	}
+
+	defines {
+		"LTC_NO_FAST",
+		"LTC_NO_PROTOTYPES",
+		"LTC_NO_RSA_BLINDING",
+	}
+end
+
+function libtomcrypt.project()
+	project "libtomcrypt"
+		language "C"
+
+		libtomcrypt.includes()
+		libtommath.import()
+
+		files {
+			path.join(libtomcrypt.source, "src/**.c"),
+		}
+
+		removefiles {
+			path.join(libtomcrypt.source, "src/**/*tab.c"),
+			path.join(libtomcrypt.source, "src/encauth/ocb3/**.c"),
+		}
+
+		defines {
+			"_CRT_SECURE_NO_WARNINGS",
+			"LTC_SOURCE",
+			"_LIB",
+			"USE_LTM"
+		}
+
+		removedefines {
+			"_DLL",
+			"_USRDLL"
+		}
+
+		linkoptions {
+			"-IGNORE:4221"
+		}
+
+		warnings "Off"
+		kind "StaticLib"
+end
+
+table.insert(dependencies, libtomcrypt)
@@ -0,0 +1,52 @@
+libtommath = {
+	source = path.join(dependencies.basePath, "libtommath"),
+}
+
+function libtommath.import()
+	links {
+		"libtommath"
+	}
+
+	libtommath.includes()
+end
+
+function libtommath.includes()
+	includedirs {
+		libtommath.source
+	}
+
+	defines {
+		"LTM_DESC",
+		"__STDC_IEC_559__",
+		"MP_NO_DEV_URANDOM",
+	}
+end
+
+function libtommath.project()
+	project "libtommath"
+		language "C"
+
+		libtommath.includes()
+
+		files {
+			path.join(libtommath.source, "*.c"),
+		}
+
+		defines {
+			"_LIB"
+		}
+
+		removedefines {
+			"_DLL",
+			"_USRDLL"
+		}
+
+		linkoptions {
+			"-IGNORE:4221"
+		}
+
+		warnings "Off"
+		kind "StaticLib"
+end
+
+table.insert(dependencies, libtommath)
@@ -0,0 +1,52 @@
+if (os.host() ~= "windows") then
+    error("automatic mysql installation is not supported on your os")
+end
+
+mysql = {
+	source = path.join(dependencies.basePath, "mysql"),
+	version = "5.7.43",
+	download = "https://cdn.alicent.cat/mysql-5.7.43-win32.zip",
+}
+
+function mysql.install()
+	local hfile = io.open(string.format("%s/include/mysql.h", mysql.source), "r")
+	if (hfile) then
+		return
+	end
+	
+    os.execute(string.format("mkdir \"%s\" 2> nul", mysql.source))
+
+	local folder = path.join(mysql.source, "mysql-5.7.43-win32")
+	local archive = path.join(mysql.source, "mysql-5.7.43-win32.zip")
+
+	print("Downloading MYSQL")
+	os.execute(string.format("curl \"%s\" -L -o \"%s\"", mysql.download, archive))
+
+    os.execute(string.format("powershell -command \"Expand-Archive -Force \\\"%s\\\" \\\"%s\\\"\"", archive, mysql.source))
+    os.execute(string.format("powershell -command \"mv \\\"%s/*\\\" \\\"%s\\\"\"", folder, mysql.source))
+    os.execute(string.format("powershell -command \"rm \\\"%s\\\"\"", archive))
+    os.execute(string.format("rmdir \"%s\"", folder))
+end
+
+function mysql.import()
+	mysql.install()
+	mysql.includes()
+end
+
+function mysql.includes()
+	includedirs {
+		path.join(mysql.source, "include"),
+	}
+end
+
+function mysql.project()
+	project "mysql"
+		language "C"
+
+		mysql.includes()
+
+		warnings "Off"
+		kind "StaticLib"
+end
+
+table.insert(dependencies, mysql)
@@ -0,0 +1,26 @@
+sqlpp11 = {
+	source = path.join(dependencies.basePath, "sqlpp11"),
+}
+
+function sqlpp11.import()
+	sqlpp11.includes()
+end
+
+function sqlpp11.includes()
+	includedirs {
+		path.join(sqlpp11.source, "include"),
+		path.join(dependencies.basePath, "date/include"),
+	}
+end
+
+function sqlpp11.project()
+	project "sqlpp11"
+		language "C++"
+
+		sqlpp11.includes()
+
+		warnings "Off"
+		kind "StaticLib"
+end
+
+table.insert(dependencies, sqlpp11)
@@ -75,18 +75,30 @@ workspace "iw5-gsc-utils"
        pchheader "stdinc.hpp"
 		pchsource "src/stdinc.cpp"

-        includedirs
-        {
-       		"src"
-    	}
-        
-        files
-        {
-            "src/**.h",
-            "src/**.hpp",
-            "src/**.cpp"
+		files 
+		{
+			"./src/**.h",
+			"./src/**.hpp",
+			"./src/**.cpp",
+			"./src/**.rc",
 		}

+		includedirs 
+		{
+			"%{prj.location}/src",
+			"./src",
+			"./deps/mysql/include"
+		}
+
+		libdirs {"./deps/mysql/lib"}
+
+		resincludedirs 
+		{
+			"$(ProjectDir)src"
+		}
+		
+		linkoptions {"/DELAYLOAD:libmysql.dll"}
+
 		dependencies.imports()
 	
 	group "Dependencies"
@@ -0,0 +1,148 @@
+#include <stdinc.hpp>
+#include "loader/component_loader.hpp"
+
+#include "gsc.hpp"
+#include "scripting.hpp"
+
+#include <utils/hook.hpp>
+
+namespace config_strings
+{
+	namespace
+	{
+		bool reserved_config_strings[600]{};
+		std::uint32_t hudelem_config_strings[1024]{};
+
+		bool is_string_reserved(const std::uint32_t string_index)
+		{
+			if (string_index >= 600)
+			{
+				return false;
+			}
+
+			return reserved_config_strings[string_index];
+		}
+
+		unsigned short get_scr_const_()
+		{
+			return *reinterpret_cast<unsigned short*>(0x1C8DF80);
+		}
+
+		std::uint32_t get_config_string()
+		{
+			auto index = 0;
+			const auto scr_const_ = get_scr_const_();
+			for (auto i = 1; i < 600; i++)
+			{
+				const auto string_value = game::sv_configstrings[i + 469];
+				if (string_value == scr_const_ && !reserved_config_strings[i])
+				{
+					index = i;
+					break;
+				}
+			}
+
+			if (index == 0)
+			{
+				throw std::runtime_error("out of config strings");
+			}
+
+			reserved_config_strings[index] = true;
+			return index;
+		}
+
+		utils::hook::detour scr_free_hud_elem_hook;
+		void scr_free_hud_elem_stub(game::game_hudelem_s* hud)
+		{
+			const auto _0 = gsl::finally([&]
+			{
+				scr_free_hud_elem_hook.invoke<void>(hud);
+			});
+
+			const auto index = hud - &game::g_hudelems[0];
+			const auto string = hudelem_config_strings[index];
+
+			if (string != 0)
+			{
+				hudelem_config_strings[index] = 0;
+				reserved_config_strings[string] = false;
+				game::sv_configstrings[string + 469] = get_scr_const_();
+				game::SV_SetConfigString(string + 496, nullptr);
+			}
+		}
+
+		__declspec(naked) void g_localized_string_index_stub()
+		{
+			__asm
+			{
+				add esp, 4
+				pushad
+				lea ecx, [ecx - 469]
+				push ecx
+				call is_string_reserved
+				test al, al
+				jz not_reserved
+
+				pop ecx
+				popad
+				push 0x52D95E
+				retn
+
+			not_reserved:
+				pop ecx
+				popad
+
+				cmp eax, edx
+				push 0x52D958
+				retn
+			};
+		}
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void on_startup([[maybe_unused]] plugin::plugin* plugin) override
+		{
+			utils::hook::jump(0x52D953, g_localized_string_index_stub);
+			scr_free_hud_elem_hook.create(0x52B0F0, scr_free_hud_elem_stub);
+
+			scripting::on_shutdown([&]
+			{
+				std::memset(reserved_config_strings, 0, sizeof(reserved_config_strings));
+				std::memset(hudelem_config_strings, 0, sizeof(hudelem_config_strings));
+			});
+
+			gsc::method::add("settextunlimited", [](const game::scr_entref_t ent, const gsc::function_args& args)
+				-> scripting::script_value
+			{
+				if (ent.classnum != gsc::class_hudelem || ent.entnum >= 1024)
+				{
+					throw std::runtime_error("not a hudelem");
+				}
+
+				const auto text = args[0].as<const char*>();
+				const auto hudelem = &game::g_hudelems[ent.entnum];
+
+				hudelem->type = 1;
+				hudelem->flags |= 1;
+
+				if (hudelem_config_strings[ent.entnum] == 0)
+				{
+					const auto index = get_config_string();
+					hudelem->text = index;
+					hudelem_config_strings[ent.entnum] = index;
+				}
+				else
+				{
+					hudelem->text = hudelem_config_strings[ent.entnum];
+				}
+
+				game::SV_SetConfigString(hudelem->text + 469, text);
+				return {};
+			});
+		}
+	};
+}
+
+REGISTER_COMPONENT(config_strings::component)
@@ -6,7 +6,6 @@

 #include "game/scripting/event.hpp"
 #include "game/scripting/execution.hpp"
-#include "game/scripting/functions.hpp"
 #include "game/scripting/array.hpp"
 #include "game/scripting/function.hpp"

@@ -16,19 +15,6 @@ namespace gsc
 {
 	namespace
 	{
-		function_args get_arguments()
-		{
-			std::vector<scripting::script_value> args;
-
-			for (auto i = 0; i < game::scr_VmPub->outparamcount; i++)
-			{
-				const auto value = game::scr_VmPub->top[-i];
-				args.push_back(value);
-			}
-
-			return args;
-		}
-
 		void return_value(const scripting::script_value& value)
 		{
 			if (game::scr_VmPub->outparamcount)
@@ -39,200 +25,187 @@ namespace gsc
 			scripting::push_value(value);
 		}

-		auto field_offset_start = 0xA000;
+		auto field_offset_start = 0xA000u;

-		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(const script_function* function, const char* name)
-		{
-			try
-			{
-				const auto result = function->operator()(get_arguments());
-				const auto type = result.get_raw().type;
-
-				if (type)
-				{
-					return_value(result);
-				}
-			}
-			catch (const std::exception& e)
-			{
-				printf("************** Script execution error **************");
-				printf("Error executing function %s:", name);
-				printf("    %s", e.what());
-				printf("****************************************************");
-			}
-		}
-
-		void call_method(const script_method* method, const char* name, game::scr_entref_t ent)
-		{
-			try
-			{
-				const auto result = method->operator()(ent, get_arguments());
-				const auto type = result.get_raw().type;
-
-				if (type)
-				{
-					return_value(result);
-				}
-			}
-			catch (const std::exception& e)
-			{
-				printf("************** Script execution error **************");
-				printf("Error executing method %s:", name);
-				printf("    %s", e.what());
-				printf("****************************************************");
-			}
-		}
+		std::unordered_map<unsigned int, entity_field_t> custom_fields[class_id_t::class_count];

 		utils::hook::detour scr_get_object_field_hook;
+		utils::hook::detour scr_set_object_field_hook;
+		utils::hook::detour scr_post_load_scripts_hook;
+
+		const char* get_script_loc()
+		{
+			return "unknown location";
+		}
+
+		void print_error(const char* fmt, ...)
+		{
+			static char buffer[0x1000];
+
+			va_list ap;
+			va_start(ap, fmt);
+			_vsnprintf_s(buffer, sizeof(buffer), sizeof(buffer), fmt, ap);
+			va_end(ap);
+
+			printf("\n"
+				"******* script runtime error *******\n"
+				"%s\n"
+				"\tat %s\n"
+				"************************************", 
+				buffer, get_script_loc());
+		}
+
+		const gsc::entity_field_t* find_field(unsigned int classnum, unsigned int offset)
+		{
+			const auto& class_map = custom_fields[classnum];
+			const auto field_iter = class_map.find(offset);
+			if (field_iter == class_map.end())
+			{
+				return nullptr;
+			}
+
+			return &field_iter->second;
+		}
+
 		void scr_get_object_field_stub(unsigned int classnum, int entnum, unsigned int offset)
 		{
-			if (custom_fields[classnum].find(offset) == custom_fields[classnum].end())
+			const auto field = find_field(classnum, offset);
+			if (field == nullptr)
 			{
 				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);
+				const auto result = field->getter(entnum);
 				return_value(result);
 			}
 			catch (const std::exception& e)
 			{
-				printf("************** Script execution error **************");
-				printf("Error getting field %s:", field.name.data());
-				printf("    %s", e.what());
-				printf("****************************************************");
+				print_error("while getting builtin field \"%s\"\n%s", field->name.data(), e.what());
 			}
 		}

-		utils::hook::detour scr_set_object_field_hook;
 		void scr_set_object_field_stub(unsigned int classnum, int entnum, unsigned int offset)
 		{
-			if (custom_fields[classnum].find(offset) == custom_fields[classnum].end())
+			const auto field = find_field(classnum, offset);
+			if (field == nullptr)
 			{
 				return scr_set_object_field_hook.invoke<void>(classnum, entnum, offset);
 			}

-			const auto args = get_arguments();
-			const auto& field = custom_fields[classnum][offset];
+			function_args args;

 			try
 			{
-				field.setter(entnum, args[0]);
+				field->setter(entnum, args[0]);
 			}
 			catch (const std::exception& e)
 			{
-				printf("************** Script execution error **************");
-				printf("Error setting field %s:", field.name.data());
-				printf("    %s", e.what());
-				printf("****************************************************");
+				print_error("while setting builtin field \"%s\"\n%s", field->name.data(), e.what());
 			}
 		}

-		utils::hook::detour scr_post_load_scripts_hook;
 		void scr_post_load_scripts_stub()
 		{
-			for (const auto& callback : post_load_callbacks)
+			for (auto i = 0; i < class_id_t::class_count; i++)
 			{
-				callback();
+				const auto& class_map = custom_fields[i];
+				for (const auto& [offset, field] : class_map)
+				{
+					const auto str_id = game::SL_GetString(field.name.data(), 0);
+					const auto canon_str = game::SL_GetCanonicalString(field.name.data());
+					game::Scr_AddClassField(i, str_id, canon_str, offset);
+				}
 			}

 			return scr_post_load_scripts_hook.invoke<void>();
 		}
 	}

-	void* make_function_thunk(const char* name, const script_function* func)
+	void call_function(const script_function& function, const std::string& name)
 	{
-		static std::uint8_t bytes[] =
+		try
 		{
-			0x68, 0x44, 0x33, 0x22, 0x11, // push
-			0x68, 0x44, 0x33, 0x22, 0x11, // push
-			0x00, 0x00, 0x00, 0x00, 0x00, // call
-			0x83, 0xC4, 0x08,			  // add esp, 8
-			0xC3						  // ret
-		};
+			function_args args;
+			const auto result = function.operator()(args);
+			const auto type = result.get_raw().type;

-		const auto stub = utils::memory::allocate_array<std::uint8_t>(sizeof(bytes));
-		std::memcpy(stub, bytes, sizeof(bytes));
-
-		utils::hook::unprotect(stub, sizeof(bytes));
-
-		*reinterpret_cast<std::size_t*>(stub + 1) = reinterpret_cast<size_t>(name);
-		*reinterpret_cast<std::size_t*>(stub + 6) = reinterpret_cast<size_t>(func);
-		utils::hook::call(stub + 10, call_function);
-
-		return stub;
+			if (type)
+			{
+				return_value(result);
+			}
+		}
+		catch (const std::exception& e)
+		{
+			print_error("in call to builtin function \"%s\"\n%s", name.data(), e.what());
+		}
 	}

-	void* make_method_thunk(const char* name, const script_method* func)
+	void call_method(const script_method& method, const std::string& name, game::scr_entref_t ent)
 	{
-		static std::uint8_t bytes[] =
+		try
 		{
-			0xFF, 0x74, 0x24, 0x04,		  // push [esp+4]
-			0x68, 0x44, 0x33, 0x22, 0x11, // push
-			0x68, 0x44, 0x33, 0x22, 0x11, // push
-			0x00, 0x00, 0x00, 0x00, 0x00, // call
-			0x83, 0xC4, 0x0C,			  // add esp, 8
-			0xC3						  // ret
-		};
+			function_args args;
+			const auto result = method.operator()(ent, args);
+			const auto type = result.get_raw().type;

-		const auto stub = utils::memory::allocate_array<std::uint8_t>(sizeof(bytes));
-		std::memcpy(stub, bytes, sizeof(bytes));
-
-		utils::hook::unprotect(stub, sizeof(bytes));
-
-		*reinterpret_cast<std::size_t*>(stub + 5) = reinterpret_cast<size_t>(name);
-		*reinterpret_cast<std::size_t*>(stub + 10) = reinterpret_cast<size_t>(func);
-		utils::hook::call(stub + 14, call_method);
-
-		return stub;
+			if (type)
+			{
+				return_value(result);
+			}
+		}
+		catch (const std::exception& e)
+		{
+			print_error("in call to builtin method \"%s\"\n%s", 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)
+		void add(const class_id_t classnum, const std::string& name, const field_getter_t getter, const field_setter_t& setter)
 		{
 			const auto offset = field_offset_start++;
-			custom_fields[classnum][offset] = {name, getter, setter};
+			auto& class_map = custom_fields[classnum];

-			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);
-			});
+			entity_field_t field{};
+			field.name = name;
+			field.getter = getter;
+			field.setter = setter;
+			class_map.insert(std::make_pair(offset, field));
 		}
 	}

-	function_args::function_args(std::vector<scripting::script_value> values)
+	function_args::function_args()
+	{
+		for (auto i = 0u; i < game::scr_VmPub->outparamcount; i++)
+		{
+			const auto value = game::scr_VmPub->top[-i];
+			this->values_.emplace_back(value);
+		}
+	}
+
+	function_args::function_args(const std::vector<scripting::script_value>& values)
 		: values_(values)
 	{
 	}

-	unsigned int function_args::size() const
+	std::uint32_t function_args::size() const
 	{
 		return this->values_.size();
 	}

-	std::vector<scripting::script_value> function_args::get_raw() const
+	const std::vector<scripting::script_value>& function_args::get_raw() const
 	{
 		return this->values_;
 	}

-	scripting::value_wrap function_args::get(const int index) const
+	std::vector<scripting::script_value>& function_args::get_raw()
+	{
+		return this->values_;
+	}
+
+	scripting::value_wrap function_args::get(const std::uint32_t index) const
 	{
 		if (index >= this->values_.size())
 		{
@@ -251,7 +224,7 @@ namespace gsc
 			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",
+			field::add(class_id_t::class_entity, "entityflags",
 				[](unsigned int entnum) -> scripting::script_value
 				{
 					const auto entity = &game::g_entities[entnum];
@@ -264,7 +237,7 @@ namespace gsc
 				}
 			);

-			field::add(classid::entity, "clientflags",
+			field::add(class_id_t::class_entity, "clientflags",
 				[](unsigned int entnum) -> scripting::script_value
 				{
 					const auto entity = &game::g_entities[entnum];
@@ -277,13 +250,15 @@ namespace gsc
 				}
 			);

-			function::add("executecommand", [](const function_args& args) -> scripting::script_value
+			function::add("executecommand", [](const function_args& args)
+				-> scripting::script_value
 			{
 				game::Cbuf_AddText(0, args[0].as<const char*>());
 				return {};
 			});

-			function::add("addcommand", [](const function_args& args) -> scripting::script_value
+			function::add("addcommand", [](const function_args& args)
+				-> scripting::script_value
 			{
 				const auto name = args[0].as<std::string>();
 				const auto function = args[1].as<scripting::function>();
@@ -301,7 +276,8 @@ namespace gsc
 				return {};
 			});

-			function::add("dropallbots", [](const function_args&) -> scripting::script_value
+			function::add("dropallbots", [](const function_args&) 
+				-> scripting::script_value
 			{
 				for (auto i = 0; i < *game::svs_clientCount; i++)
 				{
@@ -315,7 +291,8 @@ namespace gsc
 				return {};
 			});

-			method::add("specialtymarathon", [](const game::scr_entref_t ent, const function_args& args) -> scripting::script_value
+			method::add("specialtymarathon", [](const game::scr_entref_t ent, const function_args& args) 
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -339,7 +316,8 @@ namespace gsc
 				return {};
 			});

-			method::add("isbot", [](const game::scr_entref_t ent, const function_args&) -> scripting::script_value
+			method::add("isbot", [](const game::scr_entref_t ent, const function_args&) 
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -356,7 +334,8 @@ namespace gsc
 				return game::svs_clients[client].bIsTestClient;
 			});

-			method::add("arecontrolsfrozen", [](const game::scr_entref_t ent, const function_args&) -> scripting::script_value
+			method::add("arecontrolsfrozen", [](const game::scr_entref_t ent, const function_args&) 
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -370,7 +349,7 @@ namespace gsc
 					throw std::runtime_error("not a player entity");
 				}

-				return {(game::g_entities[client].client->flags & 4) != 0};
+				return (game::g_entities[client].client->flags & 4) != 0;
 			});
 		}
 	};
@@ -4,25 +4,37 @@

 namespace gsc
 {
-	enum classid
+	enum class_id_t
 	{
-		entity,
-		hudelem,
-		pathnode,
-		node,
-		count
+		class_entity,
+		class_hudelem,
+		class_pathnode,
+		class_node,
+		class_count
+	};
+
+	using field_getter_t = std::function<scripting::script_value(unsigned int entnum)>;
+	using field_setter_t = std::function<void(unsigned int entnum, const scripting::script_value&)>;
+
+	struct entity_field_t
+	{
+		std::string name;
+		field_getter_t getter;
+		field_setter_t setter;
 	};

 	class function_args
 	{
 	public:
-		function_args(std::vector<scripting::script_value>);
+		function_args();
+		function_args(const std::vector<scripting::script_value>&);

-		unsigned int size() const;
-		std::vector<scripting::script_value> get_raw() const;
-		scripting::value_wrap get(const int index) const;
+		std::uint32_t size() const;
+		const std::vector<scripting::script_value>& get_raw() const;
+		std::vector<scripting::script_value>& get_raw();
+		scripting::value_wrap get(const std::uint32_t index) const;

-		scripting::value_wrap operator[](const int index) const
+		scripting::value_wrap operator[](const std::uint32_t index) const
 		{
 			return this->get(index);
 		}
@@ -36,39 +48,55 @@ namespace gsc
 	using script_function = std::function<scripting::script_value(const function_args&)>;
 	using script_method = std::function<scripting::script_value(const game::scr_entref_t, const function_args&)>;

-	void* make_function_thunk(const char* name, const script_function* func);
-	void* make_method_thunk(const char* name, const script_method* meth);
+	void call_function(const script_function& function, const std::string& name);
+	void call_method(const script_method& method, const std::string& name, game::scr_entref_t ent);

 	namespace function
 	{
 		template <typename F>
-		void add(const std::string& name, F&& f)
+		void add(const std::string& n, F&& f)
 		{
-			const auto name_str = utils::memory::duplicate_string(name);
-			const auto func = new script_function(std::forward<F>(f));
-			const auto thunk = reinterpret_cast<
-				plutonium::sdk::interfaces::gsc::function_callback>(make_function_thunk(name_str, func));
-			plugin::get()->get_interface()->gsc()->register_function(name, thunk);
+			static auto done = false;
+			assert(!done);
+			done = true;
+
+			static struct
+			{
+				std::string name;
+				script_function function;
+			} ctx{n, f};
+
+			plugin::get()->get_interface()->gsc()->register_function(n, []()
+			{
+				call_function(ctx.function, ctx.name);
+			});
 		}
 	}

 	namespace method
 	{
 		template <typename F>
-		void add(const std::string& name, F&& f)
+		void add(const std::string& n, F&& f)
 		{
-			const auto name_str = utils::memory::duplicate_string(name);
-			const auto func = new script_method(std::forward<F>(f));
-			const auto thunk = reinterpret_cast<
-				plutonium::sdk::interfaces::gsc::method_callback>(make_method_thunk(name_str, func));
-			plugin::get()->get_interface()->gsc()->register_method(name, thunk);
+			static auto done = false;
+			assert(!done);
+			done = true;
+
+			static struct
+			{
+				std::string name;
+				script_method function;
+			} ctx{n, f};
+
+			plugin::get()->get_interface()->gsc()->register_method(n, [](plutonium::sdk::types::entref entref)
+			{
+				call_method(ctx.function, ctx.name, *reinterpret_cast<game::scr_entref_t*>(&entref));
+			});
 		}
 	}

 	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);
+		void add(const class_id_t classnum, const std::string& name, const field_getter_t getter, const field_setter_t& setter);
 	}
 }
@@ -0,0 +1,218 @@
+#include <stdinc.hpp>
+#include "loader/component_loader.hpp"
+
+#include "game/structs.hpp"
+#include "game/game.hpp"
+
+#include "gsc.hpp"
+#include "scheduler.hpp"
+#include "scripting.hpp"
+
+#include <utils/http.hpp>
+#include <utils/concurrency.hpp>
+#include <curl/curl.h>
+
+namespace http
+{
+	namespace
+	{
+		constexpr const auto max_result_size = 0x5000u;
+
+		struct http_request_params_t
+		{
+			std::string method;
+			std::string url;
+			std::string fields;
+			utils::http::headers headers;
+		};
+
+		struct http_request_t
+		{
+			http_request_params_t params;
+			scripting::object handle;
+			std::optional<utils::http::result> result;
+			std::atomic_bool completed;
+		};
+
+		std::vector<std::shared_ptr<http_request_t>> requests;
+
+		void notify_request_result(std::shared_ptr<http_request_t>& request)
+		{
+			const auto handle_id = request->handle.get_entity_id();
+
+			if (!request->result.has_value())
+			{
+				scripting::notify(handle_id, "done", {{}, false, "unknown error"});
+				return;
+			}
+
+			auto& result = request->result.value();
+			const auto error = curl_easy_strerror(result.code);
+
+			if (result.code != CURLE_OK)
+			{
+				scripting::notify(handle_id, "done", {{}, false, error});
+				return;
+			}
+
+			if (result.buffer.size() >= max_result_size)
+			{
+				printf("^3WARNING: http result size bigger than %i bytes (%i), truncating!", max_result_size,
+					static_cast<int>(result.buffer.size()));
+				result.buffer.resize(max_result_size);
+			}
+
+			scripting::notify(handle_id, "done", {result.buffer, true});
+		}
+
+		void check_requests()
+		{
+			for (auto i = requests.begin(); i != requests.end(); )
+			{
+				auto& request = *i;
+				if (!request->completed)
+				{
+					++i;
+					continue;
+				}
+				else
+				{
+					notify_request_result(request);
+					i = requests.erase(i);
+				}
+			}
+		}
+
+		scripting::object create_request(const http_request_params_t& params)
+		{
+			const auto request = std::make_shared<http_request_t>();
+			requests.emplace_back(request);
+
+			request->params = params;
+			scheduler::thread_pool.push([request]
+			{
+				request->result = utils::http::get_data(
+					request->params.url,
+					request->params.fields,
+					request->params.headers,
+					request->params.method);
+				request->completed = true;
+			});
+
+			return request->handle;
+		}
+
+		template <typename T>
+		void push_request(T&& r)
+		{
+			const auto request = std::make_shared<http_request_t>(std::forward<T>(r));
+			requests.emplace_back(request);
+		}
+
+		void wait_and_clear_requests()
+		{
+			for (auto& task : requests)
+			{
+				while (!task->completed)
+				{
+					std::this_thread::sleep_for(10ms);
+				}
+			}
+
+			requests.clear();
+		}
+
+		void parse_request_options(http_request_params_t& params, const scripting::array& options)
+		{
+			const auto fields = options["parameters"];
+			const auto body = options["body"];
+			const auto headers = options["headers"];
+			const auto method = options["method"];
+
+			if (method.is<std::string>())
+			{
+				params.method = method.as<std::string>();
+			}
+
+			if (fields.is<scripting::array>())
+			{
+				const auto fields_ = fields.as<scripting::array>();
+				const auto keys = fields_.get_keys();
+
+				for (const auto& key : keys)
+				{
+					if (!key.is<std::string>())
+					{
+						continue;
+					}
+
+					const auto key_ = key.as<std::string>();
+					const auto value = fields_[key].to_string();
+					params.fields += key_ + "=" + value + "&";
+				}
+
+			}
+			else if (body.is<std::string>())
+			{
+				params.fields = body.as<std::string>();
+			}
+
+			if (headers.is<scripting::array>())
+			{
+				const auto headers_arr = headers.as<scripting::array>();
+				const auto keys = headers_arr.get_keys();
+
+				for (const auto& key : keys)
+				{
+					if (!key.is<std::string>())
+					{
+						continue;
+					}
+
+					const auto key_str = key.as<std::string>();
+					const auto value = headers_arr[key].to_string();
+
+					params.headers[key_str] = value;
+				}
+			}
+		}
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void on_shutdown([[maybe_unused]] plugin::plugin* plugin) override
+		{
+			scripting::on_shutdown(wait_and_clear_requests);
+		}
+
+		void on_startup([[maybe_unused]] plugin::plugin* plugin) override
+		{
+			scheduler::loop(check_requests, scheduler::server);
+			scripting::on_shutdown(wait_and_clear_requests);
+
+			gsc::function::add("httpget", [](const gsc::function_args& args)
+			{
+				http_request_params_t params{};
+				params.url = args[0].as<std::string>();
+				return create_request(params);
+			});
+
+			gsc::function::add("httprequest", [](const gsc::function_args& args)
+			{
+				http_request_params_t params{};
+				params.url = args[0].as<std::string>();
+
+				if (args.size() > 1)
+				{
+					const auto options = args[1].as<scripting::array>();
+					parse_request_options(params, options);
+				}
+
+				return create_request(params);
+			});
+		}
+	};
+}
+
+REGISTER_COMPONENT(http::component)
@@ -8,72 +8,6 @@

 namespace io
 {
-	namespace
-	{
-		struct http_request_t
-		{
-			std::string url;
-			bool completed;
-			std::string result;
-			scripting::entity handle;
-		};
-
-		utils::concurrency::container<std::vector<http_request_t>> requests;
-
-		void run_requests()
-		{
-			requests.access([&](std::vector<http_request_t>& r)
-			{
-				for (auto& request : r)
-				{
-					const auto data = utils::http::get_data(request.url.data());
-					if (data.has_value())
-					{
-						request.result = data->substr(0, 0x5000);
-					}
-					else
-					{
-						request.result = "";
-					}
-
-					request.completed = true;
-				}
-			});
-		}
-
-		void check_requests()
-		{
-			requests.access([&](std::vector<http_request_t>& r)
-			{
-				for (auto i = r.begin(); i != r.end(); )
-				{
-					if (!i->completed)
-					{
-						++i;
-						continue;
-					}
-					else
-					{
-						scripting::notify(i->handle, "done", {i->result});
-						i = r.erase(i);
-					}
-				}
-			});
-		}
-
-		void add_request(const std::string& url, const scripting::entity& handle)
-		{
-			requests.access([&](std::vector<http_request_t>& r)
-			{
-				http_request_t request{};
-				request.handle = handle;
-				request.url = url;
-				request.completed = false;
-				r.emplace_back(request);
-			});
-		}
-	}
-
 	class component final : public component_interface
 	{
 	public:
@@ -91,18 +25,8 @@ namespace io

 		void on_startup([[maybe_unused]] plugin::plugin* plugin) override
 		{
-			scheduler::loop(run_requests, scheduler::async);
-			scheduler::loop(check_requests, scheduler::server);
-
-			scripting::on_shutdown([]()
-			{
-				requests.access([&](std::vector<http_request_t>& r)
-				{
-					r.clear();
-				});
-			});
-
-			gsc::function::add("jsonprint", [](const gsc::function_args& args) -> scripting::script_value
+			gsc::function::add("jsonprint", [](const gsc::function_args& args) 
+				-> scripting::script_value
 			{
 				std::string buffer;

@@ -188,16 +112,6 @@ 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());
-
-				add_request(url, object);
-			
-				return object;
-			});
 		}
 	};
 }
@@ -20,7 +20,8 @@ namespace json

 			auto string_indexed = -1;
 			const auto keys = array.get_keys();
-			for (auto i = 0; i < keys.size(); i++)
+
+			for (auto i = 0u; i < keys.size(); i++)
 			{
 				const auto is_int = keys[i].is<int>();
 				const auto is_string = keys[i].is<std::string>();
@@ -0,0 +1,556 @@
+#include <stdinc.hpp>
+#include "loader/component_loader.hpp"
+
+#include "mysql.hpp"
+#include "component/gsc.hpp"
+#include "component/scheduler.hpp"
+#include "component/scripting.hpp"
+
+#include <utils/string.hpp>
+
+namespace mysql
+{
+	namespace
+	{
+		struct mysql_result_t
+		{
+			MYSQL_RES* result;
+			MYSQL_STMT* stmt;
+			uint64_t affected_rows;
+			std::string error;
+		};
+
+		struct task_t
+		{
+			scripting::object handle;
+			mysql_result_t result{};
+			std::atomic_bool completed;
+		};
+
+		std::vector<std::shared_ptr<task_t>> tasks;
+		std::array<connection, max_connections> connection_pool;
+
+		scripting::script_value field_to_value(const MYSQL_FIELD* field, const std::string& row)
+		{
+			switch (field->type)
+			{
+			case enum_field_types::MYSQL_TYPE_INT24:
+			case enum_field_types::MYSQL_TYPE_LONG:
+			case enum_field_types::MYSQL_TYPE_SHORT:
+				return std::atoi(row.data());
+			case enum_field_types::MYSQL_TYPE_LONGLONG:
+				return row;
+			case enum_field_types::MYSQL_TYPE_FLOAT:
+			case enum_field_types::MYSQL_TYPE_DOUBLE:
+				return static_cast<float>(std::atof(row.data()));
+			}
+
+			return row;
+		}
+
+		scripting::script_value bind_to_value(const MYSQL_BIND* bind)
+		{
+			switch (bind->buffer_type)
+			{
+			case enum_field_types::MYSQL_TYPE_INT24:
+			case enum_field_types::MYSQL_TYPE_LONG:
+			case enum_field_types::MYSQL_TYPE_SHORT:
+				return *reinterpret_cast<int*>(bind->buffer);
+			case enum_field_types::MYSQL_TYPE_LONGLONG:
+				return std::to_string(*reinterpret_cast<std::int64_t*>(bind->buffer));
+			case enum_field_types::MYSQL_TYPE_FLOAT:
+				return *reinterpret_cast<float*>(bind->buffer);
+			case enum_field_types::MYSQL_TYPE_DOUBLE:
+				return static_cast<float>(*reinterpret_cast<double*>(bind->buffer));
+			case enum_field_types::MYSQL_TYPE_STRING:
+				return std::string{reinterpret_cast<char*>(bind->buffer), bind->buffer_length};
+			}
+
+			return {};
+		}
+
+		scripting::array generate_result(MYSQL_STMT* stmt)
+		{
+			if (stmt == nullptr)
+			{
+				return {};
+			}
+
+			utils::memory::allocator allocator;
+
+			scripting::array result_arr;
+
+			const auto meta = mysql_stmt_result_metadata(stmt);
+			if (meta == nullptr)
+			{
+				return {};
+			}
+
+			const auto column_count = mysql_num_fields(meta);
+			const auto fields = mysql_fetch_fields(meta);
+
+			const auto is_null = allocator.allocate_array<my_bool>(column_count);
+			const auto errors = allocator.allocate_array<my_bool>(column_count);
+			const auto real_lengths = allocator.allocate_array<unsigned long>(column_count);
+			const auto binds = allocator.allocate_array<MYSQL_BIND>(column_count);
+
+			for (auto i = 0u; i < column_count; i++)
+			{
+				binds[i].length = &real_lengths[i];
+				binds[i].is_null = &is_null[i];
+				binds[i].error = &errors[i];
+			}
+
+			if (mysql_stmt_bind_result(stmt, binds) != 0 ||
+				mysql_stmt_store_result(stmt) != 0)
+			{
+				return {};
+			}
+
+			while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
+			{
+				for (auto i = 0u; i < column_count; i++)
+				{
+					switch (fields[i].type)
+					{
+					case enum_field_types::MYSQL_TYPE_INT24:
+					case enum_field_types::MYSQL_TYPE_LONG:
+					case enum_field_types::MYSQL_TYPE_SHORT:
+					{
+						binds[i].buffer_type = MYSQL_TYPE_LONG;
+						binds[i].buffer = allocator.allocate<int>();
+						binds[i].buffer_length = sizeof(int);
+						break;
+					};
+					case enum_field_types::MYSQL_TYPE_LONGLONG:
+					{
+						binds[i].buffer_type = MYSQL_TYPE_LONGLONG;
+						binds[i].buffer = allocator.allocate<std::int64_t>();
+						binds[i].buffer_length = sizeof(std::int64_t);
+						break;
+					};
+					case enum_field_types::MYSQL_TYPE_FLOAT:
+						binds[i].buffer_type = MYSQL_TYPE_FLOAT;
+						binds[i].buffer = allocator.allocate<float>();
+						binds[i].buffer_length = sizeof(float);
+						break;
+					case enum_field_types::MYSQL_TYPE_DOUBLE:
+					{
+						binds[i].buffer_type = MYSQL_TYPE_DOUBLE;
+						binds[i].buffer = allocator.allocate<double>();
+						binds[i].buffer_length = sizeof(double);
+						break;
+					}
+					default:
+						binds[i].buffer_type = MYSQL_TYPE_STRING;
+						binds[i].buffer = allocator.allocate_array<char>(real_lengths[i]);
+						binds[i].buffer_length = real_lengths[i];
+						break;
+					}
+
+					mysql_stmt_fetch_column(stmt, &binds[i], i, 0);
+				}
+
+				scripting::array row_arr;
+
+				for (auto i = 0u; i < column_count; i++)
+				{
+					const auto field = &fields[i];
+					const std::string field_name = {field->name, field->name_length};
+					row_arr[field_name] = bind_to_value(&binds[i]);
+				}
+
+				result_arr.push(row_arr);
+			}
+
+			mysql_free_result(meta);
+
+			return result_arr;
+		}
+
+		scripting::array generate_result(MYSQL_RES* result)
+		{
+			if (result == nullptr)
+			{
+				return {};
+			}
+
+			scripting::array result_arr;
+
+			const auto num_rows = mysql_num_rows(result);
+			const auto num_fields = mysql_num_fields(result);
+			const auto fields = mysql_fetch_fields(result);
+
+			for (auto i = 0u; i < num_rows; i++)
+			{
+				scripting::array row_arr;
+
+				const auto row = mysql_fetch_row(result);
+				const auto lengths = mysql_fetch_lengths(result);
+
+				for (auto f = 0u; f < num_fields; f++)
+				{
+					const auto field = &fields[f];
+
+					const std::string field_str = {field->name, field->name_length};
+					const std::string row_str = {row[f], lengths[f]};
+					const auto value = field_to_value(field, row_str);
+
+					row_arr[field_str] = value;
+				}
+
+				result_arr.push(row_arr);
+			}
+
+			return result_arr;
+		}
+
+		template <typename F>
+		scripting::object create_mysql_query(F&& cb)
+		{
+			auto task = std::make_shared<task_t>();
+			tasks.emplace_back(task);
+
+			scheduler::thread_pool.push([=]
+			{
+				try
+				{
+					mysql::access([&](database_t& db)
+					{
+						task->result = cb(db);
+						task->completed = true;
+					});
+				}
+				catch (const std::exception& e)
+				{
+					printf("^1MySQL ERROR: %s\n", e.what());
+					task->completed = true;
+				}
+			});
+
+			return task->handle;
+		}
+
+		void wait_and_clear_tasks()
+		{
+			for (auto& task : tasks)
+			{
+				while (!task->completed)
+				{
+					std::this_thread::sleep_for(10ms);
+				}
+			}
+
+			tasks.clear();
+		}
+
+		void notify_task_result(std::shared_ptr<task_t>& task)
+		{
+			const auto result = task->result.result
+				? generate_result(task->result.result)
+				: generate_result(task->result.stmt);
+
+			const auto rows = static_cast<std::size_t>(task->result.affected_rows);
+			scripting::notify(task->handle.get_entity_id(), "done", {result, rows, task->result.error});
+
+			if (task->result.result != nullptr)
+			{
+				mysql_free_result(task->result.result);
+				task->result.result = nullptr;
+			}
+
+			if (task->result.stmt != nullptr)
+			{
+				mysql_stmt_close(task->result.stmt);
+				task->result.stmt = nullptr;
+			}
+		}
+
+		void check_tasks()
+		{
+			for (auto i = tasks.begin(); i != tasks.end(); )
+			{
+				auto& task = *i;
+				if (!task->completed)
+				{
+					++i;
+					continue;
+				}
+				else
+				{
+					notify_task_result(task);
+					i = tasks.erase(i);
+				}
+			}
+		}
+
+		template <typename T>
+		MYSQL_BIND* bind_statement_args(const T& args, std::size_t& bind_count)
+		{
+			bind_count = args.size();
+			const auto binds = utils::memory::allocate_array<MYSQL_BIND>(bind_count);
+
+			for (auto i = 0u; i < args.size(); i++)
+			{
+				const auto& arg = args[i];
+				const auto& raw_value = arg.get_raw();
+
+				switch (raw_value.type)
+				{
+				case game::SCRIPT_FLOAT:
+				{
+					binds[i].buffer = utils::memory::allocate<float>();
+					binds[i].buffer_type = MYSQL_TYPE_FLOAT;
+					*reinterpret_cast<float*>(binds[i].buffer) = raw_value.u.floatValue;
+					break;
+				}
+				case game::SCRIPT_INTEGER:
+				{
+					binds[i].buffer = utils::memory::allocate<int>();
+					binds[i].buffer_type = MYSQL_TYPE_LONG;
+					*reinterpret_cast<int*>(binds[i].buffer) = raw_value.u.intValue;
+					break;
+				}
+				case game::SCRIPT_STRING:
+				{
+					const auto str = arg.as<std::string>();
+					const auto str_copy = utils::memory::duplicate_string(str);
+					binds[i].buffer = str_copy;
+					binds[i].buffer_length = str.size();
+					binds[i].buffer_type = MYSQL_TYPE_STRING;
+					break;
+				}
+				default:
+				{
+					binds[i].buffer_type = MYSQL_TYPE_NULL;
+					break;
+				}
+				}
+			}
+
+			return binds;
+		}
+
+		void cleanup_connections()
+		{
+			for (auto& connection : connection_pool)
+			{
+				connection.cleanup();
+			}
+		}
+
+		void free_statement_binds(MYSQL_BIND* binds, const std::size_t bind_count)
+		{
+			if (binds == nullptr)
+			{
+				return;
+			}
+
+			for (auto i = 0u; i < bind_count; i++)
+			{
+				utils::memory::free(binds[i].buffer);
+			}
+
+			utils::memory::free(binds);
+		}
+	}
+
+	utils::concurrency::container<sql::connection_config>& get_config()
+	{
+		static utils::concurrency::container<sql::connection_config> config;
+		static auto initialized = false;
+
+		if (!initialized)
+		{
+			config.access([&](sql::connection_config& cfg)
+			{
+				cfg.user = "root";
+				cfg.password = "root";
+				cfg.host = "localhost";
+				cfg.port = 3306;
+				cfg.database = "default";
+			});
+
+			initialized = true;
+		}
+		return config;
+	}
+
+	void connection::check()
+	{
+		const auto now = std::chrono::high_resolution_clock::now();
+		const auto diff = now - this->start_;
+
+		if (this->db.get() == nullptr || !this->db->ping_server() || diff >= connection_timeout)
+		{
+			get_config().access([&](sql::connection_config& cfg)
+			{
+				this->db = std::make_unique<sql::connection>(cfg);
+				this->start_ = now;
+			});
+		}
+
+		this->last_access_ = now;
+	}
+
+	void connection::cleanup()
+	{
+		std::unique_lock<database_mutex_t> lock(this->mutex, std::try_to_lock);
+		if (!lock.owns_lock())
+		{
+			return;
+		}
+
+		const auto now = std::chrono::high_resolution_clock::now();
+		const auto diff = now - this->last_access_;
+		if (diff >= connection_timeout)
+		{
+			this->db.reset();
+		}
+	}
+
+	connection* get_connection(std::unique_lock<database_mutex_t>& lock)
+	{
+		static thread_local connection* last_connection{};
+		if (last_connection != nullptr)
+		{
+			lock = std::unique_lock(last_connection->mutex, std::try_to_lock);
+			if (lock.owns_lock())
+			{
+				return last_connection;
+			}
+		}
+
+		for (auto i = 0u; i < connection_pool.size(); i++)
+		{
+			auto connection = &connection_pool[i];
+			if (connection == last_connection)
+			{
+				continue;
+			}
+
+			lock = std::unique_lock(connection->mutex, std::try_to_lock);
+			if (!lock.owns_lock())
+			{
+				continue;
+			}
+
+			last_connection = connection;
+			return connection;
+		}
+
+		return nullptr;
+	}
+
+	class component final : public component_interface
+	{
+	public:
+		void on_shutdown([[maybe_unused]] plugin::plugin* plugin) override
+		{
+			wait_and_clear_tasks();
+		}
+
+		void on_startup([[maybe_unused]] plugin::plugin* plugin) override
+		{
+			scripting::on_shutdown(wait_and_clear_tasks);
+			scheduler::loop(cleanup_connections, scheduler::async, 60s);
+			scheduler::loop(check_tasks, scheduler::server);
+
+			gsc::function::add("mysql_set_config", [](const gsc::function_args& args)
+				-> scripting::script_value
+			{
+				const auto config = args[0].as<scripting::array>();
+				get_config().access([&](sql::connection_config& cfg)
+				{
+					cfg.host = config["host"].as<std::string>();
+					cfg.user = config["user"].as<std::string>();
+					cfg.password = config["password"].as<std::string>();
+					cfg.port = config["port"].as<unsigned short>();
+					cfg.database = config["database"].as<std::string>();
+				});
+
+				return {};
+			});
+
+			gsc::function::add("mysql_query", [](const gsc::function_args& args)
+				-> scripting::script_value
+			{
+				const auto query = args[0].as<std::string>();
+				return create_mysql_query([=](database_t& db)
+				{
+					const auto handle = db->get_handle();
+
+					mysql_result_t result{};
+					if (mysql_query(handle, query.data()) != 0)
+					{
+						result.error = mysql_error(handle);
+						return result;
+					}
+
+					result.result = mysql_store_result(handle);
+					result.affected_rows = mysql_affected_rows(handle);
+
+					return result;
+				});
+			});
+
+			gsc::function::add("mysql_prepared_statement", [](const gsc::function_args& args)
+				-> scripting::script_value
+			{
+				MYSQL_BIND* binds = nullptr;
+				auto bind_count = 0u;
+
+				const auto query = args[0].as<std::string>();
+				auto args_vec = args.get_raw();
+				args_vec.erase(args_vec.begin());
+
+				try
+				{
+					if (args_vec.size() > 0 && args_vec[0].is<scripting::array>())
+					{
+						binds = bind_statement_args(args_vec[0].as<scripting::array>(), bind_count);
+					}
+					else
+					{
+						binds = bind_statement_args(args_vec, bind_count);
+					}
+
+					const auto handle = create_mysql_query([binds, bind_count, query](database_t& db)
+					{
+						const auto _0 = gsl::finally([=]
+						{
+							free_statement_binds(binds, bind_count);
+						});
+
+						mysql_result_t result{};
+
+						const auto handle = db->get_handle();
+						const auto stmt = mysql_stmt_init(handle);
+
+						if (mysql_stmt_prepare(stmt, query.data(), query.size()) != 0 ||
+							(binds != nullptr && mysql_stmt_bind_param(stmt, binds) != 0) ||
+							mysql_stmt_execute(stmt) != 0)
+						{
+							result.error = mysql_stmt_error(stmt);
+							return result;
+						}
+
+						result.stmt = stmt;
+						result.affected_rows = mysql_stmt_affected_rows(stmt);
+
+						return result;
+					});
+
+					return handle;
+				}
+				catch (const std::exception& e)
+				{
+					free_statement_binds(binds, bind_count);
+					throw e;
+				}
+			});
+		}
+	};
+}
+
+REGISTER_COMPONENT(mysql::component)
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <utils/concurrency.hpp>
+
+#pragma warning(push)
+#pragma warning(disable: 4127)
+#pragma warning(disable: 4267)
+#pragma warning(disable: 4018)
+#pragma warning(disable: 4996)
+#pragma warning(disable: 4244)
+#include <sqlpp11/sqlpp11.h>
+#include <sqlpp11/mysql/mysql.h>
+#pragma warning(pop)
+
+namespace sql = sqlpp::mysql;
+
+namespace mysql
+{
+	constexpr auto max_connections = 100;
+	constexpr auto connection_timeout = 200s;
+
+	using database_mutex_t = std::recursive_mutex;
+	using database_t = std::unique_ptr<sql::connection>;
+
+	utils::concurrency::container<sql::connection_config>& get_config();
+
+	class connection
+	{
+	public:
+		connection() = default;
+		void check();
+		void cleanup();
+
+		database_t db;
+		database_mutex_t mutex;
+
+	private:
+		std::chrono::high_resolution_clock::time_point start_;
+		std::chrono::high_resolution_clock::time_point last_access_;
+
+	};
+
+	connection* get_connection(std::unique_lock<database_mutex_t>& lock);
+
+	template <typename T = void, typename F>
+	T access(F&& accessor)
+	{
+		std::unique_lock<database_mutex_t> lock;
+		auto conn = get_connection(lock);
+		if (conn == nullptr)
+		{
+			throw std::runtime_error("out of connections");
+		}
+
+		conn->check();
+		return accessor(conn->db);
+	}
+}
@@ -5,6 +5,8 @@

 namespace scheduler
 {
+	utils::thread_pool thread_pool;
+
 	namespace
 	{
 		struct task
@@ -131,6 +133,9 @@ namespace scheduler
 	public:
 		void on_startup([[maybe_unused]] plugin::plugin* plugin) override
 		{
+			thread_pool.initialize(8);
+			thread_pool.start();
+
 			thread = std::thread([]()
 			{
 				while (!killed)
@@ -145,6 +150,7 @@ namespace scheduler

 		void on_shutdown([[maybe_unused]] plugin::plugin* plugin) override
 		{
+			thread_pool.stop();
 			killed = true;

 			if (thread.joinable())
@@ -1,5 +1,7 @@
 #pragma once

+#include <utils/thread_pool.hpp>
+
 namespace scheduler
 {
 	enum pipeline
@@ -18,4 +20,6 @@ namespace scheduler
 		std::chrono::milliseconds delay = 0ms);
 	void once(const std::function<void()>& callback, pipeline type = pipeline::server,
 		std::chrono::milliseconds delay = 0ms);
+
+	extern utils::thread_pool thread_pool;
 }
@@ -7,7 +7,6 @@

 #include "game/scripting/event.hpp"
 #include "game/scripting/execution.hpp"
-#include "game/scripting/functions.hpp"

 #include "gsc.hpp"

@@ -3,10 +3,159 @@

 #include "gsc.hpp"

+// lua/lstrlib.c
+#define MAX_FORMAT	32
+#define L_FMTFLAGSF	"-+#0 "
+#define L_FMTFLAGSX	"-#0"
+#define L_FMTFLAGSI	"-+0 "
+#define L_FMTFLAGSU	"-0"
+#define L_FMTFLAGSC	"-"
+
 #include <utils/string.hpp>

 namespace string
 {
+	namespace
+	{
+		// lua/lstrlib.c
+		const char* getformat(const char* strfrmt, char* form)
+		{
+			const auto len = std::strspn(strfrmt, L_FMTFLAGSF "123456789.") + 1;
+			if (len >= MAX_FORMAT - 10)
+			{
+				throw std::runtime_error("invalid format (too long)");
+			}
+
+			*(form++) = '%';
+			std::memcpy(form, strfrmt, len * sizeof(char));
+			*(form + len) = '\0';
+			return strfrmt + len - 1;
+		}
+
+		// lua/lstrlib.c
+		const char* get_2_digits(const char* s)
+		{
+			if (isdigit(static_cast<unsigned char>(*s)))
+			{
+				s++;
+				if (isdigit(static_cast<unsigned char>(*s)))
+				{
+					s++;
+				}
+			}
+
+			return s;
+		}
+
+		// lua/lstrlib.c
+		void check_format(const char* form, const char* flags, int precision)
+		{
+			const char* spec = form + 1;
+			spec += std::strspn(spec, flags);
+			if (*spec != '0')
+			{
+				spec = get_2_digits(spec);
+				if (*spec == '.' && precision)
+				{
+					spec++;
+					spec = get_2_digits(spec);
+				}
+			}
+			if (!std::isalpha(static_cast<unsigned char>(*spec)))
+			{
+				throw std::runtime_error(utils::string::va("invalid conversion specification: '%s'", form));
+			}
+		}
+
+		// partially lua/lstrlib.c
+		std::string format_string(const gsc::function_args& args)
+		{
+			std::string buffer{};
+			size_t va_index = 1;
+
+			const auto fmt = args[0].as<std::string>();
+
+			const char* strfrmt = fmt.data();
+			const char* strfrmt_end = strfrmt + fmt.size();
+
+			while (strfrmt < strfrmt_end)
+			{
+				if (*strfrmt != '%')
+				{
+					buffer.push_back(*strfrmt++);
+				}
+				else if (*++strfrmt == '%')
+				{
+					buffer.push_back(*strfrmt++);
+				}
+				else
+				{
+					char form[MAX_FORMAT]{};
+					const char* flags = "";
+					strfrmt = getformat(strfrmt, form);
+
+					switch (*strfrmt++)
+					{
+					case 'd':
+					case 'i':
+						flags = L_FMTFLAGSI;
+						goto intcase;
+					case 'u':
+					case 'p':
+						flags = L_FMTFLAGSU;
+						goto intcase;
+					case 'o':
+					case 'x':
+					case 'X':
+						flags = L_FMTFLAGSX;
+					intcase:
+						{
+							check_format(form, flags, 1);
+							const auto value = args[va_index].as<int>();
+							buffer.append(utils::string::va(form, value));
+							va_index++;
+							break;
+						}
+					case 'f':
+					case 'F':
+					case 'e':
+					case 'E':
+					case 'g':
+					case 'G':
+					{
+						check_format(form, L_FMTFLAGSF, 1);
+						const auto value = args[va_index].as<float>();
+						buffer.append(utils::string::va(form, value));
+						va_index++;
+						break;
+					}
+					case 'c':
+					{
+						const auto value = args[va_index].as<int>();
+						check_format(form, L_FMTFLAGSC, 0);
+						buffer.append(utils::string::va(form, static_cast<char>(value)));
+						va_index++;
+						break;
+					}
+					case 's':
+					{
+						const auto str = args[va_index].as<std::string>();
+						buffer.append(str);
+						va_index++;
+						break;
+					}
+					default:
+					{
+						throw std::runtime_error(utils::string::va("invalid conversion '%s' to 'format'", form));
+					}
+					}
+				}
+			}
+
+			return buffer;
+		}
+	}
+
 	class component final : public component_interface
 	{
 	public:
@@ -34,6 +183,14 @@ namespace string
 				const auto char_ = static_cast<char>(args[0].as<int>());
 				return std::string(1, char_);
 			});
+
+			gsc::function::add("parsehex", [](const gsc::function_args& args)
+			{
+				const auto str = args[0].as<std::string>();
+				return static_cast<unsigned int>(std::strtoul(str.data(), nullptr, 0x10));
+			});
+
+			gsc::function::add("string_format", format_string);
 		}
 	};
 }
@@ -7,23 +7,23 @@
 namespace userinfo
 {
 	using userinfo_map = std::unordered_map<std::string, std::string>;
-	std::unordered_map<int, userinfo_map> userinfo_overrides;
+	std::array<userinfo_map, 18> userinfo_overrides;

 	namespace
 	{
 		utils::hook::detour sv_getuserinfo_hook;

-		userinfo_map userinfo_to_map(std::string userinfo)
+		userinfo_map userinfo_to_map(const char* userinfo)
 		{
 			userinfo_map map{};

 			if (userinfo[0] == '\\')
 			{
-				userinfo = userinfo.substr(1);
+				++userinfo;
 			}

 			const auto args = utils::string::split(userinfo, '\\');
-			for (size_t i = 0; !args.empty() && i < (args.size() - 1); i += 2)
+			for (auto i = 0u; !args.empty() && i < (args.size() - 1); i += 2)
 			{
 				map[args[i]] = args[i + 1];
 			}
@@ -49,12 +49,8 @@ namespace userinfo
 		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] = {};
-			}
+			auto map = userinfo_to_map(buffer);

 			for (const auto& values : userinfo_overrides[index])
 			{
@@ -76,11 +72,27 @@ namespace userinfo
 		{
 			userinfo_overrides[client].clear();
 		}
+
+		void* client_connect_stub(int client_num, int script_pers_id)
+		{
+			const auto res = utils::hook::invoke<void*>(0x4FAFB0, client_num, script_pers_id);
+
+			if (res == nullptr)
+			{
+				const scripting::entity player = game::Scr_GetEntityId(client_num, 0);
+				scripting::notify(*game::levelEntityId, "direct_connect", {player});
+			}
+
+			return res;
+		}
 	}

 	void clear_overrides()
 	{
-		userinfo_overrides.clear();
+		for (auto& entry : userinfo_overrides)
+		{
+			entry.clear();
+		}
 	}

 	class component final : public component_interface
@@ -89,11 +101,13 @@ namespace userinfo
 		void on_startup([[maybe_unused]] plugin::plugin* plugin) override
 		{
 			sv_getuserinfo_hook.create(0x573E00, sv_getuserinfo_stub);
+			utils::hook::call(0x573042, client_connect_stub);

 			plugin->get_interface()->callbacks()->on_player_connect(clear_client_overrides);
 			plugin->get_interface()->callbacks()->on_player_disconnect(clear_client_overrides);

-			gsc::method::add("setname", [](const game::scr_entref_t ent, const gsc::function_args& args) -> scripting::script_value
+			gsc::method::add("setname", [](const game::scr_entref_t ent, const gsc::function_args& args) 
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -113,7 +127,8 @@ namespace userinfo
 				return {};
 			});

-			gsc::method::add("resetname", [](const game::scr_entref_t ent, const gsc::function_args&) -> scripting::script_value
+			gsc::method::add("resetname", [](const game::scr_entref_t ent, const gsc::function_args&)
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -131,7 +146,8 @@ namespace userinfo
 				return {};
 			});

-			gsc::method::add("setclantag", [](const game::scr_entref_t ent, const gsc::function_args& args) -> scripting::script_value
+			gsc::method::add("setclantag", [](const game::scr_entref_t ent, const gsc::function_args& args) 
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -153,7 +169,8 @@ namespace userinfo
 				return {};
 			});

-			gsc::method::add("resetclantag", [](const game::scr_entref_t ent, const gsc::function_args&) -> scripting::script_value
+			gsc::method::add("resetclantag", [](const game::scr_entref_t ent, const gsc::function_args&) 
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -173,7 +190,8 @@ namespace userinfo
 				return {};
 			});

-			gsc::method::add("removeclantag", [](const game::scr_entref_t ent, const gsc::function_args&) -> scripting::script_value
+			gsc::method::add("removeclantag", [](const game::scr_entref_t ent, const gsc::function_args&) 
+				-> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
@@ -2,6 +2,5 @@

 namespace userinfo
 {
-	void clear_client_overrides(int client);
 	void clear_overrides();
 }
@@ -3,22 +3,76 @@

 #include "plugin.hpp"

+#include "game/game.hpp"
+
+#include <utils/hook.hpp>
+#include <utils/binary_resource.hpp>
+#include <utils/nt.hpp>
+#include <utils/cryptography.hpp>
+#include <utils/io.hpp>
+
+namespace
+{
+	utils::hook::detour load_library_hook;
+
+	std::string extract_resource(const std::string& name, const int resource)
+	{
+		const auto data = utils::nt::load_resource(resource);
+		const auto path = std::filesystem::current_path() / "tmp" / name;
+		const auto path_str = path.generic_string();
+
+		if (!utils::io::write_file(path_str, data))
+		{
+			const auto current = utils::io::read_file(path_str);
+			const auto hash_current = utils::cryptography::md5::compute(current);
+			const auto hash_target = utils::cryptography::md5::compute(data);
+			if (hash_target != hash_current)
+			{
+				throw std::runtime_error("failed to extract libmysql.dll!");
+			}
+		}
+
+		return path_str;
+	}
+
+	HMODULE __stdcall load_library_stub(LPCSTR lib_name, HANDLE file, DWORD flags)
+	{
+		if (lib_name == "libmysql.dll"s)
+		{
+			const auto path = extract_resource(lib_name, LIBMYSQL_DLL);
+			const auto handle = load_library_hook.invoke_pascal<HMODULE>(path.data(), file, flags);
+
+			if (handle != nullptr)
+			{
+				return handle;
+			}
+			else
+			{
+				throw std::runtime_error(std::format("failed to load libmysql.dll: {}", GetLastError()));
+			}
+		}
+
+		return load_library_hook.invoke_pascal<HMODULE>(lib_name, file, flags);
+	}
+}
+
 PLUTONIUM_API plutonium::sdk::plugin* PLUTONIUM_CALLBACK on_initialize()
 {
-    return plugin::get();
+	return plugin::get();
 }

-BOOL APIENTRY DllMain(HMODULE /*module*/, DWORD reason, LPVOID /*reserved*/)
+BOOL APIENTRY DllMain(HMODULE module, DWORD ul_reason_for_call, LPVOID /*reserved*/)
 {
-    if (reason == DLL_PROCESS_ATTACH)
-    {
+	if (ul_reason_for_call == DLL_PROCESS_ATTACH)
+	{
+		utils::nt::library::set_current_handle(module);
+		load_library_hook.create(LoadLibraryExA, load_library_stub);
+	}

-    }
+	if (ul_reason_for_call == DLL_PROCESS_DETACH)
+	{
+		component_loader::on_shutdown();
+	}

-    if (reason == DLL_PROCESS_DETACH)
-    {
-        component_loader::on_shutdown();
-    }
-
-    return TRUE;
+	return TRUE;
 }
@@ -15,30 +15,30 @@ namespace scripting
 		}

 		const auto value = game::scr_VarGlob->childVariableValue[this->id_ + 0xC800 * (this->parent_id_ & 1)];
-		game::VariableValue variable;
+		game::VariableValue variable{};
 		variable.u = value.u.u;
 		variable.type = (game::scriptType_e)value.type;

 		this->value_ = variable;
 	}

-	void array_value::operator=(const script_value& _value)
+	void array_value::operator=(const script_value& value)
 	{
 		if (!this->id_)
 		{
 			return;
 		}

-		const auto value = _value.get_raw();
+		const auto& value_raw = value.get_raw();

 		const auto variable = &game::scr_VarGlob->childVariableValue[this->id_ + 0xC800 * (this->parent_id_ & 1)];
-		game::AddRefToValue(value.type, value.u);
+		game::AddRefToValue(value_raw.type, value_raw.u);
 		game::RemoveRefToValue(variable->type, variable->u.u);

-		variable->type = value.type;
-		variable->u.u = value.u;
+		variable->type = value_raw.type;
+		variable->u.u = value_raw.u;

-		this->value_ = value;
+		this->value_ = value_raw;
 	}

 	array::array(const unsigned int id)
@@ -170,7 +170,7 @@ namespace scripting
 		return game::Scr_GetSelf(this->id_);
 	}

-	unsigned int array::push(script_value value) const
+	unsigned int array::push(const script_value& value) const
 	{
 		this->set(this->size(), value);
 		return this->size();
@@ -225,7 +225,7 @@ namespace scripting
 		}

 		const auto value = game::scr_VarGlob->childVariableValue[variable_id + 0xC800 * (this->id_ & 1)];
-		game::VariableValue variable;
+		game::VariableValue variable{};
 		variable.u = value.u.u;
 		variable.type = (game::scriptType_e)value.type;

@@ -242,7 +242,7 @@ namespace scripting
 		}

 		const auto value = game::scr_VarGlob->childVariableValue[variable_id + 0xC800 * (this->id_ & 1)];
-		game::VariableValue variable;
+		game::VariableValue variable{};
 		variable.u = value.u.u;
 		variable.type = (game::scriptType_e)value.type;

@@ -261,9 +261,9 @@ namespace scripting
 		}
 	}

-	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_raw = value.get_raw();
 		const auto variable_id = this->get_value_id(key);

 		if (!variable_id)
@@ -273,16 +273,16 @@ namespace scripting

 		const auto variable = &game::scr_VarGlob->childVariableValue[variable_id + 0xC800 * (this->id_ & 1)];

-		game::AddRefToValue(value.type, value.u);
+		game::AddRefToValue(value_raw.type, value_raw.u);
 		game::RemoveRefToValue(variable->type, variable->u.u);

-		variable->type = value.type;
-		variable->u.u = value.u;
+		variable->type = value_raw.type;
+		variable->u.u = value_raw.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_raw = value.get_raw();
 		const auto variable_id = this->get_value_id(index);

 		if (!variable_id)
@@ -292,11 +292,11 @@ namespace scripting

 		const auto variable = &game::scr_VarGlob->childVariableValue[variable_id + 0xC800 * (this->id_ & 1)];

-		game::AddRefToValue(value.type, value.u);
+		game::AddRefToValue(value_raw.type, value_raw.u);
 		game::RemoveRefToValue(variable->type, variable->u.u);

-		variable->type = value.type;
-		variable->u.u = value.u;
+		variable->type = value_raw.type;
+		variable->u.u = value_raw.u;
 	}

 	unsigned int array::get_entity_id() const
@@ -320,6 +320,7 @@ namespace scripting
 	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);
@@ -34,7 +34,7 @@ namespace scripting
 		std::vector<script_value> get_keys() const;
 		unsigned int size() const;

-		unsigned int push(script_value) const;
+		unsigned int push(const script_value&) const;
 		void erase(const unsigned int) const;
 		void erase(const std::string&) const;
 		script_value pop() const;
@@ -69,13 +69,15 @@ namespace scripting
 		{
 			if (key.is<I>())
 			{
-				return { this->id_, this->get_value_id(key.as<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>()) };
+				return {this->id_, this->get_value_id(key.as<S>())};
 			}
+
+			throw std::runtime_error("invalid key type");
 		}

 	private:
@@ -2,6 +2,7 @@
 #include "game/game.hpp"
 #include "entity.hpp"
 #include "array.hpp"
+#include "object.hpp"
 #include "function.hpp"
 #include "script_value.hpp"

@@ -11,10 +11,9 @@ namespace scripting

 	script_value function::get_raw() const
 	{
-		game::VariableValue value;
+		game::VariableValue value{};
 		value.type = game::SCRIPT_FUNCTION;
 		value.u.codePosValue = this->pos_;
-
 		return value;
 	}

@@ -23,7 +22,7 @@ namespace scripting
 		return this->pos_;
 	}

-	script_value function::call(const entity& self, std::vector<script_value> arguments) const
+	script_value function::call(const entity& self, const std::vector<script_value>& arguments) const
 	{
 		return exec_ent_thread(self, this->pos_, arguments);
 	}
@@ -12,14 +12,14 @@ namespace scripting
 		script_value get_raw() const;
 		const char* get_pos() const;

-		script_value call(const entity& self, std::vector<script_value> arguments) const;
+		script_value call(const entity& self, const std::vector<script_value>& arguments) const;

-		script_value operator()(const entity& self, std::vector<script_value> arguments) const
+		script_value operator()(const entity& self, const std::vector<script_value>& arguments) const
 		{
 			return this->call(self, arguments);
 		}

-		script_value operator()(std::vector<script_value> arguments) const
+		script_value operator()(const std::vector<script_value>& arguments) const
 		{
 			return this->call(*game::levelEntityId, arguments);
 		}
@@ -28,7 +28,9 @@ namespace scripting
 		{
 			return this->call(*game::levelEntityId, {});
 		}
+
 	private:
 		const char* pos_;
+
 	};
 }
@@ -1,9 +0,0 @@
-#include <stdinc.hpp>
-#include "functions.hpp"
-
-#include <utils/string.hpp>
-
-namespace scripting
-{
-
-}
@@ -1,7 +0,0 @@
-#pragma once
-#include "game/game.hpp"
-
-namespace scripting
-{
-	using script_function = void(*)(game::scr_entref_t);
-}
@@ -0,0 +1,89 @@
+#include <stdinc.hpp>
+#include "object.hpp"
+#include "script_value.hpp"
+#include "execution.hpp"
+
+namespace scripting
+{
+	object::object(const unsigned int id)
+		: id_(id)
+	{
+		this->add();
+	}
+
+	object::object(const object& other)
+		: object(other.id_)
+	{
+	}
+
+	object::object(object&& other) noexcept
+	{
+		this->id_ = other.id_;
+		other.id_ = 0;
+	}
+
+	object::object()
+	{
+		this->id_ = make_object();
+	}
+
+	object::~object()
+	{
+		this->release();
+	}
+
+	object& object::operator=(const object& other)
+	{
+		if (&other != this)
+		{
+			this->release();
+			this->id_ = other.id_;
+			this->add();
+		}
+
+		return *this;
+	}
+
+	object& object::operator=(object&& other) noexcept
+	{
+		if (&other != this)
+		{
+			this->release();
+			this->id_ = other.id_;
+			other.id_ = 0;
+		}
+
+		return *this;
+	}
+
+	void object::add() const
+	{
+		if (this->id_)
+		{
+			game::AddRefToValue(game::SCRIPT_OBJECT, {static_cast<int>(this->id_)});
+		}
+	}
+
+	void object::release() const
+	{
+		if (this->id_)
+		{
+			game::RemoveRefToValue(game::SCRIPT_OBJECT, {static_cast<int>(this->id_)});
+		}
+	}
+
+	unsigned int object::size() const
+	{
+		return game::Scr_GetSelf(this->id_);
+	}
+
+	unsigned int object::get_entity_id() const
+	{
+		return this->id_;
+	}
+
+	entity object::get_raw() const
+	{
+		return entity(this->id_);
+	}
+}
@@ -0,0 +1,32 @@
+#pragma once
+#include "game/game.hpp"
+#include "script_value.hpp"
+
+namespace scripting
+{
+	class object final
+	{
+	public:
+		object();
+		object(const unsigned int);
+
+		object(const object& other);
+		object(object&& other) noexcept;
+
+		~object();
+
+		object& operator=(const object& other);
+		object& operator=(object&& other) noexcept;
+
+		unsigned int size() const;
+		unsigned int get_entity_id() const;
+
+		entity get_raw() const;
+
+	private:
+		void add() const;
+		void release() const;
+
+		unsigned int id_;
+	};
+}
@@ -2,6 +2,7 @@
 #include "script_value.hpp"
 #include "entity.hpp"
 #include "array.hpp"
+#include "object.hpp"
 #include "function.hpp"

 namespace scripting
@@ -117,6 +118,15 @@ namespace scripting
 		this->value_ = variable;
 	}

+	script_value::script_value(const object& 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{};
@@ -142,6 +152,12 @@ namespace scripting
 		return this->is<int>();
 	}

+	template <>
+	bool script_value::is<unsigned short>() const
+	{
+		return this->is<int>();
+	}
+
 	template <>
 	bool script_value::is<bool>() const
 	{
@@ -160,6 +176,12 @@ namespace scripting
 		return this->get_raw().u.uintValue;
 	}

+	template <>
+	unsigned short script_value::get() const
+	{
+		return static_cast<unsigned short>(this->get_raw().u.uintValue);
+	}
+
 	template <>
 	bool script_value::get() const
 	{
@@ -262,6 +284,32 @@ namespace scripting
 		return array(this->get_raw().u.uintValue);
 	}

+	
+	/***************************************************************
+	 * Array
+	 **************************************************************/
+
+	template <>
+	bool script_value::is<object>() const
+	{
+		if (this->get_raw().type != game::SCRIPT_OBJECT)
+		{
+			return false;
+		}
+
+		const auto id = this->get_raw().u.uintValue;
+		const auto type = game::scr_VarGlob->objectVariableValue[id].w.type;
+
+		return type == game::SCRIPT_STRUCT;
+	}
+
+	template <>
+	object script_value::get() const
+	{
+		return object(this->get_raw().u.uintValue);
+	}
+
+
 	/***************************************************************
 	 * Struct
 	 **************************************************************/
@@ -321,7 +369,45 @@ namespace scripting
 		return this->value_.get();
 	}

-	value_wrap::value_wrap(const scripting::script_value& value, int argument_index)
+	std::string script_value::to_string() const
+	{
+		if (this->is<int>())
+		{
+			return utils::string::va("%i", this->as<int>());
+		}
+
+		if (this->is<float>())
+		{
+			return utils::string::va("%f", this->as<float>());
+		}
+
+		if (this->is<std::string>())
+		{
+			return this->as<std::string>();
+		}
+
+		if (this->is<vector>())
+		{
+			const auto vec = this->as<vector>();
+			return utils::string::va("(%g, %g, %g)",
+				vec.get_x(),
+				vec.get_y(),
+				vec.get_z()
+			);
+		}
+
+		if (this->is<function>())
+		{
+			const auto func = this->as<function>();
+			const auto pos = func.get_pos();
+			return utils::string::va("[[ function: %p ]]", pos);
+		}
+
+		return this->type_name();
+	}
+
+
+	value_wrap::value_wrap(const scripting::script_value& value, const std::uint32_t argument_index)
 		: value_(value)
 		, argument_index_(argument_index)
 	{
@@ -7,6 +7,7 @@ namespace scripting
 {
 	class entity;
 	class array;
+	class object;
 	class function;
 	class value_wrap;

@@ -82,6 +83,11 @@ namespace scripting
 				return "array";
 			}

+			if (info == typeid(object))
+			{
+				return "object";
+			}
+
 			if (info == typeid(function))
 			{
 				return "function";
@@ -121,6 +127,8 @@ namespace scripting

 		script_value(const array& value);

+		script_value(const object& value);
+
 		script_value(const function& value);

 		template <typename T>
@@ -153,8 +161,15 @@ namespace scripting
 			return reinterpret_cast<T*>(value);
 		}

+		std::string type_name() const
+		{
+			return get_typename(this->get_raw());
+		}
+
 		const game::VariableValue& get_raw() const;

+		std::string to_string() const;
+
 		variable_value value_{};
 	private:
 		template <typename T>
@@ -164,7 +179,7 @@ namespace scripting
 	class value_wrap
 	{
 	public:
-		value_wrap(const scripting::script_value& value, int argument_index);
+		value_wrap(const scripting::script_value& value, const std::uint32_t);

 		template <typename T>
 		T as() const
@@ -179,7 +194,7 @@ namespace scripting
 			}
 		}

-		template <typename T, typename I = int>
+		template <typename T>
 		T* as_ptr()
 		{
 			try
@@ -203,7 +218,7 @@ namespace scripting
 			return this->value_.get_raw();
 		}

-		int argument_index_{};
+		std::uint32_t argument_index_{};
 		scripting::script_value value_;
 	};
 }
@@ -26,6 +26,6 @@ namespace scripting
 		void set_z(float value);

 	private:
-		game::vec3_t value_{ 0 };
+		game::vec3_t value_{};
 	};
 }
@@ -426,4 +426,18 @@ namespace game
 	};

 	static_assert(sizeof(client_s) == 0x78698);
+
+	struct game_hudelem_s
+	{
+		unsigned int type;
+		char __pad0[128];
+		unsigned int text;
+		char __pad1[28];
+		unsigned int flags;
+		char __pad2[12];
+	};
+
+	static_assert(offsetof(game_hudelem_s, text) == 132);
+	static_assert(offsetof(game_hudelem_s, flags) == 164);
+	static_assert(sizeof(game_hudelem_s) == 180);
 }
@@ -48,6 +48,7 @@ namespace game
 	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<void()> Scr_ErrorInternal{0x568FD0};

 	WEAK symbol<unsigned int(const char* str, unsigned int user)> SL_GetString{0x5649E0};
 	WEAK symbol<unsigned int(const char* str)> SL_GetCanonicalString{0x5619A0};
@@ -56,6 +57,7 @@ namespace game
 	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, const char*)> SV_SetConfigString{0x574BD0};

 	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};
@@ -75,10 +77,12 @@ namespace game

 	WEAK symbol<scr_classStruct_t*> g_classMap{0x8B4300};

+	WEAK symbol<game_hudelem_s> g_hudelems{0x1A39E00};
 	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};
+	WEAK symbol<unsigned short> sv_configstrings{0x20FA3AE};
 }
@@ -0,0 +1,3 @@
+#pragma once
+
+#define LIBMYSQL_DLL	100
@@ -0,0 +1,3 @@
+#include "resource.hpp"
+
+LIBMYSQL_DLL    RCDATA "../../deps/mysql/lib/libmysql.dll"
@@ -1 +1,24 @@
 #include <stdinc.hpp>
+
+extern "C"
+{
+	int s_read_arc4random(void*, size_t)
+	{
+		return -1;
+	}
+
+	int s_read_getrandom(void*, size_t)
+	{
+		return -1;
+	}
+
+	int s_read_urandom(void*, size_t)
+	{
+		return -1;
+	}
+
+	int s_read_ltm_rng(void*, size_t)
+	{
+		return -1;
+	}
+}
@@ -12,6 +12,9 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>

+#undef min
+#undef max
+
 #include <vector>
 #include <cassert>
 #include <mutex>
@@ -31,6 +34,11 @@
 #include <Psapi.h>

 #pragma comment(lib, "urlmon.lib")
+#pragma comment(lib, "libmysql.lib")
+#pragma comment(lib, "delayimp.lib")
+#pragma comment(lib, "secur32.lib")
+
+#include "resource.hpp"

 using namespace std::literals;

@@ -0,0 +1,76 @@
+#include <stdinc.hpp>
+#include "binary_resource.hpp"
+
+#include <utility>
+#include "nt.hpp"
+#include "io.hpp"
+
+namespace utils
+{
+	namespace
+	{
+		std::string get_temp_folder()
+		{
+			char path[MAX_PATH] = {0};
+			if (!GetTempPathA(sizeof(path), path))
+			{
+				throw std::runtime_error("Unable to get temp path");
+			}
+
+			return path;
+		}
+
+		std::string write_exitisting_temp_file(const std::string& file, const std::string& data,
+		                                       const bool fatal_if_overwrite_fails)
+		{
+			const auto temp = get_temp_folder();
+			auto file_path = temp + file;
+
+			std::string current_data;
+			if (!io::read_file(file_path, &current_data))
+			{
+				if (!io::write_file(file_path, data))
+				{
+					throw std::runtime_error("Failed to write file: " + file_path);
+				}
+
+				return file_path;
+			}
+
+			if (current_data == data || io::write_file(file_path, data) || !fatal_if_overwrite_fails)
+			{
+				return file_path;
+			}
+
+			throw std::runtime_error(
+				"Temporary file was already written, but differs. It can't be overwritten as it's still in use: " +
+				file_path);
+		}
+	}
+
+	binary_resource::binary_resource(const int id, std::string file)
+		: filename_(std::move(file))
+	{
+		this->resource_ = nt::load_resource(id);
+
+		if (this->resource_.empty())
+		{
+			throw std::runtime_error("Unable to load resource: " + std::to_string(id));
+		}
+	}
+
+	std::string binary_resource::get_extracted_file(const bool fatal_if_overwrite_fails)
+	{
+		if (this->path_.empty())
+		{
+			this->path_ = write_exitisting_temp_file(this->filename_, this->resource_, fatal_if_overwrite_fails);
+		}
+
+		return this->path_;
+	}
+
+	const std::string& binary_resource::get_data() const
+	{
+		return this->resource_;
+	}
+}
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+
+namespace utils
+{
+	class binary_resource
+	{
+	public:
+		binary_resource(int id, std::string file);
+
+		std::string get_extracted_file(bool fatal_if_overwrite_fails = false);
+		const std::string& get_data() const;
+
+	private:
+		std::string resource_;
+		std::string filename_;
+		std::string path_;
+	};
+}
@@ -0,0 +1,691 @@
+#include <stdinc.hpp>
+
+#include "cryptography.hpp"
+#include "nt.hpp"
+#include <gsl/gsl>
+
+#undef max
+using namespace std::string_literals;
+
+/// http://www.opensource.apple.com/source/CommonCrypto/CommonCrypto-55010/Source/libtomcrypt/doc/libTomCryptDoc.pdf
+
+#pragma warning(push)
+#pragma warning(disable: 4996)
+
+namespace utils::cryptography
+{
+	namespace
+	{
+		struct __
+		{
+			__()
+			{
+				ltc_mp = ltm_desc;
+
+				register_cipher(&aes_desc);
+				register_cipher(&des3_desc);
+
+				register_prng(&sprng_desc);
+				register_prng(&fortuna_desc);
+				register_prng(&yarrow_desc);
+
+				register_hash(&sha1_desc);
+				register_hash(&sha256_desc);
+				register_hash(&sha512_desc);
+			}
+		} ___;
+
+		[[maybe_unused]] const char* cs(const uint8_t* data)
+		{
+			return reinterpret_cast<const char*>(data);
+		}
+
+		[[maybe_unused]] char* cs(uint8_t* data)
+		{
+			return reinterpret_cast<char*>(data);
+		}
+
+		[[maybe_unused]] const uint8_t* cs(const char* data)
+		{
+			return reinterpret_cast<const uint8_t*>(data);
+		}
+
+		[[maybe_unused]] uint8_t* cs(char* data)
+		{
+			return reinterpret_cast<uint8_t*>(data);
+		}
+
+		[[maybe_unused]] unsigned long ul(const size_t value)
+		{
+			return static_cast<unsigned long>(value);
+		}
+
+		class prng
+		{
+		public:
+			prng(const ltc_prng_descriptor& descriptor, const bool autoseed = true)
+				: state_(std::make_unique<prng_state>())
+				  , descriptor_(descriptor)
+			{
+				this->id_ = register_prng(&descriptor);
+				if (this->id_ == -1)
+				{
+					throw std::runtime_error("PRNG "s + this->descriptor_.name + " could not be registered!");
+				}
+
+				if (autoseed)
+				{
+					this->auto_seed();
+				}
+				else
+				{
+					this->descriptor_.start(this->state_.get());
+				}
+			}
+
+			~prng()
+			{
+				this->descriptor_.done(this->state_.get());
+			}
+
+			prng_state* get_state() const
+			{
+				this->descriptor_.ready(this->state_.get());
+				return this->state_.get();
+			}
+
+			int get_id() const
+			{
+				return this->id_;
+			}
+
+			void add_entropy(const void* data, const size_t length) const
+			{
+				this->descriptor_.add_entropy(static_cast<const uint8_t*>(data), ul(length), this->state_.get());
+			}
+
+			void read(void* data, const size_t length) const
+			{
+				this->descriptor_.read(static_cast<unsigned char*>(data), ul(length), this->get_state());
+			}
+
+		private:
+			int id_;
+			std::unique_ptr<prng_state> state_;
+			const ltc_prng_descriptor& descriptor_;
+
+			void auto_seed() const
+			{
+				rng_make_prng(128, this->id_, this->state_.get(), nullptr);
+
+				int i[4]; // uninitialized data
+				auto* i_ptr = &i;
+				this->add_entropy(reinterpret_cast<uint8_t*>(&i), sizeof(i));
+				this->add_entropy(reinterpret_cast<uint8_t*>(&i_ptr), sizeof(i_ptr));
+
+				auto t = time(nullptr);
+				this->add_entropy(reinterpret_cast<uint8_t*>(&t), sizeof(t));
+			}
+		};
+
+		const prng prng_(fortuna_desc);
+	}
+
+	ecc::key::key()
+	{
+		ZeroMemory(&this->key_storage_, sizeof(this->key_storage_));
+	}
+
+	ecc::key::~key()
+	{
+		this->free();
+	}
+
+	ecc::key::key(key&& obj) noexcept
+		: key()
+	{
+		this->operator=(std::move(obj));
+	}
+
+	ecc::key::key(const key& obj)
+		: key()
+	{
+		this->operator=(obj);
+	}
+
+	ecc::key& ecc::key::operator=(key&& obj) noexcept
+	{
+		if (this != &obj)
+		{
+			std::memmove(&this->key_storage_, &obj.key_storage_, sizeof(this->key_storage_));
+			ZeroMemory(&obj.key_storage_, sizeof(obj.key_storage_));
+		}
+
+		return *this;
+	}
+
+	ecc::key& ecc::key::operator=(const key& obj)
+	{
+		if (this != &obj && obj.is_valid())
+		{
+			this->deserialize(obj.serialize(obj.key_storage_.type));
+		}
+
+		return *this;
+	}
+
+	bool ecc::key::is_valid() const
+	{
+		return (!memory::is_set(&this->key_storage_, 0, sizeof(this->key_storage_)));
+	}
+
+	ecc_key& ecc::key::get()
+	{
+		return this->key_storage_;
+	}
+
+	const ecc_key& ecc::key::get() const
+	{
+		return this->key_storage_;
+	}
+
+	std::string ecc::key::get_public_key() const
+	{
+		uint8_t buffer[512] = {0};
+		unsigned long length = sizeof(buffer);
+
+		if (ecc_ansi_x963_export(&this->key_storage_, buffer, &length) == CRYPT_OK)
+		{
+			return std::string(cs(buffer), length);
+		}
+
+		return {};
+	}
+
+	void ecc::key::set(const std::string& pub_key_buffer)
+	{
+		this->free();
+
+		if (ecc_ansi_x963_import(cs(pub_key_buffer.data()),
+		                         ul(pub_key_buffer.size()),
+		                         &this->key_storage_) != CRYPT_OK)
+		{
+			ZeroMemory(&this->key_storage_, sizeof(this->key_storage_));
+		}
+	}
+
+	void ecc::key::deserialize(const std::string& key)
+	{
+		this->free();
+
+		if (ecc_import(cs(key.data()), ul(key.size()),
+		               &this->key_storage_) != CRYPT_OK
+		)
+		{
+			ZeroMemory(&this->key_storage_, sizeof(this->key_storage_));
+		}
+	}
+
+	std::string ecc::key::serialize(const int type) const
+	{
+		uint8_t buffer[4096] = {0};
+		unsigned long length = sizeof(buffer);
+
+		if (ecc_export(buffer, &length, type, &this->key_storage_) == CRYPT_OK)
+		{
+			return std::string(cs(buffer), length);
+		}
+
+		return "";
+	}
+
+	void ecc::key::free()
+	{
+		if (this->is_valid())
+		{
+			ecc_free(&this->key_storage_);
+		}
+
+		ZeroMemory(&this->key_storage_, sizeof(this->key_storage_));
+	}
+
+	bool ecc::key::operator==(key& key) const
+	{
+		return (this->is_valid() && key.is_valid() && this->serialize(PK_PUBLIC) == key.serialize(PK_PUBLIC));
+	}
+
+	uint64_t ecc::key::get_hash() const
+	{
+		const auto hash = sha1::compute(this->get_public_key());
+		if (hash.size() >= 8)
+		{
+			return *reinterpret_cast<const uint64_t*>(hash.data());
+		}
+
+		return 0;
+	}
+
+	ecc::key ecc::generate_key(const int bits)
+	{
+		key key;
+		ecc_make_key(prng_.get_state(), prng_.get_id(), bits / 8, &key.get());
+
+		return key;
+	}
+
+	ecc::key ecc::generate_key(const int bits, const std::string& entropy)
+	{
+		key key{};
+		const prng yarrow(yarrow_desc, false);
+		yarrow.add_entropy(entropy.data(), entropy.size());
+
+		ecc_make_key(yarrow.get_state(), yarrow.get_id(), bits / 8, &key.get());
+
+		return key;
+	}
+
+	std::string ecc::sign_message(const key& key, const std::string& message)
+	{
+		if (!key.is_valid()) return "";
+
+		uint8_t buffer[512];
+		unsigned long length = sizeof(buffer);
+
+		ecc_sign_hash(cs(message.data()), ul(message.size()), buffer, &length, prng_.get_state(), prng_.get_id(),
+		              &key.get());
+
+		return std::string(cs(buffer), length);
+	}
+
+	bool ecc::verify_message(const key& key, const std::string& message, const std::string& signature)
+	{
+		if (!key.is_valid()) return false;
+
+		auto result = 0;
+		return (ecc_verify_hash(cs(signature.data()),
+		                        ul(signature.size()),
+		                        cs(message.data()),
+		                        ul(message.size()), &result,
+		                        &key.get()) == CRYPT_OK && result != 0);
+	}
+
+	bool ecc::encrypt(const key& key, std::string& data)
+	{
+		std::string out_data{};
+		out_data.resize(std::max(ul(data.size() * 3), ul(0x100)));
+
+		auto out_len = ul(out_data.size());
+		auto crypt = [&]()
+		{
+			return ecc_encrypt_key(cs(data.data()), ul(data.size()), cs(out_data.data()), &out_len,
+			                       prng_.get_state(), prng_.get_id(), find_hash("sha512"), &key.get());
+		};
+
+		auto res = crypt();
+
+		if (res == CRYPT_BUFFER_OVERFLOW)
+		{
+			out_data.resize(out_len);
+			res = crypt();
+		}
+
+		if (res != CRYPT_OK)
+		{
+			return false;
+		}
+
+		out_data.resize(out_len);
+		data = std::move(out_data);
+		return true;
+	}
+
+	bool ecc::decrypt(const key& key, std::string& data)
+	{
+		std::string out_data{};
+		out_data.resize(std::max(ul(data.size() * 3), ul(0x100)));
+
+		auto out_len = ul(out_data.size());
+		auto crypt = [&]()
+		{
+			return ecc_decrypt_key(cs(data.data()), ul(data.size()), cs(out_data.data()), &out_len, &key.get());
+		};
+
+		auto res = crypt();
+
+		if (res == CRYPT_BUFFER_OVERFLOW)
+		{
+			out_data.resize(out_len);
+			res = crypt();
+		}
+
+		if (res != CRYPT_OK)
+		{
+			return false;
+		}
+
+		out_data.resize(out_len);
+		data = std::move(out_data);
+		return true;
+	}
+
+	std::string rsa::encrypt(const std::string& data, const std::string& hash, const std::string& key)
+	{
+		rsa_key new_key;
+		rsa_import(cs(key.data()), ul(key.size()), &new_key);
+		const auto _ = gsl::finally([&]()
+		{
+			rsa_free(&new_key);
+		});
+
+
+		std::string out_data{};
+		out_data.resize(std::max(ul(data.size() * 3), ul(0x100)));
+
+		auto out_len = ul(out_data.size());
+		auto crypt = [&]()
+		{
+			return rsa_encrypt_key_ex(cs(data.data()), ul(data.size()), cs(out_data.data()), &out_len, cs(hash.data()),
+			                       ul(hash.size()), prng_.get_state(), prng_.get_id(), find_hash("sha512"), LTC_PKCS_1_V1_5, &new_key);
+		};
+
+		auto res = crypt();
+
+		if (res == CRYPT_BUFFER_OVERFLOW)
+		{
+			out_data.resize(out_len);
+			res = crypt();
+		}
+
+		if (res == CRYPT_OK)
+		{
+			out_data.resize(out_len);
+			return out_data;
+		}
+
+		return {};
+	}
+
+	std::string des3::encrypt(const std::string& data, const std::string& iv, const std::string& key)
+	{
+		std::string enc_data;
+		enc_data.resize(data.size());
+
+		symmetric_CBC cbc;
+		const auto des3 = find_cipher("3des");
+
+		cbc_start(des3, cs(iv.data()), cs(key.data()), static_cast<int>(key.size()), 0, &cbc);
+		cbc_encrypt(cs(data.data()), cs(enc_data.data()), ul(data.size()), &cbc);
+		cbc_done(&cbc);
+
+		return enc_data;
+	}
+
+	std::string des3::decrypt(const std::string& data, const std::string& iv, const std::string& key)
+	{
+		std::string dec_data;
+		dec_data.resize(data.size());
+
+		symmetric_CBC cbc;
+		const auto des3 = find_cipher("3des");
+
+		cbc_start(des3, cs(iv.data()), cs(key.data()), static_cast<int>(key.size()), 0, &cbc);
+		cbc_decrypt(cs(data.data()), cs(dec_data.data()), ul(data.size()), &cbc);
+		cbc_done(&cbc);
+
+		return dec_data;
+	}
+
+	std::string tiger::compute(const std::string& data, const bool hex)
+	{
+		return compute(cs(data.data()), data.size(), hex);
+	}
+
+	std::string tiger::compute(const uint8_t* data, const size_t length, const bool hex)
+	{
+		uint8_t buffer[24] = {0};
+
+		hash_state state;
+		tiger_init(&state);
+		tiger_process(&state, data, ul(length));
+		tiger_done(&state, buffer);
+
+		std::string hash(cs(buffer), sizeof(buffer));
+		if (!hex) return hash;
+
+		return string::dump_hex(hash, "");
+	}
+
+	std::string aes::encrypt(const std::string& data, const std::string& iv, const std::string& key)
+	{
+		std::string aligned_data = data;
+		const auto mod = aligned_data.size() % 16;
+		if (mod != 0)
+		{
+			aligned_data.resize(aligned_data.size() + (16 - mod));
+		}
+
+		std::string enc_data;
+		enc_data.resize(aligned_data.size());
+
+		symmetric_CBC cbc;
+		const auto aes = find_cipher("aes");
+
+		cbc_start(aes, cs(iv.data()), cs(key.data()),
+		          static_cast<int>(key.size()), 0, &cbc);
+		cbc_encrypt(cs(aligned_data.data()),
+		            cs(enc_data.data()),
+		            ul(aligned_data.size()), &cbc);
+		cbc_done(&cbc);
+
+		return enc_data;
+	}
+
+	std::string aes::decrypt(const std::string& data, const std::string& iv, const std::string& key)
+	{
+		std::string dec_data;
+		dec_data.resize(data.size());
+
+		symmetric_CBC cbc;
+		const auto aes = find_cipher("aes");
+
+		cbc_start(aes, cs(iv.data()), cs(key.data()),
+		          static_cast<int>(key.size()), 0, &cbc);
+		cbc_decrypt(cs(data.data()),
+		            cs(dec_data.data()),
+		            ul(data.size()), &cbc);
+		cbc_done(&cbc);
+
+		return dec_data;
+	}
+
+	std::string hmac_sha1::compute(const std::string& data, const std::string& key)
+	{
+		std::string buffer;
+		buffer.resize(20);
+
+		hmac_state state;
+		hmac_init(&state, find_hash("sha1"), cs(key.data()), ul(key.size()));
+		hmac_process(&state, cs(data.data()), static_cast<int>(data.size()));
+
+		auto out_len = ul(buffer.size());
+		hmac_done(&state, cs(buffer.data()), &out_len);
+
+		buffer.resize(out_len);
+		return buffer;
+	}
+
+	std::string sha1::compute(const std::string& data, const bool hex)
+	{
+		return compute(cs(data.data()), data.size(), hex);
+	}
+
+	std::string sha1::compute(const uint8_t* data, const size_t length, const bool hex)
+	{
+		uint8_t buffer[20] = {0};
+
+		hash_state state;
+		sha1_init(&state);
+		sha1_process(&state, data, ul(length));
+		sha1_done(&state, buffer);
+
+		std::string hash(cs(buffer), sizeof(buffer));
+		if (!hex) return hash;
+
+		return string::dump_hex(hash, "");
+	}
+
+	std::string sha256::compute(const std::string& data, const bool hex)
+	{
+		return compute(cs(data.data()), data.size(), hex);
+	}
+
+	std::string sha256::compute(const uint8_t* data, const size_t length, const bool hex)
+	{
+		uint8_t buffer[32] = {0};
+
+		hash_state state;
+		sha256_init(&state);
+		sha256_process(&state, data, ul(length));
+		sha256_done(&state, buffer);
+
+		std::string hash(cs(buffer), sizeof(buffer));
+		if (!hex) return hash;
+
+		return string::dump_hex(hash, "");
+	}
+
+	std::string sha512::compute(const std::string& data, const bool hex)
+	{
+		return compute(cs(data.data()), data.size(), hex);
+	}
+
+	std::string sha512::compute(const uint8_t* data, const size_t length, const bool hex)
+	{
+		uint8_t buffer[64] = {0};
+
+		hash_state state;
+		sha512_init(&state);
+		sha512_process(&state, data, ul(length));
+		sha512_done(&state, buffer);
+
+		std::string hash(cs(buffer), sizeof(buffer));
+		if (!hex) return hash;
+
+		return string::dump_hex(hash, "");
+	}
+
+	namespace md5
+	{
+		std::string compute(const std::string& data, bool hex)
+		{
+			return compute(cs(data.data()), data.size(), hex);
+		}
+
+		std::string compute(const uint8_t* data, size_t length, bool hex)
+		{
+			uint8_t buffer[16] = {0};
+
+			hash_state state;
+			md5_init(&state);
+			md5_process(&state, data, ul(length));
+			md5_done(&state, buffer);
+
+			std::string hash(cs(buffer), sizeof(buffer));
+			if (!hex) return hash;
+
+			return string::dump_hex(hash, "");
+		}
+	}
+	
+	std::string base64::encode(const uint8_t* data, const size_t len)
+	{
+		std::string result;
+		result.resize((len + 2) * 2);
+
+		auto out_len = ul(result.size());
+		if (base64_encode(data, ul(len), result.data(), &out_len) != CRYPT_OK)
+		{
+			return {};
+		}
+
+		result.resize(out_len);
+		return result;
+	}
+
+	std::string base64::encode(const std::string& data)
+	{
+		return base64::encode(cs(data.data()), static_cast<unsigned>(data.size()));
+	}
+
+	std::string base64::decode(const std::string& data)
+	{
+		std::string result;
+		result.resize((data.size() + 2) * 2);
+
+		auto out_len = ul(result.size());
+		if (base64_decode(data.data(), ul(data.size()), cs(result.data()), &out_len) != CRYPT_OK)
+		{
+			return {};
+		}
+
+		result.resize(out_len);
+		return result;
+	}
+
+	unsigned int jenkins_one_at_a_time::compute(const std::string& data)
+	{
+		return compute(data.data(), data.size());
+	}
+
+	unsigned int jenkins_one_at_a_time::compute(const char* key, const size_t len)
+	{
+		unsigned int hash, i;
+		for (hash = i = 0; i < len; ++i)
+		{
+			hash += key[i];
+			hash += (hash << 10);
+			hash ^= (hash >> 6);
+		}
+		hash += (hash << 3);
+		hash ^= (hash >> 11);
+		hash += (hash << 15);
+		return hash;
+	}
+
+	uint32_t random::get_integer()
+	{
+		uint32_t result;
+		random::get_data(&result, sizeof(result));
+		return result;
+	}
+
+	uint32_t random::get_integer(const std::uint32_t min, const std::uint32_t max)
+	{
+		const auto range = max - min + 1;
+		const auto value = random::get_integer();
+		return value % range + min;
+	}
+
+	std::string random::get_challenge()
+	{
+		std::string result;
+		result.resize(sizeof(uint32_t));
+		random::get_data(result.data(), result.size());
+		return string::dump_hex(result, "");
+	}
+
+	void random::get_data(void* data, const size_t size)
+	{
+		prng_.read(data, size);
+	}
+
+	std::string random::get_data(const size_t size)
+	{
+		std::string data;
+		data.resize(size);
+		random::get_data(data.data(), size);
+		return data;
+	}
+}
+
+#pragma warning(pop)
@@ -0,0 +1,151 @@
+#pragma once
+
+#include <string>
+#include <tomcrypt.h>
+#include "string.hpp"
+
+namespace utils::cryptography
+{
+	namespace ecc
+	{
+		class key final
+		{
+		public:
+			key();
+			~key();
+
+			key(key&& obj) noexcept;
+			key(const key& obj);
+			key& operator=(key&& obj) noexcept;
+			key& operator=(const key& obj);
+
+			bool is_valid() const;
+
+			ecc_key& get();
+			const ecc_key& get() const;
+
+			std::string get_public_key() const;
+
+			void set(const std::string& pub_key_buffer);
+
+			void deserialize(const std::string& key);
+
+			std::string serialize(int type = PK_PRIVATE) const;
+
+			void free();
+
+			bool operator==(key& key) const;
+
+			uint64_t get_hash() const;
+
+		private:
+			ecc_key key_storage_{};
+		};
+
+		key generate_key(int bits);
+		key generate_key(int bits, const std::string& entropy);
+		std::string sign_message(const key& key, const std::string& message);
+		bool verify_message(const key& key, const std::string& message, const std::string& signature);
+
+		bool encrypt(const key& key, std::string& data);
+		bool decrypt(const key& key, std::string& data);
+	}
+
+	namespace rsa
+	{
+		std::string encrypt(const std::string& data, const std::string& hash, const std::string& key);
+		std::string decrypt(const std::string& data, const std::string& hash, const std::string& key);
+	}
+
+	namespace des3
+	{
+		std::string encrypt(const std::string& data, const std::string& iv, const std::string& key);
+		std::string decrypt(const std::string& data, const std::string& iv, const std::string& key);
+	}
+
+	namespace tiger
+	{
+		std::string compute(const std::string& data, bool hex = false);
+		std::string compute(const uint8_t* data, size_t length, bool hex = false);
+	}
+
+	namespace aes
+	{
+		std::string encrypt(const std::string& data, const std::string& iv, const std::string& key);
+		std::string decrypt(const std::string& data, const std::string& iv, const std::string& key);
+	}
+
+	namespace hmac_sha1
+	{
+		std::string compute(const std::string& data, const std::string& key);
+	}
+
+	namespace sha1
+	{
+		std::string compute(const std::string& data, bool hex = false);
+		std::string compute(const uint8_t* data, size_t length, bool hex = false);
+	}
+
+	namespace sha256
+	{
+		std::string compute(const std::string& data, bool hex = false);
+		std::string compute(const uint8_t* data, size_t length, bool hex = false);
+	}
+
+	namespace sha512
+	{
+		std::string compute(const std::string& data, bool hex = false);
+		std::string compute(const uint8_t* data, size_t length, bool hex = false);
+	}
+
+	namespace md5
+	{
+		std::string compute(const std::string& data, bool hex = false);
+		std::string compute(const uint8_t* data, size_t length, bool hex = false);
+	}
+
+	namespace argon2
+	{
+		template <size_t HashLen = 32, size_t SaltLen = 16, std::uint32_t TCost = 2,
+			std::uint32_t MCost = 1 << 6, std::uint32_t Threads = 1>
+		std::string compute(const std::string& data, bool hex = false)
+		{
+			std::uint8_t buffer[HashLen]{};
+			std::uint8_t salt[SaltLen]{};
+
+			argon2i_hash_raw(TCost, MCost, Threads, data.data(), data.size(), salt, SaltLen, buffer, HashLen);
+
+			const auto str = std::string{reinterpret_cast<char*>(buffer), HashLen};
+			if (hex)
+			{
+				return string::dump_hex(str, "", false);
+			}
+			else
+			{
+				return str;
+			}
+		}
+	}
+
+	namespace base64
+	{
+		std::string encode(const uint8_t* data, size_t len);
+		std::string encode(const std::string& data);
+		std::string decode(const std::string& data);
+	}
+
+	namespace jenkins_one_at_a_time
+	{
+		unsigned int compute(const std::string& data);
+		unsigned int compute(const char* key, size_t len);
+	};
+
+	namespace random
+	{
+		uint32_t get_integer();
+		uint32_t get_integer(const std::uint32_t min, const std::uint32_t max);
+		std::string get_challenge();
+		void get_data(void* data, size_t size);
+		std::string get_data(const size_t size);
+	}
+}
@@ -55,6 +55,12 @@ namespace utils::hook
 			return static_cast<T(*)(Args ...)>(this->get_original())(args...);
 		}

+		template <typename T, typename... Args>
+		T invoke_pascal(Args... args)
+		{
+			return static_cast<T(__stdcall*)(Args ...)>(this->get_original())(args...);
+		}
+
 		[[nodiscard]] void* get_original() const;

 	private:
@@ -1,47 +1,79 @@
 #include <stdinc.hpp>
 #include "http.hpp"

+#include <gsl/gsl>
+
+#pragma comment(lib, "ws2_32.lib")
+
 namespace utils::http
 {
-	std::optional<std::string> get_data(const std::string& url)
+	namespace
 	{
-		CComPtr<IStream> stream;
-
-		if (FAILED(URLOpenBlockingStreamA(nullptr, url.data(), &stream, 0, nullptr)))
+		size_t write_callback(void* contents, const size_t size, const size_t nmemb, void* userp)
 		{
-			return {};
+			const auto buffer = static_cast<std::string*>(userp);
+			const auto total_size = size * nmemb;
+			buffer->append(static_cast<char*>(contents), total_size);
+			return total_size;
 		}
-
-		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)
+	std::optional<result> get_data(const std::string& url, const std::string& fields,
+		const headers& headers, const std::string& method)
 	{
-		return std::async(std::launch::async, [url]()
+		curl_slist* header_list = nullptr;
+		const auto curl = curl_easy_init();
+		if (!curl)
 		{
-			return get_data(url);
+			return {};
+		}
+
+		auto _ = gsl::finally([&]()
+		{
+			curl_slist_free_all(header_list);
+			curl_easy_cleanup(curl);
 		});
+
+		for (const auto& header : headers)
+		{
+			auto data = header.first + ": " + header.second;
+			header_list = curl_slist_append(header_list, data.data());
+		}
+
+		std::string buffer{};
+
+		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header_list);
+		curl_easy_setopt(curl, CURLOPT_URL, url.data());
+
+		if (!fields.empty())
+		{
+			curl_easy_setopt(curl, CURLOPT_POSTFIELDS, fields.data());
+			curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, fields.size());
+		}
+
+		if (!method.empty())
+		{
+			curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method.data());
+		}
+
+		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
+		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
+
+		const auto code = curl_easy_perform(curl);
+
+		if (code == CURLE_OK)
+		{
+			result result;
+			result.code = code;
+			result.buffer = std::move(buffer);
+			return result;
+		}
+		else
+		{
+			result result;
+			result.code = code;
+			return result;
+		}
 	}
 }
@@ -2,10 +2,19 @@

 #include <string>
 #include <optional>
-#include <future>
+
+#include <curl/curl.h>

 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);
+	struct result
+	{
+		CURLcode code;
+		std::string buffer;
+	};
+
+	using headers = std::unordered_map<std::string, std::string>;
+
+	std::optional<result> get_data(const std::string& url, const std::string& fields = {},
+		const headers& headers = {}, const std::string& method = {});
 }
@@ -0,0 +1,250 @@
+#include <stdinc.hpp>
+#include "nt.hpp"
+#include "string.hpp"
+
+namespace utils::nt
+{
+	HMODULE library::current_handle_;
+
+	library library::load(const std::string& name)
+	{
+		return library(LoadLibraryA(name.data()));
+	}
+
+	library library::load(const std::filesystem::path& path)
+	{
+		return library::load(path.generic_string());
+	}
+
+	library library::get_by_address(void* address)
+	{
+		HMODULE handle = nullptr;
+		GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, static_cast<LPCSTR>(address), &handle);
+		return library(handle);
+	}
+
+	void library::set_current_handle(HMODULE handle)
+	{
+		current_handle_ = handle;
+	}
+
+	HMODULE library::get_current_handle()
+	{
+		return current_handle_;
+	}
+
+	library::library()
+	{
+		this->module_ = GetModuleHandleA(nullptr);
+	}
+
+	library::library(const std::string& name)
+	{
+		this->module_ = GetModuleHandleA(name.data());
+	}
+
+	library::library(const HMODULE handle)
+	{
+		this->module_ = handle;
+	}
+
+	bool library::operator==(const library& obj) const
+	{
+		return this->module_ == obj.module_;
+	}
+
+	library::operator bool() const
+	{
+		return this->is_valid();
+	}
+
+	library::operator HMODULE() const
+	{
+		return this->get_handle();
+	}
+
+	PIMAGE_NT_HEADERS library::get_nt_headers() const
+	{
+		if (!this->is_valid()) return nullptr;
+		return reinterpret_cast<PIMAGE_NT_HEADERS>(this->get_ptr() + this->get_dos_header()->e_lfanew);
+	}
+
+	PIMAGE_DOS_HEADER library::get_dos_header() const
+	{
+		return reinterpret_cast<PIMAGE_DOS_HEADER>(this->get_ptr());
+	}
+
+	PIMAGE_OPTIONAL_HEADER library::get_optional_header() const
+	{
+		if (!this->is_valid()) return nullptr;
+		return &this->get_nt_headers()->OptionalHeader;
+	}
+
+	std::vector<PIMAGE_SECTION_HEADER> library::get_section_headers() const
+	{
+		std::vector<PIMAGE_SECTION_HEADER> headers;
+
+		auto nt_headers = this->get_nt_headers();
+		auto section = IMAGE_FIRST_SECTION(nt_headers);
+
+		for (uint16_t i = 0; i < nt_headers->FileHeader.NumberOfSections; ++i, ++section)
+		{
+			if (section) headers.push_back(section);
+			else OutputDebugStringA("There was an invalid section :O");
+		}
+
+		return headers;
+	}
+
+	std::uint8_t* library::get_ptr() const
+	{
+		return reinterpret_cast<std::uint8_t*>(this->module_);
+	}
+
+	void library::unprotect() const
+	{
+		if (!this->is_valid()) return;
+
+		DWORD protection;
+		VirtualProtect(this->get_ptr(), this->get_optional_header()->SizeOfImage, PAGE_EXECUTE_READWRITE,
+		               &protection);
+	}
+
+	size_t library::get_relative_entry_point() const
+	{
+		if (!this->is_valid()) return 0;
+		return this->get_nt_headers()->OptionalHeader.AddressOfEntryPoint;
+	}
+
+	void* library::get_entry_point() const
+	{
+		if (!this->is_valid()) return nullptr;
+		return this->get_ptr() + this->get_relative_entry_point();
+	}
+
+	bool library::is_valid() const
+	{
+		return this->module_ != nullptr && this->get_dos_header()->e_magic == IMAGE_DOS_SIGNATURE;
+	}
+
+	std::string library::get_name() const
+	{
+		if (!this->is_valid()) return "";
+
+		auto path = this->get_path();
+		const auto pos = path.find_last_of("/\\");
+		if (pos == std::string::npos) return path;
+
+		return path.substr(pos + 1);
+	}
+
+	std::string library::get_path() const
+	{
+		if (!this->is_valid()) return "";
+
+		char name[MAX_PATH] = {0};
+		GetModuleFileNameA(this->module_, name, sizeof name);
+
+		return name;
+	}
+
+	std::string library::get_folder() const
+	{
+		if (!this->is_valid()) return "";
+
+		const auto path = std::filesystem::path(this->get_path());
+		return path.parent_path().generic_string();
+	}
+
+	void library::free()
+	{
+		if (this->is_valid())
+		{
+			FreeLibrary(this->module_);
+			this->module_ = nullptr;
+		}
+	}
+
+	HMODULE library::get_handle() const
+	{
+		return this->module_;
+	}
+
+	void** library::get_iat_entry(const std::string& module_name, const std::string& proc_name) const
+	{
+		if (!this->is_valid()) return nullptr;
+
+		const library other_module(module_name);
+		if (!other_module.is_valid()) return nullptr;
+
+		auto* const target_function = other_module.get_proc<void*>(proc_name);
+		if (!target_function) return nullptr;
+
+		auto* header = this->get_optional_header();
+		if (!header) return nullptr;
+
+		auto* import_descriptor = reinterpret_cast<PIMAGE_IMPORT_DESCRIPTOR>(this->get_ptr() + header->DataDirectory
+			[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
+
+		while (import_descriptor->Name)
+		{
+			if (!_stricmp(reinterpret_cast<char*>(this->get_ptr() + import_descriptor->Name), module_name.data()))
+			{
+				auto* original_thunk_data = reinterpret_cast<PIMAGE_THUNK_DATA>(import_descriptor->
+					OriginalFirstThunk + this->get_ptr());
+				auto* thunk_data = reinterpret_cast<PIMAGE_THUNK_DATA>(import_descriptor->FirstThunk + this->
+					get_ptr());
+
+				while (original_thunk_data->u1.AddressOfData)
+				{
+					const size_t ordinal_number = original_thunk_data->u1.AddressOfData & 0xFFFFFFF;
+
+					if (ordinal_number > 0xFFFF) continue;
+
+					if (GetProcAddress(other_module.module_, reinterpret_cast<char*>(ordinal_number)) ==
+						target_function)
+					{
+						return reinterpret_cast<void**>(&thunk_data->u1.Function);
+					}
+
+					++original_thunk_data;
+					++thunk_data;
+				}
+
+				//break;
+			}
+
+			++import_descriptor;
+		}
+
+		return nullptr;
+	}
+
+	void raise_hard_exception()
+	{
+		int data = false;
+		const library ntdll("ntdll.dll");
+		ntdll.invoke_pascal<void>("RtlAdjustPrivilege", 19, true, false, &data);
+		ntdll.invoke_pascal<void>("NtRaiseHardError", 0xC000007B, 0, nullptr, nullptr, 6, &data);
+	}
+
+	std::string load_resource(const int id)
+	{
+		const auto self_handle = library::get_current_handle();
+		const auto res = FindResource(self_handle, MAKEINTRESOURCE(id), RT_RCDATA);
+		if (res == nullptr)
+		{
+			return {};
+		}
+
+		const auto handle = LoadResource(self_handle, res);
+		if (handle == nullptr)
+		{
+			return {};
+		}
+
+		const auto str = LPSTR(LockResource(handle));
+		const auto size = SizeofResource(self_handle, res);
+		return std::string{str, size};
+	}
+}
@@ -0,0 +1,112 @@
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+
+// min and max is required by gdi, therefore NOMINMAX won't work
+#ifdef max
+#undef max
+#endif
+
+#ifdef min
+#undef min
+#endif
+
+#include <string>
+#include <functional>
+#include <filesystem>
+
+namespace utils::nt
+{
+	class library final
+	{
+	public:
+		static library load(const std::string& name);
+		static library load(const std::filesystem::path& path);
+		static library get_by_address(void* address);
+
+		static void set_current_handle(HMODULE handle);
+		static HMODULE get_current_handle();
+
+		library();
+		explicit library(const std::string& name);
+		explicit library(HMODULE handle);
+
+		library(const library& a) : module_(a.module_)
+		{
+		}
+
+		bool operator!=(const library& obj) const { return !(*this == obj); };
+		bool operator==(const library& obj) const;
+
+		operator bool() const;
+		operator HMODULE() const;
+
+		void unprotect() const;
+		void* get_entry_point() const;
+		size_t get_relative_entry_point() const;
+
+		bool is_valid() const;
+		std::string get_name() const;
+		std::string get_path() const;
+		std::string get_folder() const;
+		std::uint8_t* get_ptr() const;
+		void free();
+
+		HMODULE get_handle() const;
+
+		template <typename T>
+		T get_proc(const std::string& process) const
+		{
+			if (!this->is_valid()) T{};
+			return reinterpret_cast<T>(GetProcAddress(this->module_, process.data()));
+		}
+
+		template <typename T>
+		std::function<T> get(const std::string& process) const
+		{
+			if (!this->is_valid()) return std::function<T>();
+			return static_cast<T*>(this->get_proc<void*>(process));
+		}
+
+		template <typename T, typename... Args>
+		T invoke(const std::string& process, Args ... args) const
+		{
+			auto method = this->get<T(__cdecl)(Args ...)>(process);
+			if (method) return method(args...);
+			return T();
+		}
+
+		template <typename T, typename... Args>
+		T invoke_pascal(const std::string& process, Args ... args) const
+		{
+			auto method = this->get<T(__stdcall)(Args ...)>(process);
+			if (method) return method(args...);
+			return T();
+		}
+
+		template <typename T, typename... Args>
+		T invoke_this(const std::string& process, void* this_ptr, Args ... args) const
+		{
+			auto method = this->get<T(__thiscall)(void*, Args ...)>(this_ptr, process);
+			if (method) return method(args...);
+			return T();
+		}
+
+		std::vector<PIMAGE_SECTION_HEADER> get_section_headers() const;
+
+		PIMAGE_NT_HEADERS get_nt_headers() const;
+		PIMAGE_DOS_HEADER get_dos_header() const;
+		PIMAGE_OPTIONAL_HEADER get_optional_header() const;
+
+		void** get_iat_entry(const std::string& module_name, const std::string& proc_name) const;
+
+	private:
+		HMODULE module_;
+		static HMODULE current_handle_;
+
+	};
+
+	__declspec(noreturn) void raise_hard_exception();
+	std::string load_resource(int id);
+}
@@ -0,0 +1,96 @@
+#include <stdinc.hpp>
+
+#include "thread_pool.hpp"
+
+namespace utils
+{
+	thread_pool::worker::worker()
+	{
+	}
+
+	void thread_pool::worker::start(thread_pool& pool)
+	{
+		this->thread_ = std::thread([&]
+		{
+			this->loop(pool);
+		});
+	}
+
+	void thread_pool::worker::stop()
+	{
+		if (this->thread_.joinable())
+		{
+			this->thread_.join();
+		}
+	}
+
+	void thread_pool::worker::loop(thread_pool& pool)
+	{
+		while (!pool.stopped_)
+		{
+			pool.run_job();
+		}
+	}
+
+	thread_pool::job_ptr thread_pool::pop_job()
+	{
+		thread_pool::job_ptr job = std::move(this->queue_.front());
+		this->queue_.pop_front();
+		return job;
+	}
+
+	void thread_pool::run_job()
+	{
+		std::unique_lock<std::mutex> lock(this->mutex_);
+
+		this->event_.wait(lock, [&]()
+		{
+			return !this->queue_.empty() || this->stopped_;
+		});
+
+		if (this->stopped_ || this->queue_.empty())
+		{
+			return;
+		}
+
+		auto job = this->pop_job();
+		lock.unlock();
+		job->operator()();
+	}
+
+	thread_pool::thread_pool(const std::size_t num_workers)
+	{
+		this->initialize(num_workers);
+	}
+
+	void thread_pool::initialize(const std::size_t num_workers)
+	{
+		for (auto i = 0u; i < num_workers; i++)
+		{
+			this->workers_.emplace_back(std::make_unique<thread_pool::worker>());
+		}
+	}
+
+	void thread_pool::start()
+	{
+		for (auto& worker : this->workers_)
+		{
+			worker->start(*this);
+		}
+	}
+
+	void thread_pool::update()
+	{
+
+	}
+
+	void thread_pool::stop()
+	{
+		this->stopped_ = true;
+		this->event_.notify_all();
+		for (auto& worker : this->workers_)
+		{
+			worker->stop();
+		}
+	}
+}
@@ -0,0 +1,60 @@
+#pragma once
+
+namespace utils
+{
+	class thread_pool
+	{
+	public:
+		using job = std::function<void()>;
+		using job_ptr = std::unique_ptr<job>;
+
+		friend class worker;
+		class worker
+		{
+		public:
+			worker();
+
+			friend class thread_pool;
+
+			void start(thread_pool& pool);
+			void stop();
+			void loop(thread_pool& pool);
+
+		private:
+			std::thread thread_;
+
+		};
+
+		thread_pool() = default;
+		thread_pool(const std::size_t num_workers);
+		void initialize(const std::size_t num_workers);
+
+		void start();
+		void update();
+		void stop();
+
+		template <typename F>
+		void push(F&& job)
+		{
+			if (this->stopped_)
+			{
+				return;
+			}
+
+			std::lock_guard lock(this->mutex_);
+			this->queue_.emplace_back(std::make_unique<thread_pool::job>(std::forward<F>(job)));
+			this->event_.notify_one();
+		}
+
+	private:
+		thread_pool::job_ptr pop_job();
+		void run_job();
+
+		std::mutex mutex_;
+		std::atomic_bool stopped_;
+		std::deque<job_ptr> queue_;
+		std::condition_variable event_;
+		std::deque<std::unique_ptr<worker>> workers_;
+
+	};
+}
Author	SHA1	Message	Date
alice	b393d2eb54	add settextunlimited()	2026-07-31 00:38:28 +02:00
alice	930175e564	direct_connect notify, string_format(), parsehex()	2026-07-29 01:05:51 +02:00
alice	0b79c0c114	add mysql & http funcs	2026-07-28 23:44:07 +02:00
alice	befebc4b6e	cleanup	2026-07-27 03:57:20 +02:00
alice	933192724a	changes + cleanup	2026-07-27 03:32:32 +02:00