Update functions.cpp

src/component/gsc.cpp

@@ -21,13 +21,13 @@ namespace gsc
 	{
 		std::string method_name(unsigned int id)
 		{
-			const auto map = *game::plutonium::method_map_rev;
+			const auto& map = *game::plutonium::method_map_rev;
 
 			for (const auto& function : map)
 			{
 				if (function.second == id)
 				{
-					return function.first;
+					return function.first.data();
 				}
 			}
 
@@ -36,13 +36,13 @@ namespace gsc
 
 		std::string function_name(unsigned int id)
 		{
-			const auto map = *game::plutonium::function_map_rev;
+			const auto& map = *game::plutonium::function_map_rev;
 
 			for (const auto& function : map)
 			{
 				if (function.second == id)
 				{
-					return function.first;
+					return function.first.data();
 				}
 			}
 
@@ -192,7 +192,7 @@ namespace gsc
 				return scr_get_object_field_hook.invoke<void>(classnum, entnum, offset);
 			}
 
-			const auto field = custom_fields[classnum][offset];
+			const auto& field = custom_fields[classnum][offset];
 
 			try
 			{
@@ -217,7 +217,7 @@ namespace gsc
 			}
 
 			const auto args = get_arguments();
-			const auto field = custom_fields[classnum][offset];
+			const auto& field = custom_fields[classnum][offset];
 
 			try
 			{
@@ -251,7 +251,8 @@ namespace gsc
 			const auto index = function_map_start++;
 
 			functions[index] = func;
-			(*game::plutonium::function_map_rev)[name] = index;
+			const auto name_view = utils::memory::get_allocator()->duplicate_string(name);
+			(*game::plutonium::function_map_rev)[name_view] = index;
 		}
 	}
 
@@ -262,7 +263,8 @@ namespace gsc
 			const auto index = method_map_start++;
 
 			methods[index] = func;
-			(*game::plutonium::method_map_rev)[name] = index;
+			const auto name_view = utils::memory::get_allocator()->duplicate_string(name);
+			(*game::plutonium::method_map_rev)[name_view] = index;
 		}
 	}
 
@@ -272,11 +274,20 @@ namespace gsc
 			const std::function<scripting::script_value(unsigned int entnum)>& getter,
 			const std::function<void(unsigned int entnum, const scripting::script_value&)>& setter)
 		{
-			const auto token_id = token_map_start++;
-			const auto offset = field_offset_start++;
+			uint16_t token_id{};
+			auto& token_map = *game::plutonium::token_map_rev;
+			if (token_map.find(name) != token_map.end())
+			{
+				token_id = token_map.at(name);
+			}
+			else
+			{
+				token_id = token_map_start++;
+				token_map.insert(std::make_pair(name, token_id));
+			}
 
+			const auto offset = field_offset_start++;
 			custom_fields[classnum][offset] = {name, getter, setter};
-			(*game::plutonium::token_map_rev)[name] = token_id;
 
 			post_load_callbacks.push_back([classnum, name, token_id, offset]()
 			{
@@ -320,7 +331,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, "flags",
+			field::add(classid::entity, "entityflags",
 				[](unsigned int entnum) -> scripting::script_value
 				{
 					const auto entity = &game::g_entities[entnum];
@@ -469,8 +480,12 @@ namespace gsc
 				return {(game::g_entities[client].client->flags & 4) != 0};
 			});
 
-			utils::hook::jump(0x56C8EB, call_builtin_stub);
-			utils::hook::jump(0x56CBDC, call_builtin_method_stub);
+			// let other plugins read the pointers
+			post_load_callbacks.push_back([]()
+			{
+				utils::hook::jump(0x56C8EB, call_builtin_stub);
+				utils::hook::jump(0x56CBDC, call_builtin_method_stub);
+			});
 		}
 	};
 }

src/component/scripting.cpp

@@ -95,7 +95,7 @@ namespace scripting
 			const auto file_id = atoi(filename);
 			if (file_id)
 			{
-				current_file = scripting::file_list[file_id];
+				current_file = scripting::find_file(file_id);
 			}
 
 			process_script_hook.invoke<void>(filename);

src/component/signatures.cpp

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

src/component/signatures.hpp

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

src/component/string.cpp

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

src/dllmain.cpp

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

src/game/game.hpp

@@ -16,6 +16,11 @@ namespace game
 			return dedi_;
 		}
 
+		void set(const size_t dedi)
+		{
+			this->dedi_ = reinterpret_cast<T*>(dedi);
+		}
+
 		operator T* () const
 		{
 			return this->get();

src/game/scripting/array.cpp

@@ -263,11 +263,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 string_value = game::SL_GetString(key.data(), 0);
+		const auto value = value_.get_raw();
 		const auto variable_id = this->get_value_id(key);
 
 		if (!variable_id)
@@ -284,9 +282,9 @@ namespace scripting
 		variable->u.u = value.u;
 	}
 
-	void array::set(const unsigned int index, const script_value& _value) const
+	void array::set(const unsigned int index, const script_value& value_) const
 	{
-		const auto value = _value.get_raw();
+		const auto value = value_.get_raw();
 		const auto variable_id = this->get_value_id(index);
 
 		if (!variable_id)

src/game/scripting/functions.cpp

@@ -7,27 +7,27 @@ namespace scripting
 {
 	namespace
 	{
-		std::unordered_map<std::string, unsigned> lowercase_map(
-			const std::unordered_map<std::string, unsigned>& old_map)
+		std::unordered_map<std::string, uint16_t> lowercase_map(
+			const std::unordered_map<std::string_view, uint16_t>& old_map)
 		{
-			std::unordered_map<std::string, unsigned> new_map{};
+			std::unordered_map<std::string, uint16_t> new_map{};
 			for (auto& entry : old_map)
 			{
-				new_map[utils::string::to_lower(entry.first)] = entry.second;
+				new_map[utils::string::to_lower(entry.first.data())] = entry.second;
 			}
 
 			return new_map;
 		}
 
-		const std::unordered_map<std::string, unsigned>& get_methods()
+		const std::unordered_map<std::string, uint16_t>& get_methods()
 		{
-			static auto methods = lowercase_map(method_map);
+			static auto methods = lowercase_map(*game::plutonium::method_map_rev);
 			return methods;
 		}
 
-		const std::unordered_map<std::string, unsigned>& get_functions()
+		const std::unordered_map<std::string, uint16_t>& get_functions()
 		{
-			static auto function = lowercase_map(function_map);
+			static auto function = lowercase_map(*game::plutonium::function_map_rev);
 			return function;
 		}
 
@@ -73,6 +73,7 @@ namespace scripting
 
 	std::string find_token(unsigned int id)
 	{
+		const auto& token_map = *game::plutonium::token_map_rev;
 		for (const auto& token : token_map)
 		{
 			if (token.second == id)
@@ -84,8 +85,14 @@ namespace scripting
 		return {};
 	}
 
+	std::string find_file(unsigned int id)
+	{
+		return find_token(id);
+	}
+
 	int find_token_id(const std::string& name)
 	{
+		const auto& token_map = *game::plutonium::token_map_rev;
 		const auto result = token_map.find(name);
 
 		if (result != token_map.end())

src/game/scripting/functions.hpp

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

src/game/symbols.hpp

@@ -86,11 +86,11 @@ namespace game
 
 	namespace plutonium
 	{
-		WEAK symbol<std::unordered_map<std::string, std::uint16_t>> function_map_rev{0x20802D34};
-		WEAK symbol<std::unordered_map<std::string, std::uint16_t>> method_map_rev{0x20802D54};
-		WEAK symbol<std::unordered_map<std::string, std::uint16_t>> token_map_rev{0x20802D94};
-		WEAK symbol<int(const char* fmt, ...)> printf{0x209F30F0};
-		WEAK symbol<void*> function_table{0x20762008};
-		WEAK symbol<void*> method_table{0x207627D8};
+		WEAK symbol<std::unordered_map<std::string_view, std::uint16_t>> function_map_rev{0};
+		WEAK symbol<std::unordered_map<std::string_view, std::uint16_t>> method_map_rev{0};
+		WEAK symbol<std::unordered_map<std::string, std::uint16_t>> token_map_rev{0};
+		WEAK symbol<int(const char* fmt, ...)> printf{0};
+		WEAK symbol<void*> function_table{0};
+		WEAK symbol<void*> method_table{0};
 	}
-}
+}

src/stdinc.hpp

@@ -28,6 +28,7 @@
 #include <map>
 #include <csetjmp>
 #include <atlcomcli.h>
+#include <Psapi.h>
 
 #pragma comment(lib, "urlmon.lib")
 

src/utils/hook.cpp

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

src/utils/hook.hpp

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

src/utils/io.cpp

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

src/utils/io.hpp

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