Fix exceptions

README.md

@@ -44,6 +44,9 @@ This plugin adds some useful functions/methods to IW5's GSC VM
   }
   ```
 # IO
+
+The basepath for all IO functions is `Plutonium/storage/iw5`
+
 * `fopen(path, mode)`: Opens a file of given name with given mode, returns a file stream.
 * `fwrite(stream, text)`: Writes a string to a stream.
 * `fread(stream)`: Reads entire file.
@@ -64,6 +67,15 @@ This plugin adds some useful functions/methods to IW5's GSC VM
       fclose(file);
   }
   ```
+ * `fileExists(path)`: Returns true if the file exists.
+ * `writeFile(path, data[, append])`: Creates a file if it doesn't exist and writes/appends text to it.
+ * `readFile(path)`: Reads a file.
+ * `fileSize(path)`: Returns file size in bytes.
+ * `createDirectory(path)`: Creates a directory.
+ * `directoryExists(path)`: Returns true if the directory exists.
+ * `directoryIsEmpty(path)`: Returns true if the directory is empty.
+ * `listFiles(path)`: Returns the list of files in the directory as an array.
+ * `copyFolder(source, target)`: Copies a folder.
 
 # JSON
 

src/component/gsc.cpp

@@ -8,11 +8,14 @@
 #include "game/scripting/execution.hpp"
 #include "game/scripting/functions.hpp"
 #include "game/scripting/array.hpp"
+#include "game/scripting/function.hpp"
 
 #include "gsc.hpp"
 
 namespace gsc
 {
+	std::unordered_map<const char*, const char*> replaced_functions;
+
 	function_args::function_args(std::vector<scripting::script_value> values)
 		: values_(values)
 	{
@@ -119,7 +122,7 @@ namespace gsc
 					return_value(result);
 				}
 			}
-			catch (std::exception e)
+			catch (const std::exception& e)
 			{
 				printf("************** Script execution error **************\n");
 				printf("Error executing function %s\n", function_name(id).data());
@@ -145,7 +148,7 @@ namespace gsc
 					return_value(result);
 				}
 			}
-			catch (std::exception e)
+			catch (const std::exception& e)
 			{
 				printf("************** Script execution error **************\n");
 				printf("Error executing method %s\n", method_name(id).data());
@@ -199,13 +202,13 @@ namespace gsc
 			}
 		}
 
-		unsigned int replaced_pos = 0;
+		const char* replaced_pos = 0;
 
-		void get_replaced_pos(unsigned int pos)
+		void get_replaced_pos(const char* pos)
 		{
-			if (scripting::replaced_functions.find(pos) != scripting::replaced_functions.end())
+			if (replaced_functions.find(pos) != replaced_functions.end())
 			{
-				replaced_pos = scripting::replaced_functions[pos];
+				replaced_pos = replaced_functions[pos];
 			}
 		}
 
@@ -283,28 +286,23 @@ namespace gsc
 	public:
 		void post_unpack() override
 		{
-			function::add("executecommand", [](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("replacefunc", [](function_args args) -> scripting::script_value
+			function::add("replacefunc", [](const function_args& args) -> scripting::script_value
 			{
-				const auto what = args[0].get_raw();
+				const auto what = args[0].as<scripting::function>();
-				const auto with = args[1].get_raw();
+				const auto with = args[1].as<scripting::function>();
 
-				if (what.type != game::SCRIPT_FUNCTION || with.type != game::SCRIPT_FUNCTION)
+				replaced_functions[what.get_pos()] = with.get_pos();
-				{
-					throw std::runtime_error("Invalid type");
-				}
-
-				scripting::replaced_functions[what.u.uintValue] = with.u.uintValue;
 
 				return {};
 			});
 
-			function::add("addcommand", [](function_args args) -> scripting::script_value
+			function::add("addcommand", [](const function_args& args) -> scripting::script_value
 			{
 				const auto name = args[0].as<std::string>();
 				const auto function = args[1].get_raw();
@@ -329,7 +327,7 @@ namespace gsc
 				return {};
 			});
 
-			function::add("say", [](function_args args) -> scripting::script_value
+			function::add("say", [](const function_args& args) -> scripting::script_value
 			{
 				const auto message = args[0].as<std::string>();
 				game::SV_GameSendServerCommand(-1, 0, utils::string::va("%c \"%s\"", 84, message.data()));
@@ -337,11 +335,11 @@ namespace gsc
 				return {};
 			});
 
-			method::add("tell", [](game::scr_entref_t ent, function_args args) -> scripting::script_value
+			method::add("tell", [](const game::scr_entref_t ent, const function_args& args) -> scripting::script_value
 			{
 				if (ent.classnum != 0)
 				{
-					throw std::runtime_error("Invalid type");
+					throw std::runtime_error("Invalid entity");
 				}
 
 				const auto client = ent.entnum;

src/component/gsc.hpp

@@ -2,6 +2,8 @@
 
 namespace gsc
 {
+	extern std::unordered_map<const char*, const char*> replaced_functions;
+
 	class function_args
 	{
 	public:
@@ -22,8 +24,8 @@ namespace gsc
 	using builtin_function = void(*)();
 	using builtin_method = void(*)(game::scr_entref_t);
 
-	using script_function = std::function<scripting::script_value(function_args)>;
+	using script_function = std::function<scripting::script_value(const function_args&)>;
-	using script_method = std::function<scripting::script_value(game::scr_entref_t, function_args)>;
+	using script_method = std::function<scripting::script_value(const game::scr_entref_t, const function_args&)>;
 
 	namespace function
 	{

src/component/io.cpp

@@ -9,6 +9,7 @@
 #include "game/scripting/array.hpp"
 
 #include "gsc.hpp"
+#include "json.hpp"
 
 namespace io
 {
@@ -20,13 +21,27 @@ namespace io
 			const auto path = game::Dvar_FindVar("fs_basegame")->current.string;
 			std::filesystem::current_path(path);
 
-			gsc::function::add("fremove", [](gsc::function_args args)
+			gsc::function::add("jsonprint", [](const gsc::function_args& args) -> scripting::script_value
+			{
+				std::string buffer;
+
+				for (const auto arg : args.get_raw())
+				{
+					buffer.append(json::gsc_to_string(arg));
+					buffer.append("\t");
+				}
+
+				printf("%s\n", buffer.data());
+				return {};
+			});
+
+			gsc::function::add("fremove", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<const char*>();
 				return std::remove(path);
 			});
 
-			gsc::function::add("fopen", [](gsc::function_args args)
+			gsc::function::add("fopen", [](const gsc::function_args& args)
 			{
 				const auto* path = args[0].as<const char*>();
 				const auto* mode = args[1].as<const char*>();
@@ -41,13 +56,13 @@ namespace io
 				return handle;
 			});
 
-			gsc::function::add("fclose", [](gsc::function_args args)
+			gsc::function::add("fclose", [](const gsc::function_args& args)
 			{
 				const auto handle = args[0].as_ptr<FILE>();
 				return fclose(handle);
 			});
 
-			gsc::function::add("fwrite", [](gsc::function_args args)
+			gsc::function::add("fwrite", [](const gsc::function_args& args)
 			{
 				const auto handle = args[0].as_ptr<FILE>();
 				const auto text = args[1].as<const char*>();
@@ -55,7 +70,7 @@ namespace io
 				return fprintf(handle, text);
 			});
 
-			gsc::function::add("fread", [](gsc::function_args args)
+			gsc::function::add("fread", [](const gsc::function_args& args)
 			{
 				const auto handle = args[0].as_ptr<FILE>();
 
@@ -74,13 +89,13 @@ namespace io
 				return result;
 			});
 
-			gsc::function::add("fileexists", [](gsc::function_args args)
+			gsc::function::add("fileexists", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::file_exists(path);
 			});
 
-			gsc::function::add("writefile", [](gsc::function_args args)
+			gsc::function::add("writefile", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				const auto data = args[1].as<std::string>();
@@ -94,37 +109,37 @@ namespace io
 				return utils::io::write_file(path, data, append);
 			});
 
-			gsc::function::add("readfile", [](gsc::function_args args)
+			gsc::function::add("readfile", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::read_file(path);
 			});
 
-			gsc::function::add("filesize", [](gsc::function_args args)
+			gsc::function::add("filesize", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::file_size(path);
 			});
 
-			gsc::function::add("createdirectory", [](gsc::function_args args)
+			gsc::function::add("createdirectory", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::create_directory(path);
 			});
 
-			gsc::function::add("directoryexists", [](gsc::function_args args)
+			gsc::function::add("directoryexists", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::directory_exists(path);
 			});
 
-			gsc::function::add("directoryisempty", [](gsc::function_args args)
+			gsc::function::add("directoryisempty", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				return utils::io::directory_is_empty(path);
 			});
 
-			gsc::function::add("listfiles", [](gsc::function_args args)
+			gsc::function::add("listfiles", [](const gsc::function_args& args)
 			{
 				const auto path = args[0].as<std::string>();
 				const auto files = utils::io::list_files(path);
@@ -138,7 +153,7 @@ namespace io
 				return array.get_raw();
 			});
 
-			gsc::function::add("copyfolder", [](gsc::function_args args)
+			gsc::function::add("copyfolder", [](const gsc::function_args& args)
 			{
 				const auto source = args[0].as<std::string>();
 				const auto target = args[1].as<std::string>();

src/component/json.cpp

@@ -9,6 +9,7 @@
 #include "game/scripting/array.hpp"
 
 #include "gsc.hpp"
+#include "json.hpp"
 
 #include <json.hpp>
 
@@ -136,18 +137,23 @@ namespace json
 		}
 	}
 
+	std::string gsc_to_string(const scripting::script_value& value)
+	{
+		return gsc_to_json(value).dump();
+	}
+
 	class component final : public component_interface
 	{
 	public:
 		void post_unpack() override
 		{
-			gsc::function::add("array", [](gsc::function_args args)
+			gsc::function::add("array", [](const gsc::function_args& args)
 			{
 				scripting::array array(args.get_raw());
 				return array.get_raw();
 			});
 
-			gsc::function::add("map", [](gsc::function_args args)
+			gsc::function::add("map", [](const gsc::function_args& args)
 			{
 				scripting::array array;
 
@@ -165,7 +171,7 @@ namespace json
 				return array.get_raw();
 			});
 
-			gsc::function::add("jsonparse", [](gsc::function_args args)
+			gsc::function::add("jsonparse", [](const gsc::function_args& args)
 			{
 				const auto json = args[0].as<std::string>();
 				const auto obj = nlohmann::json::parse(json);
@@ -173,7 +179,7 @@ namespace json
 				return json_to_gsc(obj);
 			});
 
-			gsc::function::add("jsonserialize", [](gsc::function_args args)
+			gsc::function::add("jsonserialize", [](const gsc::function_args& args)
 			{
 				const auto value = args[0];
 				auto indent = -1;

src/component/json.hpp

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

src/component/scheduler.hpp

@@ -5,6 +5,4 @@ namespace scheduler
 	void schedule(const std::function<bool()>& callback, std::chrono::milliseconds delay = 0ms);
 	void loop(const std::function<void()>& callback, std::chrono::milliseconds delay = 0ms);
 	void once(const std::function<void()>& callback, std::chrono::milliseconds delay = 0ms);
-
-	void init();
 }

src/component/scripting.cpp

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

src/component/scripting.hpp

@@ -2,8 +2,6 @@
 
 namespace scripting
 {
-	extern std::unordered_map<unsigned, unsigned> replaced_functions;
-
 	extern std::unordered_map<int, std::unordered_map<std::string, int>> fields_table;
-	extern std::unordered_map<std::string, std::unordered_map<std::string, char*>> script_function_table;
+	extern std::unordered_map<std::string, std::unordered_map<std::string, const char*>> script_function_table;
 }

src/component/userinfo.cpp

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

src/component/userinfo.hpp

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

src/game/scripting/array.cpp

@@ -110,14 +110,41 @@ namespace scripting
 		return result;
 	}
 
-	int array::size() const
+	unsigned int array::size() const
 	{
 		return game::Scr_GetSelf(this->id_);
 	}
 
-	void array::push(script_value value) const
+	unsigned int array::push(script_value value) const
 	{
 		this->set(this->size(), value);
+		return this->size();
+	}
+
+	void array::erase(const unsigned int index) const
+	{
+		const auto variable_id = game::FindVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
+		if (variable_id)
+		{
+			game::RemoveVariableValue(this->id_, variable_id);
+		}
+	}
+
+	void array::erase(const std::string& key) const
+	{
+		const auto string_value = game::SL_GetString(key.data(), 0);
+		const auto variable_id = game::FindVariable(this->id_, string_value);
+		if (variable_id)
+		{
+			game::RemoveVariableValue(this->id_, variable_id);
+		}
+	}
+
+	script_value array::pop() const
+	{
+		const auto value = this->get(this->size() - 1);
+		this->erase(this->size() - 1);
+		return value;
 	}
 
 	script_value array::get(const std::string& key) const
@@ -155,35 +182,6 @@ namespace scripting
 		return variable;
 	}
 
-	unsigned int array::get_entity_id() const
-	{
-		return this->id_;
-	}
-
-	unsigned int array::get_value_id(const std::string& key) const
-	{
-		const auto string_value = game::SL_GetString(key.data(), 0);
-		const auto variable_id = game::GetVariable(this->id_, string_value);
-
-		if (!variable_id)
-		{
-			return game::GetNewVariable(this->id_, string_value);
-		}
-
-		return variable_id;
-	}
-
-	unsigned int array::get_value_id(const unsigned int index) const
-	{
-		const auto variable_id = game::GetVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
-		if (!variable_id)
-		{
-			return game::GetNewArrayVariable(this->id_, index);
-		}
-
-		return variable_id;
-	}
-
 	void array::set(const std::string& key, const script_value& _value) const
 	{
 		const auto value = _value.get_raw();
@@ -224,6 +222,35 @@ namespace scripting
 		variable->u.u = value.u;
 	}
 
+	unsigned int array::get_entity_id() const
+	{
+		return this->id_;
+	}
+
+	unsigned int array::get_value_id(const std::string& key) const
+	{
+		const auto string_value = game::SL_GetString(key.data(), 0);
+		const auto variable_id = game::FindVariable(this->id_, string_value);
+
+		if (!variable_id)
+		{
+			return game::GetNewVariable(this->id_, string_value);
+		}
+
+		return variable_id;
+	}
+
+	unsigned int array::get_value_id(const unsigned int index) const
+	{
+		const auto variable_id = game::FindVariable(this->id_, (index - 0x800000) & 0xFFFFFF);
+		if (!variable_id)
+		{
+			return game::GetNewArrayVariable(this->id_, index);
+		}
+
+		return variable_id;
+	}
+
 	entity array::get_raw() const
 	{
 		return entity(this->id_);

src/game/scripting/array.hpp

@@ -30,21 +30,24 @@ namespace scripting
 		array(std::unordered_map<std::string, script_value>);
 
 		std::vector<array_key> get_keys() const;
+		unsigned int size() const;
 
-		int size() const;
+		unsigned int push(script_value) const;
-		void push(script_value) const;
+		void erase(const unsigned int index) const;
+		void erase(const std::string& key) const;
+		script_value pop() const;
 
 		script_value get(const std::string&) const;
 		script_value get(const unsigned int) const;
 
+		void set(const std::string&, const script_value&) const;
+		void set(const unsigned int, const script_value&) const;
+
 		unsigned int get_entity_id() const;
 
 		unsigned int get_value_id(const std::string&) const;
 		unsigned int get_value_id(const unsigned int) const;
 
-		void set(const std::string&, const script_value&) const;
-		void set(const unsigned int, const script_value&) const;
-
 		entity get_raw() const;
 
 		array_value array::operator[](const int index) const

src/game/scripting/execution.cpp

@@ -155,8 +155,7 @@ namespace scripting
 		return get_return_value();
 	}
 
-	script_value call_script_function(const entity& entity, const std::string& filename,
+	const char* get_function_pos(const std::string& filename, const std::string& function)
-		const std::string& function, const std::vector<script_value>& arguments)
 	{
 		if (scripting::script_function_table.find(filename) == scripting::script_function_table.end())
 		{
@@ -164,14 +163,18 @@ namespace scripting
 		};
 
 		const auto functions = scripting::script_function_table[filename];
-
 		if (functions.find(function) == functions.end())
 		{
 			throw std::runtime_error("Function '" + function + "' in file '" + filename + "' not found");
 		}
 
-		const auto pos = functions.at(function);
+		return functions.at(function);
+	}
 
+	script_value call_script_function(const entity& entity, const std::string& filename,
+		const std::string& function, const std::vector<script_value>& arguments)
+	{
+		const auto pos = get_function_pos(filename, function);
 		return exec_ent_thread(entity, pos, arguments);
 	}
 

src/game/scripting/function.cpp

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

src/game/scripting/function.hpp

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

src/game/scripting/functions.cpp

@@ -71,6 +71,19 @@ namespace scripting
 		}
 	}
 
+	std::string find_token(unsigned int id)
+	{
+		for (const auto& token : token_map)
+		{
+			if (token.second == id)
+			{
+				return token.first;
+			}
+		}
+
+		return {};
+	}
+
 	int find_token_id(const std::string& name)
 	{
 		const auto result = token_map.find(name);

src/game/scripting/functions.hpp

@@ -12,4 +12,5 @@ namespace scripting
 
 	script_function find_function(const std::string& name, const bool prefer_global);
 	int find_token_id(const std::string& name);
+	std::string find_token(unsigned int id);
 }

src/game/scripting/script_value.cpp

@@ -2,6 +2,7 @@
 #include "script_value.hpp"
 #include "entity.hpp"
 #include "array.hpp"
+#include "function.hpp"
 
 namespace scripting
 {
@@ -261,11 +262,17 @@ namespace scripting
 	 **************************************************************/
 
 	template <>
-	bool script_value::is<std::function<void()>>() const
+	bool script_value::is<function>() const
 	{
 		return this->get_raw().type == game::SCRIPT_FUNCTION;
 	}
 
+	template <>
+	function script_value::get() const
+	{
+		return function(this->get_raw().u.codePosValue);
+	}
+
 	/***************************************************************
 	 * Vector
 	 **************************************************************/

src/game/symbols.hpp

@@ -16,6 +16,7 @@ namespace game
 
 	WEAK symbol<void(unsigned int weapon, bool isAlternate, char* output, unsigned int maxStringLen)> BG_GetWeaponNameComplete{0x42F760};
 
+	WEAK symbol<void(int client)> ClientUserinfoChanged{0x4FADB0};
 	WEAK symbol<const char*(int index)> ConcatArgs{0x502150};
 	WEAK symbol<void(int localClientNum, const char* text)> Cbuf_AddText{0x545680};
 	WEAK symbol<void(const char* cmdName, void(), cmd_function_t* allocedCmd)> Cmd_AddCommandInternal{0x545DF0};
@@ -33,6 +34,7 @@ namespace game
 	WEAK symbol<unsigned int(unsigned int parentId, unsigned int name)> GetNewVariable{0x566390};
 	WEAK symbol<unsigned int(unsigned int parentId, unsigned int unsignedValue)> GetNewArrayVariable{0x5668C0};
 	WEAK symbol<void(unsigned int parentId, unsigned int id, VariableValue* value)> SetNewVariableValue{0x5658D0};
+	WEAK symbol<void(unsigned int parentId, unsigned int index)> RemoveVariableValue{0x566500};
 
 	WEAK symbol<const float* (const float* v)> Scr_AllocVector{0x565680};
 	WEAK symbol<void()> Scr_ClearOutParams{0x569010};