From cd6670d75aefa1d3d124c64c7494f1a03c819aae Mon Sep 17 00:00:00 2001 From: Federico Cecchetto Date: Fri, 23 Apr 2021 03:46:11 +0200 Subject: [PATCH] Scripting progress + some commands --- .gitmodules | 9 + deps/GSL | 1 + deps/lua | 1 + deps/premake/gsl.lua | 19 + deps/premake/l_u_a.lua | 37 + deps/premake/sol2.lua | 20 + deps/sol2 | 1 + src/component/command.cpp | 41 + src/component/scheduler.cpp | 5 +- src/component/scripting.cpp | 94 ++ src/component/scripting.hpp | 8 + src/dllmain.cpp | 1 + src/game/scripting/entity.cpp | 120 ++ src/game/scripting/entity.hpp | 50 + src/game/scripting/event.hpp | 13 + src/game/scripting/execution.cpp | 196 ++++ src/game/scripting/execution.hpp | 31 + src/game/scripting/function_tables.cpp | 1109 +++++++++++++++++++ src/game/scripting/functions.cpp | 81 ++ src/game/scripting/functions.hpp | 12 + src/game/scripting/lua/context.cpp | 240 ++++ src/game/scripting/lua/context.hpp | 39 + src/game/scripting/lua/engine.cpp | 67 ++ src/game/scripting/lua/engine.hpp | 11 + src/game/scripting/lua/error.cpp | 37 + src/game/scripting/lua/error.hpp | 8 + src/game/scripting/lua/event_handler.cpp | 119 ++ src/game/scripting/lua/event_handler.hpp | 54 + src/game/scripting/lua/scheduler.cpp | 122 ++ src/game/scripting/lua/scheduler.hpp | 50 + src/game/scripting/lua/value_conversion.cpp | 192 ++++ src/game/scripting/lua/value_conversion.hpp | 9 + src/game/scripting/safe_execution.cpp | 72 ++ src/game/scripting/safe_execution.hpp | 10 + src/game/scripting/script_value.cpp | 252 +++++ src/game/scripting/script_value.hpp | 52 + src/game/scripting/stack_isolation.cpp | 27 + src/game/scripting/stack_isolation.hpp | 25 + src/game/scripting/variable_value.cpp | 68 ++ src/game/scripting/variable_value.hpp | 27 + src/game/scripting/vector.cpp | 85 ++ src/game/scripting/vector.hpp | 31 + src/game/structs.hpp | 103 +- src/game/symbols.hpp | 28 +- src/stdinc.hpp | 6 + src/utils/io.cpp | 115 ++ src/utils/io.hpp | 19 + src/utils/string.cpp | 17 + src/utils/string.hpp | 2 + 49 files changed, 3728 insertions(+), 8 deletions(-) create mode 160000 deps/GSL create mode 160000 deps/lua create mode 100644 deps/premake/gsl.lua create mode 100644 deps/premake/l_u_a.lua create mode 100644 deps/premake/sol2.lua create mode 160000 deps/sol2 create mode 100644 src/component/scripting.cpp create mode 100644 src/component/scripting.hpp create mode 100644 src/game/scripting/entity.cpp create mode 100644 src/game/scripting/entity.hpp create mode 100644 src/game/scripting/event.hpp create mode 100644 src/game/scripting/execution.cpp create mode 100644 src/game/scripting/execution.hpp create mode 100644 src/game/scripting/function_tables.cpp create mode 100644 src/game/scripting/functions.cpp create mode 100644 src/game/scripting/functions.hpp create mode 100644 src/game/scripting/lua/context.cpp create mode 100644 src/game/scripting/lua/context.hpp create mode 100644 src/game/scripting/lua/engine.cpp create mode 100644 src/game/scripting/lua/engine.hpp create mode 100644 src/game/scripting/lua/error.cpp create mode 100644 src/game/scripting/lua/error.hpp create mode 100644 src/game/scripting/lua/event_handler.cpp create mode 100644 src/game/scripting/lua/event_handler.hpp create mode 100644 src/game/scripting/lua/scheduler.cpp create mode 100644 src/game/scripting/lua/scheduler.hpp create mode 100644 src/game/scripting/lua/value_conversion.cpp create mode 100644 src/game/scripting/lua/value_conversion.hpp create mode 100644 src/game/scripting/safe_execution.cpp create mode 100644 src/game/scripting/safe_execution.hpp create mode 100644 src/game/scripting/script_value.cpp create mode 100644 src/game/scripting/script_value.hpp create mode 100644 src/game/scripting/stack_isolation.cpp create mode 100644 src/game/scripting/stack_isolation.hpp create mode 100644 src/game/scripting/variable_value.cpp create mode 100644 src/game/scripting/variable_value.hpp create mode 100644 src/game/scripting/vector.cpp create mode 100644 src/game/scripting/vector.hpp create mode 100644 src/utils/io.cpp create mode 100644 src/utils/io.hpp diff --git a/.gitmodules b/.gitmodules index 4c70f39e..a3ad53c3 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,12 @@ [submodule "deps/minhook"] path = deps/minhook url = https://github.com/TsudaKageyu/minhook.git +[submodule "deps/lua"] + path = deps/lua + url = https://github.com/lua/lua.git +[submodule "deps/sol2"] + path = deps/sol2 + url = https://github.com/ThePhD/sol2.git +[submodule "deps/GSL"] + path = deps/GSL + url = https://github.com/Microsoft/GSL.git diff --git a/deps/GSL b/deps/GSL new file mode 160000 index 00000000..ef0ffefe --- /dev/null +++ b/deps/GSL @@ -0,0 +1 @@ +Subproject commit ef0ffefe525a6219ff245d19a832ce06f3fd3504 diff --git a/deps/lua b/deps/lua new file mode 160000 index 00000000..68129718 --- /dev/null +++ b/deps/lua @@ -0,0 +1 @@ +Subproject commit 681297187ec45268e872b26753c441586c12bdd8 diff --git a/deps/premake/gsl.lua b/deps/premake/gsl.lua new file mode 100644 index 00000000..7a2daf64 --- /dev/null +++ b/deps/premake/gsl.lua @@ -0,0 +1,19 @@ +gsl = { + source = path.join(dependencies.basePath, "GSL"), +} + +function gsl.import() + gsl.includes() +end + +function gsl.includes() + includedirs { + path.join(gsl.source, "include") + } +end + +function gsl.project() + +end + +table.insert(dependencies, gsl) diff --git a/deps/premake/l_u_a.lua b/deps/premake/l_u_a.lua new file mode 100644 index 00000000..618f10c9 --- /dev/null +++ b/deps/premake/l_u_a.lua @@ -0,0 +1,37 @@ +-- Scripts or variables named lua fuck with premake ._. +l_u_a = { + source = path.join(dependencies.basePath, "lua"), +} + +function l_u_a.import() + links { "lua" } + l_u_a.includes() +end + +function l_u_a.includes() + includedirs { + l_u_a.source + } + +end + +function l_u_a.project() + project "lua" + language "C" + + l_u_a.includes() + + files { + path.join(l_u_a.source, "*.h"), + path.join(l_u_a.source, "*.c"), + } + + removefiles { + path.join(l_u_a.source, "onelua.c"), + } + + warnings "Off" + kind "StaticLib" +end + +table.insert(dependencies, l_u_a) diff --git a/deps/premake/sol2.lua b/deps/premake/sol2.lua new file mode 100644 index 00000000..253a25ee --- /dev/null +++ b/deps/premake/sol2.lua @@ -0,0 +1,20 @@ +sol2 = { + source = path.join(dependencies.basePath, "sol2"), +} + +function sol2.import() + sol2.includes() + l_u_a.import() +end + +function sol2.includes() + includedirs { + path.join(sol2.source, "include") + } +end + +function sol2.project() + +end + +table.insert(dependencies, sol2) diff --git a/deps/sol2 b/deps/sol2 new file mode 160000 index 00000000..f56b3c69 --- /dev/null +++ b/deps/sol2 @@ -0,0 +1 @@ +Subproject commit f56b3c698c2116f41aad3bf731ba8400e68c498b diff --git a/src/component/command.cpp b/src/component/command.cpp index 443c68f1..c7d78279 100644 --- a/src/component/command.cpp +++ b/src/component/command.cpp @@ -11,6 +11,8 @@ namespace command { namespace { + utils::hook::detour dvar_command_hook; + std::unordered_map> handlers; void main_handler() @@ -32,6 +34,43 @@ namespace command cb(header); }), &callback, includeOverride); } + + game::dvar_t* dvar_command_stub() + { + const params args; + + if (args.size() <= 0) + { + return 0; + } + + const auto dvar = game::Dvar_FindVar(args[0]); + + if (dvar) + { + if (args.size() == 1) + { + const auto current = game::Dvar_ValueToString(dvar, nullptr, &dvar->current); + const auto reset = game::Dvar_ValueToString(dvar, nullptr, &dvar->reset); + + game_console::print(game_console::con_type_info, "\"%s\" is: \"%s\" default: \"%s\" hash: %i", + args[0], current, reset, dvar->name); + + game_console::print(game_console::con_type_info, " %s\n", + dvars::dvar_get_domain(dvar->type, dvar->domain).data()); + } + else + { + char command[0x1000] = { 0 }; + game::Dvar_GetCombinedString(command, 1); + game::Dvar_SetCommand(dvar->name, "", command); + } + + return dvar; + } + + return 0; + } } params::params() @@ -105,6 +144,8 @@ namespace command void init() { + utils::hook::jump(game::base_address + 0x5A74F0, dvar_command_stub, true); + add("listassetpool", [](const params& params) { if (params.size() < 2) diff --git a/src/component/scheduler.cpp b/src/component/scheduler.cpp index 41c0828f..151bccc8 100644 --- a/src/component/scheduler.cpp +++ b/src/component/scheduler.cpp @@ -81,6 +81,7 @@ namespace scheduler std::thread thread; task_pipeline pipelines[pipeline::count]; utils::hook::detour r_end_frame_hook; + utils::hook::detour g_run_frame_hook; void execute(const pipeline type) { @@ -96,7 +97,7 @@ namespace scheduler void server_frame_stub() { - //game::G_Glass_Update(); + g_run_frame_hook.invoke(); execute(pipeline::server); } } @@ -146,6 +147,6 @@ namespace scheduler }); r_end_frame_hook.create(game::base_address + 0x76D7B0, scheduler::r_end_frame_stub); - //utils::hook::call(0x1402F8879, scheduler::server_frame_stub); + g_run_frame_hook.create(game::base_address + 0x4CB030, scheduler::server_frame_stub); } } diff --git a/src/component/scripting.cpp b/src/component/scripting.cpp new file mode 100644 index 00000000..0ecd0d63 --- /dev/null +++ b/src/component/scripting.cpp @@ -0,0 +1,94 @@ +#include + +#include "game/game.hpp" +#include + +#include "game/scripting/event.hpp" +#include "game/scripting/execution.hpp" +#include "game/scripting/lua/engine.hpp" + +#include "scheduler.hpp" + +namespace scripting +{ + std::unordered_map> fields_table; + + namespace + { + utils::hook::detour vm_notify_hook; + + utils::hook::detour scr_load_level_hook; + utils::hook::detour g_shutdown_game_hook; + + utils::hook::detour scr_add_class_field_hook; + + std::string last_event; + + void vm_notify_stub(const unsigned int notify_list_owner_id, const game::scr_string_t string_value, + game::VariableValue* top) + { + const auto* string = game::SL_ConvertToString(string_value); + if (string) + { + event e; + e.name = string; + e.entity = notify_list_owner_id; + + for (auto* value = top; value->type != game::SCRIPT_END; --value) + { + e.arguments.emplace_back(*value); + } + + if (last_event != e.name) + { + last_event = e.name; + + //printf("notify: %s\n", e.name.data()); + } + + lua::engine::notify(e); + } + + vm_notify_hook.invoke(notify_list_owner_id, string_value, top); + } + + void scr_load_level_stub() + { + scr_load_level_hook.invoke(); + lua::engine::start(); + } + + void g_shutdown_game_stub(const int free_scripts) + { + lua::engine::stop(); + return g_shutdown_game_hook.invoke(free_scripts); + } + + void scr_add_class_field_stub(unsigned int classnum, game::scr_string_t _name, unsigned int canonicalString, unsigned int offset) + { + const auto name = game::SL_ConvertToString(_name); + + if (fields_table[classnum].find(name) == fields_table[classnum].end()) + { + fields_table[classnum][name] = offset; + } + + scr_add_class_field_hook.invoke(classnum, _name, canonicalString, offset); + } + } + + void init() + { + vm_notify_hook.create(game::base_address + 0x5CC450, vm_notify_stub); + + scr_load_level_hook.create(game::base_address + 0x520AB0, scr_load_level_stub); + g_shutdown_game_hook.create(game::base_address + 0x4CBAD0, g_shutdown_game_stub); + + scr_add_class_field_hook.create(game::base_address + 0x5C2C30, scr_add_class_field_stub); + + scheduler::loop([]() + { + lua::engine::run_frame(); + }, scheduler::pipeline::server); + } +} diff --git a/src/component/scripting.hpp b/src/component/scripting.hpp new file mode 100644 index 00000000..4bd33dc8 --- /dev/null +++ b/src/component/scripting.hpp @@ -0,0 +1,8 @@ +#pragma once + +namespace scripting +{ + extern std::unordered_map> fields_table; + + void init(); +} \ No newline at end of file diff --git a/src/dllmain.cpp b/src/dllmain.cpp index 1dd660e6..a2aae362 100644 --- a/src/dllmain.cpp +++ b/src/dllmain.cpp @@ -35,6 +35,7 @@ void init() input::init(); scheduler::init(); game_console::init(); + scripting::init(); } BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) diff --git a/src/game/scripting/entity.cpp b/src/game/scripting/entity.cpp new file mode 100644 index 00000000..f495ce64 --- /dev/null +++ b/src/game/scripting/entity.cpp @@ -0,0 +1,120 @@ +#include +#include "entity.hpp" +#include "script_value.hpp" +#include "execution.hpp" + +namespace scripting +{ + entity::entity() + : entity(0) + { + } + + entity::entity(const entity& other) : entity(other.entity_id_) + { + } + + entity::entity(entity&& other) noexcept + { + this->entity_id_ = other.entity_id_; + other.entity_id_ = 0; + } + + entity::entity(const unsigned int entity_id) + : entity_id_(entity_id) + { + this->add(); + } + + entity::entity(game::scr_entref_t entref) + : entity(game::FindEntityId(entref.entnum, entref.classnum)) + { + } + + entity::~entity() + { + this->release(); + } + + entity& entity::operator=(const entity& other) + { + if (&other != this) + { + this->release(); + this->entity_id_ = other.entity_id_; + this->add(); + } + + return *this; + } + + entity& entity::operator=(entity&& other) noexcept + { + if (&other != this) + { + this->release(); + this->entity_id_ = other.entity_id_; + other.entity_id_ = 0; + } + + return *this; + } + + unsigned int entity::get_entity_id() const + { + return this->entity_id_; + } + + game::scr_entref_t entity::get_entity_reference() const + { + if (!this->entity_id_) + { + const auto not_null = static_cast(~0ui16); + return game::scr_entref_t{not_null, not_null}; + } + + return game::Scr_GetEntityIdRef(this->get_entity_id()); + } + + bool entity::operator==(const entity& other) const noexcept + { + return this->get_entity_id() == other.get_entity_id(); + } + + bool entity::operator!=(const entity& other) const noexcept + { + return !this->operator==(other); + } + + void entity::add() const + { + if (this->entity_id_) + { + game::AddRefToValue(game::SCRIPT_OBJECT, {static_cast(this->entity_id_)}); + } + } + + void entity::release() const + { + if (this->entity_id_) + { + game::RemoveRefToValue(game::SCRIPT_OBJECT, {static_cast(this->entity_id_)}); + } + } + + void entity::set(const std::string& field, const script_value& value) const + { + set_entity_field(*this, field, value); + } + + template <> + script_value entity::get(const std::string& field) const + { + return get_entity_field(*this, field); + } + + script_value entity::call(const std::string& name, const std::vector& arguments) const + { + return call_function(name, *this, arguments); + } +} diff --git a/src/game/scripting/entity.hpp b/src/game/scripting/entity.hpp new file mode 100644 index 00000000..b1702379 --- /dev/null +++ b/src/game/scripting/entity.hpp @@ -0,0 +1,50 @@ +#pragma once +#include "game/game.hpp" +#include "script_value.hpp" + +namespace scripting +{ + class entity final + { + public: + entity(); + entity(unsigned int entity_id); + entity(game::scr_entref_t entref); + + entity(const entity& other); + entity(entity&& other) noexcept; + + ~entity(); + + entity& operator=(const entity& other); + entity& operator=(entity&& other) noexcept; + + void set(const std::string& field, const script_value& value) const; + + template + T get(const std::string& field) const; + + script_value call(const std::string& name, const std::vector& arguments = {}) const; + + unsigned int get_entity_id() const; + game::scr_entref_t get_entity_reference() const; + + bool operator ==(const entity& other) const noexcept; + bool operator !=(const entity& other) const noexcept; + + private: + unsigned int entity_id_; + + void add() const; + void release() const; + }; + + template <> + script_value entity::get(const std::string& field) const; + + template + T entity::get(const std::string& field) const + { + return this->get(field).as(); + } +} diff --git a/src/game/scripting/event.hpp b/src/game/scripting/event.hpp new file mode 100644 index 00000000..bc1d53e0 --- /dev/null +++ b/src/game/scripting/event.hpp @@ -0,0 +1,13 @@ +#pragma once +#include "script_value.hpp" +#include "entity.hpp" + +namespace scripting +{ + struct event + { + std::string name; + entity entity{}; + std::vector arguments; + }; +} diff --git a/src/game/scripting/execution.cpp b/src/game/scripting/execution.cpp new file mode 100644 index 00000000..27c3d5b7 --- /dev/null +++ b/src/game/scripting/execution.cpp @@ -0,0 +1,196 @@ +#include +#include "execution.hpp" +#include "safe_execution.hpp" +#include "stack_isolation.hpp" + +#include "component/scripting.hpp" + +namespace scripting +{ + namespace + { + game::VariableValue* allocate_argument() + { + game::VariableValue* value_ptr = ++game::scr_VmPub->top; + ++game::scr_VmPub->inparamcount; + return value_ptr; + } + + void push_value(const script_value& value) + { + auto* value_ptr = allocate_argument(); + *value_ptr = value.get_raw(); + + game::AddRefToValue(value_ptr->type, value_ptr->u); + } + + int get_field_id(const int classnum, const std::string& field) + { + if (scripting::fields_table[classnum].find(field) != scripting::fields_table[classnum].end()) + { + return scripting::fields_table[classnum][field]; + } + + return -1; + } + + script_value get_return_value() + { + if (game::scr_VmPub->inparamcount == 0) + { + return {}; + } + + game::Scr_ClearOutParams(); + game::scr_VmPub->outparamcount = game::scr_VmPub->inparamcount; + game::scr_VmPub->inparamcount = 0; + + return script_value(game::scr_VmPub->top[1 - game::scr_VmPub->outparamcount]); + } + } + + void notify(const entity& entity, const std::string& event, const std::vector& arguments) + { + stack_isolation _; + for (auto i = arguments.rbegin(); i != arguments.rend(); ++i) + { + push_value(*i); + } + + const auto event_id = game::SL_GetString(event.data(), 0); + game::Scr_NotifyId(entity.get_entity_id(), event_id, game::scr_VmPub->inparamcount); + } + + script_value call_function(const std::string& name, const entity& entity, + const std::vector& arguments) + { + const auto entref = entity.get_entity_reference(); + + const auto is_method_call = *reinterpret_cast(&entref) != -1; + const auto function = find_function(name, !is_method_call); + if (function == nullptr) + { + throw std::runtime_error("Unknown "s + (is_method_call ? "method" : "function") + " '" + name + "'"); + } + + stack_isolation _; + + for (auto i = arguments.rbegin(); i != arguments.rend(); ++i) + { + push_value(*i); + } + + game::scr_VmPub->outparamcount = game::scr_VmPub->inparamcount; + game::scr_VmPub->inparamcount = 0; + + if (!safe_execution::call(function, entref)) + { + throw std::runtime_error( + "Error executing "s + (is_method_call ? "method" : "function") + " '" + name + "'"); + } + + return get_return_value(); + } + + script_value call_function(const std::string& name, const std::vector& arguments) + { + return call_function(name, entity(), arguments); + } + + template <> + script_value call(const std::string& name, const std::vector& arguments) + { + return call_function(name, arguments); + } + + static std::unordered_map> custom_fields; + + script_value get_custom_field(const entity& entity, const std::string& field) + { + auto& fields = custom_fields[entity.get_entity_id()]; + const auto _field = fields.find(field); + if (_field != fields.end()) + { + return _field->second; + } + return {}; + } + + void set_custom_field(const entity& entity, const std::string& field, const script_value& value) + { + const auto id = entity.get_entity_id(); + + if (custom_fields[id].find(field) != custom_fields[id].end()) + { + custom_fields[id][field] = value; + return; + } + + custom_fields[id].insert(std::make_pair(field, value)); + } + + void clear_entity_fields(const entity& entity) + { + const auto id = entity.get_entity_id(); + + if (custom_fields.find(id) != custom_fields.end()) + { + custom_fields[id].clear(); + } + } + + void clear_custom_fields() + { + custom_fields.clear(); + } + + void set_entity_field(const entity& entity, const std::string& field, const script_value& value) + { + const auto entref = entity.get_entity_reference(); + const int id = get_field_id(entref.classnum, field); + + if (id != -1) + { + stack_isolation _; + push_value(value); + + game::scr_VmPub->outparamcount = game::scr_VmPub->inparamcount; + game::scr_VmPub->inparamcount = 0; + + if (!safe_execution::set_entity_field(entref, id)) + { + throw std::runtime_error("Failed to set value for field '" + field + "'"); + } + } + else + { + set_custom_field(entity, field, value); + } + } + + script_value get_entity_field(const entity& entity, const std::string& field) + { + const auto entref = entity.get_entity_reference(); + const auto id = get_field_id(entref.classnum, field); + + if (id != -1) + { + stack_isolation _; + + game::VariableValue value{}; + if (!safe_execution::get_entity_field(entref, id, &value)) + { + throw std::runtime_error("Failed to get value for field '" + field + "'"); + } + + const auto __ = gsl::finally([value]() + { + game::RemoveRefToValue(value.type, value.u); + }); + + return value; + } + + return get_custom_field(entity, field); + } +} diff --git a/src/game/scripting/execution.hpp b/src/game/scripting/execution.hpp new file mode 100644 index 00000000..027d2a4b --- /dev/null +++ b/src/game/scripting/execution.hpp @@ -0,0 +1,31 @@ +#pragma once +#include "game/game.hpp" +#include "entity.hpp" +#include "script_value.hpp" + +namespace scripting +{ + script_value call_function(const std::string& name, const std::vector& arguments); + script_value call_function(const std::string& name, const entity& entity, + const std::vector& arguments); + + template + T call(const std::string& name, const std::vector& arguments = {}); + + template <> + script_value call(const std::string& name, const std::vector& arguments); + + template + T call(const std::string& name, const std::vector& arguments) + { + return call(name, arguments).as(); + } + + void clear_entity_fields(const entity& entity); + void clear_custom_fields(); + + void set_entity_field(const entity& entity, const std::string& field, const script_value& value); + script_value get_entity_field(const entity& entity, const std::string& field); + + void notify(const entity& entity, const std::string& event, const std::vector& arguments); +} diff --git a/src/game/scripting/function_tables.cpp b/src/game/scripting/function_tables.cpp new file mode 100644 index 00000000..7f87c56e --- /dev/null +++ b/src/game/scripting/function_tables.cpp @@ -0,0 +1,1109 @@ +#include + +// This file has been generated. +// Do not touch! + +namespace scripting +{ + std::unordered_map function_map = + { + {"spawnturret", 23}, + {"canspawnturret", 24}, + {"isdefined", 46}, + {"issentient", 47}, + {"lookupsoundlength", 19}, + {"isstring", 48}, + {"isplayer", 213}, + {"loadluifile", 212}, + {"setclientdvar", 51}, + {"getzonecount", 65}, + {"getentbynum", 63}, + {"getweaponcamoname", 100}, + {"getanimlength", 102}, + {"animhasnotetrack", 103}, + {"getnotetracktimes", 104}, + {"bullettracepassed", 142}, + {"getangledelta", 147}, + {"getmovedelta", 148}, + {"getangledelta3d", 45}, + {"getnorthyaw", 149}, + {"randomint", 182}, + {"randomfloat", 183}, + {"randomintrange", 184}, + {"randomfloatrange", 185}, + {"sin", 186}, + {"cos", 187}, + {"tan", 188}, + {"asin", 190}, + {"atan", 191}, + {"castint", 192}, + {"castfloat", 193}, + {"getenemysquaddogtype", 194}, + {"floor", 230}, + {"log", 231}, + {"angleclamp360", 232}, + {"exp", 233}, + {"sqrt", 235}, + {"squared", 236}, + {"pow", 248}, + {"angleclamp180", 239}, + {"vectorfromlinetopoint", 240}, + {"pointonsegmentnearesttopoint", 241}, + {"ispointinvolume", 54}, + {"distance2dsquared", 44}, + {"vectornormalize", 24}, + {"vectortoangles", 25}, + {"vectortoyaw", 26}, + {"setclientmatchdata", 27}, + {"axistoangles", 252}, + {"anglestoup", 28}, + {"anglesdelta", 31}, + {"rotatepointaroundvector", 35}, + {"issubstr", 36}, + {"isendstr", 37}, + {"getsubstr", 38}, + {"tolower", 39}, + {"getactiveclientcount", 41}, + {"precachemodel", 75}, + {"initdefaultviewmodelrumbles", 81}, + {"loadfx", 84}, + {"physicsexplosionsphere", 132}, + {"physicsradiusjolt", 133}, + {"isexplosivedamagemod", 141}, + {"getnumparts", 146}, + {"getpartname", 180}, + {"ceil", 182}, + {"botmemoryflags", 183}, + {"getactivecount", 184}, + {"getsquadassaultenemyprestige", 185}, + {"getteamscore", 186}, + {"getent", 241}, + {"getnodearray", 242}, + {"getallnodes", 243}, + {"spawn", 246}, + {"getarray", 247}, + {"getspawnerarray", 203}, + {"gettime", 249}, + {"ishairrunning", 250}, + {"getentchannelname", 251}, + {"getuavstrengthmin", 253}, + {"getbuildversion", 254}, + {"tablelookupistringbyrow", 193}, + {"tablelookuprownum", 195}, + {"tablelookup", 14}, + {"tableexists", 197}, + {"getmissileowner", 198}, + {"magicbullet", 199}, + {"getweaponflashtagname", 200}, + {"summarizearraypoints", 201}, + {"buildhudoutlineclientmaskfromentarray", 202}, + {"getglass", 218}, + {"getglassarray", 219}, + {"getglassorigin", 220}, + {"isglassdestroyed", 221}, + {"destroyglass", 222}, + {"deletepiece", 223}, + {"getalpha", 224}, + {"setteammode", 121}, + {"runbadplaces", 30}, + {"isteamradarblocked", 65}, + {"issquadsmode", 66}, + {"stoploopsound", 47}, + {"trajectorycalculateexitangle", 49}, + {"trajectorycomputedeltaheightattime", 51}, + {"getteamradar", 52}, + {"isarray", 210}, + {"disconnectnodepair", 29}, + {"connectnodepair", 30}, + {"addbot", 96}, + {"getcsplinecount", 97}, + {"getcsplinepointcount", 98}, + {"getcsplinelength", 99}, + {"getcsplinepointid", 100}, + {"getcsplinepointlabel", 101}, + {"getcsplinepointtension", 102}, + {"getcsplinepointcorridordims", 103}, + {"getcsplinepointtangent", 104}, + {"getcsplinepointdisttonextpoint", 106}, + {"calccsplinetangent", 107}, + {"calccsplinecorridor", 108}, + {"assertexcmd", 111}, + {"playsoundasmaster", 137}, + {"isvalidgametype", 164}, + {"getuavstrengthlevelshowenemyfastsweep", 180}, + {"getteamradarstrength", 190}, + {"abs", 202}, + }; + + std::unordered_map method_map = + { + {"thermaldrawdisable", 32768}, + {"heli_setdamagestage", 32770}, + {"playsoundtoteam", 32771}, + {"playsoundtoplayer", 32772}, + {"playerhide", 32773}, + {"playershow", 32774}, + {"showtoplayer", 32775}, + {"threatdetectedtoplayer", 32776}, + {"clearthreatdetected", 32777}, + {"enableplayeruse", 32778}, + {"disableplayeruse", 32779}, + {"enableammogeneration", 32780}, + {"disableammogeneration", 32781}, + {"makescrambler", 32782}, + {"makeportableradar", 32783}, + {"clearscrambler", 32784}, + {"clearportableradar", 32785}, + {"placespawnpoint", 32786}, + {"setteamfortrigger", 32787}, + {"clientclaimtrigger", 32788}, + {"clientreleasetrigger", 32789}, + {"releaseclaimedtrigger", 32790}, + {"isusingonlinedataoffline", 32791}, + {"getrestedtime", 32792}, + {"sendleaderboards", 32793}, + {"isonladder", 32794}, + {"getcorpseanim", 32795}, + {"playerforcedeathanim", 32796}, + {"attach", 32797}, + {"startragdoll", 32803}, + {"thermaldrawenable", 32809}, + {"detach", 32810}, + {"detachall", 32811}, + {"getattachsize", 32812}, + {"getattachmodelname", 32813}, + {"getattachtagname", 32814}, + {"gethighestnodestance", 32820}, + {"doesnodeallowstance", 32821}, + {"getlightcolor", 32835}, + {"setlightcolor", 32836}, + {"getattachignorecollision", 32839}, + {"hidepart", 32840}, + {"hidepartallinstances", 32841}, + {"hideallparts", 32842}, + {"showpart", 32843}, + {"showallparts", 32844}, + {"linkto", 32845}, + {"linktoblendtotag", 32846}, + {"unlink", 32847}, + {"setnormalhealth", 32848}, + {"dodamage", 32849}, + {"show", 32851}, + {"hide", 32852}, + {"disconnectpaths", 32855}, + {"connectpaths", 32856}, + {"disconnectnode", 32857}, + {"connectnode", 32858}, + {"digitaldistortsetparams", 32868}, + {"setmode", 32869}, + {"getmode", 32870}, + {"islinked", 32872}, + {"enablelinkto", 32873}, + {"setpitch", 32876}, + {"scalepitch", 32877}, + {"setvolume", 32878}, + {"scalevolume", 32879}, + {"playsound", 32884}, + {"playloopsound", 32885}, + {"getnormalhealth", 32891}, + {"playerlinkto", 32892}, + {"playerlinktodelta", 32893}, + {"playerlinkweaponviewtodelta", 32894}, + {"playerlinktoabsolute", 32895}, + {"playerlinktoblend", 32896}, + {"playerlinkedoffsetenable", 32897}, + {"setwaypointedgestyle_secondaryarrow", 32898}, + {"setwaypointiconoffscreenonly", 32899}, + {"fadeovertime", 32900}, + {"scaleovertime", 32901}, + {"moveovertime", 32902}, + {"reset", 32903}, + {"destroy", 32904}, + {"setpulsefx", 32905}, + {"setplayernamestring", 32906}, + {"changefontscaleovertime", 32907}, + {"playersetgroundreferenceent", 32913}, + {"dontinterpolate", 32914}, + {"getorigin", 32917}, + {"useby", 32921}, + {"playsoundasmaster", 32922}, + {"playerlinkedoffsetdisable", 32927}, + {"playerlinkedsetviewznear", 32928}, + {"playerlinkedsetusebaseangleforviewclamp", 32929}, + {"lerpviewangleclamp", 32930}, + {"geteye", 32936}, + {"istouching", 32937}, + {"getistouchingentities", 32938}, + {"stoploopsound", 32939}, + {"stopsounds", 32940}, + {"playrumbleonentity", 32941}, + {"playrumblelooponentity", 32942}, + {"stoprumble", 32943}, + {"delete", 32944}, + {"setmodel", 32945}, + {"laseron", 32946}, + {"laseroff", 32947}, + {"thermalvisionon", 32950}, + {"thermalvisionoff", 32951}, + {"thermalvisionfofoverlayon", 32952}, + {"thermalvisionfofoverlayoff", 32953}, + {"autospotoverlayon", 32954}, + {"autospotoverlayoff", 32955}, + {"seteyesonuplinkenabled", 32956}, + {"setcontents", 32958}, + {"makeusable", 32959}, + {"makeunusable", 32960}, + {"makeglobalusable", 32961}, + {"makeglobalunusable", 32962}, + {"settext", 32970}, + {"setmaterial", 32972}, + {"settargetent", 32973}, + {"cleartargetent", 32974}, + {"settimer", 32975}, + {"settimerup", 32976}, + {"settimerstatic", 32977}, + {"settenthstimer", 32978}, + {"settenthstimerup", 32979}, + {"settenthstimerstatic", 32980}, + {"setclock", 32981}, + {"setclockup", 32982}, + {"setvalue", 32983}, + {"setwaypoint", 32984}, + {"setwaypointedgestyle_rotatingicon", 32985}, + {"setcursorhint", 32986}, + {"sethintstring", 32987}, + {"setsecondaryhintstring", 32988}, + {"forceusehinton", 32989}, + {"forceusehintoff", 32990}, + {"makesoft", 32991}, + {"makehard", 32992}, + {"entitywillneverchange", 32993}, + {"startfiring", 32994}, + {"stopfiring", 32995}, + {"isfiringturret", 32996}, + {"startbarrelspin", 32997}, + {"stopbarrelspin", 32998}, + {"getbarrelspinrate", 32999}, + {"remotecontrolturret", 33000}, + {"remotecontrolturretoff", 33001}, + {"shootturret", 33002}, + {"getturretowner", 33003}, + {"giveachievement", 33017}, + {"sub_1402ddb00", 33022}, + {"sub_1402ddcc0", 33023}, + {"setsentryowner", 33027}, + {"setsentrycarrier", 33028}, + {"setturretminimapvisible", 33029}, + {"settargetentity", 33030}, + {"snaptotargetentity", 33031}, + {"cleartargetentity", 33032}, + {"getturrettarget", 33033}, + {"setplayerspread", 33034}, + {"setaispread", 33035}, + {"setsuppressiontime", 33036}, + {"allowstand", 33048}, + {"allowcrouch", 33049}, + {"allowprone", 33050}, + {"sub_1402dd9e0", 33051}, + {"isthrowinggrenade", 33068}, + {"isfiring", 33069}, + {"ismeleeing", 33070}, + {"allowmelee", 33072}, + {"allowfire", 33073}, + {"setconvergencetime", 33075}, + {"setconvergenceheightpercent", 33076}, + {"setturretteam", 33077}, + {"maketurretsolid", 33078}, + {"maketurretoperable", 33079}, + {"maketurretinoperable", 33080}, + {"makeentitysentient", 33081}, + {"freeentitysentient", 33082}, + {"setrightarc", 33109}, + {"setleftarc", 33110}, + {"settoparc", 33111}, + {"setbottomarc", 33112}, + {"setautorotationdelay", 33113}, + {"setdefaultdroppitch", 33114}, + {"restoredefaultdroppitch", 33115}, + {"turretfiredisable", 33116}, + {"getenemyinfo", 33125}, + {"getenemysqdist", 33141}, + {"getclosestenemysqdist", 33142}, + {"setthreatbiasgroup", 33143}, + {"getthreatbiasgroup", 33144}, + {"turretfireenable", 33145}, + {"setturretmodechangewait", 33146}, + {"usetriggerrequirelookat", 33147}, + {"getstance", 33148}, + {"setstance", 33149}, + {"itemweaponsetammo", 33150}, + {"getammocount", 33151}, + {"gettagorigin", 33152}, + {"gettagangles", 33153}, + {"shellshock", 33154}, + {"stunplayer", 33155}, + {"stopshellshock", 33156}, + {"fadeoutshellshock", 33157}, + {"setdepthoffield", 33158}, + {"setviewmodeldepthoffield", 33159}, + {"setmotionblurmovescale", 33160}, + {"getnegotiationstartnode", 33181}, + {"getnegotiationendnode", 33182}, + {"getnegotiationnextnode", 33183}, + {"setmotionblurturnscale", 33197}, + {"setmotionblurzoomscale", 33198}, + {"viewkick", 33199}, + {"localtoworldcoords", 33200}, + {"getentitynumber", 33201}, + {"getentityvelocity", 33202}, + {"enablegrenadetouchdamage", 33203}, + {"disablegrenadetouchdamage", 33204}, + {"enableaimassist", 33205}, + {"lastknowntime", 33216}, + {"lastknownpos", 33217}, + {"disableaimassist", 33236}, + {"entityradiusdamage", 33237}, + {"detonate", 33238}, + {"damageconetrace", 33239}, + {"sightconetrace", 33240}, + {"missilesettargetent", 33241}, + {"missilesettargetpos", 33242}, + {"missilecleartarget", 33243}, + {"missilesetflightmodedirect", 33244}, + {"missilesetflightmodetop", 33245}, + {"getlightintensity", 33246}, + {"setlightintensity", 33247}, + {"isragdoll", 33248}, + {"setmovespeedscale", 33249}, + {"cameralinkto", 33250}, + {"cameraunlink", 33251}, + {"controlslinkto", 33280}, + {"controlsunlink", 33281}, + {"makevehiclesolidcapsule", 33282}, + {"makevehiclesolidsphere", 33284}, + {"remotecontrolvehicle", 33286}, + {"remotecontrolvehicleoff", 33287}, + {"isfiringvehicleturret", 33288}, + {"remotecontrolvehicletarget", 33289}, + {"remotecontrolvehicletargetoff", 33290}, + {"drivevehicleandcontrolturret", 33291}, + {"drivevehicleandcontrolturretoff", 33292}, + {"getplayersetting", 33293}, + {"getlocalplayerprofiledata", 33294}, + {"setlocalplayerprofiledata", 33295}, + {"remotecamerasoundscapeon", 33296}, + {"remotecamerasoundscapeoff", 33297}, + {"setmotiontrackervisible", 33298}, + {"getmotiontrackervisible", 33299}, + {"worldpointinreticle_circle", 33300}, + {"worldpointinreticle_rect", 33301}, + {"getpointinbounds", 33302}, + {"transfermarkstonewscriptmodel", 33303}, + {"setwatersheeting", 33304}, + {"setweaponhudiconoverride", 33307}, + {"getweaponhudiconoverride", 33308}, + {"setempjammed", 33309}, + {"playersetexpfogext", 33310}, + {"playersetexpfog", 33311}, + {"playersetatmosfog", 33312}, + {"isitemunlocked", 33313}, + {"getplayerdata", 33314}, + {"getrankedplayerdata", 33315}, + {"getprivateplayerdata", 33316}, + {"getcoopplayerdata", 33317}, + {"getcommonplayerdata", 33318}, + {"vehicleturretcontroloff", 33319}, + {"isturretready", 33320}, + {"vehicledriveto", 33321}, + {"dospawn", 33322}, + {"isphysveh", 33323}, + {"crash", 33324}, + {"launch", 33325}, + {"disablecrashing", 33326}, + {"enablecrashing", 33327}, + {"setphysvehspeed", 33328}, + {"setconveyorbelt", 33329}, + {"freevehicle", 33330}, + {"setplayerdata", 33347}, + {"setrankedplayerdata", 33348}, + {"setprivateplayerdata", 33349}, + {"setcoopplayerdata", 33350}, + {"setcommonplayerdata", 33351}, + {"getcacplayerdata", 33352}, + {"setcacplayerdata", 33353}, + {"trackerupdate", 33354}, + {"pingplayer", 33355}, + {"buttonpressed", 33356}, + {"sayall", 33357}, + {"sayteam", 33358}, + {"setspawnweapon", 33359}, + {"dropitem", 33360}, + {"dropscavengerbag", 33361}, + {"setjitterparams", 33362}, + {"sethoverparams", 33363}, + {"joltbody", 33364}, + {"getwheelsurface", 33366}, + {"getvehicleowner", 33367}, + {"setvehiclelookattext", 33368}, + {"setvehicleteam", 33369}, + {"neargoalnotifydist", 33370}, + {"setvehgoalpos", 33371}, + {"setgoalyaw", 33372}, + {"cleargoalyaw", 33373}, + {"settargetyaw", 33374}, + {"cleartargetyaw", 33375}, + {"helisetgoal", 33376}, + {"setturrettargetvec", 33377}, + {"setturrettargetent", 33378}, + {"clearturrettargetent", 33379}, + {"canturrettargetpoint", 33380}, + {"setlookatent", 33381}, + {"clearlookatent", 33382}, + {"setweapon", 33383}, + {"fireweapon", 33384}, + {"vehicleturretcontrolon", 33385}, + {"finishplayerdamage", 33386}, + {"suicide", 33387}, + {"closeingamemenu", 33388}, + {"iclientprintln", 33389}, + {"iclientprintlnbold", 33390}, + {"spawn", 33391}, + {"setentertime", 33392}, + {"cloneplayer", 33393}, + {"istalking", 33394}, + {"allowspectateteam", 33395}, + {"forcespectatepov", 33396}, + {"getguid", 33397}, + {"physicslaunchserver", 33398}, + {"physicslaunchserveritem", 33399}, + {"clonebrushmodeltoscriptmodel", 33400}, + {"scriptmodelplayanim", 33401}, + {"scriptmodelclearanim", 33402}, + {"scriptmodelplayanimdeltamotion", 33403}, + {"teleport", 33404}, + {"attachpath", 33405}, + {"getattachpos", 33406}, + {"startpath", 33407}, + {"setswitchnode", 33408}, + {"setwaitspeed", 33409}, + {"finishdamage", 33410}, + {"setspeed", 33411}, + {"setspeedimmediate", 33412}, + {"rotatevehyaw", 33413}, + {"getspeed", 33414}, + {"getvehvelocity", 33415}, + {"getbodyvelocity", 33416}, + {"getsteering", 33417}, + {"getthrottle", 33418}, + {"turnengineoff", 33419}, + {"turnengineon", 33420}, + {"getgoalspeedmph", 33422}, + {"setacceleration", 33423}, + {"setdeceleration", 33424}, + {"resumespeed", 33425}, + {"setyawspeed", 33426}, + {"setyawspeedbyname", 33427}, + {"setmaxpitchroll", 33428}, + {"setairresitance", 33429}, + {"setturningability", 33430}, + {"getxuid", 33431}, + {"getucdidhigh", 33432}, + {"getucdidlow", 33433}, + {"getclanidhigh", 33434}, + {"getclanidlow", 33435}, + {"ishost", 33436}, + {"getspectatingplayer", 33437}, + {"predictstreampos", 33438}, + {"setrank", 33441}, + {"weaponlocknoclearance", 33443}, + {"visionsyncwithplayer", 33444}, + {"showhudsplash", 33445}, + {"setperk", 33446}, + {"hasperk", 33447}, + {"clearperks", 33448}, + {"unsetperk", 33449}, + {"registerparty", 33450}, + {"getfireteammembers", 33451}, + {"moveto", 33454}, + {"movex", 33455}, + {"movey", 33456}, + {"movez", 33457}, + {"gravitymove", 33458}, + {"moveslide", 33459}, + {"stopmoveslide", 33460}, + {"rotateto", 33461}, + {"rotatepitch", 33462}, + {"rotateyaw", 33463}, + {"rotateroll", 33464}, + {"addpitch", 33465}, + {"addyaw", 33466}, + {"addroll", 33467}, + {"vibrate", 33468}, + {"rotatevelocity", 33469}, + {"solid", 33470}, + {"notsolid", 33471}, + {"setcandamage", 33472}, + {"setcanradiusdamage", 33473}, + {"physicslaunchclient", 33474}, + {"setcarddisplayslot", 33477}, + {"kc_regweaponforfxremoval", 33478}, + {"laststandrevive", 33479}, + {"laststand", 33480}, + {"setspectatedefaults", 33481}, + {"getthirdpersoncrosshairoffset", 33482}, + {"disableweaponpickup", 33483}, + {"enableweaponpickup", 33484}, + {"issplitscreenplayer", 33485}, + {"getweaponslistoffhands", 33486}, + {"getweaponslistitems", 33487}, + {"getweaponslistexclusives", 33488}, + {"getweaponslist", 33489}, + {"canplayerplacesentry", 33490}, + {"canplayerplacetank", 33491}, + {"visionsetnakedforplayer", 33492}, + {"visionsetnightforplayer", 33493}, + {"visionsetmissilecamforplayer", 33494}, + {"visionsetthermalforplayer", 33495}, + {"visionsetpainforplayer", 33496}, + {"setblurforplayer", 33497}, + {"getplayerweaponmodel", 33498}, + {"getplayerknifemodel", 33499}, + {"notifyonplayercommand", 33501}, + {"canmantle", 33502}, + {"forcemantle", 33503}, + {"ismantling", 33504}, + {"playfx", 33505}, + {"playerrecoilscaleon", 33506}, + {"playerrecoilscaleoff", 33507}, + {"weaponlockstart", 33508}, + {"weaponlockfinalize", 33509}, + {"weaponlockfree", 33510}, + {"weaponlocktargettooclose", 33511}, + {"issplitscreenplayerprimary", 33512}, + {"markforeyeson", 33513}, + {"issighted", 33514}, + {"getsightedplayers", 33515}, + {"getplayerssightingme", 33516}, + {"getviewmodel", 33517}, + {"fragbuttonpressed", 33518}, + {"secondaryoffhandbuttonpressed", 33519}, + {"getcurrentweaponclipammo", 33520}, + {"setvelocity", 33521}, + {"getviewheight", 33522}, + {"getnormalizedmovement", 33523}, + {"playlocalsound", 33524}, + {"stoplocalsound", 33525}, + {"setweaponammoclip", 33526}, + {"setweaponammostock", 33527}, + {"getweaponammoclip", 33528}, + {"getweaponammostock", 33529}, + {"anyammoforweaponmodes", 33530}, + {"setclientomnvar", 33531}, + {"setclientdvar", 33532}, + {"setclientdvars", 33533}, + {"setclientspawnsighttraces", 33534}, + {"clientspawnsighttracepassed", 33535}, + {"allowads", 33536}, + {"allowjump", 33537}, + {"allowladder", 33538}, + {"allowmantle", 33539}, + {"allowsprint", 33540}, + {"setspreadoverride", 33541}, + {"resetspreadoverride", 33542}, + {"setaimspreadmovementscale", 33543}, + {"setactionslot", 33544}, + {"setviewkickscale", 33545}, + {"getviewkickscale", 33546}, + {"getweaponslistall", 33547}, + {"getweaponslistprimaries", 33548}, + {"getnormalizedcameramovement", 33549}, + {"giveweapon", 33550}, + {"takeweapon", 33551}, + {"takeallweapons", 33552}, + {"getcurrentweapon", 33553}, + {"getcurrentprimaryweapon", 33554}, + {"getcurrentoffhand", 33555}, + {"hasweapon", 33556}, + {"switchtoweapon", 33557}, + {"switchtoweaponimmediate", 33558}, + {"sub_1402e1d60", 33559}, + {"switchtooffhand", 33560}, + {"setoffhandsecondaryclass", 33561}, + {"getoffhandsecondaryclass", 33562}, + {"beginlocationselection", 33563}, + {"endlocationselection", 33564}, + {"disableweapons", 33565}, + {"enableweapons", 33566}, + {"disableoffhandweapons", 33567}, + {"enableoffhandweapons", 33568}, + {"disableweaponswitch", 33569}, + {"enableweaponswitch", 33570}, + {"openpopupmenu", 33571}, + {"openpopupmenunomouse", 33572}, + {"closepopupmenu", 33573}, + {"openmenu", 33574}, + {"closemenu", 33575}, + {"freezecontrols", 33577}, + {"disableusability", 33578}, + {"enableusability", 33579}, + {"setwhizbyspreads", 33580}, + {"setwhizbyradii", 33581}, + {"setchannelvolume", 33584}, + {"givestartammo", 33585}, + {"givemaxammo", 33586}, + {"getfractionstartammo", 33587}, + {"getfractionmaxammo", 33588}, + {"isdualwielding", 33589}, + {"isreloading", 33590}, + {"isswitchingweapon", 33591}, + {"setorigin", 33592}, + {"getvelocity", 33593}, + {"setangles", 33594}, + {"getangles", 33595}, + {"usebuttonpressed", 33596}, + {"attackbuttonpressed", 33597}, + {"adsbuttonpressed", 33598}, + {"meleebuttonpressed", 33599}, + {"playerads", 33600}, + {"isonground", 33601}, + {"isusingturret", 33602}, + {"setviewmodel", 33603}, + {"setoffhandprimaryclass", 33604}, + {"getoffhandprimaryclass", 33605}, + {"sub_14032dff0", 33610}, + {"sub_14032e040", 33611}, + {"enablemousesteer", 33612}, + {"setscriptmoverkillcam", 33613}, + {"usinggamepad", 33614}, + {"forcethirdpersonwhenfollowing", 33615}, + {"disableforcethirdpersonwhenfollowing", 33616}, + {"botsetflag", 33617}, + {"botsetstance", 33618}, + {"botsetscriptmove", 33619}, + {"botsetscriptgoal", 33620}, + {"botsetscriptgoalnode", 33621}, + {"botclearscriptgoal", 33622}, + {"botsetscriptenemy", 33623}, + {"botclearscriptenemy", 33624}, + {"botsetattacker", 33625}, + {"botgetscriptgoal", 33626}, + {"botgetscriptgoalradius", 33627}, + {"botgetscriptgoalyaw", 33628}, + {"botgetscriptgoaltype", 33629}, + {"botgetworldsize", 33631}, + {"botnodeavailable", 33632}, + {"botfindnoderandom", 33633}, + {"botmemoryevent", 33634}, + {"botnodepick", 33636}, + {"bothasscriptgoal", 33637}, + {"botgetpersonality", 33638}, + {"botthrowgrenade", 33639}, + {"botsetpersonality", 33641}, + {"botsetdifficulty", 33642}, + {"botgetdifficulty", 33643}, + {"botgetworldclosestedge", 33644}, + {"botlookatpoint", 33645}, + {"botpredictseepoint", 33646}, + {"botcanseeentity", 33647}, + {"botgetnodesonpath", 33648}, + {"botnodepickmultiple", 33649}, + {"botgetfovdot", 33651}, + {"botsetawareness", 33652}, + {"botpursuingscriptgoal", 33653}, + {"botgetscriptgoalnode", 33654}, + {"botgetimperfectenemyinfo", 33655}, + {"botsetpathingstyle", 33657}, + {"botsetdifficultysetting", 33658}, + {"botgetdifficultysetting", 33659}, + {"botgetpathdist", 33660}, + {"botisrandomized", 33661}, + {"botpressbutton", 33662}, + {"botclearbutton", 33663}, + {"botnodescoremultiple", 33664}, + {"getnodenumber", 33665}, + {"setclientowner", 33666}, + {"setotherent", 33667}, + {"setaisightlinevisible", 33668}, + {"setentityowner", 33669}, + {"nodeisdisconnected", 33670}, + {"getnearestnode", 33671}, + {"makeentitynomeleetarget", 33672}, + {"spawnagent", 33674}, + {"finishagentdamage", 33675}, + {"setagentattacker", 33676}, + {"cloneagent", 33677}, + {"agentcanseesentient", 33678}, + {"setagentwaypoint", 33679}, + {"setgoalpos", 33680}, + {"getgoalpos", 33681}, + {"setgoalnode", 33682}, + {"setgoalentity", 33683}, + {"setgoalradius", 33684}, + {"setanimscale", 33685}, + {"setorientmode", 33686}, + {"setanimmode", 33687}, + {"setphysicsmode", 33688}, + {"setclipmode", 33689}, + {"setmaxturnspeed", 33690}, + {"getmaxturnspeed", 33691}, + {"beginmelee", 33692}, + {"setscripted", 33693}, + {"dotrajectory", 33694}, + {"doanimlerp", 33695}, + {"setviewheight", 33696}, + {"claimnode", 33697}, + {"relinquishclaimednode", 33698}, + {"setradarping", 33699}, + {"visitfxent", 33700}, + {"sub_1402ef480", 33701}, + {"sub_1402ef4e0", 33702}, + {"sub_1402dd560", 33704}, + {"sub_1402dd590", 33705}, + {"allowhighjump", 33714}, + {"isjumping", 33715}, + {"ishighjumping", 33716}, + {"sub_140529a10", 33717}, + {"sub_140529a20", 33718}, + {"getbraggingright", 33719}, + {"getmodelfromentity", 33720}, + {"getweaponheatlevel", 33721}, + {"isweaponoverheated", 33722}, + {"isshiftbuttonpresseddown", 33723}, + {"sub_14052be00", 33724}, + {"sub_14052beb0", 33725}, + {"sub_14052bf30", 33726}, + {"lightsetforplayer", 33728}, + {"lightsetoverrideenableforplayer", 33729}, + {"lightsetoverridedisableforplayer", 33730}, + {"sub_140333c10", 33731}, + {"sub_140043710", 33732}, + {"sub_14052b420", 33733}, + {"sub_1402ddd70", 33734}, + {"setanimclass", 33744}, + {"enableanimstate", 33745}, + {"setanimstate", 33746}, + {"getanimentry", 33747}, + {"getanimentryname", 33748}, + {"getanimentryalias", 33749}, + {"getanimentrycount", 33750}, + {"issprinting", 33752}, + {"jumpbuttonpressed", 33758}, + {"rotateby", 33759}, + {"getlookaheaddir", 33760}, + {"getpathgoalpos", 33761}, + {"sub_140316940", 33762}, + {"setcorpsefalling", 33763}, + {"setsurfacetype", 33764}, + {"aiphysicstrace", 33765}, + {"aiphysicstracepassed", 33766}, + {"visionsetstage", 33770}, + {"linkwaypointtotargetwithoffset", 33771}, + {"getlinkedparent", 33772}, + {"getmovingplatformparent", 33773}, + {"setnameplatematerial", 33774}, + {"sub_140313d20", 33777}, + {"sub_1403131d0", 33778}, + {"makevehiclenotcollidewithplayers", 33779}, + {"setscriptablepartstate", 33782}, + {"stopsliding", 33783}, + {"sub_140316a60", 33784}, + {"setdronegoalpos", 33785}, + {"hudoutlineenable", 33786}, + {"hudoutlinedisable", 33787}, + {"worldpointtoscreenpos", 33792}, + {"botfirstavailablegrenade", 33795}, + {"emissiveblend", 33801}, + {"sub_1402e66d0", 33804}, + {"sub_1402e66e0", 33805}, + {"sub_1402e66f0", 33806}, + {"physicssetmaxlinvel", 33810}, + {"physicssetmaxangvel", 33811}, + {"physicsgetlinvel", 33812}, + {"physicsgetlinspeed", 33813}, + {"physicsgetangvel", 33814}, + {"physicsgetangspeed", 33815}, + {"disablemissileboosting", 33816}, + {"enablemissileboosting", 33817}, + {"canspawntestclient", 33818}, + {"spawntestclient", 33819}, + {"loadcustomizationplayerview", 33820}, + {"setgrenadethrowscale", 33821}, + {"setgrenadecookscale", 33822}, + {"setplanesplineid", 33823}, + {"hudoutlineenableforclient", 33824}, + {"hudoutlinedisableforclient", 33825}, + {"hudoutlineenableforclients", 33826}, + {"hudoutlinedisableforclients", 33827}, + {"turretsetbarrelspinenabled", 33828}, + {"hasloadedcustomizationplayerview", 33829}, + {"sub_140313420", 33830}, + {"sub_1403136f0", 33831}, + {"doanimrelative", 33832}, + {"getcorpseentity", 33836}, + {"logmatchdatalife", 33838}, + {"logmatchdatadeath", 33839}, + {"queuedialogforplayer", 33840}, + {"setmlgcameradefaults", 33841}, + {"ismlgspectator", 33842}, + {"disableautoreload", 33843}, + {"enableautoreload", 33844}, + {"getlinkedchildren", 33846}, + {"botpredictenemycampspots", 33847}, + {"playsoundonmovingent", 33848}, + {"cancelmantle", 33849}, + {"hasfemalecustomizationmodel", 33850}, + {"sub_1402e6bb0", 33851}, + {"setscriptabledamageowner", 33852}, + {"setfxkilldefondelete", 33853}, + {"sub_1402e1b80", 33856}, + {"sub_140310fb0", 33858}, + {"challengenotification", 33859}, + {"sub_140528300", 33860}, + {"sub_14052bff0", 33861}, + {"linktosynchronizedparent", 33862}, + {"getclientomnvar", 33863}, + {"getcacplayerdataforgroup", 33866}, + {"cloakingenable", 33867}, + {"cloakingdisable", 33868}, + {"getunnormalizedcameramovement", 33869}, + {"sub_14031edf0", 33870}, + {"isturretoverheated", 33871}, + {"sub_14052c170", 33872}, + {"sub_14052c190", 33873}, + {"sub_14052c1b0", 33874}, + {"sub_14052c1d0", 33875}, + {"sub_14052c0b0", 33878}, + {"sub_1402de140", 33879}, + {"getvieworigin", 33884}, + {"setweaponmodelvariant", 33885}, + {"ridevehicle", 33886}, + {"stopridingvehicle", 33887}, + {"autoboltmissileeffects", 33889}, + {"disablemissilestick", 33890}, + {"enablemissilestick", 33891}, + {"setmissileminimapvisible", 33892}, + {"isoffhandweaponreadytothrow", 33893}, + {"makecollidewithitemclip", 33895}, + {"visionsetpostapplyforplayer", 33897}, + {"setlookattarget", 33898}, + {"clearlookattarget", 33899}, + {"sub_14052c250", 33907}, + {"sub_14052c290", 33908}, + {"sub_14052c2f0", 33909}, + {"sub_14052c340", 33910}, + {"sub_14052c360", 33911}, + {"sub_14031c170", 33912}, + {"sub_14031c590", 33913}, + {"setclienttriggervisionset", 33914}, + {"sub_1402e41c0", 33917}, + {"sub_1402e43b0", 33918}, + {"sub_14052b4d0", 33919}, + {"sub_14052b550", 33920}, + {"showviewmodel", 33921}, + {"hideviewmodel", 33922}, + {"setpickupweapon", 33923}, + {"allowpowerslide", 33925}, + {"allowhighjumpdrop", 33926}, + {"sub_1404045e0", 33927}, + {"sub_1405297e0", 33928}, + {"sub_14052c200", 33929}, + {"clearentity", 33930}, + {"sub_140334a40", 33931}, + {"allowdodge", 33933}, + {"sub_140529860", 33934}, + {"setminimapvisible", 33935}, + {"sub_1402e0a90", 33936}, + {"sub_1402e0bc0", 33937}, + {"sub_1402e0cf0", 33938}, + {"setplayermech", 33940}, + {"setdamagecallbackon", 33941}, + {"finishentitydamage", 33942}, + {"designatefoftarget", 33946}, + {"sethintstringvisibleonlytoowner", 33947}, + {"notifyonplayercommandremove", 33948}, + {"sub_1402e3bf0", 33949}, + {"allowboostjump", 33950}, + {"batterydischargebegin", 33951}, + {"batterydischargeend", 33952}, + {"batterydischargeonce", 33953}, + {"batterygetcharge", 33954}, + {"batterysetcharge", 33955}, + {"batteryfullrecharge", 33956}, + {"batterygetsize", 33957}, + {"batterysetdischargescale", 33958}, + {"batterygetdischargerate", 33959}, + {"batteryisinuse", 33960}, + {"enablephysicaldepthoffieldscripting", 33961}, + {"disablephysicaldepthoffieldscripting", 33962}, + {"setphysicaldepthoffield", 33963}, + {"sub_140313860", 33964}, + {"sub_14052a560", 33965}, + {"sub_140321790", 33966}, + {"sub_140321a50", 33967}, + {"sub_1402dda50", 33968}, + {"sub_14052ac50", 33969}, + {"sub_14052ad50", 33970}, + {"setdemigod", 33971}, + {"sub_140310840", 33972}, + {"setcostumemodels", 33978}, + {"sub_140529e00", 33979}, + {"sub_140313510", 33980}, + {"scriptmodelpauseanim", 33981}, + {"digitaldistortsetmaterial", 33982}, + {"disableoffhandsecondaryweapons", 33983}, + {"enableoffhandsecondaryweapons", 33984}, + {"canplaceriotshield", 33985}, + {"setriotshieldfailhint", 33986}, + {"enabledetonate", 33987}, + {"getdetonateenabled", 33988}, + {"playergetuseent", 33989}, + {"refreshshieldmodels", 33990}, + {"sub_14052c3a0", 33991}, + {"locret_140406a70", 33993}, + {"getgravity", 33994}, + {"sub_140529560", 33997}, + {"sub_140529650", 33998}, + {"setcommonplayerdatareservedint", 33999}, + {"getrankedplayerdatareservedint", 34000}, + {"setrankedplayerdatareservedint", 34001}, + {"getcommonplayerdatareservedint", 34002}, + {"sub_1402e8a20", 34003}, + {"sub_14052c3c0", 34004}, + {"addsoundmutedevice", 34005}, + {"removesoundmutedevice", 34006}, + {"clientaddsoundsubmix", 34007}, + {"clientclearsoundsubmix", 34008}, + {"sub_140312520", 34009}, + {"sub_140312ba0", 34010}, + {"sub_140312bf0", 34011}, + {"sub_140312cb0", 34012}, + {"sub_140312df0", 34013}, + {"sub_140312ff0", 34014}, + {"isusingoffhand", 34016}, + {"physicsstop", 34017}, + {"sub_14031b9e0", 34018}, + {"sub_14031e3c0", 34023}, + {"sub_1402ef8a0", 34024}, + {"sub_14052c400", 34025}, + {"initwaterclienttrigger", 34026}, + {"getcurrentweaponmodelname", 34027}, + {"sub_14031f000", 34028}, + {"setignorefoliagesightingme", 34030}, + {"loadcostumemodels", 34031}, + {"sub_14030cd90", 34036}, + {"sub_14030b1c0", 34038}, + {"sub_140322450", 34039}, + {"iscloaked", 34040}, + {"sub_140528bc0", 34041}, + {"sub_140528cf0", 34042}, + {"sub_14031fb80", 34043}, + {"sub_140320180", 34044}, + {"selfieaccessselfievalidflaginplayerdef", 34045}, + {"selfieaccessselfiecustomassetsarestreamed", 34046}, + {"sub_14031ede0", 34048}, + {"selfiescreenshottaken", 34049}, + {"sub_14031f190", 34050}, + {"sub_140319de0", 34052}, + {"setmissilecoasting", 34053}, + {"setmlgspectator", 34054}, + {"gettotalmpxp", 34055}, + {"turretsetgroundaimentity", 34056}, + {"sub_140318610", 34057}, + {"sub_140317760", 34058}, + {"sub_14032e9a0", 34059}, + {"sub_140320830", 34060}, + {"sub_140329bc0", 34061}, + {"sub_14032e370", 34062}, + {"consumereinforcement", 34063}, + {"ghost", 34064}, + {"loadweapons", 34065}, + {"sub_1402e0e80", 34067}, + {"setwaypointiconfadeatcenter", 34068}, + {"setreinforcementhintstrings", 34069}, + {"playgoliathentryanim", 34070}, + {"playgoliathtoidleanim", 34071}, + {"sub_140312210", 34072}, + {"sub_140312280", 34073}, + {"sub_140321660", 34074}, + {"playlocalannouncersound", 34075}, + {"setmissilespecialclipmask", 34076}, + {"sub_140527c40", 34077}, + {"sub_140527c60", 34078}, + {"isdodging", 34079}, + {"ispowersliding", 34080}, + {"sub_140320ab0", 34081}, + {"getcurrentping", 34082}, + {"sub_1402eeb60", 34083}, + {"sub_140329390", 34084}, + {"gethordeplayerdata", 34085}, + {"sethordeplayerdata", 34086}, + {"sub_1402dcbc0", 34087}, + {"sub_14031a0b0", 34088}, + {"sub_1403198a0", 34089}, + {"sub_1403345e0", 34090}, + {"sub_1402e7d80", 34092}, + {"sub_140404f00", 34093}, + {"issplitscreenplayer2", 34095}, + {"setowneroriginal", 34096}, + {"getlinkedtagname", 34097}, + {"sub_14032de80", 34098}, + {"sub_14032dfb0", 34099}, + {"setwaypointaerialtargeting", 34100}, + {"worldweaponsloaded", 34101}, + {"sub_140320aa0", 34102}, + {"usetriggertouchcheckstance", 34103}, + {"onlystreamactiveweapon", 34104}, + {"precachekillcamiconforweapon", 34105}, + {"selfierequestupdate", 34106}, + {"getclanwarsbonus", 34107}, + {"sub_140406810", 34108}, + {"sub_1404051d0", 34109}, + {"sub_140406340", 34110}, + {"sub_1402e72a0", 34111}, + {"sub_140404c70", 34112}, + {"sub_1404065c0", 34113}, + {"sub_140405c60", 34114}, + {"sub_140406400", 34115}, + {"sub_140406230", 34116}, + {"sub_140406650", 34117}, + {"sub_1402e7de0", 34118}, + {"sub_140333550", 34119}, + {"sub_140403fe0", 34120}, + {"sub_140320360", 34121}, + {"canhighjump", 34122}, + {"setprestigemastery", 34123}, + {"sub_140403f50", 34124}, + {"sub_14030c7b0", 34125}, + {"sub_1403206b0", 34126}, + {"sub_140329960", 34127}, + {"sub_140328100", 34128}, + {"sub_140405990", 34129}, + {"sub_1402e70c0", 34130}, + {"sub_1403335f0", 34131}, + {"getcoopplayerdatareservedint", 34132}, + {"setcoopplayerdatareservedint", 34133}, + {"sub_140406b50", 34134}, + {"sub_1402de070", 34135}, + {"sub_1402e7e40", 34136}, + {"sub_140329ba0", 34137}, + {"sub_140405af0", 34138}, + {"sub_1402e7240", 34139}, + {"sub_14031a370", 34140}, + {"sub_140406970", 34141}, + {"sub_140405b60", 34142}, + {"sub_140334e10", 34143}, + {"sub_140320a90", 34144}, + {"sub_140406c00", 34145}, + {"sub_140328bf0", 34146}, + {"sub_1404053e0", 34147}, + {"sub_140406d20", 34148}, + {"sub_14032c900", 34149}, + {"sub_14032c9e0", 34150}, + {"sub_140044360", 34151}, + {"sub_140333680", 34152}, + {"sub_1402e7130", 34153}, + {"sub_1403294b0", 34154}, + {"sub_140320b40", 34155}, + {"sub_140333710", 34156}, + }; +} diff --git a/src/game/scripting/functions.cpp b/src/game/scripting/functions.cpp new file mode 100644 index 00000000..a904cee7 --- /dev/null +++ b/src/game/scripting/functions.cpp @@ -0,0 +1,81 @@ +#include +#include "functions.hpp" + +#include + +namespace scripting +{ + namespace + { + std::unordered_map lowercase_map( + const std::unordered_map& old_map) + { + std::unordered_map new_map{}; + for (auto& entry : old_map) + { + new_map[utils::string::to_lower(entry.first)] = entry.second; + } + + return new_map; + } + + const std::unordered_map& get_methods() + { + static auto methods = lowercase_map(method_map); + return methods; + } + + const std::unordered_map& get_functions() + { + static auto function = lowercase_map(function_map); + return function; + } + + int find_function_index(const std::string& name, const bool prefer_global) + { + const auto target = utils::string::to_lower(name); + + const auto& primary_map = prefer_global + ? get_functions() + : get_methods(); + const auto& secondary_map = !prefer_global + ? get_functions() + : get_methods(); + + auto function_entry = primary_map.find(target); + if (function_entry != primary_map.end()) + { + return function_entry->second; + } + + function_entry = secondary_map.find(target); + if (function_entry != secondary_map.end()) + { + return function_entry->second; + } + + return -1; + } + + script_function get_function_by_index(const unsigned index) + { + static const auto function_table = 0xB153F90; + static const auto method_table = 0xB155890; + + if (index < 0x2DF) + { + return reinterpret_cast(game::base_address + function_table)[index]; + } + + return reinterpret_cast(game::base_address + method_table)[index]; + } + } + + script_function find_function(const std::string& name, const bool prefer_global) + { + const auto index = find_function_index(name, prefer_global); + if (index < 0) return nullptr; + + return get_function_by_index(index); + } +} diff --git a/src/game/scripting/functions.hpp b/src/game/scripting/functions.hpp new file mode 100644 index 00000000..b49d2feb --- /dev/null +++ b/src/game/scripting/functions.hpp @@ -0,0 +1,12 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + extern std::unordered_map method_map; + extern std::unordered_map function_map; + + using script_function = void(*)(game::scr_entref_t); + + script_function find_function(const std::string& name, const bool prefer_global); +} diff --git a/src/game/scripting/lua/context.cpp b/src/game/scripting/lua/context.cpp new file mode 100644 index 00000000..551f3f60 --- /dev/null +++ b/src/game/scripting/lua/context.cpp @@ -0,0 +1,240 @@ +#include +#include "context.hpp" +#include "error.hpp" +#include "value_conversion.hpp" + +#include "../execution.hpp" +#include "../functions.hpp" + +#include "../../../component/command.hpp" + +#include + +namespace scripting::lua +{ + namespace + { + void setup_entity_type(sol::state& state, event_handler& handler, scheduler& scheduler) + { + state["level"] = entity{*game::levelEntityId}; + + auto vector_type = state.new_usertype("vector", sol::constructors()); + vector_type["x"] = sol::property(&vector::get_x, &vector::set_x); + vector_type["y"] = sol::property(&vector::get_y, &vector::set_y); + vector_type["z"] = sol::property(&vector::get_z, &vector::set_z); + + vector_type["r"] = sol::property(&vector::get_x, &vector::set_x); + vector_type["g"] = sol::property(&vector::get_y, &vector::set_y); + vector_type["b"] = sol::property(&vector::get_z, &vector::set_z); + + auto entity_type = state.new_usertype("entity"); + + for (const auto& func : method_map) + { + const auto name = utils::string::to_lower(func.first); + entity_type[name.data()] = [name](const entity& entity, const sol::this_state s, sol::variadic_args va) + { + std::vector arguments{}; + + for (auto arg : va) + { + arguments.push_back(convert({s, arg})); + } + + return convert(s, entity.call(name, arguments)); + }; + } + + entity_type["set"] = [](const entity& entity, const std::string& field, + const sol::lua_value& value) + { + entity.set(field, convert(value)); + }; + + entity_type["get"] = [](const entity& entity, const sol::this_state s, const std::string& field) + { + return convert(s, entity.get(field)); + }; + + entity_type["notify"] = [](const entity& entity, const sol::this_state s, const std::string& event, + sol::variadic_args va) + { + std::vector arguments{}; + + for (auto arg : va) + { + arguments.push_back(convert({s, arg})); + } + + notify(entity, event, arguments); + }; + + entity_type["onnotify"] = [&handler](const entity& entity, const std::string& event, + const event_callback& callback) + { + event_listener listener{}; + listener.callback = callback; + listener.entity = entity; + listener.event = event; + listener.is_volatile = false; + + return handler.add_event_listener(std::move(listener)); + }; + + entity_type["onnotifyonce"] = [&handler](const entity& entity, const std::string& event, + const event_callback& callback) + { + event_listener listener{}; + listener.callback = callback; + listener.entity = entity; + listener.event = event; + listener.is_volatile = true; + + return handler.add_event_listener(std::move(listener)); + }; + + entity_type["call"] = [](const entity& entity, const sol::this_state s, const std::string& function, + sol::variadic_args va) + { + std::vector arguments{}; + + for (auto arg : va) + { + arguments.push_back(convert({s, arg})); + } + + return convert(s, entity.call(function, arguments)); + }; + + entity_type[sol::meta_function::new_index] = [](const entity& entity, const std::string& field, + const sol::lua_value& value) + { + entity.set(field, convert(value)); + }; + + entity_type[sol::meta_function::index] = [](const entity& entity, const sol::this_state s, const std::string& field) + { + return convert(s, entity.get(field)); + }; + + struct game + { + }; + auto game_type = state.new_usertype("game_"); + state["game"] = game(); + + for (const auto& func : function_map) + { + const auto name = utils::string::to_lower(func.first); + game_type[name] = [name](const game&, const sol::this_state s, sol::variadic_args va) + { + std::vector arguments{}; + + for (auto arg : va) + { + arguments.push_back(convert({s, arg})); + } + + return convert(s, call(name, arguments)); + }; + } + + game_type["call"] = [](const game&, const sol::this_state s, const std::string& function, + sol::variadic_args va) + { + std::vector arguments{}; + + for (auto arg : va) + { + arguments.push_back(convert({s, arg})); + } + + return convert(s, call(function, arguments)); + }; + + game_type["ontimeout"] = [&scheduler](const game&, const sol::protected_function& callback, + const long long milliseconds) + { + return scheduler.add(callback, milliseconds, true); + }; + + game_type["oninterval"] = [&scheduler](const game&, const sol::protected_function& callback, + const long long milliseconds) + { + return scheduler.add(callback, milliseconds, false); + }; + + game_type["executecommand"] = [](const game&, const std::string& command) + { + command::execute(command, false); + }; + } + } + + context::context(std::string folder) + : folder_(std::move(folder)) + , scheduler_(state_) + , event_handler_(state_) + + { + this->state_.open_libraries(sol::lib::base, + sol::lib::package, + sol::lib::io, + sol::lib::string, + sol::lib::os, + sol::lib::math, + sol::lib::table); + + this->state_["include"] = [this](const std::string& file) + { + this->load_script(file); + }; + + sol::function old_require = this->state_["require"]; + auto base_path = utils::string::replace(this->folder_, "/", ".") + "."; + this->state_["require"] = [base_path, old_require](const std::string& path) + { + return old_require(base_path + path); + }; + + this->state_["scriptdir"] = [this]() + { + return this->folder_; + }; + + setup_entity_type(this->state_, this->event_handler_, this->scheduler_); + + printf("Loading script '%s'\n", this->folder_.data()); + this->load_script("__init__"); + } + + context::~context() + { + this->state_.collect_garbage(); + this->scheduler_.clear(); + this->event_handler_.clear(); + this->state_ = {}; + } + + void context::run_frame() + { + this->scheduler_.run_frame(); + this->state_.collect_garbage(); + } + + void context::notify(const event& e) + { + this->event_handler_.dispatch(e); + } + + void context::load_script(const std::string& script) + { + if (!this->loaded_scripts_.emplace(script).second) + { + return; + } + + const auto file = (std::filesystem::path{this->folder_} / (script + ".lua")).generic_string(); + handle_error(this->state_.safe_script_file(file, &sol::script_pass_on_error)); + } +} diff --git a/src/game/scripting/lua/context.hpp b/src/game/scripting/lua/context.hpp new file mode 100644 index 00000000..336d7ff6 --- /dev/null +++ b/src/game/scripting/lua/context.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include "../event.hpp" + +#define SOL_ALL_SAFETIES_ON 1 +#define SOL_PRINT_ERRORS 0 +#include + +#include "scheduler.hpp" +#include "event_handler.hpp" + +namespace scripting::lua +{ + class context + { + public: + context(std::string folder); + ~context(); + + context(context&&) noexcept = delete; + context& operator=(context&&) noexcept = delete; + + context(const context&) = delete; + context& operator=(const context&) = delete; + + void run_frame(); + void notify(const event& e); + + private: + sol::state state_{}; + std::string folder_; + std::unordered_set loaded_scripts_; + + scheduler scheduler_; + event_handler event_handler_; + + void load_script(const std::string& script); + }; +} diff --git a/src/game/scripting/lua/engine.cpp b/src/game/scripting/lua/engine.cpp new file mode 100644 index 00000000..983f823c --- /dev/null +++ b/src/game/scripting/lua/engine.cpp @@ -0,0 +1,67 @@ +#include +#include "engine.hpp" +#include "context.hpp" + +#include "../execution.hpp" + +#include + +namespace scripting::lua::engine +{ + namespace + { + auto& get_scripts() + { + static std::vector> scripts{}; + return scripts; + } + + void load_scripts() + { + const auto script_dir = "scripts/"s; + + if (!utils::io::directory_exists(script_dir)) + { + return; + } + + const auto scripts = utils::io::list_files(script_dir); + + for (const auto& script : scripts) + { + if (std::filesystem::is_directory(script) && utils::io::file_exists(script + "/__init__.lua")) + { + get_scripts().push_back(std::make_unique(script)); + } + } + } + } + + void start() + { + clear_custom_fields(); + get_scripts().clear(); + load_scripts(); + } + + void stop() + { + get_scripts().clear(); + } + + void notify(const event& e) + { + for (auto& script : get_scripts()) + { + script->notify(e); + } + } + + void run_frame() + { + for (auto& script : get_scripts()) + { + script->run_frame(); + } + } +} diff --git a/src/game/scripting/lua/engine.hpp b/src/game/scripting/lua/engine.hpp new file mode 100644 index 00000000..471316cd --- /dev/null +++ b/src/game/scripting/lua/engine.hpp @@ -0,0 +1,11 @@ +#pragma once + +#include "../event.hpp" + +namespace scripting::lua::engine +{ + void start(); + void stop(); + void notify(const event& e); + void run_frame(); +} diff --git a/src/game/scripting/lua/error.cpp b/src/game/scripting/lua/error.cpp new file mode 100644 index 00000000..a71efef5 --- /dev/null +++ b/src/game/scripting/lua/error.cpp @@ -0,0 +1,37 @@ +#include +#include "error.hpp" +#include "../execution.hpp" + +#include "component/game_console.hpp" + +namespace scripting::lua +{ + namespace + { + void notify_error() + { + try + { + call("iprintln", {"^1Script execution error!"}); + } + catch (...) + { + } + } + } + + void handle_error(const sol::protected_function_result& result) + { + if (!result.valid()) + { + game_console::print(game_console::con_type_error, "************** Script execution error **************\n"); + + const sol::error err = result; + game_console::print(game_console::con_type_error, "%s\n", err.what()); + + game_console::print(game_console::con_type_error, "****************************************************\n"); + + notify_error(); + } + } +} diff --git a/src/game/scripting/lua/error.hpp b/src/game/scripting/lua/error.hpp new file mode 100644 index 00000000..dab56bee --- /dev/null +++ b/src/game/scripting/lua/error.hpp @@ -0,0 +1,8 @@ +#pragma once + +#include "context.hpp" + +namespace scripting::lua +{ + void handle_error(const sol::protected_function_result& result); +} diff --git a/src/game/scripting/lua/event_handler.cpp b/src/game/scripting/lua/event_handler.cpp new file mode 100644 index 00000000..2b02a509 --- /dev/null +++ b/src/game/scripting/lua/event_handler.cpp @@ -0,0 +1,119 @@ +#include "stdinc.hpp" +#include "context.hpp" +#include "error.hpp" +#include "value_conversion.hpp" + +namespace scripting::lua +{ + event_handler::event_handler(sol::state& state) + : state_(state) + { + auto event_listener_handle_type = state.new_usertype("event_listener_handle"); + + event_listener_handle_type["clear"] = [this](const event_listener_handle& handle) + { + this->remove(handle); + }; + } + + void event_handler::dispatch(const event& event) + { + std::vector arguments; + + for (const auto& argument : event.arguments) + { + arguments.emplace_back(convert(this->state_, argument)); + } + + this->dispatch_to_specific_listeners(event, arguments); + } + + void event_handler::dispatch_to_specific_listeners(const event& event, + const event_arguments& arguments) + { + callbacks_.access([&](task_list& tasks) + { + this->merge_callbacks(); + + for (auto i = tasks.begin(); i != tasks.end();) + { + if (i->event != event.name || i->entity != event.entity) + { + ++i; + continue; + } + + if (!i->is_deleted) + { + handle_error(i->callback(sol::as_args(arguments))); + } + + if (i->is_volatile || i->is_deleted) + { + i = tasks.erase(i); + } + else + { + ++i; + } + } + }); + } + + event_listener_handle event_handler::add_event_listener(event_listener&& listener) + { + const uint64_t id = ++this->current_listener_id_; + listener.id = id; + listener.is_deleted = false; + + new_callbacks_.access([&listener](task_list& tasks) + { + tasks.emplace_back(std::move(listener)); + }); + + return {id}; + } + + void event_handler::clear() + { + callbacks_.access([&](task_list& tasks) + { + new_callbacks_.access([&](task_list& new_tasks) + { + new_tasks.clear(); + tasks.clear(); + }); + }); + } + + void event_handler::remove(const event_listener_handle& handle) + { + auto mask_as_deleted = [&](task_list& tasks) + { + for (auto& task : tasks) + { + if (task.id == handle.id) + { + task.is_deleted = true; + break; + } + } + }; + + callbacks_.access(mask_as_deleted); + new_callbacks_.access(mask_as_deleted); + } + + void event_handler::merge_callbacks() + { + callbacks_.access([&](task_list& tasks) + { + new_callbacks_.access([&](task_list& new_tasks) + { + tasks.insert(tasks.end(), std::move_iterator(new_tasks.begin()), + std::move_iterator(new_tasks.end())); + new_tasks = {}; + }); + }); + } +} diff --git a/src/game/scripting/lua/event_handler.hpp b/src/game/scripting/lua/event_handler.hpp new file mode 100644 index 00000000..ca554286 --- /dev/null +++ b/src/game/scripting/lua/event_handler.hpp @@ -0,0 +1,54 @@ +#pragma once + +namespace scripting::lua +{ + using event_arguments = std::vector; + using event_callback = sol::protected_function; + + class event_listener_handle + { + public: + uint64_t id = 0; + }; + + class event_listener final : public event_listener_handle + { + public: + std::string event = {}; + entity entity{}; + event_callback callback = {}; + bool is_volatile = false; + bool is_deleted = false; + }; + + class event_handler final + { + public: + event_handler(sol::state& state); + + event_handler(event_handler&&) noexcept = delete; + event_handler& operator=(event_handler&&) noexcept = delete; + + event_handler(const scheduler&) = delete; + event_handler& operator=(const event_handler&) = delete; + + void dispatch(const event& event); + + event_listener_handle add_event_listener(event_listener&& listener); + + void clear(); + + private: + sol::state& state_; + std::atomic_int64_t current_listener_id_ = 0; + + using task_list = std::vector; + utils::concurrency::container new_callbacks_; + utils::concurrency::container callbacks_; + + void dispatch_to_specific_listeners(const event& event, const event_arguments& arguments); + + void remove(const event_listener_handle& handle); + void merge_callbacks(); + }; +} diff --git a/src/game/scripting/lua/scheduler.cpp b/src/game/scripting/lua/scheduler.cpp new file mode 100644 index 00000000..781e5cab --- /dev/null +++ b/src/game/scripting/lua/scheduler.cpp @@ -0,0 +1,122 @@ +#include "stdinc.hpp" +#include "context.hpp" +#include "error.hpp" + +namespace scripting::lua +{ + scheduler::scheduler(sol::state& state) + { + auto task_handle_type = state.new_usertype("task_handle"); + + task_handle_type["clear"] = [this](const task_handle& handle) + { + this->remove(handle); + }; + } + + void scheduler::run_frame() + { + callbacks_.access([&](task_list& tasks) + { + this->merge_callbacks(); + + for (auto i = tasks.begin(); i != tasks.end();) + { + const auto now = std::chrono::high_resolution_clock::now(); + const auto diff = now - i->last_call; + + if (diff < i->delay) + { + ++i; + continue; + } + + i->last_call = now; + + if (!i->is_deleted) + { + handle_error(i->callback()); + } + + if (i->is_volatile || i->is_deleted) + { + i = tasks.erase(i); + } + else + { + ++i; + } + } + }); + } + + void scheduler::clear() + { + callbacks_.access([&](task_list& tasks) + { + new_callbacks_.access([&](task_list& new_tasks) + { + new_tasks.clear(); + tasks.clear(); + }); + }); + } + + task_handle scheduler::add(const sol::protected_function& callback, const long long milliseconds, + const bool is_volatile) + { + return this->add(callback, std::chrono::milliseconds(milliseconds), is_volatile); + } + + task_handle scheduler::add(const sol::protected_function& callback, const std::chrono::milliseconds delay, + const bool is_volatile) + { + const uint64_t id = ++this->current_task_id_; + + task task; + task.is_volatile = is_volatile; + task.callback = callback; + task.delay = delay; + task.last_call = std::chrono::steady_clock::now(); + task.id = id; + task.is_deleted = false; + + new_callbacks_.access([&task](task_list& tasks) + { + tasks.emplace_back(std::move(task)); + }); + + return {id}; + } + + void scheduler::remove(const task_handle& handle) + { + auto mask_as_deleted = [&](task_list& tasks) + { + for (auto& task : tasks) + { + if (task.id == handle.id) + { + task.is_deleted = true; + break; + } + } + }; + + callbacks_.access(mask_as_deleted); + new_callbacks_.access(mask_as_deleted); + } + + void scheduler::merge_callbacks() + { + callbacks_.access([&](task_list& tasks) + { + new_callbacks_.access([&](task_list& new_tasks) + { + tasks.insert(tasks.end(), std::move_iterator(new_tasks.begin()), + std::move_iterator(new_tasks.end())); + new_tasks = {}; + }); + }); + } +} diff --git a/src/game/scripting/lua/scheduler.hpp b/src/game/scripting/lua/scheduler.hpp new file mode 100644 index 00000000..a939d65f --- /dev/null +++ b/src/game/scripting/lua/scheduler.hpp @@ -0,0 +1,50 @@ +#pragma once +#include + +namespace scripting::lua +{ + class context; + + class task_handle + { + public: + uint64_t id = 0; + }; + + class task final : public task_handle + { + public: + std::chrono::steady_clock::time_point last_call{}; + sol::protected_function callback{}; + std::chrono::milliseconds delay{}; + bool is_volatile = false; + bool is_deleted = false; + }; + + class scheduler final + { + public: + scheduler(sol::state& state); + + scheduler(scheduler&&) noexcept = delete; + scheduler& operator=(scheduler&&) noexcept = delete; + + scheduler(const scheduler&) = delete; + scheduler& operator=(const scheduler&) = delete; + + void run_frame(); + void clear(); + + task_handle add(const sol::protected_function& callback, long long milliseconds, bool is_volatile); + task_handle add(const sol::protected_function& callback, std::chrono::milliseconds delay, bool is_volatile); + + private: + using task_list = std::vector; + utils::concurrency::container new_callbacks_; + utils::concurrency::container callbacks_; + std::atomic_int64_t current_task_id_ = 0; + + void remove(const task_handle& handle); + void merge_callbacks(); + }; +} diff --git a/src/game/scripting/lua/value_conversion.cpp b/src/game/scripting/lua/value_conversion.cpp new file mode 100644 index 00000000..5b6778a6 --- /dev/null +++ b/src/game/scripting/lua/value_conversion.cpp @@ -0,0 +1,192 @@ +#include +#include "value_conversion.hpp" + +namespace scripting::lua +{ + /*namespace + { + struct array_value + { + int index; + script_value value; + }; + + sol::lua_value entity_to_array(lua_State* state, unsigned int id) + { + auto table = sol::table::create(state); + auto metatable = sol::table::create(state); + + std::unordered_map values; + + const auto offset = 64000 * (id & 3); + + auto current = game::scr_VarGlob->objectVariableChildren[id].firstChild; + auto idx = 1; + + for (auto i = offset + current; current; i = offset + current) + { + const auto var = game::scr_VarGlob->childVariableValue[i]; + + if (var.type == game::SCRIPT_NONE) + { + current = var.nextSibling; + continue; + } + + const auto string_value = (game::scr_string_t)((unsigned __int8)var.name_lo + (var.k.keys.name_hi << 8)); + const auto* str = game::SL_ConvertToString(string_value); + + std::string key = string_value < 0x40000 && str + ? str + : std::to_string(idx++); + + game::VariableValue variable{}; + variable.type = var.type; + variable.u = var.u.u; + + array_value value; + value.index = i; + value.value = variable; + + values[key] = value; + + current = var.nextSibling; + } + + table["getkeys"] = [values]() + { + std::vector _keys; + + for (const auto& entry : values) + { + _keys.push_back(entry.first); + } + + return _keys; + }; + + metatable[sol::meta_function::new_index] = [values](const sol::table t, const sol::this_state s, + const sol::lua_value& key_value, const sol::lua_value& value) + { + const auto key = key_value.is() + ? std::to_string(key_value.as()) + : key_value.as(); + + if (values.find(key) == values.end()) + { + return; + } + + const auto variable = convert({s, value}).get_raw(); + const auto i = values.at(key).index; + + game::scr_VarGlob->childVariableValue[i].type = (char)variable.type; + game::scr_VarGlob->childVariableValue[i].u.u = variable.u; + }; + + metatable[sol::meta_function::index] = [values](const sol::table t, const sol::this_state s, + const sol::lua_value& key_value) + { + const auto key = key_value.is() + ? std::to_string(key_value.as()) + : key_value.as(); + + if (values.find(key) == values.end()) + { + return sol::lua_value{}; + } + + return convert(s, values.at(key).value); + }; + + metatable[sol::meta_function::length] = [values]() + { + return values.size(); + }; + + table[sol::metatable_key] = metatable; + + return {state, table}; + } + }*/ + + script_value convert(const sol::lua_value& value) + { + if (value.is()) + { + return {value.as()}; + } + + if (value.is()) + { + return {value.as()}; + } + + if (value.is()) + { + return {value.as()}; + } + + if (value.is()) + { + return {value.as()}; + } + + if (value.is()) + { + return {value.as()}; + } + + if (value.is()) + { + return {value.as()}; + } + + if (value.is()) + { + return {value.as()}; + } + + if (value.is()) + { + return {value.as()}; + } + + return {}; + } + + sol::lua_value convert(lua_State* state, const script_value& value) + { + if (value.is()) + { + return {state, value.as()}; + } + + if (value.is()) + { + return {state, value.as()}; + } + + if (value.is()) + { + return {state, value.as()}; + } + + /*if (value.is>()) + { + return entity_to_array(state, value.get_raw().u.uintValue); + }*/ + + if (value.is()) + { + return {state, value.as()}; + } + + if (value.is()) + { + return {state, value.as()}; + } + + return {}; + } +} diff --git a/src/game/scripting/lua/value_conversion.hpp b/src/game/scripting/lua/value_conversion.hpp new file mode 100644 index 00000000..27acaad3 --- /dev/null +++ b/src/game/scripting/lua/value_conversion.hpp @@ -0,0 +1,9 @@ +#pragma once + +#include "context.hpp" + +namespace scripting::lua +{ + script_value convert(const sol::lua_value& value); + sol::lua_value convert(lua_State* state, const script_value& value); +} diff --git a/src/game/scripting/safe_execution.cpp b/src/game/scripting/safe_execution.cpp new file mode 100644 index 00000000..e58eb228 --- /dev/null +++ b/src/game/scripting/safe_execution.cpp @@ -0,0 +1,72 @@ +#include +#include "safe_execution.hpp" + +#pragma warning(push) +#pragma warning(disable: 4611) + +namespace scripting::safe_execution +{ + namespace + { + bool execute_with_seh(const script_function function, const game::scr_entref_t& entref) + { + __try + { + function(entref); + return true; + } + __except (EXCEPTION_EXECUTE_HANDLER) + { + return false; + } + } + } + + bool call(const script_function function, const game::scr_entref_t& entref) + { + *game::g_script_error_level += 1; + if (game::_setjmp(&game::g_script_error[*game::g_script_error_level])) + { + *game::g_script_error_level -= 1; + return false; + } + + const auto result = execute_with_seh(function, entref); + *game::g_script_error_level -= 1; + return result; + } + + bool set_entity_field(const game::scr_entref_t& entref, const int offset) + { + *game::g_script_error_level += 1; + if (game::_setjmp(&game::g_script_error[*game::g_script_error_level])) + { + *game::g_script_error_level -= 1; + return false; + } + + game::Scr_SetObjectField(entref.classnum, entref.entnum, offset); + + *game::g_script_error_level -= 1; + return true; + } + + bool get_entity_field(const game::scr_entref_t& entref, const int offset, game::VariableValue* value) + { + *game::g_script_error_level += 1; + if (game::_setjmp(&game::g_script_error[*game::g_script_error_level])) + { + value->type = game::SCRIPT_NONE; + value->u.intValue = 0; + *game::g_script_error_level -= 1; + return false; + } + + game::GetEntityFieldValue(value, entref.classnum, entref.entnum, offset); + + *game::g_script_error_level -= 1; + return true; + } +} + +#pragma warning(pop) diff --git a/src/game/scripting/safe_execution.hpp b/src/game/scripting/safe_execution.hpp new file mode 100644 index 00000000..6eea59d2 --- /dev/null +++ b/src/game/scripting/safe_execution.hpp @@ -0,0 +1,10 @@ +#pragma once +#include "functions.hpp" + +namespace scripting::safe_execution +{ + bool call(script_function function, const game::scr_entref_t& entref); + + bool set_entity_field(const game::scr_entref_t& entref, int offset); + bool get_entity_field(const game::scr_entref_t& entref, int offset, game::VariableValue* value); +} diff --git a/src/game/scripting/script_value.cpp b/src/game/scripting/script_value.cpp new file mode 100644 index 00000000..1d84f47d --- /dev/null +++ b/src/game/scripting/script_value.cpp @@ -0,0 +1,252 @@ +#include +#include "script_value.hpp" +#include "entity.hpp" + + +namespace scripting +{ + /*************************************************************** + * Constructors + **************************************************************/ + + script_value::script_value(const game::VariableValue& value) + : value_(value) + { + } + + script_value::script_value(const int value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_INTEGER; + variable.u.intValue = value; + + this->value_ = variable; + } + + script_value::script_value(const unsigned int value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_INTEGER; + variable.u.uintValue = value; + + this->value_ = variable; + } + + script_value::script_value(const bool value) + : script_value(static_cast(value)) + { + } + + script_value::script_value(const float value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_FLOAT; + variable.u.floatValue = value; + + this->value_ = variable; + } + + script_value::script_value(const double value) + : script_value(static_cast(value)) + { + } + + script_value::script_value(const char* value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_STRING; + variable.u.stringValue = game::SL_GetString(value, 0); + + const auto _ = gsl::finally([&variable]() + { + game::RemoveRefToValue(variable.type, variable.u); + }); + + this->value_ = variable; + } + + script_value::script_value(const std::string& value) + : script_value(value.data()) + { + } + + script_value::script_value(const entity& value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_OBJECT; + variable.u.pointerValue = value.get_entity_id(); + + this->value_ = variable; + } + + script_value::script_value(const vector& value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_VECTOR; + variable.u.vectorValue = game::Scr_AllocVector(value); + + const auto _ = gsl::finally([&variable]() + { + game::RemoveRefToValue(variable.type, variable.u); + }); + + this->value_ = variable; + } + + /*************************************************************** + * Integer + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_INTEGER; + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + int script_value::get() const + { + return this->get_raw().u.intValue; + } + + template <> + unsigned int script_value::get() const + { + return this->get_raw().u.uintValue; + } + + template <> + bool script_value::get() const + { + return this->get_raw().u.uintValue != 0; + } + + /*************************************************************** + * Float + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_FLOAT; + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + float script_value::get() const + { + return this->get_raw().u.floatValue; + } + + template <> + double script_value::get() const + { + return static_cast(this->get_raw().u.floatValue); + } + + /*************************************************************** + * String + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_STRING; + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + const char* script_value::get() const + { + return game::SL_ConvertToString(static_cast(this->get_raw().u.stringValue)); + } + + template <> + std::string script_value::get() const + { + return this->get(); + } + + /*************************************************************** + * Array + **************************************************************/ + + template <> + bool script_value::is>() 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_ARRAY;*/ + + return false; + } + + /*************************************************************** + * Entity + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_OBJECT; + } + + template <> + entity script_value::get() const + { + return entity(this->get_raw().u.pointerValue); + } + + /*************************************************************** + * Vector + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_VECTOR; + } + + template <> + vector script_value::get() const + { + return this->get_raw().u.vectorValue; + } + + /*************************************************************** + * + **************************************************************/ + + const game::VariableValue& script_value::get_raw() const + { + return this->value_.get(); + } +} diff --git a/src/game/scripting/script_value.hpp b/src/game/scripting/script_value.hpp new file mode 100644 index 00000000..df8a95b6 --- /dev/null +++ b/src/game/scripting/script_value.hpp @@ -0,0 +1,52 @@ +#pragma once +#include "game/game.hpp" +#include "variable_value.hpp" +#include "vector.hpp" + +namespace scripting +{ + class entity; + + class script_value + { + public: + script_value() = default; + script_value(const game::VariableValue& value); + + script_value(int value); + script_value(unsigned int value); + script_value(bool value); + + script_value(float value); + script_value(double value); + + script_value(const char* value); + script_value(const std::string& value); + + script_value(const entity& value); + + script_value(const vector& value); + + template + bool is() const; + + template + T as() const + { + if (!this->is()) + { + throw std::runtime_error("Invalid type"); + } + + return get(); + } + + const game::VariableValue& get_raw() const; + + private: + template + T get() const; + + variable_value value_{}; + }; +} diff --git a/src/game/scripting/stack_isolation.cpp b/src/game/scripting/stack_isolation.cpp new file mode 100644 index 00000000..25fd621c --- /dev/null +++ b/src/game/scripting/stack_isolation.cpp @@ -0,0 +1,27 @@ +#include +#include "stack_isolation.hpp" + +namespace scripting +{ + stack_isolation::stack_isolation() + { + this->in_param_count_ = game::scr_VmPub->inparamcount; + this->out_param_count_ = game::scr_VmPub->outparamcount; + this->top_ = game::scr_VmPub->top; + this->max_stack_ = game::scr_VmPub->maxstack; + + game::scr_VmPub->top = this->stack_; + game::scr_VmPub->maxstack = &this->stack_[ARRAYSIZE(this->stack_) - 1]; + game::scr_VmPub->inparamcount = 0; + game::scr_VmPub->outparamcount = 0; + } + + stack_isolation::~stack_isolation() + { + game::Scr_ClearOutParams(); + game::scr_VmPub->inparamcount = this->in_param_count_; + game::scr_VmPub->outparamcount = this->out_param_count_; + game::scr_VmPub->top = this->top_; + game::scr_VmPub->maxstack = this->max_stack_; + } +} diff --git a/src/game/scripting/stack_isolation.hpp b/src/game/scripting/stack_isolation.hpp new file mode 100644 index 00000000..8dffd4bc --- /dev/null +++ b/src/game/scripting/stack_isolation.hpp @@ -0,0 +1,25 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + class stack_isolation final + { + public: + stack_isolation(); + ~stack_isolation(); + + stack_isolation(stack_isolation&&) = delete; + stack_isolation(const stack_isolation&) = delete; + stack_isolation& operator=(stack_isolation&&) = delete; + stack_isolation& operator=(const stack_isolation&) = delete; + + private: + game::VariableValue stack_[512]{}; + + game::VariableValue* max_stack_; + game::VariableValue* top_; + unsigned int in_param_count_; + unsigned int out_param_count_; + }; +} diff --git a/src/game/scripting/variable_value.cpp b/src/game/scripting/variable_value.cpp new file mode 100644 index 00000000..583daab2 --- /dev/null +++ b/src/game/scripting/variable_value.cpp @@ -0,0 +1,68 @@ +#include +#include "variable_value.hpp" + +namespace scripting +{ + variable_value::variable_value(const game::VariableValue& value) + { + this->assign(value); + } + + variable_value::variable_value(const variable_value& other) noexcept + { + this->operator=(other); + } + + variable_value::variable_value(variable_value&& other) noexcept + { + this->operator=(std::move(other)); + } + + variable_value& variable_value::operator=(const variable_value& other) noexcept + { + if (this != &other) + { + this->release(); + this->assign(other.value_); + } + + return *this; + } + + variable_value& variable_value::operator=(variable_value&& other) noexcept + { + if (this != &other) + { + this->release(); + this->value_ = other.value_; + other.value_.type = game::SCRIPT_NONE; + } + + return *this; + } + + variable_value::~variable_value() + { + this->release(); + } + + const game::VariableValue& variable_value::get() const + { + return this->value_; + } + + void variable_value::assign(const game::VariableValue& value) + { + this->value_ = value; + game::AddRefToValue(this->value_.type, this->value_.u); + } + + void variable_value::release() + { + if (this->value_.type != game::SCRIPT_NONE) + { + game::RemoveRefToValue(this->value_.type, this->value_.u); + this->value_.type = game::SCRIPT_NONE; + } + } +} diff --git a/src/game/scripting/variable_value.hpp b/src/game/scripting/variable_value.hpp new file mode 100644 index 00000000..7a962612 --- /dev/null +++ b/src/game/scripting/variable_value.hpp @@ -0,0 +1,27 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + class variable_value + { + public: + variable_value() = default; + variable_value(const game::VariableValue& value); + variable_value(const variable_value& other) noexcept; + variable_value(variable_value&& other) noexcept; + + variable_value& operator=(const variable_value& other) noexcept; + variable_value& operator=(variable_value&& other) noexcept; + + ~variable_value(); + + const game::VariableValue& get() const; + + private: + void assign(const game::VariableValue& value); + void release(); + + game::VariableValue value_{{0}, game::SCRIPT_NONE}; + }; +} diff --git a/src/game/scripting/vector.cpp b/src/game/scripting/vector.cpp new file mode 100644 index 00000000..7410ddb5 --- /dev/null +++ b/src/game/scripting/vector.cpp @@ -0,0 +1,85 @@ +#include +#include "vector.hpp" + +namespace scripting +{ + vector::vector(const float* value) + { + for (auto i = 0; i < 3; ++i) + { + this->value_[i] = value[i]; + } + } + + vector::vector(const game::vec3_t& value) + : vector(&value[0]) + { + } + + vector::vector(const float x, const float y, const float z) + { + this->value_[0] = x; + this->value_[1] = y; + this->value_[2] = z; + } + + vector::operator game::vec3_t&() + { + return this->value_; + } + + vector::operator const game::vec3_t&() const + { + return this->value_; + } + + game::vec_t& vector::operator[](const size_t i) + { + if (i >= 3) + { + throw std::runtime_error("Out of bounds."); + } + + return this->value_[i]; + } + + const game::vec_t& vector::operator[](const size_t i) const + { + if (i >= 3) + { + throw std::runtime_error("Out of bounds."); + } + + return this->value_[i]; + } + + float vector::get_x() const + { + return this->operator[](0); + } + + float vector::get_y() const + { + return this->operator[](1); + } + + float vector::get_z() const + { + return this->operator[](2); + } + + void vector::set_x(const float value) + { + this->operator[](0) = value; + } + + void vector::set_y(const float value) + { + this->operator[](1) = value; + } + + void vector::set_z(const float value) + { + this->operator[](2) = value; + } +} diff --git a/src/game/scripting/vector.hpp b/src/game/scripting/vector.hpp new file mode 100644 index 00000000..70b146d6 --- /dev/null +++ b/src/game/scripting/vector.hpp @@ -0,0 +1,31 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + class vector final + { + public: + vector() = default; + vector(const float* value); + vector(const game::vec3_t& value); + vector(float x, float y, float z); + + operator game::vec3_t&(); + operator const game::vec3_t&() const; + + game::vec_t& operator[](size_t i); + const game::vec_t& operator[](size_t i) const; + + float get_x() const; + float get_y() const; + float get_z() const; + + void set_x(float value); + void set_y(float value); + void set_z(float value); + + private: + game::vec3_t value_{0}; + }; +} diff --git a/src/game/structs.hpp b/src/game/structs.hpp index 5200539f..c9cd90b5 100644 --- a/src/game/structs.hpp +++ b/src/game/structs.hpp @@ -9,8 +9,12 @@ namespace game struct gclient_s { - char __pad0[7684]; - int flags; + + }; + + struct client_t + { + char __pad0[13508]; }; struct EntityState @@ -20,8 +24,8 @@ namespace game struct gentity_s { - EntityState s; - }; + char __pad0[760]; + }; // size = 760 struct Material { @@ -283,7 +287,7 @@ namespace game struct dvar_t { - const char* name; //00 + int name; //00 unsigned int flags; //08 dvar_type type; //0C bool modified; //0D @@ -528,4 +532,93 @@ namespace game unsigned int nextOverride; unsigned int nextPoolEntry; }; + + enum scr_string_t + { + scr_string_t_dummy = 0x0, + }; + + struct scr_entref_t + { + unsigned short entnum; + unsigned short classnum; + }; + + enum scriptType_e + { + SCRIPT_NONE = 0, + SCRIPT_OBJECT = 1, + SCRIPT_STRING = 2, + SCRIPT_ISTRING = 3, + SCRIPT_VECTOR = 4, + SCRIPT_FLOAT = 5, + SCRIPT_INTEGER = 6, + SCRIPT_END = 8, + SCRIPT_ARRAY = 22 + }; + + struct VariableStackBuffer + { + const char* pos; + unsigned __int16 size; + unsigned __int16 bufLen; + unsigned __int16 localId; + char time; + char buf[1]; + }; + + union VariableUnion + { + int intValue; + unsigned int uintValue; + float floatValue; + unsigned int stringValue; + const float* vectorValue; + const char* codePosValue; + unsigned int pointerValue; + VariableStackBuffer* stackValue; + unsigned int entityOffset; + }; + + struct VariableValue + { + VariableUnion u; + int type; + }; + + struct function_stack_t + { + const char* pos; + unsigned int localId; + unsigned int localVarCount; + VariableValue* top; + VariableValue* startTop; + }; + + struct function_frame_t + { + function_stack_t fs; + int topType; + }; + + struct scrVmPub_t + { + unsigned int* localVars; + VariableValue* maxstack; + int function_count; + function_frame_t* function_frame; + VariableValue* top; + unsigned int inparamcount; + unsigned int outparamcount; + function_frame_t function_frame_start[32]; + VariableValue stack[2048]; + }; + + struct scr_classStruct_t + { + unsigned __int16 id; + unsigned __int16 entArrayId; + char charId; + const char* name; + }; } \ No newline at end of file diff --git a/src/game/symbols.hpp b/src/game/symbols.hpp index b7592d0c..3bcdd373 100644 --- a/src/game/symbols.hpp +++ b/src/game/symbols.hpp @@ -6,6 +6,9 @@ namespace game { // Functions + WEAK symbol AddRefToValue{0x5C0EB0}; + WEAK symbol RemoveRefToValue{0x5C29B0}; + WEAK symbol Cbuf_AddText{0x59A050}; WEAK symbol Cmd_AddCommandInternal{0x59A5F0}; @@ -21,12 +24,22 @@ namespace game Dvar_RegisterBool{0x617BB0}; WEAK symbol Dvar_RegisterVec4{0x6185F0}; - WEAK symbol Dvar_ValueToString{0x61B8F0}; + WEAK symbol Dvar_ValueToString{0x61B8F0}; + WEAK symbol Dvar_SetCommand{0x61A5C0}; WEAK symbol generateHashValue{0x343D20}; + WEAK symbol FindEntityId{0x5C1C50}; + WEAK symbol GetEntityFieldValue{0x5C6100}; + WEAK symbol Material_RegisterHandle{0x759BA0}; + WEAK symbol Scr_AllocVector{0x5C3220}; + WEAK symbol Scr_ClearOutParams{0x5C6E50}; + WEAK symbol Scr_GetEntityIdRef{0x5C56C0}; + WEAK symbol Scr_SetObjectField{0x512190}; + WEAK symbol Scr_NotifyId{0x5C8240}; + WEAK symbol R_AddCmdDrawStretchPic{0x3C9710}; WEAK symbol ScrPlace_GetViewPlacement{0x3E16A0}; + WEAK symbol SL_ConvertToString{0x5BFBB0}; + WEAK symbol SL_GetString{0x5C0170}; + WEAK symbol Sys_ShowConsole{0x633080}; + WEAK symbol longjmp{0x89EED0}; + WEAK symbol _setjmp{0x8EC2E0}; + // Variables WEAK symbol cmd_functions{0xAD17BB8}; @@ -55,4 +74,11 @@ namespace game WEAK symbol dvarCount{0xBFBB310}; WEAK symbol sortedDvars{0xBFBB320}; + + WEAK symbol levelEntityId{0xB5E0B30}; + WEAK symbol g_script_error_level{0xBA9CC24}; + WEAK symbol g_script_error{0xBA9CD40}; + WEAK symbol g_classMap{0xBF95C0}; + + WEAK symbol scr_VmPub{0xBA9EE40}; } diff --git a/src/stdinc.hpp b/src/stdinc.hpp index 8e86df63..c9f56c2c 100644 --- a/src/stdinc.hpp +++ b/src/stdinc.hpp @@ -19,8 +19,11 @@ #include #include #include +#include +#include #include +#include using namespace std::literals; @@ -28,11 +31,14 @@ using namespace std::literals; #include "utils/string.hpp" #include "utils/hook.hpp" #include "utils/string.hpp" +#include "utils/io.hpp" #include "game/structs.hpp" #include "game/game.hpp" +#include "game/dvars.hpp" #include "component/command.hpp" +#include "component/scripting.hpp" #include "component/scheduler.hpp" #include "component/input.hpp" #include "component/game_console.hpp" diff --git a/src/utils/io.cpp b/src/utils/io.cpp new file mode 100644 index 00000000..b2325a0f --- /dev/null +++ b/src/utils/io.cpp @@ -0,0 +1,115 @@ +#include +#include "io.hpp" +#include + +namespace utils::io +{ + bool file_exists(const std::string& file) + { + return std::ifstream(file).good(); + } + + bool write_file(const std::string& file, const std::string& data, const bool append) + { + const auto pos = file.find_last_of("/\\"); + if (pos != std::string::npos) + { + create_directory(file.substr(0, pos)); + } + + std::ofstream stream( + file, std::ios::binary | std::ofstream::out | (append ? std::ofstream::app : 0)); + + if (stream.is_open()) + { + stream.write(data.data(), data.size()); + stream.close(); + return true; + } + + return false; + } + + std::string read_file(const std::string& file) + { + std::string data; + read_file(file, &data); + return data; + } + + bool read_file(const std::string& file, std::string* data) + { + if (!data) return false; + data->clear(); + + if (file_exists(file)) + { + std::ifstream stream(file, std::ios::binary); + if (!stream.is_open()) return false; + + stream.seekg(0, std::ios::end); + const std::streamsize size = stream.tellg(); + stream.seekg(0, std::ios::beg); + + if (size > -1) + { + data->resize(static_cast(size)); + stream.read(const_cast(data->data()), size); + stream.close(); + return true; + } + } + + return false; + } + + size_t file_size(const std::string& file) + { + if (file_exists(file)) + { + std::ifstream stream(file, std::ios::binary); + + if (stream.good()) + { + stream.seekg(0, std::ios::end); + return static_cast(stream.tellg()); + } + } + + return 0; + } + + bool create_directory(const std::string& directory) + { + return std::filesystem::create_directories(directory); + } + + bool directory_exists(const std::string& directory) + { + return std::filesystem::is_directory(directory); + } + + bool directory_is_empty(const std::string& directory) + { + return std::filesystem::is_empty(directory); + } + + std::vector list_files(const std::string& directory) + { + std::vector files; + + for (auto& file : std::filesystem::directory_iterator(directory)) + { + files.push_back(file.path().generic_string()); + } + + return files; + } + + void copy_folder(const std::filesystem::path& src, const std::filesystem::path& target) + { + std::filesystem::copy(src, target, + std::filesystem::copy_options::overwrite_existing | + std::filesystem::copy_options::recursive); + } +} diff --git a/src/utils/io.hpp b/src/utils/io.hpp new file mode 100644 index 00000000..e82a416c --- /dev/null +++ b/src/utils/io.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include +#include +#include + +namespace utils::io +{ + 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); + std::string read_file(const std::string& file); + size_t file_size(const std::string& file); + bool create_directory(const std::string& directory); + bool directory_exists(const std::string& directory); + bool directory_is_empty(const std::string& directory); + std::vector list_files(const std::string& directory); + void copy_folder(const std::filesystem::path& src, const std::filesystem::path& target); +} diff --git a/src/utils/string.cpp b/src/utils/string.cpp index 934a9dba..a1bc1cce 100644 --- a/src/utils/string.cpp +++ b/src/utils/string.cpp @@ -121,4 +121,21 @@ namespace utils::string } *out = '\0'; } + + std::string replace(std::string str, const std::string& from, const std::string& to) + { + if (from.empty()) + { + return str; + } + + size_t start_pos = 0; + while ((start_pos = str.find(from, start_pos)) != std::string::npos) + { + str.replace(start_pos, from.length(), to); + start_pos += to.length(); + } + + return str; + } } diff --git a/src/utils/string.hpp b/src/utils/string.hpp index 2a3cbdaf..174228bd 100644 --- a/src/utils/string.hpp +++ b/src/utils/string.hpp @@ -85,4 +85,6 @@ namespace utils::string std::string get_clipboard_data(); void strip(const char* in, char* out, int max); + + std::string replace(std::string str, const std::string& from, const std::string& to); }