From 99b3831dd8b18623df0bf82376a5862ae033afb8 Mon Sep 17 00:00:00 2001 From: m Date: Sun, 11 Sep 2022 12:14:42 -0500 Subject: [PATCH] GSC support (#247) Co-authored-by: Federico Cecchetto --- .gitmodules | 3 + deps/extra/gsc-tool/interface.cpp | 20 + deps/extra/gsc-tool/interface.hpp | 7 + deps/gsc-tool | 1 + deps/premake/gsc-tool.lua | 68 + src/client/component/bots.cpp | 2 +- src/client/component/gsc.cpp | 817 +++ src/client/component/gsc.hpp | 27 + src/client/component/logfile.cpp | 126 +- src/client/component/logfile.hpp | 7 +- src/client/component/scripting.cpp | 123 +- src/client/component/scripting.hpp | 7 +- src/client/component/ui_scripting.cpp | 37 +- src/client/game/scripting/function_tables.cpp | 4413 ----------------- src/client/game/scripting/functions.cpp | 97 +- src/client/game/scripting/functions.hpp | 6 +- src/client/game/scripting/lua/context.cpp | 22 +- .../game/scripting/lua/value_conversion.cpp | 7 +- src/client/game/symbols.hpp | 18 + src/common/utils/string.cpp | 11 +- 20 files changed, 1260 insertions(+), 4559 deletions(-) create mode 100644 deps/extra/gsc-tool/interface.cpp create mode 100644 deps/extra/gsc-tool/interface.hpp create mode 160000 deps/gsc-tool create mode 100644 deps/premake/gsc-tool.lua create mode 100644 src/client/component/gsc.cpp create mode 100644 src/client/component/gsc.hpp delete mode 100644 src/client/game/scripting/function_tables.cpp diff --git a/.gitmodules b/.gitmodules index 2f46cb5f..4112be93 100644 --- a/.gitmodules +++ b/.gitmodules @@ -48,3 +48,6 @@ [submodule "deps/curl"] path = deps/curl url = https://github.com/curl/curl.git +[submodule "deps/gsc-tool"] + path = deps/gsc-tool + url = https://github.com/h1-mod/gsc-tool.git diff --git a/deps/extra/gsc-tool/interface.cpp b/deps/extra/gsc-tool/interface.cpp new file mode 100644 index 00000000..209f2c99 --- /dev/null +++ b/deps/extra/gsc-tool/interface.cpp @@ -0,0 +1,20 @@ +#include "stdafx.hpp" + +#include + +#include "interface.hpp" + +namespace gsc +{ + std::unique_ptr compiler() + { + auto compiler = std::make_unique(); + compiler->mode(xsk::gsc::build::prod); + return compiler; + } + + std::unique_ptr assembler() + { + return std::make_unique(); + } +} diff --git a/deps/extra/gsc-tool/interface.hpp b/deps/extra/gsc-tool/interface.hpp new file mode 100644 index 00000000..4d98ad35 --- /dev/null +++ b/deps/extra/gsc-tool/interface.hpp @@ -0,0 +1,7 @@ +#pragma once + +namespace gsc +{ + std::unique_ptr compiler(); + std::unique_ptr assembler(); +} diff --git a/deps/gsc-tool b/deps/gsc-tool new file mode 160000 index 00000000..74b20527 --- /dev/null +++ b/deps/gsc-tool @@ -0,0 +1 @@ +Subproject commit 74b205271bdd934d85de9b3b06d7008bb7b260c2 diff --git a/deps/premake/gsc-tool.lua b/deps/premake/gsc-tool.lua new file mode 100644 index 00000000..08da07de --- /dev/null +++ b/deps/premake/gsc-tool.lua @@ -0,0 +1,68 @@ +gsc_tool = { + source = path.join(dependencies.basePath, "gsc-tool/src") +} + +function gsc_tool.import() + links {"xsk-gsc-h1", "xsk-gsc-utils"} + gsc_tool.includes() +end + +function gsc_tool.includes() + includedirs { + path.join(gsc_tool.source, "utils"), + path.join(gsc_tool.source, "h1"), + path.join(dependencies.basePath, "extra/gsc-tool") -- https://github.com/GEEKiDoS/open-teknomw3/blob/master/deps/extra/gsc-tool + } +end + +-- https://github.com/xensik/gsc-tool/blob/dev/premake5.lua#L95 +function gsc_tool.project() + project "xsk-gsc-utils" + kind "StaticLib" + language "C++" + + pchheader "stdafx.hpp" + pchsource(path.join(gsc_tool.source, "utils/stdafx.cpp")) + + files { + path.join(gsc_tool.source, "utils/**.h"), + path.join(gsc_tool.source, "utils/**.hpp"), + path.join(gsc_tool.source, "utils/**.cpp") + } + + includedirs { + path.join(gsc_tool.source, "utils"), + gsc_tool.source + } + + zlib.includes() + + project "xsk-gsc-h1" + kind "StaticLib" + language "C++" + + pchheader "stdafx.hpp" + pchsource(path.join(gsc_tool.source, "h1/stdafx.cpp")) + + files { + path.join(gsc_tool.source, "h1/**.h"), + path.join(gsc_tool.source, "h1/**.hpp"), + path.join(gsc_tool.source, "h1/**.cpp"), + path.join(dependencies.basePath, "extra/gsc-tool/interface.cpp") + } + + includedirs { + path.join(gsc_tool.source, "h1"), + gsc_tool.source, + path.join(dependencies.basePath, "extra/gsc-tool") + } + + -- https://github.com/xensik/gsc-tool/blob/dev/premake5.lua#L25 + -- adding these build options fixes a bunch of parser stuff + filter "action:vs*" + buildoptions "/bigobj" + buildoptions "/Zc:__cplusplus" + filter {} +end + +table.insert(dependencies, gsc_tool) diff --git a/src/client/component/bots.cpp b/src/client/component/bots.cpp index 3bb8382d..4c82cd4e 100644 --- a/src/client/component/bots.cpp +++ b/src/client/component/bots.cpp @@ -151,7 +151,7 @@ namespace bots }); // Clear bot names and reset ID on game shutdown to allow new names to be added without restarting - scripting::on_shutdown([] + scripting::on_shutdown([](int) { bot_names.clear(); bot_id = 0; diff --git a/src/client/component/gsc.cpp b/src/client/component/gsc.cpp new file mode 100644 index 00000000..4b53de1d --- /dev/null +++ b/src/client/component/gsc.cpp @@ -0,0 +1,817 @@ +#include +#include "loader/component_loader.hpp" + +#include "console.hpp" +#include "fastfiles.hpp" +#include "gsc.hpp" +#include "filesystem.hpp" +#include "logfile.hpp" +#include "scripting.hpp" + +#include "game/game.hpp" +#include "game/dvars.hpp" +#include "game/scripting/functions.hpp" + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace gsc +{ + void* func_table[0x1000]{}; + void* meth_table[0x1000]{}; + + namespace + { + game::dvar_t* developer_script = nullptr; + + auto compiler = ::gsc::compiler(); + auto assembler = ::gsc::assembler(); + + std::unordered_map main_handles; + std::unordered_map init_handles; + std::unordered_map loaded_scripts; + + std::unordered_map functions; + std::unordered_map methods; + + std::optional gsc_error; + + bool force_error_print = false; + + auto function_id_start = 0x30A; + auto method_id_start = 0x8586; + + game::scr_entref_t saved_ent_ref; + + std::string unknown_function_error{}; + unsigned int current_filename{}; + + char* allocate_buffer(size_t size) + { + // PMem_AllocFromSource_NoDebug + return utils::hook::invoke(SELECT_VALUE(0x41FB50_b, 0x5A4DC0_b), size, 4, 1, 5); + } + + bool read_scriptfile(const std::string& name, std::string* data) + { + if (filesystem::read_file(name, data)) + { + return true; + } + + // TODO: check back on this to see if there is a property we can distinguish compared to our rawfiles, like compressedLen? + // this will filter out the rawfile "gsc" the game zones actually have, this seems to get all of them + if (name.starts_with("maps/createfx") || name.starts_with("maps/createart") + || (name.starts_with("maps/mp") && name.ends_with("_fx.gsc"))) + { + return false; + } + + const auto name_str = name.data(); + + if (game::DB_XAssetExists(game::ASSET_TYPE_RAWFILE, name_str) && + !game::DB_IsXAssetDefault(game::ASSET_TYPE_RAWFILE, name_str)) + { + const auto asset = game::DB_FindXAssetHeader(game::ASSET_TYPE_RAWFILE, name_str, false); + const auto len = game::DB_GetRawFileLen(asset.rawfile); + data->resize(len); + game::DB_GetRawBuffer(asset.rawfile, data->data(), len); + if (len > 0) + { + data->pop_back(); + } + + return true; + } + + return false; + } + + game::ScriptFile* load_custom_script(const char* file_name, const std::string& real_name) + { + if (loaded_scripts.find(real_name) != loaded_scripts.end()) + { + return loaded_scripts[real_name]; + } + + std::string source_buffer{}; + if (!read_scriptfile(real_name + ".gsc", &source_buffer)) + { + return nullptr; + } + + auto data = std::vector{source_buffer.begin(), source_buffer.end()}; + + try + { + compiler->compile(real_name, data); + } + catch (const std::exception& e) + { + console::error("*********** script compile error *************\n"); + console::error("failed to compile '%s':\n%s", real_name.data(), e.what()); + console::error("**********************************************\n"); + return nullptr; + } + + auto assembly = compiler->output(); + + try + { + assembler->assemble(real_name, assembly); + } + catch (const std::exception& e) + { + console::error("*********** script compile error *************\n"); + console::error("failed to assemble '%s':\n%s", real_name.data(), e.what()); + console::error("**********************************************\n"); + return nullptr; + } + + const auto script_file_ptr = reinterpret_cast(allocate_buffer(sizeof(game::ScriptFile))); + script_file_ptr->name = file_name; + + const auto stack = assembler->output_stack(); + script_file_ptr->len = static_cast(stack.size()); + + const auto script = assembler->output_script(); + script_file_ptr->bytecodeLen = static_cast(script.size()); + + const auto script_size = script.size(); + const auto buffer_size = script_size + stack.size() + 2; + + const auto buffer = allocate_buffer(buffer_size); + std::memcpy(buffer, script.data(), script_size); + std::memcpy(&buffer[script_size], stack.data(), stack.size()); + + script_file_ptr->bytecode = &buffer[0]; + script_file_ptr->buffer = &buffer[script.size()]; + script_file_ptr->compressedLen = 0; + + loaded_scripts[real_name] = script_file_ptr; + + return script_file_ptr; + } + + void load_script(const std::string& name) + { + if (!game::Scr_LoadScript(name.data())) + { + return; + } + + const auto main_handle = game::Scr_GetFunctionHandle(name.data(), + xsk::gsc::h1::resolver::token_id("main")); + const auto init_handle = game::Scr_GetFunctionHandle(name.data(), + xsk::gsc::h1::resolver::token_id("init")); + + if (main_handle) + { + console::info("Loaded '%s::main'\n", name.data()); + main_handles[name] = main_handle; + } + + if (init_handle) + { + console::info("Loaded '%s::init'\n", name.data()); + init_handles[name] = init_handle; + } + } + + void load_scripts(const std::filesystem::path& root_dir, const std::filesystem::path& script_dir) + { + std::filesystem::path script_dir_path = root_dir / script_dir; + if (!utils::io::directory_exists(script_dir_path.generic_string())) + { + return; + } + + const auto scripts = utils::io::list_files(script_dir_path.generic_string()); + for (const auto& script : scripts) + { + if (!script.ends_with(".gsc")) + { + continue; + } + + std::filesystem::path path(script); + const auto relative = path.lexically_relative(root_dir).generic_string(); + const auto base_name = relative.substr(0, relative.size() - 4); + + load_script(base_name); + } + } + + void clear() + { + main_handles.clear(); + init_handles.clear(); + loaded_scripts.clear(); + } + + void load_gametype_script_stub(void* a1, void* a2) + { + utils::hook::invoke(SELECT_VALUE(0x2B9DA0_b, 0x18BC00_b), a1, a2); + + if (game::VirtualLobby_Loaded()) + { + return; + } + + clear(); + + for (const auto& path : filesystem::get_search_paths()) + { + load_scripts(path, "scripts/"); + if (game::environment::is_sp()) + { + load_scripts(path, "scripts/sp/"); + } + else + { + load_scripts(path, "scripts/mp/"); + } + } + } + + int db_is_xasset_default(game::XAssetType type, const char* name) + { + if (loaded_scripts.find(name) != loaded_scripts.end()) + { + return 0; + } + + return game::DB_IsXAssetDefault(type, name); + } + + void db_get_raw_buffer_stub(const game::RawFile* rawfile, char* buf, const int size) + { + if (rawfile->len > 0 && rawfile->compressedLen == 0) + { + std::memset(buf, 0, size); + std::memcpy(buf, rawfile->buffer, std::min(rawfile->len, size)); + return; + } + + utils::hook::invoke(SELECT_VALUE(0x1F1E00_b, 0x396080_b), rawfile, buf, size); + } + + std::optional> find_function(const char* pos) + { + for (const auto& file : scripting::script_function_table_sort) + { + for (auto i = file.second.begin(); i != file.second.end() && std::next(i) != file.second.end(); ++i) + { + const auto next = std::next(i); + if (pos >= i->second && pos < next->second) + { + return {std::make_pair(i->first, file.first)}; + } + } + } + + return {}; + } + + void print_callstack() + { + for (auto frame = game::scr_VmPub->function_frame; frame != game::scr_VmPub->function_frame_start; --frame) + { + const auto pos = frame == game::scr_VmPub->function_frame + ? game::scr_function_stack->pos + : frame->fs.pos; + const auto function = find_function(pos); + + if (function.has_value()) + { + console::warn("\tat function \"%s\" in file \"%s.gsc\"", + function.value().first.data(), function.value().second.data()); + } + else + { + console::warn("\tat unknown location %p", pos); + } + } + } + + std::optional get_opcode_name(const std::uint8_t opcode) + { + try + { + return {xsk::gsc::h1::resolver::opcode_name(opcode)}; + } + catch (...) + { + return {}; + } + } + + void builtin_call_error() + { + const auto pos = game::scr_function_stack->pos; + const auto function_id = *reinterpret_cast( + reinterpret_cast(pos - 2)); + + if (function_id > 0x1000) + { + console::warn("in call to builtin method \"%s\"", + xsk::gsc::h1::resolver::method_name(function_id).data()); + } + else + { + console::warn("in call to builtin function \"%s\"", + xsk::gsc::h1::resolver::function_name(function_id).data()); + } + } + + void* vm_error_stub(void* a1) + { + if (!developer_script->current.enabled && !force_error_print) + { + return utils::hook::invoke(SELECT_VALUE(0x415C90_b, 0x59DDA0_b), a1); + } + + console::warn("*********** script runtime error *************\n"); + + const auto opcode_id = *reinterpret_cast(SELECT_VALUE(0xC4015E8_b, 0xB7B8968_b)); + if ((opcode_id >= 0x1A && opcode_id <= 0x20) || (opcode_id >= 0xA9 && opcode_id <= 0xAF)) + { + builtin_call_error(); + } + else + { + const auto opcode = get_opcode_name(opcode_id); + const std::string error_str = gsc_error.has_value() + ? utils::string::va(": %s", gsc_error.value().data()) + : ""; + if (opcode.has_value()) + { + console::warn("while processing instruction %s%s\n", + opcode.value().data(), error_str.data()); + } + else + { + console::warn("while processing instruction 0x%X%s\n", + opcode_id, error_str.data()); + } + } + + force_error_print = false; + gsc_error = {}; + + print_callstack(); + console::warn("**********************************************\n"); + return utils::hook::invoke(SELECT_VALUE(0x415C90_b, 0x59DDA0_b), a1); + } + + void get_unknown_function_error(const char* code_pos) + { + const auto function = find_function(code_pos); + if (function.has_value()) + { + const auto& pos = function.value(); + unknown_function_error = utils::string::va( + "while processing function '%s' in script '%s':\nunknown script '%s'", + pos.first.data(), pos.second.data(), scripting::current_file.data() + ); + } + else + { + unknown_function_error = utils::string::va( + "unknown script '%s'", + scripting::current_file.data() + ); + } + } + + std::string get_filename_name() + { + const auto filename_str = game::SL_ConvertToString( + static_cast(current_filename)); + const auto id = std::atoi(filename_str); + if (id == 0) + { + return filename_str; + } + + return scripting::get_token(id); + } + + void get_unknown_function_error(unsigned int thread_name) + { + const auto filename = get_filename_name(); + const auto name = scripting::get_token(thread_name); + + unknown_function_error = utils::string::va( + "while processing script '%s':\nunknown function '%s::%s'", + scripting::current_file.data(), filename.data(), name.data() + ); + } + + void unknown_function_stub(const char* code_pos) + { + get_unknown_function_error(code_pos); + game::Com_Error(game::ERR_DROP, "script link error\n%s", + unknown_function_error.data()); + } + + unsigned int find_variable_stub(unsigned int parent_id, unsigned int thread_name) + { + const auto res = game::FindVariable(parent_id, thread_name); + if (!res) + { + get_unknown_function_error(thread_name); + game::Com_Error(game::ERR_DROP, "script link error\n%s", + unknown_function_error.data()); + } + return res; + } + + void register_gsc_functions_stub(void* a1, void* a2) + { + utils::hook::invoke(SELECT_VALUE(0x2E0F50_b, 0x1CE010_b), a1, a2); + for (const auto& function : functions) + { + game::Scr_RegisterFunction(function.first, 0, function.second); + } + } + + void register_gsc_methods_stub(void* a1, void* a2) + { + utils::hook::invoke(SELECT_VALUE(0x2E0FB0_b, 0x1CE120_b), a1, a2); + for (const auto& method : methods) + { + game::Scr_RegisterFunction(method.first, 0, method.second); + } + } + + scripting::script_value get_argument(int index) + { + if (index >= static_cast(game::scr_VmPub->outparamcount)) + { + return {}; + } + + return game::scr_VmPub->top[-index]; + } + + void execute_custom_function(builtin_function function) + { + auto error = false; + + try + { + function(); + } + catch (const std::exception& e) + { + error = true; + force_error_print = true; + gsc_error = e.what(); + } + + if (error) + { + game::Scr_ErrorInternal(); + } + } + + void execute_custom_method(builtin_method method, game::scr_entref_t ent_ref) + { + auto error = false; + + try + { + method(ent_ref); + } + catch (const std::exception& e) + { + error = true; + force_error_print = true; + gsc_error = e.what(); + } + + if (error) + { + game::Scr_ErrorInternal(); + } + } + + void vm_call_builtin_function_stub(builtin_function function) + { + auto is_custom_function = false; + { + is_custom_function = functions.find(function) != functions.end(); + } + + if (!is_custom_function) + { + function(); + } + else + { + execute_custom_function(function); + } + } + + game::scr_entref_t get_entity_id_stub(unsigned int ent_id) + { + const auto ref = game::Scr_GetEntityIdRef(ent_id); + saved_ent_ref = ref; + return ref; + } + + void vm_call_builtin_method_stub(builtin_method method) + { + auto is_custom_function = false; + { + is_custom_function = methods.find(method) != methods.end(); + } + + if (!is_custom_function) + { + method(saved_ent_ref); + } + else + { + execute_custom_method(method, saved_ent_ref); + } + } + + utils::hook::detour scr_emit_function_hook; + void scr_emit_function_stub(unsigned int filename, unsigned int thread_name, char* code_pos) + { + current_filename = filename; + scr_emit_function_hook.invoke(filename, thread_name, code_pos); + } + + void replace(std::string& str, const std::string& from, const std::string& to) + { + const auto start_pos = str.find(from); + + if (start_pos == std::string::npos) + { + return; + } + + str.replace(start_pos, from.length(), to); + } + } + + game::ScriptFile* find_script(game::XAssetType /*type*/, const char* name, int /*allow_create_default*/) + { + if (game::VirtualLobby_Loaded()) + { + return game::DB_FindXAssetHeader(game::ASSET_TYPE_SCRIPTFILE, name, 1).scriptfile; + } + + std::string real_name = name; + const auto id = static_cast(std::atoi(name)); + if (id) + { + real_name = xsk::gsc::h1::resolver::token_name(id); + } + + const auto script = load_custom_script(name, real_name); + if (script) + { + return script; + } + + return game::DB_FindXAssetHeader(game::ASSET_TYPE_SCRIPTFILE, name, 1).scriptfile; + } + + void load_main_handles() + { + for (auto& function_handle : main_handles) + { + console::info("Executing '%s::main'\n", function_handle.first.data()); + game::RemoveRefToObject(game::Scr_ExecThread(function_handle.second, 0)); + } + } + + void load_init_handles() + { + for (auto& function_handle : init_handles) + { + console::info("Executing '%s::init'\n", function_handle.first.data()); + game::RemoveRefToObject(game::Scr_ExecThread(function_handle.second, 0)); + } + } + + namespace function + { + void add(const std::string& name, builtin_function function) + { + if (xsk::gsc::h1::resolver::find_function(name)) + { + const auto id = xsk::gsc::h1::resolver::function_id(name); + functions[function] = id; + } + else + { + const auto id = ++function_id_start; + xsk::gsc::h1::resolver::add_function(name, static_cast(id)); + functions[function] = id; + } + } + } + + namespace method + { + void add(const std::string& name, builtin_method method) + { + if (xsk::gsc::h1::resolver::find_method(name)) + { + const auto id = xsk::gsc::h1::resolver::method_id(name); + methods[method] = id; + } + else + { + const auto id = ++method_id_start; + xsk::gsc::h1::resolver::add_method(name, static_cast(id)); + methods[method] = id; + } + } + } + + class component final : public component_interface + { + public: + void post_unpack() override + { + developer_script = dvars::register_bool("developer_script", false, 0, "Print GSC errors"); + + // Allow custom scripts to include other custom scripts + xsk::gsc::h1::resolver::init([](const auto& include_name) + { + const auto real_name = include_name + ".gsc"; + + std::string file_buffer; + if (!read_scriptfile(real_name, &file_buffer) || file_buffer.empty()) + { + throw std::runtime_error(std::format("could not load gsc file '{}'", real_name)); + } + + std::vector result; + result.assign(file_buffer.begin(), file_buffer.end()); + + return result; + }); + + // hook xasset functions to return our own custom scripts + utils::hook::call(SELECT_VALUE(0x3C7217_b, 0x50E357_b), find_script); + utils::hook::call(SELECT_VALUE(0x3C7227_b, 0x50E367_b), db_is_xasset_default); + + // loads scripts with an uncompressed stack + utils::hook::call(SELECT_VALUE(0x3C7280_b, 0x50E3C0_b), db_get_raw_buffer_stub); + + // load script handles + utils::hook::call(SELECT_VALUE(0x2BA152_b, 0x18C325_b), load_gametype_script_stub); + + utils::hook::call(SELECT_VALUE(0x3CC9F3_b, 0x513A53_b), vm_error_stub); + + // patch error to drop + give more information + utils::hook::call(SELECT_VALUE(0x3BD626_b, 0x504606_b), unknown_function_stub); // CompileError + utils::hook::call(SELECT_VALUE(0x3BD672_b, 0x504652_b), unknown_function_stub); // ^ + utils::hook::call(SELECT_VALUE(0x3BD75A_b, 0x50473A_b), find_variable_stub); + scr_emit_function_hook.create(SELECT_VALUE(0x3BD680_b, 0x504660_b), scr_emit_function_stub); + + utils::hook::call(SELECT_VALUE(0x3BDC4F_b, 0x504C7F_b), register_gsc_functions_stub); + utils::hook::call(SELECT_VALUE(0x3BDC5B_b, 0x504C8B_b), register_gsc_methods_stub); + + utils::hook::set(SELECT_VALUE(0x3BD86C_b, 0x50484C_b), 0x1000); // change builtin func count + +#define RVA(ptr) static_cast(reinterpret_cast(ptr) - 0x140000000) + + std::memcpy(&func_table, reinterpret_cast(SELECT_VALUE(0xB8CC510_b, 0xAC83820_b)), + sizeof(reinterpret_cast(SELECT_VALUE(0xB8CC510_b, 0xAC83820_b)))); + + utils::hook::set(SELECT_VALUE(0x3BD872_b, 0x504852_b) + 4, RVA(&func_table)); + utils::hook::inject(SELECT_VALUE(0x3BDC28_b, 0x504C58_b) + 3, &func_table); + utils::hook::set(SELECT_VALUE(0x3CB718_b, 0x512778_b) + 4, RVA(&func_table)); + + std::memcpy(&meth_table, reinterpret_cast(SELECT_VALUE(0xB8CDD60_b, 0xAC85070_b)), + sizeof(reinterpret_cast(SELECT_VALUE(0xB8CDD60_b, 0xAC85070_b)))); + + utils::hook::set(SELECT_VALUE(0x3BD882_b, 0x504862_b) + 4, RVA(&meth_table)); + utils::hook::inject(SELECT_VALUE(0x3BDC36_b, 0x504C66_b) + 3, &meth_table); + utils::hook::set(SELECT_VALUE(0x3CBA3B_b, 0x512A9B_b) + 4, RVA(&meth_table)); + + // nop original code and handle calling builtin functions + utils::hook::nop(SELECT_VALUE(0x3CB723_b, 0x512783_b), 8); + utils::hook::call(SELECT_VALUE(0x3CB723_b, 0x512783_b), vm_call_builtin_function_stub); + + // same as above, but for builtin methods (different method of doing it, is this overdone?) + utils::hook::call(SELECT_VALUE(0x3CBA12_b, 0x512A72_b), get_entity_id_stub); + utils::hook::nop(SELECT_VALUE(0x3CBA46_b, 0x512AA6_b), 6); + utils::hook::nop(SELECT_VALUE(0x3CBA4E_b, 0x512AAE_b), 2); + utils::hook::call(SELECT_VALUE(0x3CBA46_b, 0x512AA6_b), vm_call_builtin_method_stub); + + function::add("print", []() + { + const auto num = game::Scr_GetNumParam(); + std::string buffer{}; + + for (auto i = 0; i < num; i++) + { + const auto str = game::Scr_GetString(i); + buffer.append(str); + buffer.append("\t"); + } + + console::info("[SCRIPT] %s\n", buffer.data()); + }); + + function::add("assert", []() + { + const auto expr = get_argument(0).as(); + if (!expr) + { + throw std::runtime_error("assert fail"); + } + }); + + function::add("assertex", []() + { + const auto expr = get_argument(0).as(); + if (!expr) + { + const auto error = get_argument(1).as(); + throw std::runtime_error(error); + } + }); + + function::add("replacefunc", []() + { + const auto what = get_argument(0).get_raw(); + const auto with = get_argument(1).get_raw(); + + if (what.type != game::SCRIPT_FUNCTION) + { + throw std::runtime_error("replaceFunc: parameter 1 must be a function"); + return; + } + + if (with.type != game::SCRIPT_FUNCTION) + { + throw std::runtime_error("replaceFunc: parameter 2 must be a function"); + return; + } + + logfile::set_gsc_hook(what.u.codePosValue, with.u.codePosValue); + }); + + function::add("toupper", []() + { + const auto string = get_argument(0).as(); + game::Scr_AddString(utils::string::to_upper(string).data()); + }); + + function::add("logprint", []() + { + std::string buffer{}; + + const auto params = game::Scr_GetNumParam(); + for (auto i = 0; i < params; i++) + { + const auto string = game::Scr_GetString(i); + buffer.append(string); + } + + game::G_LogPrintf("%s", buffer.data()); + }); + + function::add("va", []() + { + auto fmt = get_argument(0).as(); + + const auto params = game::Scr_GetNumParam(); + for (auto i = 1; i < params; i++) + { + const auto arg = get_argument(i).to_string(); + replace(fmt, "%s", arg); + } + + game::Scr_AddString(fmt.data()); + }); + + scripting::on_shutdown([](int free_scripts) + { + if (free_scripts) + { + clear(); + } + }); + } + }; +} + +REGISTER_COMPONENT(gsc::component) diff --git a/src/client/component/gsc.hpp b/src/client/component/gsc.hpp new file mode 100644 index 00000000..727722fd --- /dev/null +++ b/src/client/component/gsc.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include "game/game.hpp" + +namespace gsc +{ + using builtin_function = void(*)(); + using builtin_method = void(*)(game::scr_entref_t); + + extern void* func_table[0x1000]; + extern void* meth_table[0x1000]; + + game::ScriptFile* find_script(game::XAssetType /*type*/, const char* name, int /*allow_create_default*/); + + void load_main_handles(); + void load_init_handles(); + + namespace function + { + void add(const std::string& name, builtin_function function); + } + + namespace method + { + void add(const std::string& name, builtin_method function); + } +} diff --git a/src/client/component/logfile.cpp b/src/client/component/logfile.cpp index 64600ffe..5d04bcea 100644 --- a/src/client/component/logfile.cpp +++ b/src/client/component/logfile.cpp @@ -1,29 +1,45 @@ #include #include "loader/component_loader.hpp" -#include "scheduler.hpp" #include "logfile.hpp" +#include "scheduler.hpp" + +#include "game/dvars.hpp" #include +#include namespace logfile { - std::unordered_map vm_execute_hooks; + bool hook_enabled = true; namespace { + struct gsc_hook_t + { + bool is_lua_hook{}; + const char* target_pos{}; + sol::protected_function lua_function; + }; + + std::unordered_map vm_execute_hooks; utils::hook::detour scr_player_killed_hook; utils::hook::detour scr_player_damage_hook; utils::hook::detour client_command_hook; utils::hook::detour g_shutdown_game_hook; + utils::hook::detour g_log_printf_hook; + std::vector player_killed_callbacks; std::vector player_damage_callbacks; + game::dvar_t* logfile; + game::dvar_t* g_log; + utils::hook::detour vm_execute_hook; char empty_function[2] = {0x32, 0x34}; // CHECK_CLEAR_PARAMS, END - bool hook_enabled = true; + const char* target_function = nullptr; sol::lua_value convert_entity(lua_State* state, const game::mp::gentity_s* ent) { @@ -166,21 +182,30 @@ namespace logfile } const auto& hook = vm_execute_hooks[pos]; - const auto state = hook.lua_state(); - - const scripting::entity self = local_id_to_entity(game::scr_VmPub->function_frame->fs.localId); - - std::vector args; - - const auto top = game::scr_function_stack->top; - - for (auto* value = top; value->type != game::SCRIPT_END; --value) + if (hook.is_lua_hook) { - args.push_back(scripting::lua::convert(state, *value)); - } + const auto& function = hook.lua_function; + const auto state = function.lua_state(); - const auto result = hook(self, sol::as_args(args)); - scripting::lua::handle_error(result); + const scripting::entity self = local_id_to_entity(game::scr_VmPub->function_frame->fs.localId); + + std::vector args; + + const auto top = game::scr_function_stack->top; + + for (auto* value = top; value->type != game::SCRIPT_END; --value) + { + args.push_back(scripting::lua::convert(state, *value)); + } + + const auto result = function(self, sol::as_args(args)); + scripting::lua::handle_error(result); + target_function = empty_function; + } + else + { + target_function = hook.target_pos; + } return true; } @@ -212,9 +237,35 @@ namespace logfile a.bind(replace); a.popad64(); - a.mov(r14, reinterpret_cast(empty_function)); + a.mov(rax, qword_ptr(reinterpret_cast(&target_function))); + a.mov(r14, rax); a.jmp(end); } + + void g_log_printf_stub(const char* fmt, ...) + { + if (!logfile->current.enabled) + { + return; + } + + char va_buffer[0x400] = {0}; + + va_list ap; + va_start(ap, fmt); + vsprintf_s(va_buffer, fmt, ap); + va_end(ap); + + const auto file = g_log->current.string; + const auto time = *game::level_time / 1000; + + utils::io::write_file(file, utils::string::va("%3i:%i%i %s", + time / 60, + time % 60 / 10, + time % 60 % 10, + va_buffer + ), true); + } } void add_player_damage_callback(const sol::protected_function& callback) @@ -266,6 +317,13 @@ namespace logfile scripting::notify(level, cmd, {player, message, hidden}); scripting::notify(player, cmd, {message, hidden}); + + game::G_LogPrintf("%s;%s;%i;%s;%s\n", + cmd, + player.call("getguid").as(), + player.call("getentitynumber").as(), + player.get("name").as(), + message.data()); }, scheduler::pipeline::server); if (hidden) @@ -277,6 +335,32 @@ namespace logfile return true; } + void set_lua_hook(const char* pos, const sol::protected_function& callback) + { + gsc_hook_t hook; + hook.is_lua_hook = true; + hook.lua_function = callback; + vm_execute_hooks[pos] = hook; + } + + void set_gsc_hook(const char* source, const char* target) + { + gsc_hook_t hook; + hook.is_lua_hook = false; + hook.target_pos = target; + vm_execute_hooks[source] = hook; + } + + void clear_hook(const char* pos) + { + vm_execute_hooks.erase(pos); + } + + size_t get_hook_count() + { + return vm_execute_hooks.size(); + } + class component final : public component_interface { public: @@ -291,6 +375,14 @@ namespace logfile scr_player_damage_hook.create(0x1CE780_b, scr_player_damage_stub); scr_player_killed_hook.create(0x1CEA60_b, scr_player_killed_stub); + + // Reimplement game log + scheduler::once([]() + { + logfile = dvars::register_bool("logfile", true, game::DVAR_FLAG_NONE, "Enable game logging"); + g_log = dvars::register_string("g_log", "h1-mod\\logs\\games_mp.log", game::DVAR_FLAG_NONE, "Log file path"); + }, scheduler::pipeline::main); + g_log_printf_hook.create(game::G_LogPrintf, g_log_printf_stub); } }; } diff --git a/src/client/component/logfile.hpp b/src/client/component/logfile.hpp index 4ab67966..6618fb05 100644 --- a/src/client/component/logfile.hpp +++ b/src/client/component/logfile.hpp @@ -7,7 +7,12 @@ namespace logfile { - extern std::unordered_map vm_execute_hooks; + extern bool hook_enabled; + + void set_lua_hook(const char* pos, const sol::protected_function&); + void set_gsc_hook(const char* source, const char* target); + void clear_hook(const char* pos); + size_t get_hook_count(); void add_player_damage_callback(const sol::protected_function& callback); void add_player_killed_callback(const sol::protected_function& callback); diff --git a/src/client/component/scripting.cpp b/src/client/component/scripting.cpp index 9bcd2bc9..448ffd89 100644 --- a/src/client/component/scripting.cpp +++ b/src/client/component/scripting.cpp @@ -10,9 +10,15 @@ #include "game/scripting/lua/engine.hpp" #include "game/scripting/execution.hpp" +#include "console.hpp" +#include "gsc.hpp" #include "scheduler.hpp" #include "scripting.hpp" +#include +#include +#include + #include #include #include @@ -21,12 +27,16 @@ namespace scripting { std::unordered_map> fields_table; std::unordered_map> script_function_table; + std::unordered_map>> script_function_table_sort; utils::concurrency::container shared_table; + std::string current_file; + namespace { utils::hook::detour vm_notify_hook; utils::hook::detour vm_execute_hook; + utils::hook::detour g_load_structs_hook; utils::hook::detour scr_load_level_hook; utils::hook::detour g_shutdown_game_hook; @@ -39,12 +49,14 @@ namespace scripting utils::hook::detour db_find_xasset_header_hook; - std::string current_file; + std::string current_scriptfile; unsigned int current_file_id{}; game::dvar_t* g_dump_scripts; - std::vector> shutdown_callbacks; + std::vector> shutdown_callbacks; + + std::unordered_map canonical_string_table; void vm_notify_stub(const unsigned int notify_list_owner_id, const game::scr_string_t string_value, game::VariableValue* top) @@ -80,29 +92,55 @@ namespace scripting return vm_execute_hook.invoke(); } - void scr_load_level_stub() + void g_load_structs_stub() { - scr_load_level_hook.invoke(); if (!game::VirtualLobby_Loaded()) { + // init game in game log + game::G_LogPrintf("------------------------------------------------------------\n"); + game::G_LogPrintf("InitGame\n"); + + // start lua engine lua::engine::start(); + + // execute main handles + gsc::load_main_handles(); } + + g_load_structs_hook.invoke(); + } + + void scr_load_level_stub() + { + if (!game::VirtualLobby_Loaded()) + { + // execute init handles + gsc::load_init_handles(); + } + + scr_load_level_hook.invoke(); } void g_shutdown_game_stub(const int free_scripts) { if (free_scripts) { + script_function_table_sort.clear(); script_function_table.clear(); + canonical_string_table.clear(); } for (const auto& callback : shutdown_callbacks) { - callback(); + callback(free_scripts); } scripting::notify(*game::levelEntityId, "shutdownGame_called", {1}); lua::engine::stop(); + + game::G_LogPrintf("ShutdownGame:\n"); + game::G_LogPrintf("------------------------------------------------------------\n"); + return g_shutdown_game_hook.invoke(free_scripts); } @@ -120,10 +158,12 @@ namespace scripting void process_script_stub(const char* filename) { + current_scriptfile = filename; + const auto file_id = atoi(filename); if (file_id) { - current_file_id = file_id; + current_file_id = static_cast(file_id); } else { @@ -134,24 +174,43 @@ namespace scripting process_script_hook.invoke(filename); } + void add_function_sort(unsigned int id, const char* pos) + { + std::string filename = current_file; + if (current_file_id) + { + filename = scripting::get_token(current_file_id); + } + + if (script_function_table_sort.find(filename) == script_function_table_sort.end()) + { + const auto script = gsc::find_script(game::ASSET_TYPE_SCRIPTFILE, current_scriptfile.data(), false); + if (script) + { + const auto end = &script->bytecode[script->bytecodeLen]; + script_function_table_sort[filename].emplace_back("__end__", end); + } + } + + const auto name = scripting::get_token(id); + auto& itr = script_function_table_sort[filename]; + itr.insert(itr.end() - 1, {name, pos}); + } + void add_function(const std::string& file, unsigned int id, const char* pos) { - const auto function_names = scripting::find_token(id); - for (const auto& name : function_names) - { - script_function_table[file][name] = pos; - } + const auto name = get_token(id); + script_function_table[file][name] = pos; } void scr_set_thread_position_stub(unsigned int thread_name, const char* code_pos) { + add_function_sort(thread_name, code_pos); + if (current_file_id) { - const auto names = scripting::find_token(current_file_id); - for (const auto& name : names) - { - add_function(name, thread_name, code_pos); - } + const auto name = get_token(current_file_id); + add_function(name, thread_name, code_pos); } else { @@ -164,16 +223,36 @@ namespace scripting unsigned int sl_get_canonical_string_stub(const char* str) { const auto result = sl_get_canonical_string_hook.invoke(str); - scripting::token_map[str] = result; + canonical_string_table[result] = str; return result; } } - void on_shutdown(const std::function& callback) + std::string get_token(unsigned int id) + { + if (canonical_string_table.find(id) != canonical_string_table.end()) + { + return canonical_string_table[id]; + } + + return scripting::find_token(id); + } + + void on_shutdown(const std::function& callback) { shutdown_callbacks.push_back(callback); } + std::optional get_canonical_string(const unsigned int id) + { + if (canonical_string_table.find(id) == canonical_string_table.end()) + { + return {}; + } + + return {canonical_string_table[id]}; + } + class component final : public component_interface { public: @@ -187,11 +266,9 @@ namespace scripting process_script_hook.create(SELECT_VALUE(0x3C7200_b, 0x50E340_b), process_script_stub); sl_get_canonical_string_hook.create(game::SL_GetCanonicalString, sl_get_canonical_string_stub); - if (!game::environment::is_sp()) - { - scr_load_level_hook.create(0x450FC0_b, scr_load_level_stub); - } - else + g_load_structs_hook.create(SELECT_VALUE(0x2E7970_b, 0x458520_b), g_load_structs_stub); + scr_load_level_hook.create(SELECT_VALUE(0x2D4CD0_b, 0x450FC0_b), scr_load_level_stub); + if (game::environment::is_sp()) { vm_execute_hook.create(0x3CA080_b, vm_execute_stub); } diff --git a/src/client/component/scripting.hpp b/src/client/component/scripting.hpp index 226b275c..1fea9b02 100644 --- a/src/client/component/scripting.hpp +++ b/src/client/component/scripting.hpp @@ -7,7 +7,12 @@ namespace scripting extern std::unordered_map> fields_table; extern std::unordered_map> script_function_table; + extern std::unordered_map>> script_function_table_sort; extern utils::concurrency::container shared_table; - void on_shutdown(const std::function& callback); + extern std::string current_file; + + void on_shutdown(const std::function& callback); + std::optional get_canonical_string(const unsigned int id); + std::string get_token(unsigned int id); } \ No newline at end of file diff --git a/src/client/component/ui_scripting.cpp b/src/client/component/ui_scripting.cpp index d0b3a3b4..ba9c272f 100644 --- a/src/client/component/ui_scripting.cpp +++ b/src/client/component/ui_scripting.cpp @@ -485,24 +485,27 @@ namespace ui_scripting } } + std::string current_error; int main_handler(game::hks::lua_State* state) { - const auto value = state->m_apistack.base[-1]; - if (value.t != game::hks::TCFUNCTION) - { - return 0; - } - - const auto closure = value.v.cClosure; - if (converted_functions.find(closure) == converted_functions.end()) - { - return 0; - } - - const auto& function = converted_functions[closure]; + bool error = false; try { + const auto value = state->m_apistack.base[-1]; + if (value.t != game::hks::TCFUNCTION) + { + return 0; + } + + const auto closure = value.v.cClosure; + if (converted_functions.find(closure) == converted_functions.end()) + { + return 0; + } + + const auto& function = converted_functions[closure]; + const auto args = get_return_values(); const auto results = function(args); @@ -515,7 +518,13 @@ namespace ui_scripting } catch (const std::exception& e) { - game::hks::hksi_luaL_error(state, e.what()); + current_error = e.what(); + error = true; + } + + if (error) + { + game::hks::hksi_luaL_error(state, current_error.data()); } return 0; diff --git a/src/client/game/scripting/function_tables.cpp b/src/client/game/scripting/function_tables.cpp deleted file mode 100644 index 641f314e..00000000 --- a/src/client/game/scripting/function_tables.cpp +++ /dev/null @@ -1,4413 +0,0 @@ -#include - -// This file has been generated. -// Do not touch! - -// https://github.com/xensik/gsc-tool/blob/dev/src/h1/xsk/resolver.cpp :) - -namespace scripting -{ - std::unordered_map function_map = - { - {"precacheturret", 0x001}, // SP 0x2D08B0 MP 0x43A900 - {"getweaponarray", 0x002}, // SP 0x2C3860 MP 0x444720 - {"createprintchannel", 0x003}, // SP 0x2CDC80 MP 0x437B40 - {"updategamerprofileall", 0x004}, // SP 0x2DF5D0 MP 0x000000 - {"clearlocalizedstrings", 0x005}, // SP 0x2D8990 MP 0x000000 - {"setphysicsgravitydir", 0x006}, // SP 0x2DCBF0 MP 0x000000 - {"gettimescale", 0x007}, // SP 0x2DC8D0 MP 0x000000 - {"settimescale", 0x008}, // SP 0x2DC8F0 MP 0x000000 - {"setslowmotionview", 0x009}, // SP 0x2DC970 MP 0x000000 - {"teleportscene", 0x00A}, // SP 0x2DC910 MP 0x000000 - {"forcesharedammo", 0x00B}, // SP 0x2DC800 MP 0x000000 - {"refreshhudcompass", 0x00C}, // SP 0x2D8C10 MP 0x000000 - {"refreshhudammocounter", 0x00D}, // SP 0x2D8C40 MP 0x000000 - {"notifyoncommand", 0x00E}, // SP 0x2D8C70 MP 0x000000 - {"setprintchannel", 0x00F}, // SP 0x2CDCE0 MP 0x437C20 - {"print", 0x010}, // SP 0x2CDD70 MP 0x437C40 - {"println", 0x011}, // SP 0x2CDFB0 MP 0x438000 - {"print3d", 0x012}, // SP 0x2CEE00 MP 0x438CE0 - {"line", 0x013}, // SP 0x2CEE30 MP 0x438CF0 - {"box", 0x014}, // SP 0x2CEE80 MP 0x438D00 - {"orientedbox", 0x015}, // SP 0x2CF040 MP 0x4390B0 - {"sphere", 0x016}, // SP 0x2CF060 MP 0x439160 - {"cylinder", 0x017}, // SP 0x2CF0D0 MP 0x4392E0 - {"spawnturret", 0x018}, // SP 0x2D0360 MP 0x43A4B0 - {"canspawnturret", 0x019}, // SP 0x2D0890 MP 0x43A7E0 - {"assert", 0x01A}, // SP 0x2CF150 MP 0x439350 - {"pausecinematicingame", 0x01B}, // SP 0x2DF520 MP 0x000000 - {"drawcompassfriendlies", 0x01C}, // SP 0x2DF550 MP 0x000000 - {"bulletspread", 0x01D}, // SP 0x2DF790 MP 0x000000 - {"bullettracer", 0x01E}, // SP 0x2D6B20 MP 0x000000 - {"badplace_delete", 0x01F}, // SP 0x2C6BD0 MP 0x4495F0 - {"badplace_cylinder", 0x020}, // SP 0x2C73D0 MP 0x449DE0 - {"badplace_arc", 0x021}, // SP 0x2C79E0 MP 0x44A490 - {"badplace_brush", 0x022}, // SP 0x2C8610 MP 0x44AC30 - {"clearallcorpses", 0x023}, // SP 0x2D7EB0 MP 0x000000 - {"setturretnode", 0x024}, // SP 0x2FC0E0 MP 0x000000 - {"unsetturretnode", 0x025}, // SP 0x2FC180 MP 0x000000 - {"setnodepriority", 0x026}, // SP 0x2FC000 MP 0x000000 - {"_func_027", 0x027}, // SP 0x2FBEC0 MP 0x000000 - {"setdebugorigin", 0x02A}, // SP 0x2D8280 MP 0x000000 - {"setdebugangles", 0x02B}, // SP 0x2D8290 MP 0x000000 - {"updategamerprofile", 0x02C}, // SP 0x2D8450 MP 0x000000 - {"assertex", 0x02D}, // SP 0x2CF1F0 MP 0x439430 - {"assertmsg", 0x02E}, // SP 0x2CF340 MP 0x439540 - {"isdefined", 0x02F}, // SP 0x2CF920 MP 0x439B50 - {"isvalidmissile", 0x030}, // SP 0x2D00C0 MP 0x43A2A0 - {"isstring", 0x031}, // SP 0x2D0110 MP 0x43A390 - {"setomnvar", 0x032}, // SP 0x2D19D0 MP 0x43BE30 - {"getomnvar", 0x033}, // SP 0x2D1C90 MP 0x43C170 - {"setdvar", 0x034}, // SP 0x2BA9D0 MP 0x43C980 - {"setdynamicdvar", 0x035}, // SP 0x000000 MP 0x43CBE0 - {"setdvarifuninitialized", 0x036}, // SP 0x2BB0E0 MP 0x43D3A0 - {"setdevdvar", 0x037}, // SP 0x2BAE10 MP 0x43CF60 - {"setdevdvarifuninitialized", 0x038}, // SP 0x2BB480 MP 0x43D9D0 - {"getdvar", 0x039}, // SP 0x2BB7B0 MP 0x43DAC0 - {"getdvarint", 0x03A}, // SP 0x2BBB90 MP 0x43E340 - {"getdvarfloat", 0x03B}, // SP 0x2BC0C0 MP 0x43E580 - {"getdvarvector", 0x03C}, // SP 0x2BCAE0 MP 0x43E940 - {"gettime", 0x03D}, // SP 0x2BD990 MP 0x43F350 - {"gettimeutc", 0x03E}, // SP 0x2BD9A0 MP 0x43F390 - {"getradiometricunit", 0x03F}, // SP 0x2BD9C0 MP 0x43F590 - {"getentbynum", 0x040}, // SP 0x2BDA80 MP 0x43F5D0 - {"getscreenwidth", 0x041}, // SP 0x2BDAC0 MP 0x000000 - {"getscreenheight", 0x042}, // SP 0x2BDAD0 MP 0x000000 - {"getweaponmodel", 0x043}, // SP 0x2BDBF0 MP 0x43F6C0 - {"getculldist", 0x044}, // SP 0x2D6DE0 MP 0x000000 - {"sethalfresparticles", 0x045}, // SP 0x2D6F30 MP 0x000000 - {"getmapsunlight", 0x046}, // SP 0x2D6F70 MP 0x000000 - {"setsunlight", 0x047}, // SP 0x2D6FD0 MP 0x0B8780 - {"resetsunlight", 0x048}, // SP 0x2D70A0 MP 0x0B8810 - {"getmapsundirection", 0x049}, // SP 0x2D71D0 MP 0x000000 - {"getmapsunangles", 0x04A}, // SP 0x2D7200 MP 0x000000 - {"setsundirection", 0x04B}, // SP 0x2D7330 MP 0x000000 - {"lerpsundirection", 0x04C}, // SP 0x2D74A0 MP 0x000000 - {"lerpsunangles", 0x04D}, // SP 0x2D77E0 MP 0x000000 - {"resetsundirection", 0x04E}, // SP 0x2D79D0 MP 0x000000 - {"enableforcedsunshadows", 0x04F}, // SP 0x2D7A00 MP 0x000000 - {"enableforcednosunshadows", 0x050}, // SP 0x2D7A20 MP 0x000000 - {"disableforcedsunshadows", 0x051}, // SP 0x2D7A40 MP 0x000000 - {"enableouterspacemodellighting", 0x052}, // SP 0x2D7A60 MP 0x000000 - {"disableouterspacemodellighting", 0x053}, // SP 0x2D7B60 MP 0x000000 - {"remapstage", 0x054}, // SP 0x2D8670 MP 0x000000 - {"changelevel", 0x055}, // SP 0x2DED50 MP 0x000000 - {"missionsuccess", 0x056}, // SP 0x2DEDF0 MP 0x000000 - {"missionfailed", 0x057}, // SP 0x2DEED0 MP 0x000000 - {"cinematic", 0x058}, // SP 0x2DEEF0 MP 0x000000 - {"cinematicingame", 0x059}, // SP 0x2DEFD0 MP 0x000000 - {"cinematicingamesync", 0x05A}, // SP 0x2DF070 MP 0x000000 - {"cinematicingameloop", 0x05B}, // SP 0x2DF150 MP 0x000000 - {"cinematicingameloopresident", 0x05C}, // SP 0x2DF2F0 MP 0x000000 - {"iscinematicplaying", 0x05D}, // SP 0x2DF370 MP 0x000000 - {"stopcinematicingame", 0x05E}, // SP 0x2DF500 MP 0x000000 - {"getweapondisplayname", 0x05F}, // SP 0x2BE240 MP 0x43FE40 - {"getweaponbasename", 0x060}, // SP 0x2BE4D0 MP 0x440150 - {"getweaponattachments", 0x061}, // SP 0x2BE820 MP 0x4407D0 - {"getweaponattachmentdisplaynames", 0x062}, // SP 0x2BEBA0 MP 0x4410F0 - {"getweaponcamoname", 0x063}, // SP 0x2BFBC0 MP 0x4421F0 - {"getweaponreticlename", 0x064}, // SP 0x2C0030 MP 0x442680 - {"getanimlength", 0x065}, // SP 0x2C2010 MP 0x4446C0 - {"animhasnotetrack", 0x066}, // SP 0x2C2410 MP 0x4447F0 - {"getnotetracktimes", 0x067}, // SP 0x2C2500 MP 0x444A10 - {"spawn", 0x068}, // SP 0x2CFF60 MP 0x439BE0 - {"spawnloopsound", 0x069}, // SP 0x2CFF60 MP 0x439BE0 - {"spawnloopingsound", 0x06A}, // SP 0x4C6570 MP 0x443210 - {"bullettrace", 0x06B}, // SP 0x2BAC20 MP 0x439D30 - {"target_setmaxsize", 0x06C}, // SP 0x2EAEE0 MP 0x000000 - {"target_setcolor", 0x06D}, // SP 0x2EA9F0 MP 0x000000 - {"target_setdelay", 0x06E}, // SP 0x2EAB80 MP 0x000000 - {"getstartorigin", 0x06F}, // SP 0x289CA0 MP 0x0E0750 - {"getstartangles", 0x070}, // SP 0x289B90 MP 0x0E0A10 - {"getcycleoriginoffset", 0x071}, // SP 0x289A40 MP 0x000000 - {"magicgrenade", 0x072}, // SP 0x2DF3E0 MP 0x000000 - {"magicgrenademanual", 0x073}, // SP 0x2CF9E0 MP 0x43D1B0 - {"setblur", 0x074}, // SP 0x2DB190 MP 0x000000 - {"musicplay", 0x075}, // SP 0x2DB2B0 MP 0x000000 - {"musicstop", 0x076}, // SP 0x2DB4E0 MP 0x000000 - {"soundfade", 0x077}, // SP 0x2DB6E0 MP 0x000000 - {"addsoundsubmix", 0x078}, // SP 0x2BEB80 MP 0x43FB10 - {"clearsoundsubmix", 0x079}, // SP 0x2BED00 MP 0x43FB60 - {"clearallsubmixes", 0x07A}, // SP 0x2BED70 MP 0x43FDC0 - {"blendsoundsubmix", 0x07B}, // SP 0x2BEDD0 MP 0x43FF20 - {"makesoundsubmixsticky", 0x07C}, // SP 0x2BEE10 MP 0x43FF40 - {"makesoundsubmixunsticky", 0x07D}, // SP 0x2BEE90 MP 0x43FFC0 - {"soundsettimescalefactor", 0x07E}, // SP 0x2DB940 MP 0x000000 - {"soundresettimescale", 0x07F}, // SP 0x2DC960 MP 0x000000 - {"levelsoundfade", 0x080}, // SP 0x2DB7A0 MP 0x000000 - {"precachenightvisioncodeassets", 0x081}, // SP 0x2DECA0 MP 0x000000 - {"precachedigitaldistortcodeassets", 0x083}, // SP 0x2DECC0 MP 0x000000 - {"precacheminimapsentrycodeassets", 0x084}, // SP 0x2DED30 MP 0x000000 - {"savegame", 0x085}, // SP 0x2DCA60 MP 0x000000 - {"issavesuccessful", 0x086}, // SP 0x2DD7A0 MP 0x000000 - {"issaverecentlyloaded", 0x087}, // SP 0x2DD7C0 MP 0x000000 - {"savegamenocommit", 0x088}, // SP 0x2DCED0 MP 0x000000 - {"commitsave", 0x089}, // SP 0x2DD7E0 MP 0x000000 - {"commitwouldbevalid", 0x08A}, // SP 0x2DD880 MP 0x000000 - {"getfxvisibility", 0x08B}, // SP 0x2DF570 MP 0x000000 - {"setculldist", 0x08C}, // SP 0x2D6D90 MP 0x000000 - {"bullettracepassed", 0x08D}, // SP 0x2BB600 MP 0x43A830 - {"sighttracepassed", 0x08E}, // SP 0x2BB860 MP 0x43AD40 - {"physicstrace", 0x08F}, // SP 0x2BBF70 MP 0x43B500 - {"playerphysicstrace", 0x090}, // SP 0x2BC200 MP 0x43B7B0 - {"getgroundposition", 0x091}, // SP 0x2BE560 MP 0x43D4B0 - {"getmovedelta", 0x092}, // SP 0x2C2780 MP 0x442560 - {"getangledelta", 0x093}, // SP 0x2C2F20 MP 0x442B50 - {"getnorthyaw", 0x094}, // SP 0x2C3E10 MP 0x443980 - {"getcommandfromkey", 0x095}, // SP 0x2DB5B0 MP 0x000000 - {"getsticksconfig", 0x096}, // SP 0x2DB760 MP 0x000000 - {"weaponfightdist", 0x097}, // SP 0x2DD930 MP 0x000000 - {"weaponmaxdist", 0x098}, // SP 0x2DD980 MP 0x000000 - {"isturretactive", 0x099}, // SP 0x2DD8F0 MP 0x000000 - {"getstarttime", 0x09A}, // SP 0x2DAA40 MP 0x000000 - {"target_alloc", 0x09B}, // SP 0x2EA180 MP 0x000000 - {"target_flush", 0x09C}, // SP 0x2EA5B0 MP 0x000000 - {"target_set", 0x09D}, // SP 0x2EA890 MP 0x000000 - {"target_remove", 0x09E}, // SP 0x2EA850 MP 0x000000 - {"target_setshader", 0x09F}, // SP 0x2EB560 MP 0x000000 - {"target_setoffscreenshader", 0x0A0}, // SP 0x2EB190 MP 0x000000 - {"target_isinrect", 0x0A1}, // SP 0x2EA730 MP 0x000000 - {"target_isincircle", 0x0A2}, // SP 0x2EA6C0 MP 0x000000 - {"target_startreticlelockon", 0x0A3}, // SP 0x2EB6B0 MP 0x000000 - {"target_clearreticlelockon", 0x0A4}, // SP 0x2EA1A0 MP 0x000000 - {"target_getarray", 0x0A5}, // SP 0x2EA640 MP 0x000000 - {"target_istarget", 0x0A6}, // SP 0x2EA7D0 MP 0x000000 - {"target_setattackmode", 0x0A7}, // SP 0x2EA8B0 MP 0x000000 - {"target_setjavelinonly", 0x0A8}, // SP 0x2EAD90 MP 0x000000 - {"target_hidefromplayer", 0x0A9}, // SP 0x2EA6B0 MP 0x000000 - {"target_showtoplayer", 0x0AA}, // SP 0x2EB6A0 MP 0x000000 - {"target_setscaledrendermode", 0x0AB}, // SP 0x2EB410 MP 0x000000 - {"target_drawcornersonly", 0x0AC}, // SP 0x2EA1D0 MP 0x000000 - {"target_drawsquare", 0x0AD}, // SP 0x2EA440 MP 0x000000 - {"target_drawsingle", 0x0AE}, // SP 0x2EA320 MP 0x000000 - {"target_setminsize", 0x0AF}, // SP 0x2EB020 MP 0x000000 - {"setnorthyaw", 0x0B0}, // SP 0x2C3EB0 MP 0x443D70 - {"setslowmotion", 0x0B1}, // SP 0x2BC560 MP 0x43D2E0 - {"randomint", 0x0B2}, // SP 0x2BE910 MP 0x43DB30 - {"randomfloat", 0x0B3}, // SP 0x2BEA90 MP 0x43E2C0 - {"randomintrange", 0x0B4}, // SP 0x2BEB30 MP 0x43E2F0 - {"randomfloatrange", 0x0B5}, // SP 0x2BED20 MP 0x43E470 - {"sin", 0x0B6}, // SP 0x2BEE50 MP 0x43E5F0 - {"cos", 0x0B7}, // SP 0x2BEF00 MP 0x43E6B0 - {"tan", 0x0B8}, // SP 0x2BF080 MP 0x43E6E0 - {"asin", 0x0B9}, // SP 0x2BF1A0 MP 0x43E7B0 - {"acos", 0x0BA}, // SP 0x2BF750 MP 0x43E8F0 - {"atan", 0x0BB}, // SP 0x2BF9A0 MP 0x43EBA0 - {"int", 0x0BC}, // SP 0x2BFDD0 MP 0x43ECF0 - {"float", 0x0BD}, // SP 0x2BFFC0 MP 0x43F160 - {"abs", 0x0BE}, // SP 0x2C04C0 MP 0x43F320 - {"min", 0x0BF}, // SP 0x2C0500 MP 0x43F360 - {"objective_additionalcurrent", 0x0C0}, // SP 0x2E6840 MP 0x000000 - {"objective_ring", 0x0C1}, // SP 0x2E6980 MP 0x000000 - {"objective_setpointertextoverride", 0x0C2}, // SP 0x2E6A40 MP 0x000000 - {"getnode", 0x0C3}, // SP 0x2FB900 MP 0x3FC1F0 - {"getnodearray", 0x0C4}, // SP 0x2FBA10 MP 0x3FC300 - {"getallnodes", 0x0C5}, // SP 0x2FB6E0 MP 0x3FBFD0 - {"getnodesinradius", 0x0C6}, // SP 0x2FBB20 MP 0x3FC4B0 - {"getnodesinradiussorted", 0x0C7}, // SP 0x2FBB30 MP 0x3FC4C0 - {"getclosestnodeinsight", 0x0C8}, // SP 0x2FB730 MP 0x3FC020 - {"getreflectionlocs", 0x0C9}, // SP 0x2D89B0 MP 0x000000 - {"getreflectionreferencelocs", 0x0CA}, // SP 0x2D8C00 MP 0x000000 - {"getvehicletracksegment", 0x0CB}, // SP 0x4EB1D0 MP 0x000000 - {"getvehicletracksegmentarray", 0x0CC}, // SP 0x4EB2B0 MP 0x000000 - {"getallvehicletracksegments", 0x0CD}, // SP 0x4EB180 MP 0x000000 - {"isarray", 0x0CE}, // SP 0x2CA9D0 MP 0x436610 - {"isai", 0x0CF}, // SP 0x2D93A0 MP 0x0B8480 - {"getindexforluincstring", 0x0D0}, // SP 0x2D11B0 MP 0x43AEA0 - {"issentient", 0x0D1}, // SP 0x2D0130 MP 0x43A460 - {"isgodmode", 0x0D2}, // SP 0x2D94B0 MP 0x000000 - {"getdebugdvar", 0x0D3}, // SP 0x2DA640 MP 0x000000 - {"getdebugdvarint", 0x0D4}, // SP 0x2DA6D0 MP 0x000000 - {"getdebugdvarfloat", 0x0D5}, // SP 0x2DA700 MP 0x000000 - {"setsaveddvar", 0x0D6}, // SP 0x2DA730 MP 0x000000 - {"getfreeaicount", 0x0D7}, // SP 0x2DAA50 MP 0x000000 - {"getaicount", 0x0D8}, // SP 0x2DAA60 MP 0x000000 - {"getaiarray", 0x0D9}, // SP 0x2DACC0 MP 0x000000 - {"getaispeciesarray", 0x0DA}, // SP 0x2DAD90 MP 0x000000 - {"getspawnerarray", 0x0DB}, // SP 0x2DAFE0 MP 0x000000 - {"getcorpsearray", 0x0DC}, // SP 0x2DAF30 MP 0x000000 - {"getspawnerteamarray", 0x0DD}, // SP 0x2DB0F0 MP 0x000000 - {"getweaponclipmodel", 0x0DE}, // SP 0x2DB230 MP 0x000000 - {"getbrushmodelcenter", 0x0DF}, // SP 0x2DB440 MP 0x000000 - {"getkeybinding", 0x0E0}, // SP 0x2DB450 MP 0x000000 - {"max", 0x0E1}, // SP 0x2C05E0 MP 0x43F560 - {"floor", 0x0E2}, // SP 0x2C0650 MP 0x43F5B0 - {"ceil", 0x0E3}, // SP 0x2C07B0 MP 0x43F620 - {"exp", 0x0E4}, // SP 0x2C0A00 MP 0x43F640 - {"exp", 0x0E5}, // SP 0x2C0A20 MP 0x43F670 - {"log", 0x0E6}, // SP 0x2C0A40 MP 0x43F6A0 - {"sqrt", 0x0E7}, // SP 0x2C0A80 MP 0x43F7A0 - {"squared", 0x0E8}, // SP 0x2C0B10 MP 0x43F8D0 - {"clamp", 0x0E9}, // SP 0x2C0D50 MP 0x43F940 - {"angleclamp", 0x0EA}, // SP 0x2C0E40 MP 0x43FA60 - {"angleclamp180", 0x0EB}, // SP 0x2C11C0 MP 0x43FAC0 - {"vectorfromlinetopoint", 0x0EC}, // SP 0x2C3460 MP 0x4415F0 - {"pointonsegmentnearesttopoint", 0x0ED}, // SP 0x2C38D0 MP 0x442060 - {"distance", 0x0EE}, // SP 0x2C4190 MP 0x442A60 - {"distance2d", 0x0EF}, // SP 0x2C43B0 MP 0x442AF0 - {"distancesquared", 0x0F0}, // SP 0x2C46B0 MP 0x442E20 - {"length", 0x0F1}, // SP 0x2C4960 MP 0x442EC0 - {"length2d", 0x0F2}, // SP 0x2C4A70 MP 0x442FE0 - {"lengthsquared", 0x0F3}, // SP 0x2C4BC0 MP 0x443090 - {"length2dsquared", 0x0F4}, // SP 0x2C4D10 MP 0x443280 - {"closer", 0x0F5}, // SP 0x2C4E10 MP 0x443650 - {"vectordot", 0x0F6}, // SP 0x2C4FF0 MP 0x4437D0 - {"vectorcross", 0x0F7}, // SP 0x2C5260 MP 0x4438D0 - {"axistoangles", 0x0F8}, // SP 0x2C5F50 MP 0x444550 - {"visionsetthermal", 0x0F9}, // SP 0x2D6D50 MP 0x0B7F50 - {"visionsetpain", 0x0FA}, // SP 0x2D6D60 MP 0x0B8030 - {"endlobby", 0x0FB}, // SP 0x000000 MP 0x0D0860 - {"setac130ambience", 0x0FC}, // SP 0x000000 MP 0x0DFE30 - {"getmapcustom", 0x0FD}, // SP 0x000000 MP 0x0BB330 - {"spawnsighttrace", 0x0FE}, // SP 0x000000 MP 0x0E2320 - {"incrementcounter", 0x0FF}, // SP 0x2D8EF0 MP 0x0E0C10 - {"getcountertotal", 0x100}, // SP 0x2D9050 MP 0x0E1740 - {"getlevelticks", 0x101}, // SP 0x2BDA70 MP 0x000000 - {"perlinnoise2d", 0x102}, // SP 0x2C1250 MP 0x000000 - {"calcrockingangles", 0x103}, // SP 0x2C1360 MP 0x000000 - {"reconevent", 0x104}, // SP 0x5D2CD0 MP 0x4F8C00 - {"reconspatialevent", 0x105}, // SP 0x5D2CE0 MP 0x4F8C10 - {"setsunflareposition", 0x106}, // SP 0x2C4F70 MP 0x000000 - {"createthreatbiasgroup", 0x107}, // SP 0x307B30 MP 0x08F880 - {"threatbiasgroupexists", 0x108}, // SP 0x307B60 MP 0x08F8B0 - {"getthreatbias", 0x109}, // SP 0x307BA0 MP 0x08F8F0 - {"setthreatbias", 0x10A}, // SP 0x307C00 MP 0x08F950 - {"setthreatbiasagainstall", 0x10B}, // SP 0x307C80 MP 0x08F9D0 - {"setignoremegroup", 0x10C}, // SP 0x307CD0 MP 0x08FA20 - {"isenemyteam", 0x10D}, // SP 0x307E10 MP 0x08FBC0 - {"objective_additionalentity", 0x10E}, // SP 0x2E6290 MP 0x000000 - {"objective_state_nomessage", 0x10F}, // SP 0x2E6590 MP 0x000000 - {"objective_string", 0x110}, // SP 0x2E65A0 MP 0x000000 - {"objective_string_nomessage", 0x111}, // SP 0x2E65B0 MP 0x000000 - {"objective_additionalposition", 0x112}, // SP 0x2E67B0 MP 0x000000 - {"objective_current_nomessage", 0x113}, // SP 0x2E6830 MP 0x000000 - {"vectornormalize", 0x114}, // SP 0x2C5470 MP 0x4439D0 - {"vectortoangles", 0x115}, // SP 0x2C55F0 MP 0x443E10 - {"vectortoyaw", 0x116}, // SP 0x2C5940 MP 0x444100 - {"vectorlerp", 0x117}, // SP 0x2C5AA0 MP 0x4441A0 - {"anglestoup", 0x118}, // SP 0x2C6240 MP 0x444790 - {"anglestoright", 0x119}, // SP 0x2C6400 MP 0x4449C0 - {"anglestoforward", 0x11A}, // SP 0x2C6460 MP 0x444A60 - {"anglesdelta", 0x11B}, // SP 0x2C6590 MP 0x444C70 - {"combineangles", 0x11C}, // SP 0x2C6A00 MP 0x444F00 - {"transformmove", 0x11D}, // SP 0x2C6C10 MP 0x445080 - {"rotatevector", 0x11E}, // SP 0x2C9010 MP 0x446C90 - {"rotatepointaroundvector", 0x11F}, // SP 0x2C91E0 MP 0x446E90 - {"issubstr", 0x120}, // SP 0x2CA530 MP 0x448130 - {"isendstr", 0x121}, // SP 0x2CA5F0 MP 0x4481D0 - {"getsubstr", 0x122}, // SP 0x2CA6F0 MP 0x4482E0 - {"tolower", 0x123}, // SP 0x2CACC0 MP 0x448E30 - {"strtok", 0x124}, // SP 0x2CB0F0 MP 0x4492B0 - {"stricmp", 0x125}, // SP 0x2CB800 MP 0x449FC0 - {"ambientplay", 0x126}, // SP 0x2BBC10 MP 0x43B1A0 - {"getuavstrengthmax", 0x127}, // SP 0x000000 MP 0x0CF770 - {"getuavstrengthlevelneutral", 0x128}, // SP 0x000000 MP 0x0CF850 - {"getuavstrengthlevelshowenemyfastsweep", 0x129}, // SP 0x000000 MP 0x0CF920 - {"getuavstrengthlevelshowenemydirectional", 0x12A}, // SP 0x000000 MP 0x0CFA10 - {"blockteamradar", 0x12B}, // SP 0x000000 MP 0x0CFB10 - {"unblockteamradar", 0x12C}, // SP 0x000000 MP 0x0D00D0 - {"isteamradarblocked", 0x12D}, // SP 0x000000 MP 0x0D0430 - {"getassignedteam", 0x12E}, // SP 0x000000 MP 0x0BAC90 - {"setmatchdata", 0x12F}, // SP 0x000000 MP 0x0C7ED0 - {"getmatchdata", 0x130}, // SP 0x000000 MP 0x0BB7F0 - {"sendmatchdata", 0x131}, // SP 0x000000 MP 0x0BBC30 - {"clearmatchdata", 0x132}, // SP 0x000000 MP 0x0BFF00 - {"setmatchdatadef", 0x133}, // SP 0x000000 MP 0x0C81E0 - {"setmatchclientip", 0x134}, // SP 0x000000 MP 0x0C0310 - {"setmatchdataid", 0x135}, // SP 0x000000 MP 0x0BF830 - {"setclientmatchdata", 0x136}, // SP 0x000000 MP 0x0C0000 - {"getclientmatchdata", 0x137}, // SP 0x000000 MP 0x0BB4A0 - {"setclientmatchdatadef", 0x138}, // SP 0x000000 MP 0x0C8730 - {"sendclientmatchdata", 0x139}, // SP 0x000000 MP 0x0C9F50 - {"getbuildversion", 0x13A}, // SP 0x000000 MP 0x0CAC50 - {"getbuildnumber", 0x13B}, // SP 0x000000 MP 0x0CADA0 - {"getsystemtime", 0x13C}, // SP 0x000000 MP 0x0CB000 - {"getmatchrulesdata", 0x13D}, // SP 0x000000 MP 0x0C8EB0 - {"isusingmatchrulesdata", 0x13E}, // SP 0x000000 MP 0x0C9170 - {"kick", 0x13F}, // SP 0x000000 MP 0x0E4200 - {"issplitscreen", 0x140}, // SP 0x2D8440 MP 0x0B9EB0 - {"setmapcenter", 0x141}, // SP 0x000000 MP 0x0CD940 - {"setgameendtime", 0x142}, // SP 0x000000 MP 0x0CDB60 - {"visionsetthermal", 0x143}, // SP 0x2D6BE0 MP 0x0B7B80 - {"visionsetpain", 0x144}, // SP 0x2D6BF0 MP 0x0B7C50 - {"visionsetnight", 0x145}, // SP 0x2D6C00 MP 0x0B7D50 - {"ambientstop", 0x146}, // SP 0x2BDF30 MP 0x43D630 - {"precachemodel", 0x147}, // SP 0x2CC0B0 MP 0x44B080 - {"precacheshellshock", 0x148}, // SP 0x2CC460 MP 0x44B4A0 - {"precacheitem", 0x149}, // SP 0x2BAF20 MP 0x4399B0 - {"precacheshader", 0x14A}, // SP 0x2BB0A0 MP 0x439BA0 - {"precachestring", 0x14B}, // SP 0x2BB590 MP 0x43A800 - {"precachemenu", 0x14C}, // SP 0x2BB740 MP 0x43AAD0 - {"precacherumble", 0x14D}, // SP 0x2BB830 MP 0x43AD10 - {"precachelocationselector", 0x14E}, // SP 0x2CC2B0 MP 0x44B170 - {"precacheleaderboards", 0x14F}, // SP 0x2BB3D0 MP 0x43A270 - {"loadfx", 0x150}, // SP 0x2C45B0 MP 0x4444A0 - {"playfx", 0x151}, // SP 0x2C57B0 MP 0x4451F0 - {"playfxontag", 0x152}, // SP 0x2C6D30 MP 0x446B50 - {"stopfxontag", 0x153}, // SP 0x2C8EF0 MP 0x448660 - {"killfxontag", 0x154}, // SP 0x2C9500 MP 0x449C90 - {"playloopedfx", 0x155}, // SP 0x4F7EB0 MP 0x1CE5A0 - {"spawnfx", 0x156}, // SP 0x4F8230 MP 0x1CEE00 - {"triggerfx", 0x157}, // SP 0x4F84E0 MP 0x1CF3E0 - {"playfxontagforclients", 0x158}, // SP 0x2C7780 MP 0x4472A0 - {"setfxkillondelete", 0x159}, // SP 0x4F81C0 MP 0x1CED00 - {"playimpactheadfatalfx", 0x15A}, // SP 0x2C8830 MP 0x447F80 - {"setwinningteam", 0x15B}, // SP 0x000000 MP 0x0B8B70 - {"announcement", 0x15C}, // SP 0x000000 MP 0x0B8D70 - {"clientannouncement", 0x15D}, // SP 0x000000 MP 0x0B8E00 - {"setteammode", 0x15E}, // SP 0x000000 MP 0x0B9070 - {"getteamscore", 0x15F}, // SP 0x000000 MP 0x0B92D0 - {"setteamscore", 0x160}, // SP 0x000000 MP 0x0B9490 - {"setclientnamemode", 0x161}, // SP 0x000000 MP 0x0B9600 - {"updateclientnames", 0x162}, // SP 0x000000 MP 0x0B9870 - {"getteamplayersalive", 0x163}, // SP 0x000000 MP 0x0B9A60 - {"logprint", 0x164}, // SP 0x000000 MP 0x0DB730 - {"worldentnumber", 0x165}, // SP 0x000000 MP 0x0DB830 - {"obituary", 0x166}, // SP 0x000000 MP 0x0DB9F0 - {"positionwouldtelefrag", 0x167}, // SP 0x000000 MP 0x0DCF60 - {"canspawn", 0x168}, // SP 0x000000 MP 0x0DE2A0 - {"getstarttime", 0x169}, // SP 0x000000 MP 0x0E10B0 - {"precacheheadicon", 0x16A}, // SP 0x2BB450 MP 0x43A5A0 - {"precacheminimapicon", 0x16B}, // SP 0x000000 MP 0x0E4CD0 - {"precachempanim", 0x16C}, // SP 0x000000 MP 0x0E4D80 - {"map_restart", 0x16D}, // SP 0x000000 MP 0x0E20A0 - {"exitlevel", 0x16E}, // SP 0x000000 MP 0x0E2670 - {"addtestclient", 0x16F}, // SP 0x000000 MP 0x0E28C0 - {"addagent", 0x170}, // SP 0x000000 MP 0x0E3590 - {"setarchive", 0x171}, // SP 0x000000 MP 0x0B9E80 - {"allclientsprint", 0x172}, // SP 0x000000 MP 0x0E3840 - {"clientprint", 0x173}, // SP 0x000000 MP 0x0E4950 - {"mapexists", 0x174}, // SP 0x000000 MP 0x0E3BE0 - {"isvalidgametype", 0x175}, // SP 0x000000 MP 0x0E3E10 - {"matchend", 0x176}, // SP 0x000000 MP 0x0B9F80 - {"setplayerteamrank", 0x177}, // SP 0x000000 MP 0x0BA120 - {"endparty", 0x178}, // SP 0x000000 MP 0x0BA790 - {"setteamradar", 0x179}, // SP 0x000000 MP 0x0CE3D0 - {"getteamradar", 0x17A}, // SP 0x000000 MP 0x0CE5C0 - {"setteamradarstrength", 0x17B}, // SP 0x000000 MP 0x0CEBE0 - {"getteamradarstrength", 0x17C}, // SP 0x000000 MP 0x0CF390 - {"getuavstrengthmin", 0x17D}, // SP 0x000000 MP 0x0CF650 - {"physicsexplosionsphere", 0x17E}, // SP 0x2C9C20 MP 0x44B1B0 - {"physicsexplosioncylinder", 0x17F}, // SP 0x2CAFB0 MP 0x44C5B0 - {"physicsjolt", 0x180}, // SP 0x2CA890 MP 0x44BC90 - {"physicsjitter", 0x181}, // SP 0x2CAA80 MP 0x44C060 - {"setexpfog", 0x182}, // SP 0x2CD880 MP 0x436D30 - {"setexpfogext", 0x183}, // SP 0x2CD9C0 MP 0x436DE0 - {"setexpfogdvarsonly", 0x184}, // SP 0x2CDEF0 MP 0x437400 - {"setexpfogextdvarsonly", 0x185}, // SP 0x2CDFC0 MP 0x437540 - {"setatmosfog", 0x186}, // SP 0x2CE170 MP 0x4375C0 - {"setatmosfogdvarsonly", 0x187}, // SP 0x2CE6D0 MP 0x4378A0 - {"isexplosivedamagemod", 0x188}, // SP 0x2BEFE0 MP 0x43EC90 - {"radiusdamage", 0x189}, // SP 0x2C04F0 MP 0x43FA50 - {"setplayerignoreradiusdamage", 0x18A}, // SP 0x2C1340 MP 0x440970 - {"glassradiusdamage", 0x18B}, // SP 0x2C0680 MP 0x43FB80 - {"earthquake", 0x18C}, // SP 0x2CE580 MP 0x438010 - {"getnumparts", 0x18D}, // SP 0x2CE8F0 MP 0x437A20 - {"objective_onentity", 0x18E}, // SP 0x2E6450 MP 0x457970 - {"objective_onentitywithrotation", 0x18F}, // SP 0x000000 MP 0x4579D0 - {"objective_team", 0x190}, // SP 0x000000 MP 0x457B10 - {"objective_player", 0x191}, // SP 0x000000 MP 0x457BB0 - {"objective_playerteam", 0x192}, // SP 0x000000 MP 0x457C10 - {"objective_playerenemyteam", 0x193}, // SP 0x000000 MP 0x457CB0 - {"objective_playermask_hidefromall", 0x194}, // SP 0x000000 MP 0x457DB0 - {"objective_playermask_hidefrom", 0x195}, // SP 0x000000 MP 0x457DF0 - {"objective_playermask_showtoall", 0x196}, // SP 0x000000 MP 0x457E60 - {"objective_playermask_showto", 0x197}, // SP 0x000000 MP 0x457EA0 - {"iprintln", 0x198}, // SP 0x2D8FD0 MP 0x0B8450 - {"iprintlnbold", 0x199}, // SP 0x2D90A0 MP 0x0B8590 - {"logstring", 0x19A}, // SP 0x2DB790 MP 0x0B9480 - {"getent", 0x19B}, // SP 0x2E84B0 MP 0x458EB0 - {"getentarray", 0x19C}, // SP 0x2E8520 MP 0x458F80 - {"getspawnarray", 0x19D}, // SP 0x000000 MP 0x459550 - {"spawnplane", 0x19E}, // SP 0x000000 MP 0x0B89A0 - {"spawnstruct", 0x19F}, // SP 0x3C7BA0 MP 0x50ECD0 - {"spawnhelicopter", 0x1A0}, // SP 0x000000 MP 0x0B9130 - {"isalive", 0x1A1}, // SP 0x2D9120 MP 0x0B85C0 - {"isspawner", 0x1A2}, // SP 0x2D9270 MP 0x0B8730 - {"missile_createattractorent", 0x1A3}, // SP 0x2B03A0 MP 0x42CE40 - {"missile_createattractororigin", 0x1A4}, // SP 0x2B03B0 MP 0x42CE50 - {"missile_createrepulsorent", 0x1A5}, // SP 0x2B0670 MP 0x42D100 - {"missile_createrepulsororigin", 0x1A6}, // SP 0x2B0680 MP 0x42D110 - {"missile_deleteattractor", 0x1A7}, // SP 0x2B0690 MP 0x42D120 - {"playsoundatpos", 0x1A8}, // SP 0x000000 MP 0x0BAFB0 - {"newhudelem", 0x1A9}, // SP 0x29BEE0 MP 0x41A250 - {"newclienthudelem", 0x1AA}, // SP 0x29BE80 MP 0x41A1F0 - {"newteamhudelem", 0x1AB}, // SP 0x000000 MP 0x41A280 - {"resettimeout", 0x1AC}, // SP 0x3C93F0 MP 0x510450 - {"isplayer", 0x1AD}, // SP 0x2D9300 MP 0x0B8240 - {"isplayernumber", 0x1AE}, // SP 0x000000 MP 0x0B8610 - {"getpartname", 0x1AF}, // SP 0x2CEA40 MP 0x437B50 - {"weaponfiretime", 0x1B0}, // SP 0x2CFEC0 MP 0x436E20 - {"weaponclipsize", 0x1B1}, // SP 0x2CD0B0 MP 0x44C9C0 - {"weaponisauto", 0x1B2}, // SP 0x2CDF20 MP 0x435450 - {"weaponissemiauto", 0x1B3}, // SP 0x2CE1A0 MP 0x435740 - {"weaponisboltaction", 0x1B4}, // SP 0x2CE790 MP 0x435EA0 - {"weaponinheritsperks", 0x1B5}, // SP 0x2CE930 MP 0x436070 - {"weaponburstcount", 0x1B6}, // SP 0x2CE4F0 MP 0x435A20 - {"weapontype", 0x1B7}, // SP 0x2CEBA0 MP 0x4361B0 - {"weaponclass", 0x1B8}, // SP 0x2CED70 MP 0x436390 - {"getnextarraykey", 0x1B9}, // SP 0x2C1210 MP 0x4415B0 - {"sortbydistance", 0x1BA}, // SP 0x2C1920 MP 0x4422A0 - {"tablelookup", 0x1BB}, // SP 0x2D10F0 MP 0x439A10 - {"tablelookupbyrow", 0x1BC}, // SP 0x2BB350 MP 0x43BBD0 - {"tablelookupistring", 0x1BD}, // SP 0x2D1910 MP 0x43A730 - {"tablelookupistringbyrow", 0x1BE}, // SP 0x2BB510 MP 0x43C0F0 - {"tablelookuprownum", 0x1BF}, // SP 0x2D1D40 MP 0x43AC60 - {"tableexists", 0x1C0}, // SP 0x2BABD0 MP 0x43B8C0 - {"getmissileowner", 0x1C1}, // SP 0x2CDC90 MP 0x4377E0 - {"magicbullet", 0x1C2}, // SP 0x2CA1A0 MP 0x44B740 - {"getweaponflashtagname", 0x1C3}, // SP 0x2CAF70 MP 0x44C7D0 - {"averagepoint", 0x1C4}, // SP 0x2BAF60 MP 0x43B910 - {"averagenormal", 0x1C5}, // SP 0x2BB170 MP 0x43BC50 - {"vehicle_getspawnerarray", 0x1C6}, // SP 0x4E9050 MP 0x60E8F0 - {"playrumbleonposition", 0x1C7}, // SP 0x2CCC00 MP 0x44C280 - {"playrumblelooponposition", 0x1C8}, // SP 0x2CCC60 MP 0x44C3F0 - {"stopallrumbles", 0x1C9}, // SP 0x2CCCE0 MP 0x44C450 - {"soundexists", 0x1CA}, // SP 0x2C3400 MP 0x445BD0 - {"openfile", 0x1CB}, // SP 0x2BEB10 MP 0x43F930 - {"closefile", 0x1CC}, // SP 0x2BEB20 MP 0x43FA40 - {"fprintln", 0x1CD}, // SP 0x2BEB90 MP 0x43FB70 - {"fprintfields", 0x1CE}, // SP 0x2BED10 MP 0x43FE30 - {"freadln", 0x1CF}, // SP 0x2BEDC0 MP 0x43FF30 - {"fgetarg", 0x1D0}, // SP 0x2BEDE0 MP 0x43FFB0 - {"setminimap", 0x1D1}, // SP 0x2BFC60 MP 0x440B10 - {"setthermalbodymaterial", 0x1D2}, // SP 0x2C0170 MP 0x441260 - {"getarraykeys", 0x1D3}, // SP 0x2C0D20 MP 0x441430 - {"getfirstarraykey", 0x1D4}, // SP 0x2C0E10 MP 0x441580 - {"getglass", 0x1D5}, // SP 0x2BB400 MP 0x43BEB0 - {"getglassarray", 0x1D6}, // SP 0x2BB6D0 MP 0x43C2C0 - {"getglassorigin", 0x1D7}, // SP 0x2BB9D0 MP 0x43C600 - {"isglassdestroyed", 0x1D8}, // SP 0x2BBB40 MP 0x43CAB0 - {"destroyglass", 0x1D9}, // SP 0x2BBEC0 MP 0x43CB20 - {"deleteglass", 0x1DA}, // SP 0x2BC080 MP 0x43CD10 - {"getentchannelscount", 0x1DB}, // SP 0x2BCBE0 MP 0x43D7D0 - {"getentchannelname", 0x1DC}, // SP 0x2BCC00 MP 0x43DA60 - {"objective_add", 0x1DD}, // SP 0x2E5DB0 MP 0x457650 - {"objective_delete", 0x1DE}, // SP 0x2E6250 MP 0x457780 - {"objective_state", 0x1DF}, // SP 0x2E6580 MP 0x4577F0 - {"objective_icon", 0x1E0}, // SP 0x2E65C0 MP 0x457890 - {"objective_indentlevel", 0x1E1}, // SP 0x2E66C0 MP 0x000000 - {"objective_position", 0x1E2}, // SP 0x2E6760 MP 0x4578D0 - {"objective_current", 0x1E3}, // SP 0x2E6820 MP 0x457A30 - {"weaponinventorytype", 0x1E4}, // SP 0x2CEFB0 MP 0x4364A0 - {"weaponstartammo", 0x1E5}, // SP 0x2CF170 MP 0x436660 - {"weaponmaxammo", 0x1E6}, // SP 0x2CF350 MP 0x436820 - {"weaponaltweaponname", 0x1E7}, // SP 0x2CF850 MP 0x436BD0 - {"isweaponcliponly", 0x1E8}, // SP 0x2D0180 MP 0x4371C0 - {"isweapondetonationtimed", 0x1E9}, // SP 0x2D0460 MP 0x437440 - {"isweaponmanuallydetonatedbyemptythrow", 0x1EA}, // SP 0x2D1040 MP 0x437660 - {"weaponhasthermalscope", 0x1EB}, // SP 0x2D1640 MP 0x437C50 - {"getvehiclenode", 0x1EC}, // SP 0x4DF7A0 MP 0x605190 - {"getvehiclenodearray", 0x1ED}, // SP 0x4DF890 MP 0x605280 - {"getallvehiclenodes", 0x1EE}, // SP 0x4DF730 MP 0x605120 - {"getnumvehicles", 0x1EF}, // SP 0x4E8D80 MP 0x60E620 - {"precachevehicle", 0x1F0}, // SP 0x4E90D0 MP 0x60E9D0 - {"spawnvehicle", 0x1F1}, // SP 0x4E9170 MP 0x60EA70 - {"vehicle_getarray", 0x1F2}, // SP 0x4E8DC0 MP 0x60E660 - {"pow", 0x1F3}, // SP 0x2C0CE0 MP 0x43F8F0 - {"atan2", 0x1F4}, // SP 0x2BFB20 MP 0x43EBD0 - {"botgetmemoryevents", 0x1F5}, // SP 0x000000 MP 0x5478E0 - {"botautoconnectenabled", 0x1F6}, // SP 0x000000 MP 0x547ED0 - {"botzonegetcount", 0x1F7}, // SP 0x000000 MP 0x547F00 - {"botzonesetteam", 0x1F8}, // SP 0x000000 MP 0x5481F0 - {"botzonenearestcount", 0x1F9}, // SP 0x000000 MP 0x548030 - {"botmemoryflags", 0x1FA}, // SP 0x000000 MP 0x547C20 - {"botflagmemoryevents", 0x1FB}, // SP 0x000000 MP 0x547600 - {"botzonegetindoorpercent", 0x1FC}, // SP 0x000000 MP 0x547FD0 - {"botsentientswap", 0x1FD}, // SP 0x000000 MP 0x547C70 - {"isbot", 0x1FE}, // SP 0x000000 MP 0x548250 - {"isagent", 0x1FF}, // SP 0x000000 MP 0x0CBBA0 - {"getmaxagents", 0x200}, // SP 0x000000 MP 0x51DAA0 - {"botdebugdrawtrigger", 0x201}, // SP 0x000000 MP 0x5475F0 - {"botgetclosestnavigablepoint", 0x202}, // SP 0x000000 MP 0x547830 - {"getnodesintrigger", 0x203}, // SP 0x000000 MP 0x3FC4D0 - {"nodesvisible", 0x204}, // SP 0x2FBF30 MP 0x3FD6C0 - {"getnodesonpath", 0x205}, // SP 0x2FBB40 MP 0x3FC5C0 - {"getzonecount", 0x206}, // SP 0x000000 MP 0x3FC9D0 - {"getzonenearest", 0x207}, // SP 0x000000 MP 0x3FC9E0 - {"getzonenodes", 0x208}, // SP 0x000000 MP 0x3FCB40 - {"getzonepath", 0x209}, // SP 0x000000 MP 0x3FD230 - {"getzoneorigin", 0x20A}, // SP 0x000000 MP 0x3FD180 - {"getnodezone", 0x20B}, // SP 0x000000 MP 0x3FC410 - {"getzonenodesbydist", 0x20C}, // SP 0x000000 MP 0x3FCE20 - {"getzonenodeforindex", 0x20D}, // SP 0x000000 MP 0x3FCB00 - {"getweaponexplosionradius", 0x20E}, // SP 0x2DB3D0 MP 0x0C9C50 - {"nodeexposedtosky", 0x211}, // SP 0x000000 MP 0x3FD490 - {"findentrances", 0x212}, // SP 0x000000 MP 0x3FBEE0 - {"badplace_global", 0x213}, // SP 0x000000 MP 0x44B2E0 - {"getpathdist", 0x214}, // SP 0x000000 MP 0x0E1DC0 - {"getlinkednodes", 0x215}, // SP 0x2FB840 MP 0x3FC130 - {"disconnectnodepair", 0x216}, // SP 0x2C62B0 MP 0x4485E0 - {"connectnodepair", 0x217}, // SP 0x2C6500 MP 0x4487E0 - {"gettimesincelastpaused", 0x218}, // SP 0x2D8D80 MP 0x000000 - {"precachesound", 0x21B}, // SP 0x2D7EA0 MP 0x0BA320 - {"devsetminimapdvarsettings", 0x21C}, // SP 0x000000 MP 0x0E0B90 - {"loadtransient", 0x21D}, // SP 0x3CE540 MP 0x000000 - {"unloadtransient", 0x21E}, // SP 0x3CE780 MP 0x000000 - {"unloadalltransients", 0x21F}, // SP 0x3CE6C0 MP 0x000000 - {"synctransients", 0x220}, // SP 0x3CE660 MP 0x000000 - {"aretransientsbusy", 0x221}, // SP 0x3CE240 MP 0x000000 - {"istransientqueued", 0x222}, // SP 0x3CE2C0 MP 0x000000 - {"istransientloaded", 0x223}, // SP 0x3CE270 MP 0x000000 - {"loadstartpointtransient", 0x224}, // SP 0x3CE300 MP 0x000000 - {"distance2dsquared", 0x225}, // SP 0x2C44E0 MP 0x442C50 - {"getangledelta3d", 0x226}, // SP 0x2C35F0 MP 0x4430F0 - {"activateclientexploder", 0x227}, // SP 0x2C9110 MP 0x44CBB0 - {"trajectorycalculateinitialvelocity", 0x228}, // SP 0x2C9450 MP 0x4355C0 - {"trajectorycalculateminimumvelocity", 0x229}, // SP 0x2C9A50 MP 0x435990 - {"trajectorycalculateexitangle", 0x22A}, // SP 0x2C9B00 MP 0x435B70 - {"trajectoryestimatedesiredinairtime", 0x22B}, // SP 0x2C9F50 MP 0x435FD0 - {"trajectorycomputedeltaheightattime", 0x22C}, // SP 0x2CA120 MP 0x436280 - {"trajectorycanattemptaccuratejump", 0x22D}, // SP 0x2CA6D0 MP 0x436410 - {"adddebugcommand", 0x22E}, // SP 0x2CF420 MP 0x4395B0 - {"ispointinvolume", 0x22F}, // SP 0x2C40E0 MP 0x4428C0 - {"cinematicgettimeinmsec", 0x230}, // SP 0x2DF4E0 MP 0x000000 - {"cinematicgetframe", 0x231}, // SP 0x2DF3C0 MP 0x000000 - {"iscinematicloaded", 0x232}, // SP 0x2DF3A0 MP 0x000000 - {"getenemysquaddata", 0x234}, // SP 0x2CC2E0 MP 0x438300 - {"getscriptablearray", 0x236}, // SP 0x2CC4E0 MP 0x438620 - {"clearfog", 0x237}, // SP 0x2CC000 MP 0x44D9C0 - {"setleveldopplerpreset", 0x238}, // SP 0x2DC150 MP 0x0CB750 - {"screenshake", 0x239}, // SP 0x2DE0B0 MP 0x000000 - {"isusinghdr", 0x23A}, // SP 0x2CACB0 MP 0x436950 - {"isusingssao", 0x23B}, // SP 0x2CAEC0 MP 0x4369D0 - {"playerphysicstraceinfo", 0x23D}, // SP 0x2BC680 MP 0x43BB20 - {"_func_23e", 0x23E}, // SP 0x2BC820 MP 0x43BF00 - {"getminchargetime", 0x23F}, // SP 0x2D1900 MP 0x4383C0 - {"getchargetimepershot", 0x240}, // SP 0x2D19C0 MP 0x4385F0 - {"getmaxchargeshots", 0x241}, // SP 0x2D1A10 MP 0x438610 - {"weaponischargeable", 0x242}, // SP 0x2D1A90 MP 0x4386E0 - {"weaponusesheat", 0x243}, // SP 0x2D1C40 MP 0x4386F0 - {"lootserviceonendgame", 0x244}, // SP 0x000000 MP 0x0BC080 - {"luinotifyevent", 0x245}, // SP 0x2CB7F0 MP 0x437430 - {"lootserviceonstartgame", 0x246}, // SP 0x000000 MP 0x0BC4D0 - {"tournamentreportplayerspm", 0x247}, // SP 0x000000 MP 0x0BF710 - {"tournamentreportwinningteam", 0x248}, // SP 0x000000 MP 0x0BF7D0 - {"tournamentreportendofgame", 0x249}, // SP 0x000000 MP 0x0BF800 - {"wakeupphysicssphere", 0x24A}, // SP 0x2DCD00 MP 0x000000 - {"wakeupragdollsphere", 0x24B}, // SP 0x2DCDA0 MP 0x000000 - {"dopplerpitch", 0x24C}, // SP 0x2C7F60 MP 0x445E70 - {"piecewiselinearlookup", 0x24D}, // SP 0x2C2B90 MP 0x440DE0 - {"anglestoaxis", 0x24E}, // SP 0x2C60A0 MP 0x444600 - {"visionsetwater", 0x24F}, // SP 0x2D6D80 MP 0x000000 - {"sendscriptusageanalysisdata", 0x250}, // SP 0x2CC0A0 MP 0x437ED0 - {"resetscriptusageanalysisdata", 0x251}, // SP 0x2CC1C0 MP 0x437FF0 - {"instantlylogusageanalysisdata", 0x252}, // SP 0x2CC290 MP 0x4382A0 - {"invertangles", 0x253}, // SP 0x2C7690 MP 0x4454E0 - {"rotatevectorinverted", 0x254}, // SP 0x2C7830 MP 0x445880 - {"calculatestartorientation", 0x255}, // SP 0x2C7D20 MP 0x445C00 - {"droptoground", 0x256}, // SP 0x000000 MP 0x458DA0 - {"setdemigodmode", 0x257}, // SP 0x2D9520 MP 0x000000 - {"precachelaser", 0x258}, // SP 0x2BBA40 MP 0x43AE70 - {"_func_259", 0x259}, // SP 0x2BBA70 MP 0x43AF90 - {"getcsplinecount", 0x25A}, // SP 0x2CCC40 MP 0x439140 - {"getcsplinepointcount", 0x25B}, // SP 0x2CCDF0 MP 0x4392F0 - {"getcsplinelength", 0x25C}, // SP 0x2CCF40 MP 0x439550 - {"getcsplinepointid", 0x25D}, // SP 0x2CD170 MP 0x4398E0 - {"getcsplinepointlabel", 0x25E}, // SP 0x2CD290 MP 0x439AC0 - {"getcsplinepointtension", 0x25F}, // SP 0x2CD610 MP 0x43A110 - {"getcsplinepointposition", 0x260}, // SP 0x2CD8B0 MP 0x43A3B0 - {"getcsplinepointcorridordims", 0x261}, // SP 0x2CDB10 MP 0x43A5D0 - {"getcsplinepointtangent", 0x262}, // SP 0x2CDD80 MP 0x43AB00 - {"getcsplinepointdisttonextpoint", 0x263}, // SP 0x2CE0A0 MP 0x43AF00 - {"calccsplineposition", 0x264}, // SP 0x2CE420 MP 0x43B430 - {"calccsplinetangent", 0x265}, // SP 0x2CE810 MP 0x43B6E0 - {"calccsplinecorridor", 0x266}, // SP 0x2CEAC0 MP 0x43BA50 - {"setnojipscore", 0x267}, // SP 0x2CEE10 MP 0x43BFE0 - {"setnojiptime", 0x268}, // SP 0x2CEF40 MP 0x43C270 - {"getpredictedentityposition", 0x269}, // SP 0x000000 MP 0x0CA120 - {"gamedvrprohibitrecording", 0x26A}, // SP 0x2CF0E0 MP 0x43C5F0 - {"gamedvrstartrecording", 0x26B}, // SP 0x2CF1E0 MP 0x43C930 - {"gamedvrstoprecording", 0x26C}, // SP 0x2CF210 MP 0x43CAA0 - {"gamedvrsetvideometadata", 0x26D}, // SP 0x2CF410 MP 0x43CB00 - {"gamedvrprohibitscreenshots", 0x26E}, // SP 0x2CF480 MP 0x43CB10 - {"gamedvrsetscreenshotmetadata", 0x26F}, // SP 0x2CF600 MP 0x43CBD0 - {"queuedialog", 0x270}, // SP 0x000000 MP 0x0BEAB0 - {"speechenablegrammar", 0x271}, // SP 0x2D9500 MP 0x000000 - {"speechenable", 0x272}, // SP 0x2D9510 MP 0x000000 - {"livestreamingenable", 0x273}, // SP 0x2CF610 MP 0x43CCF0 - {"livestreamingsetbitrate", 0x274}, // SP 0x2CF7C0 MP 0x43CD00 - {"livestreamingsetmetadata", 0x275}, // SP 0x2CF840 MP 0x43CD50 - {"livestreamingenablearchiving", 0x276}, // SP 0x2CF970 MP 0x43D080 - {"triggerportableradarping", 0x277}, // SP 0x000000 MP 0x0D0360 - {"botgetteamlimit", 0x279}, // SP 0x000000 MP 0x547BE0 - {"spawnfxforclient", 0x27A}, // SP 0x000000 MP 0x1CEF60 - {"botgetteamdifficulty", 0x27B}, // SP 0x000000 MP 0x547BA0 - {"debugstar", 0x27C}, // SP 0x2CEF60 MP 0x438E00 - {"newdebughudelem", 0x27D}, // SP 0x29BED0 MP 0x41A240 - {"printlightsetsettings", 0x27E}, // SP 0x2CED20 MP 0x436E10 - {"lightsetdumpstate", 0x27F}, // SP 0x2CEDF0 MP 0x436F20 - {"getsquadassaultelo", 0x280}, // SP 0x2CC2F0 MP 0x4385E0 - {"loadluifile", 0x281}, // SP 0x2D11C0 MP 0x43B090 - {"isdedicatedserver", 0x282}, // SP 0x000000 MP 0x0D0BD0 - {"getplaylistversion", 0x283}, // SP 0x000000 MP 0x0D0C70 - {"getplaylistid", 0x284}, // SP 0x000000 MP 0x0D0D40 - {"getactiveclientcount", 0x285}, // SP 0x000000 MP 0x0D3D20 - {"issquadsmode", 0x286}, // SP 0x000000 MP 0x0D4440 - {"getsquadassaultsquadindex", 0x287}, // SP 0x2CC4D0 MP 0x438600 - {"visionsetpostapply", 0x288}, // SP 0x000000 MP 0x0B8180 - {"addbot", 0x289}, // SP 0x000000 MP 0x0E2980 - {"ishairrunning", 0x28A}, // SP 0x2D0450 MP 0x43DAB0 - {"getnearbyarrayelements", 0x28B}, // SP 0x2C95C0 MP 0x447350 - {"vectorclamp", 0x28C}, // SP 0x2C9DC0 MP 0x447BB0 - {"isalliedsentient", 0x28D}, // SP 0x000000 MP 0x08FB60 - {"istestclient", 0x28E}, // SP 0x000000 MP 0x0E2FB0 - {"getrandomnodedestination", 0x28F}, // SP 0x000000 MP 0x3FC940 - {"debuglocalizestring", 0x290}, // SP 0x000000 MP 0x0B8840 - {"enablesoundcontextoverride", 0x291}, // SP 0x2BEF30 MP 0x440040 - {"disablesoundcontextoverride", 0x292}, // SP 0x2BF060 MP 0x4400A0 - {"notifyoncommandremove", 0x293}, // SP 0x2D8CB0 MP 0x000000 - {"getsndaliasvalue", 0x294}, // SP 0x2D08E0 MP 0x43DB80 - {"setsndaliasvalue", 0x295}, // SP 0x2BD070 MP 0x441830 - {"packedtablelookup", 0x296}, // SP 0x2CF490 MP 0x438990 - {"packedtablesectionlookup", 0x297}, // SP 0x2CFB50 MP 0x438D10 - {"packedtablelookupwithrange", 0x298}, // SP 0x2D0270 MP 0x439450 - {"grappletrace", 0x299}, // SP 0x2D6C10 MP 0x000000 - {"stopclientexploder", 0x29A}, // SP 0x2C9430 MP 0x44CD70 - {"closestpointstwosegs", 0x29B}, // SP 0x2C3F50 MP 0x442750 - {"isremovedentity", 0x29C}, // SP 0x2CFB10 MP 0x439CF0 - {"tablegetrowcount", 0x29D}, // SP 0x2BB770 MP 0x43C330 - {"tablegetcolumncount", 0x29E}, // SP 0x2BBB00 MP 0x43C940 - {"batteryusepershot", 0x29F}, // SP 0x000000 MP 0x0E3890 - {"batteryreqtouse", 0x2A0}, // SP 0x000000 MP 0x0E3900 - {"isweaponmanuallydetonatedbydoubletap", 0x2A1}, // SP 0x2D1220 MP 0x437920 - {"grapplegetmagnets", 0x2A2}, // SP 0x2D6E40 MP 0x000000 - {"getweaponname", 0x2A3}, // SP 0x2BE770 MP 0x440600 - {"activatepersistentclientexploder", 0x2A4}, // SP 0x2C91A0 MP 0x44CCB0 - {"deployriotshield", 0x2A5}, // SP 0x2BEAC0 MP 0x446770 - {"validatecostume", 0x2A6}, // SP 0x2BEEF0 MP 0x446E30 - {"randomcostume", 0x2A7}, // SP 0x2BEE80 MP 0x446AF0 - {"shootblank", 0x2A8}, // SP 0x000000 MP 0x0B8290 - {"boidflockupdate", 0x2A9}, // SP 0x2D9580 MP 0x000000 - {"debuggetanimname", 0x2AA}, // SP 0x2CED30 MP 0x437EE0 - {"setspmatchdata", 0x2AB}, // SP 0x2BF6A0 MP 0x447D40 - {"getspmatchdata", 0x2AC}, // SP 0x2BF0E0 MP 0x4477C0 - {"sendspmatchdata", 0x2AD}, // SP 0x2BF1F0 MP 0x447B80 - {"clearspmatchdata", 0x2AE}, // SP 0x2BF620 MP 0x447BA0 - {"setspmatchdatadef", 0x2AF}, // SP 0x2BF7A0 MP 0x447D60 - {"playcinematicforall", 0x2B0}, // SP 0x000000 MP 0x0DAB80 - {"preloadcinematicforall", 0x2B1}, // SP 0x000000 MP 0x0DB390 - {"stopcinematicforall", 0x2B2}, // SP 0x000000 MP 0x0DB530 - {"capsuletracepassed", 0x2B3}, // SP 0x000000 MP 0x0DEE10 - {"stopfxontagforclient", 0x2B4}, // SP 0x2C91D0 MP 0x448FE0 - {"killfxontagforclient", 0x2B5}, // SP 0x2C9AE0 MP 0x44A310 - {"isvector", 0x2B6}, // SP 0x2CA870 MP 0x436530 - {"notifychallengecomplete", 0x2B7}, // SP 0x2DB5E0 MP 0x000000 - {"lootservicestarttrackingplaytime", 0x2B8}, // SP 0x000000 MP 0x0BD640 - {"lootservicestoptrackingplaytime", 0x2B9}, // SP 0x000000 MP 0x0BE3A0 - {"lootservicevalidateplaytime", 0x2BA}, // SP 0x000000 MP 0x0BEFC0 - {"recordbreadcrumbdataforplayer", 0x2BB}, // SP 0x000000 MP 0x0C28B0 - {"getweaponandattachmentmodels", 0x2BC}, // SP 0x2C0FD0 MP 0x443470 - {"changewhizbyautosimparams", 0x2BD}, // SP 0x2DB640 MP 0x000000 - {"sysprint", 0x2BE}, // SP 0x2CE050 MP 0x4382B0 - {"objective_mlgspectator", 0x2BF}, // SP 0x000000 MP 0x457D70 - {"setspcheckpointdata", 0x2C0}, // SP 0x2BF7C0 MP 0x447E00 - {"getspcheckpointdata", 0x2C1}, // SP 0x2BF890 MP 0x447E10 - {"isnumber", 0x2C2}, // SP 0x2CAA60 MP 0x436740 - {"isonlinegame", 0x2C3}, // SP 0x2BD760 MP 0x43EE60 - {"issystemlink", 0x2C4}, // SP 0x2BD790 MP 0x43F300 - {"setsoundmasteringfadetime", 0x2C5}, // SP 0x2DC1C0 MP 0x000000 - {"getstanceandmotionstateforplayer", 0x2C6}, // SP 0x000000 MP 0x0C3310 - {"nodeisnotusable", 0x2C7}, // SP 0x000000 MP 0x3FD5E0 - {"nodesetnotusable", 0x2C8}, // SP 0x000000 MP 0x3FD640 - {"spawnlinkedfx", 0x2C9}, // SP 0x000000 MP 0x1CF110 - {"spawnlinkedfxforclient", 0x2CA}, // SP 0x000000 MP 0x1CF180 - {"getplaylistname", 0x2CB}, // SP 0x000000 MP 0x0D10A0 - {"getlocaltimestring", 0x2CC}, // SP 0x000000 MP 0x0D1E60 - {"isonwifi", 0x2CD}, // SP 0x000000 MP 0x0D37B0 - {"getbuttonsconfig", 0x2CE}, // SP 0x2DB610 MP 0x000000 - {"getchallengeid", 0x2CF}, // SP 0x000000 MP 0x0C91F0 - {"soundsettraceflags", 0x2D4}, // SP 0x2DBA00 MP 0x000000 - {"handlepickupdeployedriotshield", 0x2D5}, // SP 0x2BECB0 MP 0x446A10 - {"getcodanywherecurrentplatform", 0x2D6}, // SP 0x000000 MP 0x0D2570 - {"getcostumefromtable", 0x2D7}, // SP 0x2BF040 MP 0x446F70 - {"visionsetoverdrive", 0x2D8}, // SP 0x2D6D70 MP 0x000000 - {"nodegetsplitgroup", 0x2D9}, // SP 0x000000 MP 0x3FD570 - {"recordbreadcrumbdataforplayersp", 0x2DA}, // SP 0x2DC210 MP 0x000000 - {"getchallengerewarditem", 0x2DB}, // SP 0x000000 MP 0x0C9310 - {"setentplayerxuidforemblem", 0x2DC}, // SP 0x000000 MP 0x1CECF0 - {"resetentplayerxuidforemblems", 0x2DD}, // SP 0x000000 MP 0x1CECE0 - {"isshipbuild", 0x2DF}, // SP 0x2C0190 MP 0x448FD0 - {"strinsertnumericdelimiters", 0x2E0}, // SP 0x2CBB20 MP 0x44A740 - {"isscriptedagent", 0x2E1}, // SP 0x000000 MP 0x0E1C40 - {"playfxonweapon", 0x2E2}, // SP 0x2C7F50 MP 0x4476F0 - {"stopfxonweapon", 0x2E3}, // SP 0x2C9440 MP 0x4496C0 - {"killfxonweapon", 0x2E4}, // SP 0x2C9AF0 MP 0x44AA30 - {"getdefaultmaxfaceenemydistance", 0x2E5}, // SP 0x2DB830 MP 0x000000 - {"applyaccelerationonentity", 0x2E6}, // SP 0x2CA0A0 MP 0x44B6A0 - {"applyimpulseonentity", 0x2E7}, // SP 0x2CA570 MP 0x44BB70 - {"applyimpulseonentity", 0x2E8}, // SP 0x2D7C10 MP 0x000000 - {"getinventoryitemtype", 0x2E9}, // SP 0x2BABC0 MP 0x439170 - {"getweaponmodelbounds", 0x2EA}, // SP 0x000000 MP 0x0BA7A0 - {"weaponitemplayidleanim", 0x2EB}, // SP 0x000000 MP 0x0BBD60 - {"_func_2ec", 0x2EC}, // SP 0x000000 MP 0x0BE870 - {"getstaticmodelcount", 0x2ED}, // SP 0x2BEE40 MP 0x440030 - {"getstaticmodelname", 0x2EE}, // SP 0x2BEEC0 MP 0x440090 - {"getstaticmodelbounds", 0x2EF}, // SP 0x2BEF70 MP 0x4400E0 - {"findstaticmodelindex", 0x2F0}, // SP 0x2BF0F0 MP 0x440360 - {"getdynentcount", 0x2F1}, // SP 0x2BF190 MP 0x440450 - {"getdynentmodelname", 0x2F2}, // SP 0x2BF200 MP 0x440530 - {"getdynentmodelbounds", 0x2F3}, // SP 0x2BF630 MP 0x440590 - {"finddynentwithmodelindex", 0x2F4}, // SP 0x2BF7B0 MP 0x440760 - {"getentitymodelname", 0x2F5}, // SP 0x2BF820 MP 0x4407C0 - {"getentitymodelbounds", 0x2F6}, // SP 0x2BF8A0 MP 0x440900 - {"findentitywithmodelindex", 0x2F7}, // SP 0x2BFB10 MP 0x4409E0 - {"_func_2f8", 0x2F8}, // SP 0x2BF570 MP 0x441780 - {"_func_2f9", 0x2F9}, // SP 0x2C44D0 MP 0x4456F0 - {"_func_2fa", 0x2FA}, // SP 0x2C4540 MP 0x446360 - {"_func_2fb", 0x2FB}, // SP 0x2D1760 MP 0x437F20 - {"_func_2fc", 0x2FC}, // SP 0x2CF430 MP 0x4395C0 - {"_func_2fd", 0x2FD}, // SP 0x2CF780 MP 0x439970 - {"_func_2fe", 0x2FE}, // SP 0x2CF820 MP 0x4399F0 - {"_func_2ff", 0x2FF}, // SP 0x000000 MP 0x43A2F0 - {"_func_300", 0x300}, // SP 0x000000 MP 0x0BC820 - {"_func_301", 0x301}, // SP 0x2CF050 MP 0x43C5E0 - {"_meth_302", 0x302}, // SP 0x000000 MP 0x0D3EC0 - {"_meth_303", 0x303}, // SP 0x2D14A0 MP 0x43A1A0 - {"_meth_304", 0x304}, // SP 0x2BAB10 MP 0x43B0F0 - {"_meth_305", 0x305}, // SP 0x000000 MP 0x0BCB60 - {"_meth_306", 0x306}, // SP 0x000000 MP 0x0BD6D0 - {"_meth_307", 0x307}, // SP 0x000000 MP 0x0BE100 - {"_meth_308", 0x308}, // SP 0x2C4550 MP 0x4467D0 - {"_meth_309", 0x309}, // SP 0x000000 MP 0x0BC940 - {"_meth_30a", 0x30A}, // SP 0x2BC310 MP 0x43D090 - }; - - std::unordered_map method_map = - { - {"motionblurhqenable", 0x8000}, // SP 0x2CE360 MP 0x435670 - {"setturretdismountorg", 0x8001}, // SP 0x2DC4E0 MP 0x000000 - {"setdamagestage", 0x8002}, // SP 0x000000 MP 0x6048A0 - {"playsoundtoteam", 0x8003}, // SP 0x000000 MP 0x0BB6A0 - {"playsoundtoplayer", 0x8004}, // SP 0x000000 MP 0x0BC9D0 - {"playerhide", 0x8005}, // SP 0x000000 MP 0x0C9190 - {"playershow", 0x8006}, // SP 0x000000 MP 0x0C9290 - {"showtoplayer", 0x8007}, // SP 0x000000 MP 0x0C9370 - {"threatdetectedtoplayer", 0x8008}, // SP 0x000000 MP 0x0C94A0 - {"clearthreatdetected", 0x8009}, // SP 0x000000 MP 0x0C9570 - {"enableplayeruse", 0x800A}, // SP 0x000000 MP 0x0D47B0 - {"disableplayeruse", 0x800B}, // SP 0x000000 MP 0x0D4B10 - {"enableammogeneration", 0x800C}, // SP 0x000000 MP 0x0D5A10 - {"disableammogeneration", 0x800D}, // SP 0x000000 MP 0x0D4DB0 - {"makescrambler", 0x800E}, // SP 0x000000 MP 0x0CFA20 - {"makeportableradar", 0x800F}, // SP 0x000000 MP 0x0CFF90 - {"clearscrambler", 0x8010}, // SP 0x000000 MP 0x0CFC40 - {"clearportableradar", 0x8011}, // SP 0x000000 MP 0x0D0280 - {"addplayermantleblockage", 0x8012}, // SP 0x000000 MP 0x0E11E0 - {"setteamfortrigger", 0x8013}, // SP 0x000000 MP 0x0CB4C0 - {"clientclaimtrigger", 0x8014}, // SP 0x000000 MP 0x0CBE10 - {"clientreleasetrigger", 0x8015}, // SP 0x000000 MP 0x0CC740 - {"releaseclaimedtrigger", 0x8016}, // SP 0x000000 MP 0x0CD360 - {"isusingonlinedataoffline", 0x8017}, // SP 0x000000 MP 0x0C9400 - {"getrestedtime", 0x8018}, // SP 0x000000 MP 0x0C99C0 - {"sendleaderboards", 0x8019}, // SP 0x000000 MP 0x0BB2C0 - {"isonladder", 0x801A}, // SP 0x2C33B0 MP 0x444260 - {"getcorpseanim", 0x801B}, // SP 0x000000 MP 0x0D9D00 - {"playerforcedeathanim", 0x801C}, // SP 0x000000 MP 0x0DC870 - {"attach", 0x801D}, // SP 0x2D1570 MP 0x43B610 - {"getlightfovinner", 0x801E}, // SP 0x2D81B0 MP 0x000000 - {"getlightfovouter", 0x801F}, // SP 0x2D8250 MP 0x000000 - {"setlightfovrange", 0x8020}, // SP 0x2D82D0 MP 0x000000 - {"getlightexponent", 0x8021}, // SP 0x2D8560 MP 0x000000 - {"setlightexponent", 0x8022}, // SP 0x2D8630 MP 0x000000 - {"startragdoll", 0x8023}, // SP 0x2D88C0 MP 0x0D7980 - {"startragdollfromimpact", 0x8024}, // SP 0x2D88E0 MP 0x000000 - {"queryshouldearlyragdoll", 0x8025}, // SP 0x2C8360 MP 0x449F50 - {"logstring", 0x8026}, // SP 0x2DB820 MP 0x0B94E0 - {"_meth_8028", 0x8028}, // SP 0x2D8CF0 MP 0x000000 - {"thermaldrawenable", 0x8029}, // SP 0x2CE130 MP 0x435410 - {"detach", 0x802A}, // SP 0x2D1C50 MP 0x43BE70 - {"detachall", 0x802B}, // SP 0x2D1DF0 MP 0x43C030 - {"getattachsize", 0x802C}, // SP 0x2BC140 MP 0x43E4C0 - {"getattachmodelname", 0x802D}, // SP 0x2BC4F0 MP 0x43E740 - {"getattachtagname", 0x802E}, // SP 0x2BC7B0 MP 0x43E800 - {"setturretcanaidetach", 0x802F}, // SP 0x2DA880 MP 0x000000 - {"setturretfov", 0x8030}, // SP 0x2DA8C0 MP 0x000000 - {"setplayerturretfov", 0x8031}, // SP 0x2DA9C0 MP 0x000000 - {"lerpfov", 0x8032}, // SP 0x2DAB40 MP 0x000000 - {"lerpfovscale", 0x8033}, // SP 0x2DAC00 MP 0x000000 - {"getvalidcoverpeekouts", 0x8034}, // SP 0x2FB620 MP 0x000000 - {"gethighestnodestance", 0x8035}, // SP 0x2FB5B0 MP 0x3FBE40 - {"doesnodeallowstance", 0x8036}, // SP 0x2FB480 MP 0x3FBD10 - {"doesnodeforcecombat", 0x8037}, // SP 0x2FB530 MP 0x3FBDC0 - {"getgunangles", 0x8038}, // SP 0x2DF0D0 MP 0x000000 - {"magicgrenade", 0x8039}, // SP 0x2DF1D0 MP 0x000000 - {"magicgrenademanual", 0x803A}, // SP 0x2DF6A0 MP 0x000000 - {"getentnum", 0x803B}, // SP 0x2D7F00 MP 0x000000 - {"launch", 0x803C}, // SP 0x2D7F20 MP 0x000000 - {"setsoundblend", 0x803D}, // SP 0x2D80F0 MP 0x000000 - {"makefakeai", 0x803E}, // SP 0x2DAE90 MP 0x000000 - {"spawndrone", 0x803F}, // SP 0x2DAED0 MP 0x000000 - {"setcorpseremovetimer", 0x8040}, // SP 0x2DAFA0 MP 0x000000 - {"setlookattext", 0x8041}, // SP 0x2DB060 MP 0x000000 - {"setspawnerteam", 0x8042}, // SP 0x2DB0B0 MP 0x000000 - {"addaieventlistener", 0x8043}, // SP 0x2DC350 MP 0x000000 - {"removeaieventlistener", 0x8044}, // SP 0x2DC410 MP 0x000000 - {"getlightcolor", 0x8045}, // SP 0x2C2E60 MP 0x443B50 - {"setlightcolor", 0x8046}, // SP 0x2C30B0 MP 0x443E70 - {"getlightradius", 0x8047}, // SP 0x2D7B40 MP 0x000000 - {"setlightradius", 0x8048}, // SP 0x2D7B80 MP 0x000000 - {"getattachignorecollision", 0x8049}, // SP 0x2BCC50 MP 0x43EC10 - {"hidepart", 0x804A}, // SP 0x2BD670 MP 0x43ED60 - {"hidepart_allinstances", 0x804B}, // SP 0x2BD870 MP 0x43F430 - {"hideallparts", 0x804C}, // SP 0x2BDAE0 MP 0x43F990 - {"showpart", 0x804D}, // SP 0x2BDE40 MP 0x43FCB0 - {"showallparts", 0x804E}, // SP 0x2BE310 MP 0x4402C0 - {"linkto", 0x804F}, // SP 0x2BEDF0 MP 0x442660 - {"linktoblendtotag", 0x8050}, // SP 0x2BF160 MP 0x442EA0 - {"unlink", 0x8051}, // SP 0x2BF210 MP 0x442F30 - {"setnormalhealth", 0x8052}, // SP 0x2D87D0 MP 0x0C3620 - {"dodamage", 0x8053}, // SP 0x2BF2B0 MP 0x43EE80 - {"kill", 0x8054}, // SP 0x2D89C0 MP 0x000000 - {"show", 0x8055}, // SP 0x2D8DA0 MP 0x0C8890 - {"hide", 0x8056}, // SP 0x2D8EA0 MP 0x0C8B00 - {"showonclient", 0x8057}, // SP 0x2D8EC0 MP 0x000000 - {"hideonclient", 0x8058}, // SP 0x2D8F40 MP 0x000000 - {"disconnectpaths", 0x8059}, // SP 0x2C59B0 MP 0x447E30 - {"connectpaths", 0x805A}, // SP 0x2C5EC0 MP 0x4480B0 - {"disconnectnode", 0x805B}, // SP 0x2C6080 MP 0x448260 - {"connectnode", 0x805C}, // SP 0x2C6170 MP 0x4482C0 - {"startusingheroonlylighting", 0x805D}, // SP 0x2DC240 MP 0x000000 - {"stopusingheroonlylighting", 0x805E}, // SP 0x2DC260 MP 0x000000 - {"startusinglessfrequentlighting", 0x805F}, // SP 0x2DC280 MP 0x000000 - {"stopusinglessfrequentlighting", 0x8060}, // SP 0x2DC2A0 MP 0x000000 - {"setmovingplatformplayerturnrate", 0x8061}, // SP 0x2DD040 MP 0x000000 - {"setthermalfog", 0x8062}, // SP 0x2DD0C0 MP 0x000000 - {"setnightvisionfog", 0x8063}, // SP 0x2DD9D0 MP 0x000000 - {"clearthermalfog", 0x8064}, // SP 0x2DEA00 MP 0x000000 - {"clearnightvisionfog", 0x8065}, // SP 0x2DEA70 MP 0x000000 - {"setmode", 0x8067}, // SP 0x2D9180 MP 0x0D81F0 - {"getmode", 0x8068}, // SP 0x2D93F0 MP 0x0D9DD0 - {"setturretignoregoals", 0x8069}, // SP 0x2DA680 MP 0x000000 - {"islinked", 0x806A}, // SP 0x2BF6B0 MP 0x443040 - {"enablelinkto", 0x806B}, // SP 0x2C0DA0 MP 0x444430 - {"playsoundatviewheight", 0x806C}, // SP 0x2D80B0 MP 0x000000 - {"setpitch", 0x806E}, // SP 0x2C37A0 MP 0x44C250 - {"scalepitch", 0x806F}, // SP 0x2C3430 MP 0x44C030 - {"setvolume", 0x8070}, // SP 0x2C3A60 MP 0x44C420 - {"scalevolume", 0x8071}, // SP 0x2C37D0 MP 0x44C370 - {"enableportalgroup", 0x8072}, // SP 0x2CADC0 MP 0x000000 - {"setspeakermapmonotostereo", 0x8073}, // SP 0x2D7D50 MP 0x000000 - {"setspeakermapmonoto51", 0x8074}, // SP 0x2D7DC0 MP 0x000000 - {"setdistributed2dsound", 0x8075}, // SP 0x2D7DD0 MP 0x000000 - {"playsoundasmaster", 0x8076}, // SP 0x2D8190 MP 0x0C22C0 - {"playloopsound", 0x8077}, // SP 0x2D81E0 MP 0x0C24C0 - {"eqon", 0x8078}, // SP 0x2D82A0 MP 0x000000 - {"eqoff", 0x8079}, // SP 0x2D84D0 MP 0x000000 - {"haseq", 0x807A}, // SP 0x2D8500 MP 0x000000 - {"iswaitingonsound", 0x807B}, // SP 0x2D8540 MP 0x000000 - {"playfoley", 0x807C}, // SP 0x2D8580 MP 0x000000 - {"getnormalhealth", 0x807D}, // SP 0x2D8750 MP 0x0C2B40 - {"playerlinkto", 0x807E}, // SP 0x2C1F80 MP 0x4454D0 - {"playerlinktodelta", 0x807F}, // SP 0x2C1F90 MP 0x445560 - {"playerlinkweaponviewtodelta", 0x8080}, // SP 0x2C2070 MP 0x445990 - {"playerlinktoabsolute", 0x8081}, // SP 0x2C2090 MP 0x4459B0 - {"playerlinktoblend", 0x8082}, // SP 0x2C5B80 MP 0x4477E0 - {"playerlinkedoffsetenable", 0x8083}, // SP 0x2C2700 MP 0x446210 - {"setwaypointedgestyle_secondaryarrow", 0x8084}, // SP 0x29AA40 MP 0x419840 - {"setwaypointiconoffscreenonly", 0x8085}, // SP 0x29AA90 MP 0x419850 - {"fadeovertime", 0x8086}, // SP 0x29AE50 MP 0x419BA0 - {"scaleovertime", 0x8087}, // SP 0x29AF90 MP 0x419CE0 - {"moveovertime", 0x8088}, // SP 0x29B070 MP 0x419DC0 - {"reset", 0x8089}, // SP 0x29B1B0 MP 0x419E80 - {"destroy", 0x808A}, // SP 0x29B1F0 MP 0x419F60 - {"setpulsefx", 0x808B}, // SP 0x29B330 MP 0x41A040 - {"setplayernamestring", 0x808C}, // SP 0x29B270 MP 0x419FB0 - {"changefontscaleovertime", 0x808D}, // SP 0x29AEF0 MP 0x419C40 - {"startignoringspotlight", 0x808E}, // SP 0x2DC1A0 MP 0x000000 - {"stopignoringspotlight", 0x808F}, // SP 0x2DC220 MP 0x000000 - {"dontcastshadows", 0x8090}, // SP 0x2DC810 MP 0x000000 - {"castshadows", 0x8091}, // SP 0x2DC830 MP 0x000000 - {"setstablemissile", 0x8092}, // SP 0x2D8F70 MP 0x000000 - {"playersetgroundreferenceent", 0x8093}, // SP 0x2DCE40 MP 0x0E2430 - {"dontinterpolate", 0x8094}, // SP 0x2C0C90 MP 0x449A90 - {"dospawn", 0x8095}, // SP 0x2DEAE0 MP 0x000000 - {"stalingradspawn", 0x8096}, // SP 0x2DEB80 MP 0x000000 - {"getorigin", 0x8097}, // SP 0x2DEC20 MP 0x0B9540 - {"getcentroid", 0x8098}, // SP 0x2DECE0 MP 0x000000 - {"getshootatpos", 0x8099}, // SP 0x2DEE20 MP 0x000000 - {"getdebugeye", 0x809A}, // SP 0x2D7440 MP 0x000000 - {"useby", 0x809B}, // SP 0x2D7720 MP 0x0B9650 - {"playsound", 0x809C}, // SP 0x2D7E00 MP 0x0B9C40 - {"playerlinkedoffsetdisable", 0x80A1}, // SP 0x2C2920 MP 0x446700 - {"playerlinkedsetviewznear", 0x80A2}, // SP 0x2C3020 MP 0x446A60 - {"playerlinkedsetusebaseangleforviewclamp", 0x80A3}, // SP 0x2C3330 MP 0x447070 - {"lerpviewangleclamp", 0x80A4}, // SP 0x2C8370 MP 0x449860 - {"setviewangleresistance", 0x80A5}, // SP 0x2C8B40 MP 0x44A270 - {"springcamenabled", 0x80A6}, // SP 0x2C9270 MP 0x000000 - {"springcamdisabled", 0x80A7}, // SP 0x2C9BA0 MP 0x000000 - {"linktoplayerview", 0x80A8}, // SP 0x2CAED0 MP 0x000000 - {"unlinkfromplayerview", 0x80A9}, // SP 0x2CB8D0 MP 0x000000 - {"geteye", 0x80AA}, // SP 0x2D17D0 MP 0x438C20 - {"istouching", 0x80AB}, // SP 0x2C28D0 MP 0x445030 - {"getistouchingentities", 0x80AC}, // SP 0x2C2D10 MP 0x4452B0 - {"stoploopsound", 0x80AD}, // SP 0x2CC600 MP 0x44B650 - {"stopsounds", 0x80AE}, // SP 0x2C3A90 MP 0x446280 - {"playrumbleonentity", 0x80AF}, // SP 0x2CC820 MP 0x44BE30 - {"playrumblelooponentity", 0x80B0}, // SP 0x2CCA30 MP 0x44BED0 - {"stoprumble", 0x80B1}, // SP 0x2CCEB0 MP 0x44C6B0 - {"delete", 0x80B2}, // SP 0x2D16B0 MP 0x438AB0 - {"setmodel", 0x80B3}, // SP 0x2CF280 MP 0x439370 - {"laseron", 0x80B4}, // SP 0x2CD320 MP 0x44CBF0 - {"laseroff", 0x80B5}, // SP 0x2CD6A0 MP 0x44D240 - {"thermalvisionon", 0x80B8}, // SP 0x2CD960 MP 0x44D4F0 - {"thermalvisionoff", 0x80B9}, // SP 0x2CDE30 MP 0x44DA70 - {"thermalvisionfofoverlayon", 0x80BA}, // SP 0x2CF070 MP 0x437230 - {"thermalvisionfofoverlayoff", 0x80BB}, // SP 0x2CF220 MP 0x4374E0 - {"autospotoverlayon", 0x80BC}, // SP 0x000000 MP 0x437700 - {"autospotoverlayoff", 0x80BD}, // SP 0x000000 MP 0x4378D0 - {"seteyesonuplinkenabled", 0x80BE}, // SP 0x000000 MP 0x437C30 - {"setcontents", 0x80C0}, // SP 0x2CBA60 MP 0x44A430 - {"makeusable", 0x80C1}, // SP 0x2CBCA0 MP 0x44A860 - {"makeunusable", 0x80C2}, // SP 0x2CBF30 MP 0x44ABD0 - {"_meth_80c3", 0x80C3}, // SP 0x2C2350 MP 0x44ADA0 - {"_meth_80c4", 0x80C4}, // SP 0x2C26C0 MP 0x44B610 - {"setwhizbyprobabilities", 0x80C5}, // SP 0x28CCC0 MP 0x000000 - {"visionsetnakedforplayer_lerp", 0x80C6}, // SP 0x2911D0 MP 0x000000 - {"setwaitnode", 0x80C7}, // SP 0x4E8850 MP 0x000000 - {"returnplayercontrol", 0x80C8}, // SP 0x4E69D0 MP 0x000000 - {"vehphys_starttrack", 0x80C9}, // SP 0x4E86B0 MP 0x000000 - {"vehphys_clearautodisable", 0x80CA}, // SP 0x4E8740 MP 0x000000 - {"vehicleusealtblendedaudio", 0x80CB}, // SP 0x4E7F80 MP 0x000000 - {"settext", 0x80CC}, // SP 0x299BD0 MP 0x418B90 - {"clearalltextafterhudelem", 0x80CD}, // SP 0x299CC0 MP 0x418C80 - {"setshader", 0x80CE}, // SP 0x299CD0 MP 0x418C90 - {"settargetent", 0x80CF}, // SP 0x29A040 MP 0x418FF0 - {"cleartargetent", 0x80D0}, // SP 0x29A1E0 MP 0x419180 - {"settimer", 0x80D1}, // SP 0x29A2C0 MP 0x419250 - {"settimerup", 0x80D2}, // SP 0x29A390 MP 0x419310 - {"settimerstatic", 0x80D3}, // SP 0x29A460 MP 0x4193B0 - {"settenthstimer", 0x80D4}, // SP 0x29A530 MP 0x419460 - {"settenthstimerup", 0x80D5}, // SP 0x29A600 MP 0x419520 - {"settenthstimerstatic", 0x80D6}, // SP 0x29A6D0 MP 0x4195C0 - {"setclock", 0x80D7}, // SP 0x29A7A0 MP 0x419670 - {"setclockup", 0x80D8}, // SP 0x29A7C0 MP 0x419690 - {"setvalue", 0x80D9}, // SP 0x29A7E0 MP 0x4196B0 - {"setwaypoint", 0x80DA}, // SP 0x29A880 MP 0x419730 - {"setwaypointedgestyle_rotatingicon", 0x80DB}, // SP 0x29A9F0 MP 0x419830 - {"setcursorhint", 0x80DC}, // SP 0x2CC300 MP 0x44B510 - {"sethintstring", 0x80DD}, // SP 0x2CCAC0 MP 0x44BEF0 - {"settertiaryhintstring", 0x80DE}, // SP 0x000000 MP 0x0E4B40 - {"forceusehinton", 0x80DF}, // SP 0x2CCD30 MP 0x44C2B0 - {"forceusehintoff", 0x80E0}, // SP 0x2CCFF0 MP 0x44C540 - {"makesoft", 0x80E1}, // SP 0x2CC050 MP 0x44AD40 - {"makehard", 0x80E2}, // SP 0x2CC0F0 MP 0x44B0C0 - {"willneverchange", 0x80E3}, // SP 0x2CC2A0 MP 0x44B130 - {"startfiring", 0x80E4}, // SP 0x2C3DC0 MP 0x446D90 - {"stopfiring", 0x80E5}, // SP 0x2C3E60 MP 0x446F20 - {"isfiringturret", 0x80E6}, // SP 0x2C4130 MP 0x4471C0 - {"startbarrelspin", 0x80E7}, // SP 0x2C4220 MP 0x447540 - {"stopbarrelspin", 0x80E8}, // SP 0x2C4480 MP 0x447600 - {"getbarrelspinrate", 0x80E9}, // SP 0x2C4660 MP 0x447770 - {"remotecontrolturret", 0x80EA}, // SP 0x000000 MP 0x446460 - {"remotecontrolturretoff", 0x80EB}, // SP 0x000000 MP 0x4468F0 - {"shootturret", 0x80EC}, // SP 0x2C64B0 MP 0x448590 - {"getturretowner", 0x80ED}, // SP 0x2C6720 MP 0x448750 - {"enabledeathshield", 0x80EE}, // SP 0x295860 MP 0x000000 - {"nightvisiongogglesforceon", 0x80EF}, // SP 0x2958C0 MP 0x000000 - {"nightvisiongogglesforceoff", 0x80F0}, // SP 0x295910 MP 0x000000 - {"enableinvulnerability", 0x80F1}, // SP 0x295960 MP 0x000000 - {"disableinvulnerability", 0x80F2}, // SP 0x2959C0 MP 0x000000 - {"enablebreaching", 0x80F3}, // SP 0x295A20 MP 0x000000 - {"disablebreaching", 0x80F4}, // SP 0x295A70 MP 0x000000 - {"forceviewmodelanimation", 0x80F5}, // SP 0x295DC0 MP 0x000000 - {"disableturretdismount", 0x80F6}, // SP 0x295F90 MP 0x000000 - {"enableturretdismount", 0x80F7}, // SP 0x295FF0 MP 0x000000 - {"uploadscore", 0x80F8}, // SP 0x296050 MP 0x000000 - {"uploadtime", 0x80F9}, // SP 0x2960E0 MP 0x000000 - {"uploadleaderboards", 0x80FA}, // SP 0x296190 MP 0x000000 - {"giveachievement", 0x80FB}, // SP 0x290DC0 MP 0x40C6A0 - {"hidehud", 0x80FC}, // SP 0x295B60 MP 0x000000 - {"showhud", 0x80FD}, // SP 0x295BB0 MP 0x000000 - {"mountvehicle", 0x80FE}, // SP 0x295C80 MP 0x000000 - {"dismountvehicle", 0x80FF}, // SP 0x295D10 MP 0x000000 - {"enableslowaim", 0x8100}, // SP 0x28ED50 MP 0x40A500 - {"disableslowaim", 0x8101}, // SP 0x28EFA0 MP 0x40A820 - {"usehintsinvehicle", 0x8102}, // SP 0x295C00 MP 0x000000 - {"vehicleattackbuttonpressed", 0x8103}, // SP 0x28F310 MP 0x000000 - {"setwhizbyoffset", 0x8104}, // SP 0x28CA40 MP 0x000000 - {"setsentryowner", 0x8105}, // SP 0x2C68A0 MP 0x448D80 - {"setsentrycarrier", 0x8106}, // SP 0x2C6B40 MP 0x449100 - {"setturretminimapvisible", 0x8107}, // SP 0x2C7600 MP 0x449570 - {"settargetentity", 0x8108}, // SP 0x2C7940 MP 0x4497C0 - {"snaptotargetentity", 0x8109}, // SP 0x2C7E40 MP 0x449B70 - {"cleartargetentity", 0x810A}, // SP 0x2C8300 MP 0x449F60 - {"getturrettarget", 0x810B}, // SP 0x2C87A0 MP 0x44A280 - {"setplayerspread", 0x810C}, // SP 0x2C8FB0 MP 0x44B020 - {"setaispread", 0x810D}, // SP 0x2C9140 MP 0x44B120 - {"setsuppressiontime", 0x810E}, // SP 0x2C93C0 MP 0x44B1A0 - {"setflaggedanimknobrestart", 0x810F}, // SP 0x2B80E0 MP 0x000000 - {"setflaggedanimknoblimitedrestart", 0x8110}, // SP 0x2B8100 MP 0x000000 - {"setflaggedanimknoball", 0x8111}, // SP 0x2B8120 MP 0x000000 - {"setflaggedanimknoballrestart", 0x8112}, // SP 0x2B8140 MP 0x000000 - {"setflaggedanim", 0x8113}, // SP 0x2B8160 MP 0x000000 - {"setflaggedanimlimited", 0x8114}, // SP 0x2B8180 MP 0x000000 - {"setflaggedanimrestart", 0x8115}, // SP 0x2B8190 MP 0x000000 - {"setflaggedanimlimitedrestart", 0x8116}, // SP 0x2B81B0 MP 0x000000 - {"useanimtree", 0x8117}, // SP 0x2B81D0 MP 0x000000 - {"stopuseanimtree", 0x8118}, // SP 0x2B82B0 MP 0x000000 - {"setanimtime", 0x8119}, // SP 0x2B8330 MP 0x000000 - {"allowstand", 0x811A}, // SP 0x28F390 MP 0x40A6F0 - {"allowcrouch", 0x811B}, // SP 0x28F4A0 MP 0x40A8A0 - {"allowprone", 0x811C}, // SP 0x28F580 MP 0x40AC20 - {"allowlean", 0x811D}, // SP 0x28F660 MP 0x40AD70 - {"allowswim", 0x811E}, // SP 0x294D10 MP 0x000000 - {"setocclusion", 0x811F}, // SP 0x295190 MP 0x000000 - {"deactivateocclusion", 0x8121}, // SP 0x294F50 MP 0x000000 - {"deactivateallocclusion", 0x8122}, // SP 0x294FD0 MP 0x000000 - {"isocclusionenabled", 0x8123}, // SP 0x2952D0 MP 0x000000 - {"iseqenabled", 0x8128}, // SP 0x295320 MP 0x000000 - {"seteq", 0x8129}, // SP 0x294FF0 MP 0x000000 - {"seteqbands", 0x812A}, // SP 0x295370 MP 0x000000 - {"deactivateeq", 0x812B}, // SP 0x2954A0 MP 0x000000 - {"seteqlerp", 0x812C}, // SP 0x294E70 MP 0x000000 - {"islookingat", 0x812D}, // SP 0x295550 MP 0x000000 - {"isthrowinggrenade", 0x812E}, // SP 0x28D580 MP 0x408590 - {"isfiring", 0x812F}, // SP 0x28D970 MP 0x408BD0 - {"ismeleeing", 0x8130}, // SP 0x290B30 MP 0x40CC70 - {"setautopickup", 0x8131}, // SP 0x295790 MP 0x000000 - {"allowmelee", 0x8132}, // SP 0x28F1B0 MP 0x40A2E0 - {"allowfire", 0x8133}, // SP 0x28F2A0 MP 0x40A490 - {"enablehealthshield", 0x8134}, // SP 0x295800 MP 0x000000 - {"setconvergencetime", 0x8135}, // SP 0x2C9770 MP 0x44B3D0 - {"setconvergenceheightpercent", 0x8136}, // SP 0x2C9D30 MP 0x44BAE0 - {"setturretteam", 0x8137}, // SP 0x2C9FF0 MP 0x44BC00 - {"maketurretsolid", 0x8138}, // SP 0x2CA680 MP 0x44BFE0 - {"maketurretoperable", 0x8139}, // SP 0x2CA820 MP 0x44C200 - {"maketurretinoperable", 0x813A}, // SP 0x2CAA00 MP 0x44C3A0 - {"makeentitysentient", 0x813B}, // SP 0x307F30 MP 0x08FCC0 - {"freeentitysentient", 0x813C}, // SP 0x307650 MP 0x08FDE0 - {"isindoor", 0x813D}, // SP 0x307780 MP 0x000000 - {"_meth_813e", 0x813E}, // SP 0x3077E0 MP 0x000000 - {"_meth_813f", 0x813F}, // SP 0x3078C0 MP 0x000000 - {"_meth_8140", 0x8140}, // SP 0x2B7D60 MP 0x000000 - {"_meth_8142", 0x8142}, // SP 0x2B7DA0 MP 0x000000 - {"_meth_8143", 0x8143}, // SP 0x2B7D40 MP 0x000000 - {"_meth_8144", 0x8144}, // SP 0x2B7DE0 MP 0x000000 - {"_meth_8145", 0x8145}, // SP 0x2B7E60 MP 0x000000 - {"_meth_8146", 0x8146}, // SP 0x2B7E80 MP 0x000000 - {"_meth_8147", 0x8147}, // SP 0x2B7E90 MP 0x000000 - {"_meth_8148", 0x8148}, // SP 0x2B7EB0 MP 0x000000 - {"_meth_8149", 0x8149}, // SP 0x2B7ED0 MP 0x000000 - {"_meth_814a", 0x814A}, // SP 0x2B7EF0 MP 0x000000 - {"_meth_814b", 0x814B}, // SP 0x2B7F00 MP 0x000000 - {"_meth_814c", 0x814C}, // SP 0x2B7F20 MP 0x000000 - {"_meth_814d", 0x814D}, // SP 0x2B7F40 MP 0x000000 - {"_meth_814e", 0x814E}, // SP 0x2B7F60 MP 0x000000 - {"_meth_814f", 0x814F}, // SP 0x2B7F70 MP 0x000000 - {"_meth_8150", 0x8150}, // SP 0x2B7F90 MP 0x000000 - {"_meth_8151", 0x8151}, // SP 0x2B7FB0 MP 0x000000 - {"_meth_8152", 0x8152}, // SP 0x2B8020 MP 0x000000 - {"_meth_8153", 0x8153}, // SP 0x2B8060 MP 0x000000 - {"_meth_8154", 0x8154}, // SP 0x2B80B0 MP 0x000000 - {"_meth_8155", 0x8155}, // SP 0x2B80D0 MP 0x000000 - {"_meth_8156", 0x8156}, // SP 0x2CAA50 MP 0x44C4A0 - {"_meth_8157", 0x8157}, // SP 0x2CB3E0 MP 0x44CD00 - {"_meth_8158", 0x8158}, // SP 0x2CB4F0 MP 0x44D2D0 - {"_meth_8159", 0x8159}, // SP 0x2CB780 MP 0x44D610 - {"_meth_815a", 0x815A}, // SP 0x2CBB90 MP 0x44DA10 - {"setautorotationdelay", 0x815B}, // SP 0x2CBD60 MP 0x435380 - {"_meth_815c", 0x815C}, // SP 0x2CC3E0 MP 0x435AF0 - {"restoredefaultdroppitch", 0x815D}, // SP 0x2CC5A0 MP 0x435F70 - {"turretfiredisable", 0x815E}, // SP 0x2CC660 MP 0x4360F0 - {"_meth_815f", 0x815F}, // SP 0x275890 MP 0x000000 - {"_meth_8160", 0x8160}, // SP 0x275960 MP 0x000000 - {"_meth_8161", 0x8161}, // SP 0x275A40 MP 0x000000 - {"_meth_8162", 0x8162}, // SP 0x275AE0 MP 0x000000 - {"_meth_8163", 0x8163}, // SP 0x275C30 MP 0x000000 - {"_meth_8164", 0x8164}, // SP 0x275D10 MP 0x000000 - {"_meth_8165", 0x8165}, // SP 0x275DA0 MP 0x000000 - {"_meth_8166", 0x8166}, // SP 0x275DE0 MP 0x000000 - {"_meth_8167", 0x8167}, // SP 0x275EC0 MP 0x000000 - {"_meth_8168", 0x8168}, // SP 0x275F50 MP 0x000000 - {"_meth_8169", 0x8169}, // SP 0x2907C0 MP 0x40BB60 - {"_meth_816a", 0x816A}, // SP 0x275FF0 MP 0x000000 - {"_meth_816b", 0x816B}, // SP 0x2761C0 MP 0x000000 - {"_meth_816c", 0x816C}, // SP 0x2763C0 MP 0x000000 - {"_meth_816d", 0x816D}, // SP 0x2764E0 MP 0x000000 - {"_meth_816e", 0x816E}, // SP 0x2765B0 MP 0x000000 - {"_meth_816f", 0x816F}, // SP 0x2766D0 MP 0x000000 - {"_meth_8170", 0x8170}, // SP 0x276760 MP 0x000000 - {"_meth_8171", 0x8171}, // SP 0x2768A0 MP 0x000000 - {"_meth_8172", 0x8172}, // SP 0x276910 MP 0x000000 - {"_meth_8173", 0x8173}, // SP 0x276A00 MP 0x000000 - {"_meth_8174", 0x8174}, // SP 0x276B70 MP 0x000000 - {"_meth_8175", 0x8175}, // SP 0x276DC0 MP 0x000000 - {"_meth_8176", 0x8176}, // SP 0x276E20 MP 0x000000 - {"_meth_8177", 0x8177}, // SP 0x276E80 MP 0x000000 - {"_meth_8178", 0x8178}, // SP 0x276F40 MP 0x000000 - {"getenemysqdist", 0x8179}, // SP 0x307920 MP 0x08F660 - {"_meth_817a", 0x817A}, // SP 0x307960 MP 0x08F6A0 - {"setthreatbiasgroup", 0x817B}, // SP 0x307D30 MP 0x08FA80 - {"getthreatbiasgroup", 0x817C}, // SP 0x307DA0 MP 0x08FAF0 - {"turretfireenable", 0x817D}, // SP 0x2CC740 MP 0x436150 - {"setturretmodechangewait", 0x817E}, // SP 0x2CCA50 MP 0x436430 - {"usetriggerrequirelookat", 0x817F}, // SP 0x2CBD00 MP 0x44A940 - {"getstance", 0x8180}, // SP 0x2D01F0 MP 0x437D20 - {"setstance", 0x8181}, // SP 0x2D0510 MP 0x4383D0 - {"itemweaponsetammo", 0x8182}, // SP 0x2CD4C0 MP 0x44D340 - {"getammocount", 0x8183}, // SP 0x2CDBC0 MP 0x44D8B0 - {"gettagorigin", 0x8184}, // SP 0x2BC330 MP 0x43CD60 - {"gettagangles", 0x8185}, // SP 0x2BC400 MP 0x43D0C0 - {"shellshock", 0x8186}, // SP 0x2C1C50 MP 0x441280 - {"stunplayer", 0x8187}, // SP 0x2C2470 MP 0x441FD0 - {"stopshellshock", 0x8188}, // SP 0x2CE9C0 MP 0x438910 - {"_meth_8189", 0x8189}, // SP 0x2CEC20 MP 0x438B30 - {"setdepthoffield", 0x818A}, // SP 0x2BC900 MP 0x43D7F0 - {"setviewmodeldepthoffield", 0x818B}, // SP 0x2BD7B0 MP 0x43E3B0 - {"_meth_818c", 0x818C}, // SP 0x2BE760 MP 0x43F610 - {"_meth_818d", 0x818D}, // SP 0x273F90 MP 0x000000 - {"_meth_818e", 0x818E}, // SP 0x273FE0 MP 0x000000 - {"_meth_818f", 0x818F}, // SP 0x274050 MP 0x000000 - {"_meth_8190", 0x8190}, // SP 0x274090 MP 0x000000 - {"_meth_8191", 0x8191}, // SP 0x274100 MP 0x000000 - {"_meth_8192", 0x8192}, // SP 0x274190 MP 0x000000 - {"_meth_8193", 0x8193}, // SP 0x274360 MP 0x000000 - {"_meth_8194", 0x8194}, // SP 0x2746C0 MP 0x000000 - {"_meth_8195", 0x8195}, // SP 0x2747C0 MP 0x000000 - {"_meth_8196", 0x8196}, // SP 0x274810 MP 0x000000 - {"_meth_8197", 0x8197}, // SP 0x274860 MP 0x000000 - {"_meth_8198", 0x8198}, // SP 0x2748C0 MP 0x000000 - {"_meth_8199", 0x8199}, // SP 0x274910 MP 0x000000 - {"_meth_819e", 0x819E}, // SP 0x2749E0 MP 0x000000 - {"_meth_819f", 0x819F}, // SP 0x274A90 MP 0x000000 - {"_meth_81a0", 0x81A0}, // SP 0x274AE0 MP 0x000000 - {"getnegotiationstartnode", 0x81A1}, // SP 0x274B90 MP 0x51C5D0 - {"getnegotiationendnode", 0x81A2}, // SP 0x274C00 MP 0x51C480 - {"getnegotiationnextnode", 0x81A3}, // SP 0x274C70 MP 0x51C520 - {"_meth_81a4", 0x81A4}, // SP 0x274D50 MP 0x000000 - {"_meth_81a5", 0x81A5}, // SP 0x274DF0 MP 0x000000 - {"_meth_81a6", 0x81A6}, // SP 0x274EE0 MP 0x000000 - {"_meth_81a7", 0x81A7}, // SP 0x275000 MP 0x000000 - {"_meth_81a8", 0x81A8}, // SP 0x2738E0 MP 0x000000 - {"_meth_81a9", 0x81A9}, // SP 0x275060 MP 0x000000 - {"_meth_81aa", 0x81AA}, // SP 0x275200 MP 0x000000 - {"_meth_81ab", 0x81AB}, // SP 0x275330 MP 0x000000 - {"_meth_81ac", 0x81AC}, // SP 0x2753D0 MP 0x000000 - {"_meth_81ad", 0x81AD}, // SP 0x275510 MP 0x000000 - {"_meth_81ae", 0x81AE}, // SP 0x275700 MP 0x000000 - {"_meth_81af", 0x81AF}, // SP 0x275750 MP 0x000000 - {"_meth_81b0", 0x81B0}, // SP 0x2757A0 MP 0x000000 - {"_meth_81b1", 0x81B1}, // SP 0x2BE800 MP 0x43F660 - {"_meth_81b2", 0x81B2}, // SP 0x2BE810 MP 0x43F690 - {"viewkick", 0x81B3}, // SP 0x2BE960 MP 0x43F7C0 - {"localtoworldcoords", 0x81B4}, // SP 0x2CE230 MP 0x437DA0 - {"getentitynumber", 0x81B5}, // SP 0x2CCC90 MP 0x4367D0 - {"getentityvelocity", 0x81B6}, // SP 0x2CCE50 MP 0x436960 - {"enablegrenadetouchdamage", 0x81B7}, // SP 0x2CCFA0 MP 0x436AD0 - {"disablegrenadetouchdamage", 0x81B8}, // SP 0x2CD060 MP 0x436B80 - {"_meth_81b9", 0x81B9}, // SP 0x2CDE90 MP 0x4379C0 - {"_meth_81ba", 0x81BA}, // SP 0x277290 MP 0x000000 - {"_meth_81bb", 0x81BB}, // SP 0x277470 MP 0x000000 - {"_meth_81bc", 0x81BC}, // SP 0x2776C0 MP 0x000000 - {"_meth_81bd", 0x81BD}, // SP 0x277810 MP 0x000000 - {"_meth_81be", 0x81BE}, // SP 0x2778A0 MP 0x000000 - {"_meth_81bf", 0x81BF}, // SP 0x277C50 MP 0x000000 - {"_meth_81c0", 0x81C0}, // SP 0x277DA0 MP 0x000000 - {"_meth_81c1", 0x81C1}, // SP 0x277E90 MP 0x000000 - {"_meth_81c2", 0x81C2}, // SP 0x277F00 MP 0x000000 - {"_meth_81c3", 0x81C3}, // SP 0x277FB0 MP 0x000000 - {"_meth_81c4", 0x81C4}, // SP 0x3076A0 MP 0x08FE40 - {"_meth_81c5", 0x81C5}, // SP 0x307700 MP 0x08FEA0 - {"_meth_81c6", 0x81C6}, // SP 0x278100 MP 0x000000 - {"_meth_81c7", 0x81C7}, // SP 0x278380 MP 0x000000 - {"_meth_81c8", 0x81C8}, // SP 0x2784F0 MP 0x000000 - {"_meth_81c9", 0x81C9}, // SP 0x2733B0 MP 0x000000 - {"_meth_81ca", 0x81CA}, // SP 0x2733C0 MP 0x000000 - {"_meth_81cb", 0x81CB}, // SP 0x2733E0 MP 0x000000 - {"_meth_81cc", 0x81CC}, // SP 0x273400 MP 0x000000 - {"_meth_81cd", 0x81CD}, // SP 0x273460 MP 0x000000 - {"_meth_81ce", 0x81CE}, // SP 0x2734D0 MP 0x000000 - {"_meth_81cf", 0x81CF}, // SP 0x2735A0 MP 0x000000 - {"_meth_81d0", 0x81D0}, // SP 0x273690 MP 0x000000 - {"_meth_81d1", 0x81D1}, // SP 0x2736D0 MP 0x000000 - {"_meth_81d2", 0x81D2}, // SP 0x273710 MP 0x000000 - {"_meth_81d3", 0x81D3}, // SP 0x273750 MP 0x000000 - {"_meth_81d4", 0x81D4}, // SP 0x273DC0 MP 0x000000 - {"_meth_81d5", 0x81D5}, // SP 0x273EC0 MP 0x000000 - {"_meth_81d6", 0x81D6}, // SP 0x273AE0 MP 0x000000 - {"_meth_81d7", 0x81D7}, // SP 0x2CDFF0 MP 0x437BC0 - {"entityradiusdamage", 0x81D8}, // SP 0x2C0610 MP 0x43FB20 - {"detonate", 0x81D9}, // SP 0x2C0EF0 MP 0x440460 - {"damageconetrace", 0x81DA}, // SP 0x2C17C0 MP 0x440DC0 - {"_meth_81db", 0x81DB}, // SP 0x2C1BB0 MP 0x4410B0 - {"_meth_81dc", 0x81DC}, // SP 0x2CD3B0 MP 0x436FF0 - {"_meth_81dd", 0x81DD}, // SP 0x2CD710 MP 0x437290 - {"_meth_81de", 0x81DE}, // SP 0x2CD7D0 MP 0x437350 - {"missilesetflightmodedirect", 0x81DF}, // SP 0x2CDAF0 MP 0x4375F0 - {"missilesetflightmodetop", 0x81E0}, // SP 0x2CDC70 MP 0x4377D0 - {"getlightintensity", 0x81E1}, // SP 0x2C2880 MP 0x443780 - {"setlightintensity", 0x81E2}, // SP 0x2C2990 MP 0x443850 - {"isragdoll", 0x81E3}, // SP 0x2C3140 MP 0x444150 - {"setmovespeedscale", 0x81E4}, // SP 0x2BE470 MP 0x440680 - {"cameralinkto", 0x81E5}, // SP 0x2C4270 MP 0x444FA0 - {"cameraunlink", 0x81E6}, // SP 0x2C4560 MP 0x4451A0 - {"_meth_81e7", 0x81E7}, // SP 0x275180 MP 0x000000 - {"_meth_81e8", 0x81E8}, // SP 0x275450 MP 0x000000 - {"_meth_81e9", 0x81E9}, // SP 0x275490 MP 0x000000 - {"_meth_81ea", 0x81EA}, // SP 0x2755F0 MP 0x000000 - {"_meth_81eb", 0x81EB}, // SP 0x2758F0 MP 0x000000 - {"_meth_81ec", 0x81EC}, // SP 0x2759B0 MP 0x000000 - {"_meth_81ed", 0x81ED}, // SP 0x275C90 MP 0x000000 - {"_meth_81ee", 0x81EE}, // SP 0x275D50 MP 0x000000 - {"_meth_81ef", 0x81EF}, // SP 0x275E60 MP 0x000000 - {"_meth_81f0", 0x81F0}, // SP 0x275F10 MP 0x000000 - {"_meth_81f1", 0x81F1}, // SP 0x275FA0 MP 0x000000 - {"_meth_81f2", 0x81F2}, // SP 0x2760E0 MP 0x000000 - {"_meth_81f3", 0x81F3}, // SP 0x276130 MP 0x000000 - {"_meth_81f4", 0x81F4}, // SP 0x2762F0 MP 0x000000 - {"_meth_81f5", 0x81F5}, // SP 0x276360 MP 0x000000 - {"_meth_81f6", 0x81F6}, // SP 0x276470 MP 0x000000 - {"_meth_81f7", 0x81F7}, // SP 0x276610 MP 0x000000 - {"_meth_81f8", 0x81F8}, // SP 0x276670 MP 0x000000 - {"_meth_81f9", 0x81F9}, // SP 0x276540 MP 0x000000 - {"_meth_81fa", 0x81FA}, // SP 0x276720 MP 0x000000 - {"_meth_81fb", 0x81FB}, // SP 0x2767D0 MP 0x000000 - {"_meth_81fc", 0x81FC}, // SP 0x2769A0 MP 0x000000 - {"_meth_81fd", 0x81FD}, // SP 0x276A70 MP 0x000000 - {"_meth_81fe", 0x81FE}, // SP 0x276C40 MP 0x000000 - {"_meth_81ff", 0x81FF}, // SP 0x276EF0 MP 0x000000 - {"_meth_8200", 0x8200}, // SP 0x277050 MP 0x000000 - {"_meth_8201", 0x8201}, // SP 0x277150 MP 0x000000 - {"_meth_8202", 0x8202}, // SP 0x2774E0 MP 0x000000 - {"_meth_8203", 0x8203}, // SP 0x2775D0 MP 0x000000 - {"controlslinkto", 0x8204}, // SP 0x2C4D60 MP 0x445B00 - {"controlsunlink", 0x8205}, // SP 0x2C5110 MP 0x445DA0 - {"_meth_8206", 0x8206}, // SP 0x000000 MP 0x4477D0 - {"_meth_8207", 0x8207}, // SP 0x2DE440 MP 0x000000 - {"_meth_8208", 0x8208}, // SP 0x000000 MP 0x447AF0 - {"_meth_820a", 0x820A}, // SP 0x000000 MP 0x447B90 - {"_meth_820b", 0x820B}, // SP 0x000000 MP 0x447D50 - {"_meth_820c", 0x820C}, // SP 0x000000 MP 0x447F70 - {"_meth_820d", 0x820D}, // SP 0x000000 MP 0x447DF0 - {"_meth_820e", 0x820E}, // SP 0x000000 MP 0x447E20 - {"drivevehicleandcontrolturret", 0x820F}, // SP 0x2C6930 MP 0x4491A0 - {"drivevehicleandcontrolturretoff", 0x8210}, // SP 0x2C7540 MP 0x449630 - {"_meth_8211", 0x8211}, // SP 0x2C7C20 MP 0x449AE0 - {"_meth_8212", 0x8212}, // SP 0x2C8D20 MP 0x44A0E0 - {"_meth_8213", 0x8213}, // SP 0x2C9840 MP 0x44AE90 - {"_meth_8214", 0x8214}, // SP 0x2CB450 MP 0x44C950 - {"_meth_8215", 0x8215}, // SP 0x2CB4A0 MP 0x44CB00 - {"_meth_8216", 0x8216}, // SP 0x2CB5D0 MP 0x44CCA0 - {"_meth_8217", 0x8217}, // SP 0x2CB720 MP 0x44CCF0 - {"circle", 0x8218}, // SP 0x2D0720 MP 0x439750 - iw6 name is WorldPointInReticle_Circle - {"rect", 0x8219}, // SP 0x2D12D0 MP 0x439F20 - {"getpointinbounds", 0x821A}, // SP 0x2D1850 MP 0x43A680 - {"transfermarkstonewscriptmodel", 0x821B}, // SP 0x2D1FC0 MP 0x43B020 - {"setwatersheeting", 0x821C}, // SP 0x2C47C0 MP 0x445400 - {"_meth_821d", 0x821D}, // SP 0x2C02D0 MP 0x000000 - {"_meth_821e", 0x821E}, // SP 0x2C0A60 MP 0x000000 - {"setweaponhudiconoverride", 0x821F}, // SP 0x2CB930 MP 0x44D150 - {"getweaponhudiconoverride", 0x8220}, // SP 0x2CC1D0 MP 0x44D750 - {"_meth_8221", 0x8221}, // SP 0x2CC6B0 MP 0x4356B0 - {"_meth_8222", 0x8222}, // SP 0x2CDCF0 MP 0x437140 - {"_meth_8223", 0x8223}, // SP 0x2CD9F0 MP 0x436F30 - {"_meth_8224", 0x8224}, // SP 0x2CE3A0 MP 0x437750 - {"isitemunlocked", 0x8225}, // SP 0x2D1E80 MP 0x438700 - {"getrankedplayerdata", 0x8226}, // SP 0x2C2210 MP 0x4432D0 - {"vehicleturretcontroloff", 0x8227}, // SP 0x4E7230 MP 0x60E170 - {"isturretready", 0x8228}, // SP 0x4E7310 MP 0x609890 - {"_meth_8229", 0x8229}, // SP 0x4E7560 MP 0x609B20 - {"vehicle_dospawn", 0x822A}, // SP 0x4E76C0 MP 0x609C40 - {"vehicle_isphysveh", 0x822B}, // SP 0x4E7790 MP 0x609D30 - {"vehphys_crash", 0x822C}, // SP 0x4E7830 MP 0x609E30 - {"vehphys_launch", 0x822D}, // SP 0x4E7970 MP 0x609F50 - {"vehphys_disablecrashing", 0x822E}, // SP 0x4E7B40 MP 0x60A0F0 - {"vehphys_enablecrashing", 0x822F}, // SP 0x4E7C30 MP 0x60A1C0 - {"vehphys_setspeed", 0x8230}, // SP 0x4E7CB0 MP 0x60A290 - {"vehphys_setconveyorbelt", 0x8231}, // SP 0x4E7E80 MP 0x60A4C0 - {"freevehicle", 0x8232}, // SP 0x000000 MP 0x60C1B0 - {"_meth_8233", 0x8233}, // SP 0x2C3800 MP 0x000000 - {"_meth_8234", 0x8234}, // SP 0x2C3D60 MP 0x000000 - {"_meth_8235", 0x8235}, // SP 0x2C4410 MP 0x000000 - {"_meth_8236", 0x8236}, // SP 0x2C4730 MP 0x000000 - {"_meth_8237", 0x8237}, // SP 0x2C4EF0 MP 0x000000 - {"_meth_8238", 0x8238}, // SP 0x2C5310 MP 0x000000 - {"_meth_8239", 0x8239}, // SP 0x2CF5B0 MP 0x000000 - {"_meth_823a", 0x823A}, // SP 0x2CF7D0 MP 0x000000 - {"_meth_823b", 0x823B}, // SP 0x2CF990 MP 0x000000 - {"_meth_823c", 0x823C}, // SP 0x2D0070 MP 0x000000 - {"_meth_823d", 0x823D}, // SP 0x2C86C0 MP 0x000000 - {"_meth_823e", 0x823E}, // SP 0x2C8A50 MP 0x000000 - {"_meth_8240", 0x8240}, // SP 0x2C4AD0 MP 0x000000 - {"_meth_8241", 0x8241}, // SP 0x274CF0 MP 0x000000 - {"_meth_8242", 0x8242}, // SP 0x2750F0 MP 0x000000 - {"setcommonplayerdata", 0x8243}, // SP 0x2C2550 MP 0x443C20 - Could be also setrankedplayerdata - {"_meth_8244", 0x8244}, // SP 0x2C2A00 MP 0x4442D0 - {"_meth_8245", 0x8245}, // SP 0x2C3190 MP 0x444850 - {"trackerupdate", 0x8246}, // SP 0x2C51C0 MP 0x447650 - {"pingplayer", 0x8247}, // SP 0x000000 MP 0x412070 - {"buttonpressed", 0x8248}, // SP 0x294C60 MP 0x411F90 - {"sayteam", 0x8249}, // SP 0x000000 MP 0x410520 - {"sayall", 0x824A}, // SP 0x000000 MP 0x4105D0 - {"setspawnweapon", 0x824B}, // SP 0x000000 MP 0x4120E0 - {"dropitem", 0x824C}, // SP 0x292EF0 MP 0x406060 - {"dropscavengerbag", 0x824D}, // SP 0x000000 MP 0x4124F0 - {"setjitterparams", 0x824E}, // SP 0x4E4DA0 MP 0x60BE40 - {"sethoverparams", 0x824F}, // SP 0x4E4E70 MP 0x60BF10 - {"joltbody", 0x8250}, // SP 0x4E4F90 MP 0x60BFB0 - {"freevehicle", 0x8251}, // SP 0x4E5190 MP 0x60C1B0 - {"_meth_8252", 0x8252}, // SP 0x4E5240 MP 0x60C220 - {"getvehicleowner", 0x8253}, // SP 0x4E5490 MP 0x60C470 - {"setvehiclelookattext", 0x8254}, // SP 0x4E5510 MP 0x60C4F0 - {"setvehicleteam", 0x8255}, // SP 0x4E55A0 MP 0x60C580 - {"neargoalnotifydist", 0x8256}, // SP 0x4E5630 MP 0x60C710 - {"setgoalpos", 0x8257}, // SP 0x4E56A0 MP 0x60C780 - {"setgoalyaw", 0x8258}, // SP 0x4E57B0 MP 0x60C8A0 - {"cleargoalyaw", 0x8259}, // SP 0x4E5840 MP 0x60C930 - {"settargetyaw", 0x825A}, // SP 0x4E58C0 MP 0x60C9B0 - {"cleartargetyaw", 0x825B}, // SP 0x4E5950 MP 0x60CA40 - {"helisetgoal", 0x825C}, // SP 0x4E59D0 MP 0x60CAC0 - {"_meth_825d", 0x825D}, // SP 0x4E62A0 MP 0x60D360 - {"setturrettargetent", 0x825E}, // SP 0x4E63A0 MP 0x60D460 - {"clearturrettargetent", 0x825F}, // SP 0x4E64A0 MP 0x60D560 - {"canturrettargetpoint", 0x8260}, // SP 0x4E6530 MP 0x60D5F0 - {"setlookatent", 0x8261}, // SP 0x4E6840 MP 0x60D8F0 - {"clearlookatent", 0x8262}, // SP 0x4E68F0 MP 0x60D9A0 - {"setvehweapon", 0x8263}, // SP 0x4E6A50 MP 0x60DA80 - {"fireweapon", 0x8264}, // SP 0x4E6AC0 MP 0x60DAF0 - {"vehicleturretcontrolon", 0x8265}, // SP 0x4E71A0 MP 0x60E0F0 - {"finishplayerdamage", 0x8266}, // SP 0x000000 MP 0x40F530 - {"suicide", 0x8267}, // SP 0x000000 MP 0x40FD30 - {"_meth_8268", 0x8268}, // SP 0x000000 MP 0x40FF20 - {"clientiprintln", 0x8269}, // SP 0x000000 MP 0x40FFD0 - {"clientiprintlnbold", 0x826A}, // SP 0x000000 MP 0x410050 - {"spawnspectator", 0x826B}, // SP 0x000000 MP 0x4100D0 - {"_meth_826c", 0x826C}, // SP 0x000000 MP 0x410160 - {"cloneplayer", 0x826D}, // SP 0x000000 MP 0x4101C0 - {"istalking", 0x826E}, // SP 0x000000 MP 0x4104A0 - {"allowspectateteam", 0x826F}, // SP 0x000000 MP 0x410680 - {"_meth_8270", 0x8270}, // SP 0x000000 MP 0x4108B0 - {"getguid", 0x8271}, // SP 0x000000 MP 0x410A50 - {"_meth_8272", 0x8272}, // SP 0x2E2760 MP 0x454340 - {"_meth_8273", 0x8273}, // SP 0x2E2990 MP 0x454590 - {"clonebrushmodeltoscriptmodel", 0x8274}, // SP 0x2E30A0 MP 0x454CC0 - {"scriptmodelplayanim", 0x8275}, // SP 0x000000 MP 0x454D90 - {"scriptmodelclearanim", 0x8276}, // SP 0x000000 MP 0x455190 - {"_meth_8277", 0x8277}, // SP 0x000000 MP 0x454FB0 - {"_meth_8278", 0x8278}, // SP 0x4E8090 MP 0x60A6A0 - {"attachpath", 0x8279}, // SP 0x4E8230 MP 0x60A840 - {"getattachpos", 0x827A}, // SP 0x4E8350 MP 0x60A970 - {"startpath", 0x827B}, // SP 0x4E8520 MP 0x60AB40 - {"setswitchnode", 0x827C}, // SP 0x4E87C0 MP 0x60ACD0 - {"setwaitspeed", 0x827D}, // SP 0x4E88C0 MP 0x60AD60 - {"finishdamage", 0x827E}, // SP 0x000000 MP 0x60ADE0 - {"vehicle_setspeed", 0x827F}, // SP 0x4E3EF0 MP 0x60B040 - {"vehicle_setspeedimmediate", 0x8280}, // SP 0x4E3F60 MP 0x60B0B0 - {"vehicle_rotateyaw", 0x8281}, // SP 0x4E4110 MP 0x60B260 - {"vehicle_getspeed", 0x8282}, // SP 0x4E4230 MP 0x60B380 - {"vehicle_getvelocity", 0x8283}, // SP 0x4E4320 MP 0x60B470 - {"vehicle_getbodyvelocity", 0x8284}, // SP 0x4E4390 MP 0x60B4E0 - {"vehicle_getsteering", 0x8285}, // SP 0x4E4400 MP 0x60B550 - {"vehicle_getthrottle", 0x8286}, // SP 0x4E4480 MP 0x60B5E0 - {"vehicle_turnengineoff", 0x8287}, // SP 0x4E44F0 MP 0x60B650 - {"vehicle_turnengineon", 0x8288}, // SP 0x4E4550 MP 0x60B6C0 - {"vehicle_orientto", 0x8289}, // SP 0x4E45B0 MP 0x000000 - {"getgoalspeedmph", 0x828A}, // SP 0x4E4690 MP 0x60B730 - {"setacceleration", 0x828B}, // SP 0x4E4700 MP 0x60B7A0 - {"setdeceleration", 0x828C}, // SP 0x4E4770 MP 0x60B810 - {"resumespeed", 0x828D}, // SP 0x4E47E0 MP 0x60B880 - {"setyawspeed", 0x828E}, // SP 0x4E4870 MP 0x60B910 - {"setyawspeedbyname", 0x828F}, // SP 0x4E49D0 MP 0x60BA70 - {"setmaxpitchroll", 0x8290}, // SP 0x4E4BE0 MP 0x60BC80 - {"setairresitance", 0x8291}, // SP 0x4E4CA0 MP 0x60BD40 - {"setturningability", 0x8292}, // SP 0x4E4D30 MP 0x60BDD0 - {"getxuid", 0x8293}, // SP 0x28EA30 MP 0x410AC0 - {"getucdidhigh", 0x8294}, // SP 0x000000 MP 0x410C80 - {"ismlgspectator", 0x8295}, // SP 0x000000 MP 0x410CE0 - {"getclanidhigh", 0x8296}, // SP 0x000000 MP 0x410D40 - {"getclanidlow", 0x8297}, // SP 0x000000 MP 0x410DA0 - {"ishost", 0x8298}, // SP 0x000000 MP 0x410E00 - {"getspectatingplayer", 0x8299}, // SP 0x000000 MP 0x410E90 - {"predictstreampos", 0x829A}, // SP 0x000000 MP 0x410F10 - {"updatescores", 0x829B}, // SP 0x000000 MP 0x411030 - {"updatedmscores", 0x829C}, // SP 0x000000 MP 0x411040 - {"setrank", 0x829D}, // SP 0x000000 MP 0x411050 - {"_meth_829e", 0x829E}, // SP 0x000000 MP 0x4110F0 - {"setmlgspectator", 0x829F}, // SP 0x28E1B0 MP 0x409FD0 - {"visionsyncwithplayer", 0x82A0}, // SP 0x000000 MP 0x40C160 - {"showhudsplash", 0x82A1}, // SP 0x291570 MP 0x40D190 - {"setperk", 0x82A2}, // SP 0x293310 MP 0x406B20 - {"hasperk", 0x82A3}, // SP 0x293820 MP 0x407100 - {"clearperks", 0x82A4}, // SP 0x294030 MP 0x407860 - {"unsetperk", 0x82A5}, // SP 0x293BC0 MP 0x4074A0 - {"registerparty", 0x82A6}, // SP 0x000000 MP 0x411740 - {"getfireteammembers", 0x82A7}, // SP 0x000000 MP 0x411870 - {"noclip", 0x82A8}, // SP 0x294080 MP 0x407CF0 - {"ufo", 0x82A9}, // SP 0x294230 MP 0x407D00 - {"moveto", 0x82AA}, // SP 0x2E1470 MP 0x453290 - {"movex", 0x82AB}, // SP 0x2E19A0 MP 0x4537F0 - {"movey", 0x82AC}, // SP 0x2E19B0 MP 0x453800 - {"movez", 0x82AD}, // SP 0x2E19D0 MP 0x453820 - {"movegravity", 0x82AE}, // SP 0x2E1610 MP 0x453440 - {"moveslide", 0x82AF}, // SP 0x2E1790 MP 0x4535D0 - {"stopmoveslide", 0x82B0}, // SP 0x2E1920 MP 0x453760 - {"rotateto", 0x82B1}, // SP 0x2E1A70 MP 0x453850 - {"rotatepitch", 0x82B2}, // SP 0x2E1EB0 MP 0x4539A0 - {"rotateyaw", 0x82B3}, // SP 0x2E1EC0 MP 0x4539B0 - {"rotateroll", 0x82B4}, // SP 0x2E1EE0 MP 0x4539D0 - {"addpitch", 0x82B5}, // SP 0x2E1E60 MP 0x453950 - {"addyaw", 0x82B6}, // SP 0x2E1E80 MP 0x453970 - {"addroll", 0x82B7}, // SP 0x2E1EA0 MP 0x453990 - {"vibrate", 0x82B8}, // SP 0x2E1F00 MP 0x4539F0 - {"rotatevelocity", 0x82B9}, // SP 0x2E2160 MP 0x453D00 - {"solid", 0x82BA}, // SP 0x2E3180 MP 0x455340 - {"notsolid", 0x82BB}, // SP 0x2E3230 MP 0x452FA0 - {"setcandamage", 0x82BC}, // SP 0x2E2300 MP 0x453ED0 - {"setcanradiusdamage", 0x82BD}, // SP 0x2E2360 MP 0x453F30 - {"physicslaunch", 0x82BE}, // SP 0x2E23E0 MP 0x453FB0 - {"setcardicon", 0x82BF}, // SP 0x000000 MP 0x411100 - {"setcardnameplate", 0x82C0}, // SP 0x000000 MP 0x411110 - {"setcarddisplayslot", 0x82C1}, // SP 0x000000 MP 0x411120 - {"regweaponforfxremoval", 0x82C2}, // SP 0x000000 MP 0x411230 - {"laststandrevive", 0x82C3}, // SP 0x000000 MP 0x411290 - {"startlaststand", 0x82C4}, // SP 0x000000 MP 0x411300 - {"setspectatedefaults", 0x82C5}, // SP 0x000000 MP 0x411370 - {"getthirdpersoncrosshairoffset", 0x82C6}, // SP 0x000000 MP 0x4115D0 - {"disableweaponpickup", 0x82C7}, // SP 0x290660 MP 0x40C550 - {"enableweaponpickup", 0x82C8}, // SP 0x290770 MP 0x40C640 - {"issplitscreenplayer", 0x82C9}, // SP 0x290840 MP 0x40C750 - {"issplitscreenplayerprimary", 0x82CA}, // SP 0x000000 MP 0x411640 - {"getweaponslistoffhands", 0x82CB}, // SP 0x290060 MP 0x40B8B0 - {"getweaponslistitems", 0x82CC}, // SP 0x290170 MP 0x40B9C0 - {"getweaponslistexclusives", 0x82CD}, // SP 0x290280 MP 0x40BBE0 - {"getweaponslist", 0x82CE}, // SP 0x290410 MP 0x40BCF0 - {"canplayerplacesentry", 0x82CF}, // SP 0x292B20 MP 0x4063C0 - {"canplayerplacetank", 0x82D0}, // SP 0x293020 MP 0x406670 - {"visionsetnakedforplayer", 0x82D1}, // SP 0x291110 MP 0x40D290 - {"visionsetnightforplayer", 0x82D2}, // SP 0x2913D0 MP 0x40D2A0 - {"visionsetmissilecamforplayer", 0x82D3}, // SP 0x2913F0 MP 0x40D2C0 - {"visionsetthermalforplayer", 0x82D4}, // SP 0x291530 MP 0x40D3E0 - {"visionsetpainforplayer", 0x82D5}, // SP 0x291550 MP 0x40D400 - {"setblurforplayer", 0x82D6}, // SP 0x292660 MP 0x40E430 - {"getplayerweaponmodel", 0x82D7}, // SP 0x292A50 MP 0x4061A0 - {"getplayerknifemodel", 0x82D8}, // SP 0x292B00 MP 0x4061C0 - {"updateplayermodelwithweapons", 0x82D9}, // SP 0x2D70D0 MP 0x000000 - {"notifyonplayercommand", 0x82DA}, // SP 0x294240 MP 0x407D10 - {"canmantle", 0x82DB}, // SP 0x28CD90 MP 0x408310 - {"forcemantle", 0x82DC}, // SP 0x28CFB0 MP 0x408630 - {"ismantling", 0x82DD}, // SP 0x28D2C0 MP 0x408990 - {"playfx", 0x82DE}, // SP 0x28D630 MP 0x408EC0 - {"player_recoilscaleon", 0x82DF}, // SP 0x28D850 MP 0x409200 - {"player_recoilscaleoff", 0x82E0}, // SP 0x28D920 MP 0x4092D0 - {"weaponlockstart", 0x82E1}, // SP 0x28DA00 MP 0x409530 - {"weaponlockfinalize", 0x82E2}, // SP 0x28DCC0 MP 0x4097A0 - {"weaponlockfree", 0x82E3}, // SP 0x28DFC0 MP 0x409C50 - was disableautoreload - {"setentertime", 0x82E4}, // SP 0x28E060 MP 0x409E60 - {"usinggamepad", 0x82E5}, // SP 0x000000 MP 0x411680 - {"_meth_82e6", 0x82E6}, // SP 0x000000 MP 0x411700 - {"issighted", 0x82E7}, // SP 0x000000 MP 0x411710 - {"_meth_82e8", 0x82E8}, // SP 0x000000 MP 0x411730 - {"_meth_82e9", 0x82E9}, // SP 0x000000 MP 0x411720 - {"_meth_82ea", 0x82EA}, // SP 0x2905B0 MP 0x40BAD0 - {"fragbuttonpressed", 0x82EB}, // SP 0x28F5E0 MP 0x40AB90 - {"secondaryoffhandbuttonpressed", 0x82EC}, // SP 0x28F6D0 MP 0x40ACC0 - {"issighted", 0x82ED}, // SP 0x2919D0 MP 0x40D2E0 - {"setvelocity", 0x82EE}, // SP 0x28DC30 MP 0x4090E0 - {"_meth_82ef", 0x82EF}, // SP 0x28E570 MP 0x409920 - {"getnormalizedmovement", 0x82F0}, // SP 0x28E980 MP 0x409B70 - {"playlocalsound", 0x82F1}, // SP 0x28DAC0 MP 0x409330 - {"stoplocalsound", 0x82F2}, // SP 0x28DBA0 MP 0x409420 - {"setweaponammoclip", 0x82F3}, // SP 0x2928A0 MP 0x405D60 - {"setweaponammostock", 0x82F4}, // SP 0x292D20 MP 0x4061E0 - {"getweaponammoclip", 0x82F5}, // SP 0x293200 MP 0x406730 - {"getweaponammostock", 0x82F6}, // SP 0x293450 MP 0x406970 - {"anyammoforweaponmodes", 0x82F7}, // SP 0x2936A0 MP 0x406D30 - {"setclientomnvar", 0x82F8}, // SP 0x293DA0 MP 0x4077B0 - {"setclientdvar", 0x82F9}, // SP 0x2942B0 MP 0x407D90 - {"setclientdvars", 0x82FA}, // SP 0x28C960 MP 0x4086D0 - {"setclientspawnsighttraces", 0x82FB}, // SP 0x000000 MP 0x408050 - {"clientspawnsighttracepassed", 0x82FC}, // SP 0x000000 MP 0x408200 - {"allowads", 0x82FD}, // SP 0x28EC70 MP 0x409ED0 - {"allowjump", 0x82FE}, // SP 0x28EFC0 MP 0x40A0B0 - {"allowladder", 0x82FF}, // SP 0x28F750 MP 0x40AE80 - {"allowmantle", 0x8300}, // SP 0x28F830 MP 0x40B030 - {"allowsprint", 0x8301}, // SP 0x28F910 MP 0x40B1A0 - {"setspreadoverride", 0x8302}, // SP 0x290890 MP 0x40C0D0 - {"resetspreadoverride", 0x8303}, // SP 0x2909D0 MP 0x40C4D0 - {"setaimspreadmovementscale", 0x8304}, // SP 0x290AA0 MP 0x40C5B0 - {"setactionslot", 0x8305}, // SP 0x28FB60 MP 0x40B340 - {"setviewkickscale", 0x8306}, // SP 0x28E330 MP 0x40A120 - {"getviewkickscale", 0x8307}, // SP 0x28E520 MP 0x40A250 - {"getweaponslistall", 0x8308}, // SP 0x28FDF0 MP 0x40B690 - {"getweaponslistprimaries", 0x8309}, // SP 0x28FF50 MP 0x40B7A0 - {"getnormalizedcameramovement", 0x830A}, // SP 0x28EBC0 MP 0x409CB0 - {"giveweapon", 0x830B}, // SP 0x290B90 MP 0x40C270 - {"takeweapon", 0x830C}, // SP 0x291080 MP 0x40C920 - {"takeallweapons", 0x830D}, // SP 0x2912B0 MP 0x40CB30 - {"getcurrentweapon", 0x830E}, // SP 0x291410 MP 0x40CED0 - {"getcurrentprimaryweapon", 0x830F}, // SP 0x291750 MP 0x40D0C0 - {"getcurrentoffhand", 0x8310}, // SP 0x291C00 MP 0x40D600 - {"hasweapon", 0x8311}, // SP 0x292480 MP 0x40E0D0 - {"switchtoweapon", 0x8312}, // SP 0x292A70 MP 0x40E5F0 - {"switchtoweaponimmediate", 0x8313}, // SP 0x292C90 MP 0x405F20 - {"gethybridscopestate", 0x8314}, // SP 0x2937D0 MP 0x406CD0 - {"switchtooffhand", 0x8315}, // SP 0x293A00 MP 0x406E20 - {"setoffhandsecondaryclass", 0x8316}, // SP 0x2920D0 MP 0x40DC70 - {"getoffhandSecondaryclass", 0x8317}, // SP 0x2923B0 MP 0x40DEF0 - {"beginlocationselection", 0x8318}, // SP 0x28E770 MP 0x409A10 - {"endlocationselection", 0x8319}, // SP 0x28EB50 MP 0x409D10 - {"disableweapons", 0x831A}, // SP 0x291CA0 MP 0x40DA50 - {"enableweapons", 0x831B}, // SP 0x291E70 MP 0x40DB40 - {"disableoffhandweapons", 0x831C}, // SP 0x291EE0 MP 0x40DD40 - {"enableoffhandweapons", 0x831D}, // SP 0x292080 MP 0x40DE90 - {"disableweaponswitch", 0x831E}, // SP 0x292430 MP 0x40E3D0 - {"enableweaponswitch", 0x831F}, // SP 0x292610 MP 0x40E570 - {"openpopupmenu", 0x8320}, // SP 0x290EF0 MP 0x40C7B0 - {"openpopupmenunomouse", 0x8321}, // SP 0x290F90 MP 0x40C9C0 - {"closepopupmenu", 0x8322}, // SP 0x291030 MP 0x40CBC0 - {"openmenu", 0x8323}, // SP 0x291130 MP 0x40CCE0 - {"closemenu", 0x8324}, // SP 0x291330 MP 0x40CFB0 - {"freezecontrols", 0x8326}, // SP 0x291880 MP 0x40D420 - {"disableusability", 0x8327}, // SP 0x291980 MP 0x40D6D0 - {"enableusability", 0x8328}, // SP 0x291BB0 MP 0x40D8D0 - {"setwhizbyspreads", 0x8329}, // SP 0x28CEE0 MP 0x408AD0 - {"setwhizbyradii", 0x832A}, // SP 0x28CFF0 MP 0x408CB0 - {"setreverb", 0x832B}, // SP 0x28D180 MP 0x408E90 - {"deactivatereverb", 0x832C}, // SP 0x28D460 MP 0x408EB0 - {"setvolmod", 0x832D}, // SP 0x28D730 MP 0x408FD0 - {"givestartammo", 0x832E}, // SP 0x293E20 MP 0x407000 - {"givemaxammo", 0x832F}, // SP 0x294090 MP 0x407300 - {"getfractionstartammo", 0x8330}, // SP 0x28C800 MP 0x407640 - {"getfractionmaxammo", 0x8331}, // SP 0x28CAC0 MP 0x407AF0 - {"isdualwielding", 0x8332}, // SP 0x28D0F0 MP 0x407FE0 - {"isreloading", 0x8333}, // SP 0x28D310 MP 0x408180 - {"isswitchingweapon", 0x8334}, // SP 0x28D3E0 MP 0x408360 - {"setorigin", 0x8335}, // SP 0x28DAE0 MP 0x408DA0 - {"getvelocity", 0x8336}, // SP 0x28DF50 MP 0x409180 - {"setplayerangles", 0x8337}, // SP 0x28E3B0 MP 0x409370 - {"getplayerangles", 0x8338}, // SP 0x28E430 MP 0x409600 - {"usebuttonpressed", 0x8339}, // SP 0x28F130 MP 0x40A3A0 - {"attackbuttonpressed", 0x833A}, // SP 0x28F220 MP 0x40A660 - {"adsbuttonpressed", 0x833B}, // SP 0x28F400 MP 0x40A760 - {"meleebuttonpressed", 0x833C}, // SP 0x28F500 MP 0x40AA40 - {"playerads", 0x833D}, // SP 0x28FCC0 MP 0x40B210 - {"isonground", 0x833E}, // SP 0x28FD10 MP 0x40B2D0 - {"isusingturret", 0x833F}, // SP 0x28FEF0 MP 0x40B570 - {"setviewmodel", 0x8340}, // SP 0x290390 MP 0x40B5E0 - {"setoffhandprimaryclass", 0x8341}, // SP 0x291DB0 MP 0x40D800 - {"getoffhandprimaryclass", 0x8342}, // SP 0x292000 MP 0x40DAB0 - {"enablefocus", 0x8343}, // SP 0x28DDE0 MP 0x000000 - {"disablefocus", 0x8344}, // SP 0x28E0C0 MP 0x000000 - {"enableaudiozoom", 0x8345}, // SP 0x28E260 MP 0x000000 - {"disableaudiozoom", 0x8346}, // SP 0x28E480 MP 0x000000 - {"_meth_8347", 0x8347}, // SP 0x299DF0 MP 0x418DA0 - {"forcethirdpersonwhenfollowing", 0x8348}, // SP 0x000000 MP 0x0DF510 - {"disableforcethirdpersonwhenfollowing", 0x8349}, // SP 0x000000 MP 0x0DFA20 - {"_meth_834a", 0x834A}, // SP 0x28E6F0 MP 0x409B60 - {"setscriptmoverkillcam", 0x834B}, // SP 0x000000 MP 0x0CC3F0 - {"secondaryoffhandbuttonpressed", 0x834C}, // SP 0x28F970 MP 0x40AFB0 - {"_meth_834d", 0x834D}, // SP 0x000000 MP 0x0DCF20 - {"_meth_834e", 0x834E}, // SP 0x000000 MP 0x0DD7F0 - {"botsetflag", 0x834F}, // SP 0x000000 MP 0x546BC0 - {"botsetstance", 0x8350}, // SP 0x000000 MP 0x5473D0 - {"botsetscriptmove", 0x8351}, // SP 0x000000 MP 0x547250 - {"_meth_8352", 0x8352}, // SP 0x000000 MP 0x546EA0 - {"botsetscriptgoal", 0x8353}, // SP 0x000000 MP 0x547090 - {"botclearscriptgoal", 0x8354}, // SP 0x000000 MP 0x544F60 - {"getnearestnode", 0x8355}, // SP 0x000000 MP 0x546DE0 - {"botclearscriptenemy", 0x8356}, // SP 0x000000 MP 0x544EE0 - {"botsetattacker", 0x8357}, // SP 0x000000 MP 0x546980 - {"botgetscriptgoal", 0x8358}, // SP 0x000000 MP 0x545780 - {"botgetscriptgoalradius", 0x8359}, // SP 0x000000 MP 0x5458D0 - {"botgetscriptgoalyaw", 0x835A}, // SP 0x000000 MP 0x5459D0 - {"botgetscriptgoaltype", 0x835B}, // SP 0x000000 MP 0x545950 - {"_meth_835d", 0x835D}, // SP 0x000000 MP 0x545B30 - {"_meth_835e", 0x835E}, // SP 0x000000 MP 0x5460F0 - {"botfindnoderandom", 0x835F}, // SP 0x000000 MP 0x544FE0 - {"botmemoryevent", 0x8360}, // SP 0x000000 MP 0x545E50 - {"botnodepick", 0x8362}, // SP 0x000000 MP 0x546190 - {"bothasscriptgoal", 0x8363}, // SP 0x000000 MP 0x545B70 - {"botgetpersonality", 0x8364}, // SP 0x000000 MP 0x545700 - {"_meth_8365", 0x8365}, // SP 0x000000 MP 0x5474A0 - {"botsetpersonality", 0x8367}, // SP 0x000000 MP 0x546D50 - {"botsetdifficulty", 0x8368}, // SP 0x000000 MP 0x546A90 - {"botgetdifficulty", 0x8369}, // SP 0x000000 MP 0x545170 - {"botgetworldclosestedge", 0x836A}, // SP 0x000000 MP 0x545A50 - {"_meth_836b", 0x836B}, // SP 0x000000 MP 0x545C70 - {"botpredictseepoint", 0x836C}, // SP 0x000000 MP 0x546700 - {"botcanseeentity", 0x836D}, // SP 0x000000 MP 0x544D70 - {"botgetnodesonpath", 0x836E}, // SP 0x000000 MP 0x545510 - {"_meth_836f", 0x836F}, // SP 0x000000 MP 0x546300 - {"_meth_8371", 0x8371}, // SP 0x000000 MP 0x5452B0 - {"botsetawareness", 0x8372}, // SP 0x000000 MP 0x546A00 - {"_meth_8373", 0x8373}, // SP 0x000000 MP 0x5468F0 - {"botgetscriptgoalnode", 0x8374}, // SP 0x000000 MP 0x545840 - {"botgetimperfectenemyinfo", 0x8375}, // SP 0x000000 MP 0x5453B0 - {"botsetpathingstyle", 0x8377}, // SP 0x000000 MP 0x546C80 - {"botsetdifficultysetting", 0x8378}, // SP 0x000000 MP 0x546B20 - {"botgetdifficultysetting", 0x8379}, // SP 0x000000 MP 0x545200 - {"botgetpathdist", 0x837A}, // SP 0x000000 MP 0x5455D0 - {"_meth_837b", 0x837B}, // SP 0x000000 MP 0x545BF0 - {"_meth_837c", 0x837C}, // SP 0x000000 MP 0x5467F0 - {"botclearbutton", 0x837D}, // SP 0x000000 MP 0x544E50 - {"_meth_837e", 0x837E}, // SP 0x000000 MP 0x5464B0 - {"getnodenumber", 0x837F}, // SP 0x000000 MP 0x40BF90 - {"setclientowner", 0x8380}, // SP 0x000000 MP 0x0C9690 - {"setotherent", 0x8381}, // SP 0x000000 MP 0x0C5BB0 - {"setaisightlinevisible", 0x8382}, // SP 0x2C6B30 MP 0x449220 - {"setentityowner", 0x8383}, // SP 0x000000 MP 0x0C8510 - {"nodeisdisconnected", 0x8384}, // SP 0x000000 MP 0x40C0B0 - {"_meth_8385", 0x8385}, // SP 0x290920 MP 0x40BE80 - {"_meth_8386", 0x8386}, // SP 0x000000 MP 0x0CB540 - {"_meth_8388", 0x8388}, // SP 0x000000 MP 0x51BBE0 - {"_meth_8389", 0x8389}, // SP 0x000000 MP 0x51B240 - {"setagentattacker", 0x838A}, // SP 0x000000 MP 0x51BA90 - {"_meth_838b", 0x838B}, // SP 0x000000 MP 0x51AD10 - {"agentcanseesentient", 0x838C}, // SP 0x000000 MP 0x51AB30 - {"setwaypoint", 0x838D}, // SP 0x000000 MP 0x51D770 - {"setgoalpos", 0x838E}, // SP 0x000000 MP 0x51CD70 - {"getgoalpos", 0x838F}, // SP 0x000000 MP 0x51C2C0 - {"setgoalnode", 0x8390}, // SP 0x000000 MP 0x51CCE0 - {"setgoalentity", 0x8391}, // SP 0x000000 MP 0x51CC50 - {"setgoalradius", 0x8392}, // SP 0x000000 MP 0x51CEB0 - {"scragentsetanimscale", 0x8393}, // SP 0x000000 MP 0x51CB10 - {"setorientmode", 0x8394}, // SP 0x000000 MP 0x51D190 - {"setanimmode", 0x8395}, // SP 0x000000 MP 0x51C9F0 - {"setphysicsmode", 0x8396}, // SP 0x000000 MP 0x51D3D0 - {"setclipmode", 0x8397}, // SP 0x000000 MP 0x51CBB0 - {"setmaxturnspeed", 0x8398}, // SP 0x000000 MP 0x51CFC0 - {"getmaxturnspeed", 0x8399}, // SP 0x000000 MP 0x51C3F0 - {"beginmelee", 0x839A}, // SP 0x000000 MP 0x51BEF0 - {"getmlgspectatorteam", 0x839B}, // SP 0x000000 MP 0x51D490 - {"dotrajectory", 0x839C}, // SP 0x000000 MP 0x51C220 - {"doanimlerp", 0x839D}, // SP 0x000000 MP 0x51C0D0 - {"setviewheight", 0x839E}, // SP 0x000000 MP 0x51D6F0 - {"claimnode", 0x839F}, // SP 0x000000 MP 0x51BFC0 - {"relinquishclaimednode", 0x83A0}, // SP 0x000000 MP 0x51C8E0 - {"_meth_83a1", 0x83A1}, // SP 0x29ABC0 MP 0x419930 - {"_meth_83a2", 0x83A2}, // SP 0x29AC70 MP 0x4199E0 - {"_meth_83a3", 0x83A3}, // SP 0x29ACE0 MP 0x419A40 - {"_meth_83a4", 0x83A4}, // SP 0x29AD50 MP 0x419AA0 - {"_meth_83a5", 0x83A5}, // SP 0x2DC2C0 MP 0x000000 - {"_meth_83a6", 0x83A6}, // SP 0x28E640 MP 0x40A350 - {"_meth_83a7", 0x83A7}, // SP 0x28E8C0 MP 0x40A430 - {"_meth_83a8", 0x83A8}, // SP 0x295740 MP 0x000000 - {"_meth_83a9", 0x83A9}, // SP 0x2DC610 MP 0x000000 - {"_meth_83aa", 0x83AA}, // SP 0x2DC6A0 MP 0x000000 - {"_meth_83ab", 0x83AB}, // SP 0x2955F0 MP 0x000000 - {"_meth_83ac", 0x83AC}, // SP 0x2956D0 MP 0x000000 - {"_meth_83ad", 0x83AD}, // SP 0x295660 MP 0x000000 - {"_meth_83b0", 0x83B0}, // SP 0x28F0C0 MP 0x40A220 - {"_meth_83b1", 0x83B1}, // SP 0x28D380 MP 0x408A60 - {"_meth_83b2", 0x83B2}, // SP 0x28D530 MP 0x408C60 - {"_meth_83b3", 0x83B3}, // SP 0x4E8200 MP 0x60A810 - {"_meth_83b4", 0x83B4}, // SP 0x4E8210 MP 0x60A820 - {"_meth_83b5", 0x83B5}, // SP 0x000000 MP 0x0D93F0 - {"_meth_83b6", 0x83B6}, // SP 0x2CF0F0 MP 0x439280 - {"_meth_83b7", 0x83B7}, // SP 0x2CCBE0 MP 0x436640 - {"_meth_83b8", 0x83B8}, // SP 0x2CCC30 MP 0x436730 - {"_meth_83b9", 0x83B9}, // SP 0x28F890 MP 0x40AF20 - {"_meth_83ba", 0x83BA}, // SP 0x4E5C30 MP 0x60CCF0 - {"_meth_83bb", 0x83BB}, // SP 0x4E5CE0 MP 0x60CDA0 - {"_meth_83bc", 0x83BC}, // SP 0x4E5D60 MP 0x60CE20 - {"_meth_83bd", 0x83BD}, // SP 0x2B84D0 MP 0x000000 - {"_meth_83be", 0x83BE}, // SP 0x2918F0 MP 0x40D750 - {"_meth_83bf", 0x83BF}, // SP 0x291AD0 MP 0x40D950 - {"_meth_83c0", 0x83C0}, // SP 0x291D00 MP 0x40DBA0 - {"_meth_83c1", 0x83C1}, // SP 0x2E25A0 MP 0x454180 - {"_meth_83c2", 0x83C2}, // SP 0x307EB0 MP 0x08FC40 - {"_meth_83c3", 0x83C3}, // SP 0x4E52E0 MP 0x60C2C0 - {"_meth_83c4", 0x83C4}, // SP 0x28F020 MP 0x40A940 - {"_meth_83c5", 0x83C5}, // SP 0x2B8460 MP 0x000000 - {"_meth_83c6", 0x83C6}, // SP 0x277200 MP 0x000000 - {"_meth_83c7", 0x83C7}, // SP 0x277310 MP 0x000000 - {"_meth_83c8", 0x83C8}, // SP 0x277650 MP 0x000000 - {"_meth_83c9", 0x83C9}, // SP 0x277740 MP 0x000000 - {"_meth_83ca", 0x83CA}, // SP 0x277A10 MP 0x000000 - {"_meth_83cb", 0x83CB}, // SP 0x2779A0 MP 0x000000 - {"_meth_83cc", 0x83CC}, // SP 0x277A80 MP 0x000000 - {"_meth_83cd", 0x83CD}, // SP 0x277AE0 MP 0x000000 - {"setanimclass", 0x83CE}, // SP 0x000000 MP 0x090580 - {"enableanimstate", 0x83CF}, // SP 0x000000 MP 0x090050 - {"setanimstate", 0x83D0}, // SP 0x000000 MP 0x0905F0 - {"getanimentry", 0x83D1}, // SP 0x000000 MP 0x090190 - {"getanimentryname", 0x83D2}, // SP 0x000000 MP 0x090340 - {"getanimentryalias", 0x83D3}, // SP 0x000000 MP 0x090220 - {"getanimentrycount", 0x83D4}, // SP 0x000000 MP 0x090280 - {"_meth_83d5", 0x83D5}, // SP 0x2D8DC0 MP 0x000000 - {"issprinting", 0x83D6}, // SP 0x28EF40 MP 0x40A040 - {"_meth_83d7", 0x83D7}, // SP 0x2C4000 MP 0x000000 - {"_meth_83d8", 0x83D8}, // SP 0x275850 MP 0x000000 - {"setclothtype", 0x83D9}, // SP 0x2C0670 MP 0x4492A0 - {"_meth_83da", 0x83DA}, // SP 0x2DC560 MP 0x000000 - {"_meth_83db", 0x83DB}, // SP 0x2DC5D0 MP 0x000000 - {"_meth_83dc", 0x83DC}, // SP 0x28F7B0 MP 0x40ADE0 - {"rotateto", 0x83DD}, // SP 0x2E1C40 MP 0x4538D0 - {"getlookaheaddir", 0x83DE}, // SP 0x000000 MP 0x51C360 - {"getpathgoalpos", 0x83DF}, // SP 0x000000 MP 0x51C720 - {"setrocketcorpse", 0x83E0}, // SP 0x2C26B0 MP 0x442290 - {"setcorpsefalling", 0x83E1}, // SP 0x000000 MP 0x0DB3D0 - {"setsurfacetype", 0x83E2}, // SP 0x2C0960 MP 0x4494D0 - {"aiphysicstrace", 0x83E3}, // SP 0x2BCCD0 MP 0x43C370 - {"_meth_83e4", 0x83E4}, // SP 0x2BE100 MP 0x43CE20 - {"_meth_83e5", 0x83E5}, // SP 0x299CB0 MP 0x418C70 - {"_meth_83e6", 0x83E6}, // SP 0x2DB850 MP 0x000000 - {"_meth_83e7", 0x83E7}, // SP 0x2DB9E0 MP 0x000000 - {"visionsetstage", 0x83E8}, // SP 0x290E40 MP 0x40CDF0 - {"hudoutlineenableforclients", 0x83E9}, // SP 0x29A0F0 MP 0x4190A0 - {"getlinkedparent", 0x83EA}, // SP 0x2BF830 MP 0x443220 - {"getmovingplatformparent", 0x83EB}, // SP 0x2C0530 MP 0x443F10 - {"setnameplatematerial", 0x83EC}, // SP 0x000000 MP 0x40A480 - {"_meth_83ed", 0x83ED}, // SP 0x2D8D40 MP 0x000000 - {"_meth_83ef", 0x83EF}, // SP 0x2C16C0 MP 0x442910 - {"_meth_83f0", 0x83F0}, // SP 0x2C0230 MP 0x440F60 - {"makevehiclenotcollidewithplayers", 0x83F1}, // SP 0x2C6190 MP 0x4484E0 - {"_meth_83f2", 0x83F2}, // SP 0x294DB0 MP 0x000000 - {"_meth_83f3", 0x83F3}, // SP 0x294E10 MP 0x000000 - {"setscriptablepartstate", 0x83F4}, // SP 0x2C1610 MP 0x44A030 - {"_meth_83f5", 0x83F5}, // SP 0x2C1DE0 MP 0x44AA20 - {"_meth_83f6", 0x83F6}, // SP 0x2C2770 MP 0x442550 - {"_meth_83f7", 0x83F7}, // SP 0x4E5620 MP 0x60C5F0 - {"_meth_83f8", 0x83F8}, // SP 0x2CE8E0 MP 0x4369E0 - {"_meth_83f9", 0x83F9}, // SP 0x2CE9B0 MP 0x436A80 - {"motionblurhqdisable", 0x83FA}, // SP 0x2CEE40 MP 0x436FB0 - {"_meth_83fb", 0x83FB}, // SP 0x2CEF70 MP 0x437100 - {"_meth_83fc", 0x83FC}, // SP 0x2DE6D0 MP 0x000000 - {"_meth_83fd", 0x83FD}, // SP 0x277010 MP 0x000000 - {"worldpointtoscreenpos", 0x83FE}, // SP 0x2CC840 MP 0x435CA0 - {"_meth_83ff", 0x83FF}, // SP 0x2CB310 MP 0x000000 - {"_meth_8400", 0x8400}, // SP 0x275BC0 MP 0x000000 - {"_meth_8401", 0x8401}, // SP 0x000000 MP 0x545070 - {"_meth_8402", 0x8402}, // SP 0x291670 MP 0x000000 - {"_meth_8403", 0x8403}, // SP 0x2961E0 MP 0x000000 - {"_meth_8404", 0x8404}, // SP 0x2CB550 MP 0x000000 - {"_meth_8405", 0x8405}, // SP 0x2CB6A0 MP 0x000000 - {"_meth_8406", 0x8406}, // SP 0x2CE710 MP 0x000000 - {"emissiveblend", 0x8407}, // SP 0x000000 MP 0x0E4370 - {"_meth_8408", 0x8408}, // SP 0x295AC0 MP 0x000000 - {"_meth_8409", 0x8409}, // SP 0x295B10 MP 0x000000 - {"_meth_840a", 0x840A}, // SP 0x2DAD40 MP 0x000000 - {"_meth_840b", 0x840B}, // SP 0x2D92C0 MP 0x000000 - {"_meth_840c", 0x840C}, // SP 0x2D9350 MP 0x000000 - {"_meth_840d", 0x840D}, // SP 0x2E2B00 MP 0x454720 - {"_meth_840e", 0x840E}, // SP 0x2E2BB0 MP 0x4547D0 - {"physicsgetlinspeed", 0x840F}, // SP 0x2E2C60 MP 0x454880 - {"_meth_8410", 0x8410}, // SP 0x2E2D20 MP 0x454940 - {"physicsgetangvel", 0x8411}, // SP 0x2E2E00 MP 0x454A20 - {"physicsgetangspeed", 0x8412}, // SP 0x2E2EC0 MP 0x454AE0 - {"disablemissileboosting", 0x8413}, // SP 0x000000 MP 0x446DE0 - {"enablemissileboosting", 0x8414}, // SP 0x000000 MP 0x4470F0 - {"canspawntestclient", 0x8415}, // SP 0x000000 MP 0x0E2B80 - {"spawntestclient", 0x8416}, // SP 0x000000 MP 0x0E2D80 - {"setgrenadethrowscale", 0x8417}, // SP 0x000000 MP 0x4409F0 - {"ismantling", 0x8418}, // SP 0x000000 MP 0x441200 - {"_meth_8419", 0x8419}, // SP 0x000000 MP 0x0E3010 - {"_meth_841a", 0x841A}, // SP 0x2CE570 MP 0x435830 - {"_meth_841b", 0x841B}, // SP 0x2CE6C0 MP 0x435C10 - {"_meth_841c", 0x841C}, // SP 0x2CE700 MP 0x436550 - {"_meth_841d", 0x841D}, // SP 0x2CE800 MP 0x436760 - {"turretsetbarrelspinenabled", 0x841E}, // SP 0x2CC790 MP 0x436300 - {"_meth_841f", 0x841F}, // SP 0x000000 MP 0x411A60 - {"autospotoverlayoff", 0x8420}, // SP 0x000000 MP 0x411C60 - {"_meth_8421", 0x8421}, // SP 0x2C07D0 MP 0x441460 - {"_meth_8422", 0x8422}, // SP 0x2C0B30 MP 0x441E10 - {"doanimrelative", 0x8423}, // SP 0x000000 MP 0x51C170 - {"_meth_8424", 0x8424}, // SP 0x2E1AF0 MP 0x000000 - {"_meth_8425", 0x8425}, // SP 0x2E1CC0 MP 0x000000 - {"_meth_8426", 0x8426}, // SP 0x2E1D60 MP 0x000000 - {"getcorpseentity", 0x8427}, // SP 0x000000 MP 0x0DBCB0 - {"_meth_8428", 0x8428}, // SP 0x2D7060 MP 0x000000 - {"_meth_8429", 0x8429}, // SP 0x000000 MP 0x0C1AE0 - {"_meth_842a", 0x842A}, // SP 0x000000 MP 0x0C4CF0 - {"queuedialogforplayer", 0x842B}, // SP 0x000000 MP 0x0BCE80 - {"setmlgcameradefaults", 0x842C}, // SP 0x000000 MP 0x411530 - {"_meth_842d", 0x842D}, // SP 0x000000 MP 0x410990 - {"_meth_842e", 0x842E}, // SP 0x290980 MP 0x40C8C0 - {"_meth_842f", 0x842F}, // SP 0x290A50 MP 0x40CAD0 - {"_meth_8430", 0x8430}, // SP 0x295780 MP 0x000000 - {"getlinkedchildren", 0x8431}, // SP 0x2C01A0 MP 0x443AC0 - {"_meth_8432", 0x8432}, // SP 0x000000 MP 0x546600 - {"playsoundonmovingent", 0x8433}, // SP 0x000000 MP 0x0B9DE0 - {"cancelmantle", 0x8434}, // SP 0x28D0B0 MP 0x408680 - {"hasfemalecustomizationmodel", 0x8435}, // SP 0x000000 MP 0x4122F0 - {"setscriptabledamageowner", 0x8437}, // SP 0x2C12E0 MP 0x449D80 - {"_meth_8438", 0x8438}, // SP 0x2C1BF0 MP 0x44A8E0 - {"_meth_8439", 0x8439}, // SP 0x000000 MP 0x0C2140 - {"_meth_843a", 0x843A}, // SP 0x277B50 MP 0x000000 - {"_meth_843b", 0x843B}, // SP 0x277BF0 MP 0x000000 - {"_meth_843c", 0x843C}, // SP 0x293780 MP 0x406AC0 - {"_meth_843d", 0x843D}, // SP 0x278050 MP 0x000000 - {"_meth_843e", 0x843E}, // SP 0x2BC730 MP 0x43D430 - {"_meth_843f", 0x843F}, // SP 0x28F030 MP 0x40AAD0 - {"_meth_8440", 0x8440}, // SP 0x4E6960 MP 0x60DA10 - {"_meth_8441", 0x8441}, // SP 0x4E5E20 MP 0x60CEE0 - {"linkto", 0x8442}, // SP 0x2BEED0 MP 0x442800 - {"_meth_8443", 0x8443}, // SP 0x293F10 MP 0x407950 - {"_meth_8444", 0x8444}, // SP 0x2DC850 MP 0x000000 - {"_meth_8445", 0x8445}, // SP 0x2DC890 MP 0x000000 - {"getcacplayerdata", 0x8446}, // SP 0x2C3AF0 MP 0x444D60 - {"_meth_8447", 0x8447}, // SP 0x2CEAB0 MP 0x436B20 - {"_meth_8448", 0x8448}, // SP 0x2CEB90 MP 0x436CD0 - {"_meth_8449", 0x8449}, // SP 0x28ECF0 MP 0x409D80 - {"_meth_844a", 0x844A}, // SP 0x2C89F0 MP 0x44A800 - {"_meth_844b", 0x844B}, // SP 0x2C8CC0 MP 0x44A9B0 - {"_meth_844c", 0x844C}, // SP 0x4E5FA0 MP 0x60D060 - {"_meth_844d", 0x844D}, // SP 0x4E5FC0 MP 0x60D080 - {"_meth_844e", 0x844E}, // SP 0x4E5FE0 MP 0x60D0A0 - {"_meth_844f", 0x844F}, // SP 0x4E6000 MP 0x60D0C0 - {"_meth_8450", 0x8450}, // SP 0x2D7EC0 MP 0x000000 - {"_meth_8451", 0x8451}, // SP 0x2D8020 MP 0x000000 - {"_meth_8452", 0x8452}, // SP 0x4E5EE0 MP 0x60CFA0 - {"_meth_8453", 0x8453}, // SP 0x28FA60 MP 0x40B270 - {"_meth_8454", 0x8454}, // SP 0x28EE50 MP 0x000000 - {"_meth_8455", 0x8455}, // SP 0x2D8060 MP 0x000000 - {"getvieworigin", 0x8458}, // SP 0x2D1A20 MP 0x4390C0 - {"_meth_8459", 0x8459}, // SP 0x293CF0 MP 0x406FF0 - {"_meth_845a", 0x845A}, // SP 0x000000 MP 0x446520 - {"stopridingvehicle", 0x845B}, // SP 0x000000 MP 0x446960 - {"_meth_845c", 0x845C}, // SP 0x2DC5F0 MP 0x000000 - {"_meth_845d", 0x845D}, // SP 0x2C0AA0 MP 0x4442C0 - {"disablemissilestick", 0x845E}, // SP 0x000000 MP 0x0B7D00 - {"enablemissilestick", 0x845F}, // SP 0x000000 MP 0x0B8130 - {"setmissileminimapvisible", 0x8460}, // SP 0x000000 MP 0x4253C0 - {"isoffhandweaponreadytothrow", 0x8461}, // SP 0x28D8C0 MP 0x4089F0 - {"isleaning", 0x8462}, // SP 0x28F050 MP 0x40A1B0 - {"makecollidewithitemclip", 0x8463}, // SP 0x2C6680 MP 0x448F30 - {"_meth_8464", 0x8464}, // SP 0x28F9F0 MP 0x000000 - {"visionsetpostapplyforplayer", 0x8465}, // SP 0x000000 MP 0x40D4D0 - {"_meth_8466", 0x8466}, // SP 0x2E3340 MP 0x453040 - {"_meth_8467", 0x8467}, // SP 0x2E3510 MP 0x453210 - {"_meth_8468", 0x8468}, // SP 0x2C3CC0 MP 0x000000 - {"_meth_8469", 0x8469}, // SP 0x2C4080 MP 0x000000 - {"_meth_846a", 0x846A}, // SP 0x2C4300 MP 0x000000 - {"_meth_846b", 0x846B}, // SP 0x2C4850 MP 0x000000 - {"_meth_846c", 0x846C}, // SP 0x2C5070 MP 0x000000 - {"_meth_846d", 0x846D}, // SP 0x28E5C0 MP 0x000000 - {"_meth_846e", 0x846E}, // SP 0x2DC390 MP 0x000000 - {"_meth_846f", 0x846F}, // SP 0x4E6080 MP 0x60D140 - {"_meth_8470", 0x8470}, // SP 0x4E60C0 MP 0x60D180 - {"_meth_8471", 0x8471}, // SP 0x4E6120 MP 0x60D1E0 - {"_meth_8472", 0x8472}, // SP 0x4E6170 MP 0x60D230 - {"_meth_8473", 0x8473}, // SP 0x4E6190 MP 0x60D250 - {"_meth_8474", 0x8474}, // SP 0x2C49D0 MP 0x447B00 - {"_meth_8475", 0x8475}, // SP 0x2C4C90 MP 0x447D70 - {"_meth_8476", 0x8476}, // SP 0x291690 MP 0x40D4F0 - {"_meth_8477", 0x8477}, // SP 0x2DC460 MP 0x000000 - {"_meth_8478", 0x8478}, // SP 0x2DC580 MP 0x000000 - {"_meth_8479", 0x8479}, // SP 0x28E610 MP 0x409660 - {"_meth_847a", 0x847A}, // SP 0x28E630 MP 0x409980 - {"_meth_847b", 0x847B}, // SP 0x4E5390 MP 0x60C370 - {"_meth_847c", 0x847C}, // SP 0x4E5410 MP 0x60C3F0 - {"_meth_847d", 0x847D}, // SP 0x290610 MP 0x40BEE0 - {"_meth_847e", 0x847E}, // SP 0x2906B0 MP 0x40BFC0 - {"_meth_847f", 0x847F}, // SP 0x2CF620 MP 0x439610 - {"_meth_8480", 0x8480}, // SP 0x2C4C20 MP 0x000000 - {"_meth_8481", 0x8481}, // SP 0x28F120 MP 0x40A2D0 - {"_meth_8482", 0x8482}, // SP 0x28F110 MP 0x40A2C0 - {"_meth_8483", 0x8483}, // SP 0x000000 MP 0x51B1E0 - {"_meth_8484", 0x8484}, // SP 0x4E7FE0 MP 0x60A5C0 - {"_meth_8485", 0x8485}, // SP 0x4E6030 MP 0x60D0F0 - {"_meth_8486", 0x8486}, // SP 0x000000 MP 0x51ABC0 - {"_meth_8487", 0x8487}, // SP 0x000000 MP 0x455090 - {"_meth_8488", 0x8488}, // SP 0x2E1B90 MP 0x000000 - {"_meth_8489", 0x8489}, // SP 0x28F100 MP 0x40A2B0 - {"_meth_848a", 0x848A}, // SP 0x4E8060 MP 0x60A640 - {"_meth_848b", 0x848B}, // SP 0x4E8050 MP 0x60A5D0 - {"_meth_848c", 0x848C}, // SP 0x291F30 MP 0x40DDA0 - {"_meth_848d", 0x848D}, // SP 0x292190 MP 0x40DF80 - {"_meth_848e", 0x848E}, // SP 0x292300 MP 0x40E1D0 - {"_meth_848f", 0x848F}, // SP 0x295120 MP 0x000000 - {"_meth_8490", 0x8490}, // SP 0x2C4EE0 MP 0x447F60 - {"_meth_8491", 0x8491}, // SP 0x000000 MP 0x0C6980 - {"_meth_8492", 0x8492}, // SP 0x000000 MP 0x0C7320 - {"_meth_8493", 0x8493}, // SP 0x2D7D60 MP 0x000000 - {"_meth_8494", 0x8494}, // SP 0x2D7E20 MP 0x000000 - {"_meth_8495", 0x8495}, // SP 0x295F30 MP 0x000000 - {"_meth_8496", 0x8496}, // SP 0x000000 MP 0x0E28D0 - {"_meth_8497", 0x8497}, // SP 0x000000 MP 0x0B7A80 - {"_meth_8498", 0x8498}, // SP 0x28C7A0 MP 0x407F90 - {"_meth_8499", 0x8499}, // SP 0x28CDE0 MP 0x4083E0 - {"_meth_849a", 0x849A}, // SP 0x28F0F0 MP 0x40A240 - {"_meth_849b", 0x849B}, // SP 0x000000 MP 0x0E2BA0 - {"_meth_849c", 0x849C}, // SP 0x000000 MP 0x0E2D70 - {"_meth_849d", 0x849D}, // SP 0x000000 MP 0x0E2E80 - {"_meth_849e", 0x849E}, // SP 0x000000 MP 0x0E3000 - {"_meth_849f", 0x849F}, // SP 0x000000 MP 0x0E3210 - {"_meth_84a0", 0x84A0}, // SP 0x000000 MP 0x0E3820 - {"_meth_84a1", 0x84A1}, // SP 0x000000 MP 0x0E3580 - {"_meth_84a2", 0x84A2}, // SP 0x000000 MP 0x0E3D40 - {"_meth_84a3", 0x84A3}, // SP 0x000000 MP 0x0E3FF0 - {"_meth_84a4", 0x84A4}, // SP 0x000000 MP 0x0E3C60 - {"_meth_84a5", 0x84A5}, // SP 0x2BD9E0 MP 0x43E620 - {"_meth_84a6", 0x84A6}, // SP 0x2BDB80 MP 0x43E880 - {"_meth_84a7", 0x84A7}, // SP 0x2BDCD0 MP 0x43EA30 - {"_meth_84a8", 0x84A8}, // SP 0x2BE6E0 MP 0x43F3B0 - {"_meth_84a9", 0x84A9}, // SP 0x4E42A0 MP 0x60B3F0 - {"_meth_84aa", 0x84AA}, // SP 0x2CB640 MP 0x44D490 - {"_meth_84ab", 0x84AB}, // SP 0x2CBA10 MP 0x44D700 - {"_meth_84ac", 0x84AC}, // SP 0x28FAA0 MP 0x40B0D0 - {"_meth_84ad", 0x84AD}, // SP 0x4E4A40 MP 0x60BAE0 - {"_meth_84ae", 0x84AE}, // SP 0x4E4B40 MP 0x60BBE0 - {"_meth_84af", 0x84AF}, // SP 0x000000 MP 0x412350 - {"_meth_84b0", 0x84B0}, // SP 0x2D11A0 MP 0x43ABB0 - {"_meth_84b1", 0x84B1}, // SP 0x2C5370 MP 0x4480A0 - {"_meth_84b2", 0x84B2}, // SP 0x2C56D0 MP 0x448170 - {"_meth_84b3", 0x84B3}, // SP 0x2C6010 MP 0x448280 - {"_meth_84b4", 0x84B4}, // SP 0x2C6330 MP 0x4482B0 - {"_meth_84b5", 0x84B5}, // SP 0x2CF980 MP 0x43D0B0 - {"_meth_84b6", 0x84B6}, // SP 0x2BE900 MP 0x444AB0 - {"_meth_84b7", 0x84B7}, // SP 0x4E8640 MP 0x60AC60 - {"_meth_84b8", 0x84B8}, // SP 0x2BE3A0 MP 0x43F1D0 - {"_meth_84b9", 0x84B9}, // SP 0x000000 MP 0x455250 - {"_meth_84bb", 0x84BB}, // SP 0x292260 MP 0x40E070 - {"_meth_84bc", 0x84BC}, // SP 0x2922B0 MP 0x40E2B0 - {"_meth_84bd", 0x84BD}, // SP 0x000000 MP 0x4123D0 - {"_meth_84be", 0x84BE}, // SP 0x000000 MP 0x412590 - {"_meth_84bf", 0x84BF}, // SP 0x2930E0 MP 0x406530 - {"_meth_84c0", 0x84C0}, // SP 0x293590 MP 0x406850 - {"_meth_84c1", 0x84C1}, // SP 0x000000 MP 0x0B8C00 - {"_meth_84c2", 0x84C2}, // SP 0x2BA6B0 MP 0x43C670 - {"_meth_84c3", 0x84C3}, // SP 0x4E61D0 MP 0x60D290 - {"_meth_84c4", 0x84C4}, // SP 0x000000 MP 0x51DA90 - {"_meth_84c5", 0x84C5}, // SP 0x000000 MP 0x51D760 - {"_meth_84c6", 0x84C6}, // SP 0x28E210 MP 0x409280 - {"_meth_84c7", 0x84C7}, // SP 0x28E010 MP 0x000000 - {"_meth_84c8", 0x84C8}, // SP 0x28E160 MP 0x000000 - {"_meth_84c9", 0x84C9}, // SP 0x4E7D50 MP 0x60A390 - {"_meth_84ca", 0x84CA}, // SP 0x4E7DF0 MP 0x60A430 - {"_meth_84cb", 0x84CB}, // SP 0x000000 MP 0x410BF0 - {"_meth_84cc", 0x84CC}, // SP 0x4E61F0 MP 0x60D2B0 - {"_meth_84cd", 0x84CD}, // SP 0x2C1DF0 MP 0x442D70 - {"_meth_84ce", 0x84CE}, // SP 0x2C1FB0 MP 0x442F70 - {"_meth_84cf", 0x84CF}, // SP 0x2BF700 MP 0x440540 - {"_meth_84d0", 0x84D0}, // SP 0x2BF7D0 MP 0x440710 - {"_meth_84d1", 0x84D1}, // SP 0x2BF910 MP 0x440770 - {"_meth_84d2", 0x84D2}, // SP 0x2BFAC0 MP 0x4408B0 - {"_meth_84d3", 0x84D3}, // SP 0x2BFE40 MP 0x440990 - {"_meth_84d4", 0x84D4}, // SP 0x2BFEB0 MP 0x440AC0 - {"_meth_84d5", 0x84D5}, // SP 0x2BFF20 MP 0x440CD0 - {"_meth_84d6", 0x84D6}, // SP 0x2C0110 MP 0x440D20 - {"_meth_84d8", 0x84D8}, // SP 0x28D800 MP 0x408930 - {"_meth_84d9", 0x84D9}, // SP 0x2E2FA0 MP 0x454BC0 - {"_meth_84da", 0x84DA}, // SP 0x000000 MP 0x447F50 - {"_meth_84db", 0x84DB}, // SP 0x274990 MP 0x000000 - {"_meth_84dc", 0x84DC}, // SP 0x4E4F10 MP 0x000000 - {"_meth_84df", 0x84DF}, // SP 0x2C5560 MP 0x44C4B0 - {"_meth_84e0", 0x84E0}, // SP 0x29B120 MP 0x419E70 - {"_meth_84e1", 0x84E1}, // SP 0x4E6230 MP 0x60D2F0 - {"_meth_84e2", 0x84E2}, // SP 0x000000 MP 0x448410 - {"_meth_84e3", 0x84E3}, // SP 0x292800 MP 0x405FB0 - {"_meth_84e4", 0x84E4}, // SP 0x2C8B30 MP 0x44A9A0 - {"_meth_84e5", 0x84E5}, // SP 0x2DC750 MP 0x000000 - {"_meth_84e6", 0x84E6}, // SP 0x2BEA70 MP 0x445580 - {"_meth_84e8", 0x84E8}, // SP 0x292740 MP 0x40E5D0 - {"_meth_84e9", 0x84E9}, // SP 0x2927A0 MP 0x40E5E0 - {"_meth_84ea", 0x84EA}, // SP 0x2B8580 MP 0x000000 - {"_meth_84eb", 0x84EB}, // SP 0x2CEE90 MP 0x438310 - {"_meth_84ec", 0x84EC}, // SP 0x2C1E80 MP 0x44AC20 - {"_meth_84ed", 0x84ED}, // SP 0x2CBDF0 MP 0x437A60 - {"_meth_84ee", 0x84EE}, // SP 0x2CFC40 MP 0x438E10 - {"_meth_84ef", 0x84EF}, // SP 0x2CED10 MP 0x436D60 - {"_meth_84f0", 0x84F0}, // SP 0x4E73A0 MP 0x609960 - {"_meth_84f1", 0x84F1}, // SP 0x4E74D0 MP 0x609A90 - {"_meth_84f2", 0x84F2}, // SP 0x2C6580 MP 0x44D480 - {"_meth_84f3", 0x84F3}, // SP 0x2C67B0 MP 0x44D560 - {"_meth_84f4", 0x84F4}, // SP 0x2C5990 MP 0x44C810 - {"_meth_84f5", 0x84F5}, // SP 0x2C5B60 MP 0x44C9A0 - {"_meth_84f6", 0x84F6}, // SP 0x2C5F40 MP 0x44CAF0 - {"_meth_84f7", 0x84F7}, // SP 0x2C6000 MP 0x44CBE0 - {"_meth_84f8", 0x84F8}, // SP 0x2C6160 MP 0x44CCE0 - {"_meth_84f9", 0x84F9}, // SP 0x2C62A0 MP 0x44D140 - {"_meth_84fa", 0x84FA}, // SP 0x2C63F0 MP 0x44D230 - {"_meth_84fb", 0x84FB}, // SP 0x2BF9D0 MP 0x447EB0 - {"_meth_84fc", 0x84FC}, // SP 0x2C5650 MP 0x447220 - {"_meth_84fd", 0x84FD}, // SP 0x000000 MP 0x4109F0 - Could be setMLGCamVisibility or SetMLGSpectator - {"_meth_84fe", 0x84FE}, // SP 0x000000 MP 0x0B90C0 - {"_meth_84ff", 0x84FF}, // SP 0x000000 MP 0x0B9280 - {"_meth_8500", 0x8500}, // SP 0x2C17E0 MP 0x443F90 - {"_meth_8501", 0x8501}, // SP 0x2C08B0 MP 0x442CB0 - {"_meth_8502", 0x8502}, // SP 0x000000 MP 0x0E3260 - {"_meth_8503", 0x8503}, // SP 0x2C74D0 MP 0x44DAD0 - {"_meth_8504", 0x8504}, // SP 0x000000 MP 0x0C5FE0 - {"_meth_8505", 0x8505}, // SP 0x000000 MP 0x0E0980 - {"_meth_8506", 0x8506}, // SP 0x000000 MP 0x0C9DD0 - {"_meth_8507", 0x8507}, // SP 0x000000 MP 0x0C90E0 - {"_meth_8508", 0x8508}, // SP 0x000000 MP 0x411EC0 - {"_meth_8509", 0x8509}, // SP 0x2D7DE0 MP 0x000000 - {"_meth_850a", 0x850A}, // SP 0x292570 MP 0x40E310 - {"_meth_850b", 0x850B}, // SP 0x29AAE0 MP 0x419860 - {"_meth_850c", 0x850C}, // SP 0x000000 MP 0x0B7A30 - {"_meth_850d", 0x850D}, // SP 0x2BF100 MP 0x4401E0 - {"_meth_850e", 0x850E}, // SP 0x2BF250 MP 0x440370 - {"_meth_850f", 0x850F}, // SP 0x2CDA70 MP 0x44D680 - {"_meth_8510", 0x8510}, // SP 0x28DB80 MP 0x409350 - {"_meth_8511", 0x8511}, // SP 0x2C5A30 MP 0x447590 - {"_meth_8512", 0x8512}, // SP 0x4E6260 MP 0x60D320 - {"_meth_8513", 0x8513}, // SP 0x4E6280 MP 0x60D340 - {"_meth_8514", 0x8514}, // SP 0x28D570 MP 0x408E80 - {"_meth_8515", 0x8515}, // SP 0x28D620 MP 0x408EA0 - {"_meth_8516", 0x8516}, // SP 0x2CD200 MP 0x44C830 - {"_meth_8517", 0x8517}, // SP 0x000000 MP 0x0D2A90 - {"_meth_8518", 0x8518}, // SP 0x29A230 MP 0x4191D0 - {"_meth_8519", 0x8519}, // SP 0x000000 MP 0x0B94F0 - {"_meth_851a", 0x851A}, // SP 0x28EED0 MP 0x409F60 - {"_meth_851b", 0x851B}, // SP 0x2BFFA0 MP 0x448290 - {"_meth_851c", 0x851C}, // SP 0x2BF180 MP 0x447AE0 - {"_meth_851d", 0x851D}, // SP 0x2E3020 MP 0x454C40 - {"_meth_851e", 0x851E}, // SP 0x2B8280 MP 0x000000 - {"_meth_851f", 0x851F}, // SP 0x000000 MP 0x40FDF0 - {"_meth_8520", 0x8520}, // SP 0x000000 MP 0x51BB10 - {"_meth_8521", 0x8521}, // SP 0x291650 MP 0x000000 - {"_meth_8522", 0x8522}, // SP 0x000000 MP 0x4116C0 - {"_meth_8523", 0x8523}, // SP 0x2BF050 MP 0x442820 - {"_meth_8524", 0x8524}, // SP 0x2BFB60 MP 0x443720 - {"_meth_8525", 0x8525}, // SP 0x000000 MP 0x0DE060 - {"_meth_8526", 0x8526}, // SP 0x000000 MP 0x0DE6B0 - {"_meth_8527", 0x8527}, // SP 0x29AB50 MP 0x4198C0 - {"_meth_8528", 0x8528}, // SP 0x000000 MP 0x411FA0 - {"_meth_8529", 0x8529}, // SP 0x2C7710 MP 0x435530 - {"_meth_852a", 0x852A}, // SP 0x2CBE90 MP 0x44AB30 - {"_meth_852b", 0x852B}, // SP 0x000000 MP 0x411E50 - {"_meth_852c", 0x852C}, // SP 0x000000 MP 0x4113E0 - {"_meth_852d", 0x852D}, // SP 0x2C6450 MP 0x44D330 - {"_meth_852e", 0x852E}, // SP 0x000000 MP 0x0B95A0 - {"_meth_852f", 0x852F}, // SP 0x000000 MP 0x51D500 - {"_meth_8530", 0x8530}, // SP 0x000000 MP 0x51BE30 - {"_meth_8531", 0x8531}, // SP 0x000000 MP 0x51D040 - {"_meth_8532", 0x8532}, // SP 0x000000 MP 0x40EF70 - {"_meth_8533", 0x8533}, // SP 0x000000 MP 0x51B870 - {"_meth_8534", 0x8534}, // SP 0x000000 MP 0x51D2C0 - {"_meth_8535", 0x8535}, // SP 0x000000 MP 0x51C960 - {"_meth_8536", 0x8536}, // SP 0x000000 MP 0x51D100 - {"_meth_8537", 0x8537}, // SP 0x000000 MP 0x51CF30 - {"_meth_8538", 0x8538}, // SP 0x000000 MP 0x51D340 - {"_meth_8539", 0x8539}, // SP 0x000000 MP 0x40FE50 - {"_meth_853a", 0x853A}, // SP 0x000000 MP 0x453C60 - {"_meth_853b", 0x853B}, // SP 0x000000 MP 0x51ACB0 - {"_meth_853c", 0x853C}, // SP 0x2C6810 MP 0x44D570 - {"_meth_853d", 0x853D}, // SP 0x28F0E0 MP 0x40A230 - {"_meth_853e", 0x853E}, // SP 0x000000 MP 0x0B97D0 - {"_meth_853f", 0x853F}, // SP 0x000000 MP 0x51AC20 - {"_meth_8540", 0x8540}, // SP 0x2D1AA0 MP 0x43A930 - {"_meth_8541", 0x8541}, // SP 0x2C6AA0 MP 0x44D810 - {"_meth_8542", 0x8542}, // SP 0x000000 MP 0x0B9AF0 - {"_meth_8543", 0x8543}, // SP 0x000000 MP 0x0E4100 - {"_meth_8544", 0x8544}, // SP 0x000000 MP 0x51C660 - {"_meth_8545", 0x8545}, // SP 0x000000 MP 0x40EEC0 - {"_meth_8547", 0x8547}, // SP 0x000000 MP 0x51D870 - {"_meth_8548", 0x8548}, // SP 0x28FD80 MP 0x40B4F0 - {"_meth_8549", 0x8549}, // SP 0x000000 MP 0x40FEB0 - {"_meth_854a", 0x854A}, // SP 0x000000 MP 0x0B9E90 - {"_meth_854b", 0x854B}, // SP 0x000000 MP 0x51C7F0 - {"_meth_854c", 0x854C}, // SP 0x000000 MP 0x40EE60 - {"_meth_854d", 0x854D}, // SP 0x2C3710 MP 0x445D20 - {"_meth_854e", 0x854E}, // SP 0x000000 MP 0x51D660 - {"_meth_854f", 0x854F}, // SP 0x000000 MP 0x51C860 - {"_meth_8550", 0x8550}, // SP 0x2E32C0 MP 0x453030 - {"_meth_8551", 0x8551}, // SP 0x2CC650 MP 0x44B730 - {"_meth_8552", 0x8552}, // SP 0x000000 MP 0x51D880 - {"_meth_8553", 0x8553}, // SP 0x000000 MP 0x0B7050 - {"_meth_8554", 0x8554}, // SP 0x000000 MP 0x51C040 - {"_meth_8555", 0x8555}, // SP 0x000000 MP 0x51D980 - {"_meth_8556", 0x8556}, // SP 0x000000 MP 0x0D3F40 - {"_meth_8557", 0x8557}, // SP 0x000000 MP 0x0D4240 - {"_meth_8558", 0x8558}, // SP 0x000000 MP 0x0904E0 - {"_meth_8559", 0x8559}, // SP 0x28F040 MP 0x40AD50 - {"_meth_855a", 0x855A}, // SP 0x28F0B0 MP 0x40AD60 - {"_meth_855b", 0x855B}, // SP 0x28F0D0 MP 0x40AE70 - {"_meth_855c", 0x855C}, // SP 0x000000 MP 0x0BA090 - {"_meth_855d", 0x855D}, // SP 0x2C0EA0 MP 0x449C80 - {"_meth_855e", 0x855E}, // SP 0x2C6DF0 MP 0x448860 - {"_meth_855f", 0x855F}, // SP 0x000000 MP 0x0D60B0 - {"_meth_8560", 0x8560}, // SP 0x000000 MP 0x0D6CC0 - {"_meth_8561", 0x8561}, // SP 0x2CB870 MP 0x437570 - {"_meth_8562", 0x8562}, // SP 0x2CBAC0 MP 0x437610 - {"_meth_8563", 0x8563}, // SP 0x2E19F0 MP 0x453840 - {"_meth_8564", 0x8564}, // SP 0x2FB570 MP 0x3FBE00 - {"_meth_8565", 0x8565}, // SP 0x273A90 MP 0x000000 - {"_meth_8566", 0x8566}, // SP 0x2DC6F0 MP 0x000000 - {"_meth_8567", 0x8567}, // SP 0x2751C0 MP 0x000000 - {"_meth_8568", 0x8568}, // SP 0x2C47A0 MP 0x447140 - {"_meth_8569", 0x8569}, // SP 0x2CBF80 MP 0x435540 - {"_meth_856a", 0x856A}, // SP 0x2CC140 MP 0x435910 - {"_meth_856b", 0x856B}, // SP 0x2CAC40 MP 0x44C760 - {"_meth_856c", 0x856C}, // SP 0x2CAE30 MP 0x44C8C0 - {"_meth_856d", 0x856D}, // SP 0x2CB090 MP 0x44CB50 - {"_meth_856e", 0x856E}, // SP 0x2B85C0 MP 0x000000 - {"_meth_856f", 0x856F}, // SP 0x2B85E0 MP 0x000000 - {"_meth_8570", 0x8570}, // SP 0x2B8630 MP 0x000000 - {"_meth_8571", 0x8571}, // SP 0x275270 MP 0x000000 - {"_meth_8572", 0x8572}, // SP 0x2770F0 MP 0x000000 - {"_meth_8573", 0x8573}, // SP 0x28E620 MP 0x409A00 - {"_meth_8574", 0x8574}, // SP 0x293950 MP 0x406F30 - {"_meth_8575", 0x8575}, // SP 0x293B10 MP 0x407240 - {"_meth_8576", 0x8576}, // SP 0x000000 MP 0x545330 - {"_meth_8577", 0x8577}, // SP 0x000000 MP 0x40EED0 - {"_meth_8578", 0x8578}, // SP 0x2CBBF0 MP 0x44A7B0 - {"_meth_8579", 0x8579}, // SP 0x2CBC40 MP 0x437840 - {"_meth_857a", 0x857A}, // SP 0x000000 MP 0x40F300 - {"_meth_857b", 0x857B}, // SP 0x000000 MP 0x4084D0 - {"_meth_857c", 0x857C}, // SP 0x2BEA80 MP 0x4462E0 - {"_meth_857d", 0x857D}, // SP 0x000000 MP 0x410750 - {"_meth_857e", 0x857E}, // SP 0x000000 MP 0x410810 - {"_meth_857f", 0x857F}, // SP 0x000000 MP 0x411D70 - {"_meth_8580", 0x8580}, // SP 0x000000 MP 0x40F3B0 - {"_meth_8581", 0x8581}, // SP 0x2C67C0 MP 0x448180 - {"_meth_8582", 0x8582}, // SP 0x000000 MP 0x40FBA0 - {"_meth_8583", 0x8583}, // SP 0x000000 MP 0x40FC70 - {"_meth_8584", 0x8584}, // SP 0x000000 MP 0x40FCD0 - {"_meth_8585", 0x8585}, // SP 0x2C4A50 MP 0x447500 - {"_meth_8586", 0x8586}, // SP 0x2BD780 MP 0x43F2A0 - }; - - std::unordered_map token_map = - { - {"", 0x000}, - {"pl#", 0x001}, - {"-", 0x002}, - {"radius`", 0x003}, - {"note:", 0x004}, - {"_", 0x005}, - {"_custom", 0x006}, - {"a", 0x007}, - {"ability", 0x008}, - {"accumulate", 0x009}, - {"accuracy", 0x00A}, - {"actionslot1", 0x00B}, - {"actionslot2", 0x00C}, - {"actionslot3", 0x00D}, - {"actionslot4", 0x00E}, - {"actionslot5", 0x00F}, - {"actionslot6", 0x010}, - {"actionslot7", 0x011}, - {"actionslot8", 0x012}, - {"activator", 0x013}, - {"active", 0x014}, - {"activecostume", 0x015}, - {"activeemblemslot", 0x016}, - {"activesquadmember", 0x017}, - {"activevisionset", 0x018}, - {"activevisionsetduration", 0x019}, - {"agent", 0x01A}, - {"agenthealth", 0x01B}, - {"agentname", 0x01C}, - {"agentteam", 0x01D}, - {"ai_event", 0x01E}, - {"ai_sight_line_cycle_group", 0x01F}, - {"ai_sight_line_group", 0x020}, - {"aim_highest_bone", 0x021}, - {"aim_vis_bone", 0x022}, - {"aispread", 0x023}, - {"aisquadmembers", 0x024}, - {"alert", 0x025}, - {"alertlevel", 0x026}, - {"alertlevelint", 0x027}, - {"alien", 0x028}, - {"alienplayerloadout", 0x029}, - {"alienplayerstats", 0x02A}, - {"aliensession", 0x02B}, - {"alignx", 0x02C}, - {"aligny", 0x02D}, - {"all", 0x02E}, - {"allies", 0x02F}, - {"allowcrouch", 0x030}, - {"allowdeath", 0x031}, - {"allowjump", 0x032}, - {"allowladders", 0x033}, - {"allowpain", 0x034}, - {"allowprone", 0x035}, - {"allstreaksrestricted", 0x036}, - {"alpha", 0x037}, - {"altmode", 0x038}, - {"always", 0x039}, - {"ambient", 0x03A}, - {"ambienttrack", 0x03B}, - {"ambienttrack_ac130", 0x03C}, - {"ambush", 0x03D}, - {"ambush_nodes_only", 0x03E}, - {"angle_deltas", 0x03F}, - {"anglelerprate", 0x040}, - {"angles", 0x041}, - {"anim_angle_delta", 0x042}, - {"anim_deltas", 0x043}, - {"anim_pose", 0x044}, - {"anim_will_finish", 0x045}, - {"animation", 0x046}, - {"animscript", 0x047}, - {"archived", 0x048}, - {"archivetime", 0x049}, - {"armor", 0x04A}, - {"asleep", 0x04B}, - {"aspectratio", 0x04C}, - {"assaultstreaks", 0x04D}, - {"assignedbucket", 0x04E}, - {"assists", 0x04F}, - {"attachment", 0x050}, - {"attachmentclassrestricted", 0x051}, - {"attachmentrestricted", 0x052}, - {"attachments", 0x053}, - {"attachtag", 0x054}, - {"attacker", 0x055}, - {"attackeraccuracy", 0x056}, - {"attackercount", 0x057}, - {"attackerisjuggernaut", 0x058}, - {"attackerpos", 0x059}, - {"author", 0x05A}, - {"auto_ai", 0x05B}, - {"auto_change", 0x05C}, - {"auto_nonai", 0x05D}, - {"avoidanceboundshalfsize", 0x05E}, - {"awards", 0x05F}, - {"axis", 0x060}, - {"b", 0x061}, - {"back", 0x062}, - {"back_left", 0x063}, - {"back_low", 0x064}, - {"back_mid", 0x065}, - {"back_right", 0x066}, - {"back_up", 0x067}, - {"background", 0x068}, - {"bad_guys", 0x069}, - {"bad_path", 0x06A}, - {"badplaceawareness", 0x06B}, - {"ball_off", 0x06C}, - {"ball_on", 0x06D}, - {"ball_pass", 0x06E}, - {"bandwidthdown", 0x06F}, - {"bandwidthtestcount", 0x070}, - {"bandwidthup", 0x071}, - {"baselineoverflow_max", 0x072}, - {"baselineoverflow_worst", 0x073}, - {"battery_discharge_begin", 0x074}, - {"battery_discharge_end", 0x075}, - {"begin", 0x076}, - {"begin_custom_anim", 0x077}, - {"begin_firing", 0x078}, - {"begin_firing_left", 0x079}, - {"bestweapon", 0x07A}, - {"bestweaponindex", 0x07B}, - {"bipods", 0x07C}, - {"birthtime", 0x07D}, - {"bl_rotor1", 0x07E}, - {"bl_rotor2", 0x07F}, - {"bl_rotor3", 0x080}, - {"blackops2prestige", 0x081}, - {"blackops2rank", 0x082}, - {"blade_hide", 0x083}, - {"blade_show", 0x084}, - {"blockfriendlies", 0x085}, - {"blurradius", 0x086}, - {"body", 0x087}, - {"body_animate_jnt", 0x088}, - {"bottomarc", 0x089}, - {"br_rotor1", 0x08A}, - {"br_rotor2", 0x08B}, - {"br_rotor3", 0x08C}, - {"breadcrumbheader", 0x08D}, - {"buff", 0x08E}, - {"bullet_hitshield", 0x08F}, - {"bullethit", 0x090}, - {"bulletwhizby", 0x091}, - {"c", 0x092}, - {"callingcardindex", 0x093}, - {"camo", 0x094}, - {"cancel_location", 0x095}, - {"canclimbladders", 0x096}, - {"canjumppath", 0x097}, - {"cardicon", 0x098}, - {"cardnameplate", 0x099}, - {"cardtitle", 0x09A}, - {"cgmchecksum", 0x09B}, - {"ch_prestige", 0x09C}, - {"ch_prestige_max", 0x09D}, - {"chainfallback", 0x09E}, - {"chainnode", 0x09F}, - {"challengeprogress", 0x0A0}, - {"challengestate", 0x0A1}, - {"chest", 0x0A2}, - {"churnscores", 0x0A3}, - {"chyron_message1", 0x0A4}, - {"chyron_message2", 0x0A5}, - {"chyron_message3", 0x0A6}, - {"civilian", 0x0A7}, - {"clanidhigh", 0x0A8}, - {"clanidlow", 0x0A9}, - {"classname", 0x0AA}, - {"clipdistance", 0x0AB}, - {"code_classname", 0x0AC}, - {"code_damageradius", 0x0AD}, - {"code_move", 0x0AE}, - {"code_move_slide", 0x0AF}, - {"codecallback_agentadded", 0x0B0}, - {"codecallback_agentdamaged", 0x0B1}, - {"codecallback_agentkilled", 0x0B2}, - {"codecallback_bullethitentity", 0x0B3}, - {"codecallback_codeendgame", 0x0B4}, - {"codecallback_entitydamage", 0x0B5}, - {"codecallback_entityoutofworld", 0x0B6}, - {"codecallback_handleinstantmessage", 0x0B7}, - {"codecallback_hostmigration", 0x0B8}, - {"codecallback_leaderdialog", 0x0B9}, - {"codecallback_partymembers", 0x0BA}, - {"codecallback_playerconnect", 0x0BB}, - {"codecallback_playerdamage", 0x0BC}, - {"codecallback_playerdisconnect", 0x0BD}, - {"codecallback_playergrenadesuicide", 0x0BE}, - {"codecallback_playerkilled", 0x0BF}, - {"codecallback_playerlaststand", 0x0C0}, - {"codecallback_playermigrated", 0x0C1}, - {"codecallback_startgametype", 0x0C2}, - {"codecallback_vehicledamage", 0x0C3}, - {"color", 0x0C4}, - {"color_blind_toggled", 0x0C5}, - {"combat", 0x0C6}, - {"combatmode", 0x0C7}, - {"combatrecord", 0x0C8}, - {"commonoption", 0x0C9}, - {"confirm_location", 0x0CA}, - {"connection_id", 0x0CB}, - {"connectionidchunkhigh", 0x0CC}, - {"connectionidchunklow", 0x0CD}, - {"consolegame", 0x0CE}, - {"consoleidchunkhigh", 0x0CF}, - {"consoleidchunklow", 0x0D0}, - {"constrained", 0x0D1}, - {"contact", 0x0D2}, - {"contextleanenabled", 0x0D3}, - {"convergencetime", 0x0D4}, - {"coopactivesquadmember", 0x0D5}, - {"coopsquadmembers", 0x0D6}, - {"costumes", 0x0D7}, - {"count", 0x0D8}, - {"cover", 0x0D9}, - {"cover_approach", 0x0DA}, - {"coversearchinterval", 0x0DB}, - {"createstruct", 0x0DC}, - {"createtime", 0x0DD}, - {"criticalbulletdamagedist", 0x0DE}, - {"crouch", 0x0DF}, - {"currency", 0x0E0}, - {"current", 0x0E1}, - {"currentanimtime", 0x0E2}, - {"currentgen", 0x0E3}, - {"currentwinstreak", 0x0E4}, - {"cursorhint", 0x0E5}, - {"custom_attach_00", 0x0E6}, - {"custom_attach_01", 0x0E7}, - {"custom_attach_02", 0x0E8}, - {"custom_attach_03", 0x0E9}, - {"custom_attach_04", 0x0EA}, - {"custom_attach_05", 0x0EB}, - {"custom_attach_06", 0x0EC}, - {"custom_attach_07", 0x0ED}, - {"custom_attach_08", 0x0EE}, - {"custom_attach_09", 0x0EF}, - {"custom_attach_10", 0x0F0}, - {"custom_attach_11", 0x0F1}, - {"custom_attach_12", 0x0F2}, - {"custom_attach_13", 0x0F3}, - {"custom_attach_14", 0x0F4}, - {"custom_attach_15", 0x0F5}, - {"customclasses", 0x0F6}, - {"customization_loaded", 0x0F7}, - {"d", 0x0F8}, - {"dailychallengeid", 0x0F9}, - {"damage", 0x0FA}, - {"damage_notdone", 0x0FB}, - {"damagedir", 0x0FC}, - {"damagelocation", 0x0FD}, - {"damagemod", 0x0FE}, - {"damagemultiplier", 0x0FF}, - {"damageshield", 0x100}, - {"damagetaken", 0x101}, - {"damageweapon", 0x102}, - {"damageyaw", 0x103}, - {"dangerreactduration", 0x104}, - {"datalength", 0x105}, - {"dcid", 0x106}, - {"dead", 0x107}, - {"death", 0x108}, - {"deathangles", 0x109}, - {"deathinvulnerabletime", 0x10A}, - {"deathplant", 0x10B}, - {"deathpos", 0x10C}, - {"deaths", 0x10D}, - {"deathshield", 0x10E}, - {"defaultclasses", 0x10F}, - {"defense", 0x110}, - {"defense_level", 0x111}, - {"delayeddeath", 0x112}, - {"deploy_riotshield", 0x113}, - {"desc", 0x114}, - {"descmodified", 0x115}, - {"desiredangle", 0x116}, - {"destructible_type", 0x117}, - {"detectable", 0x118}, - {"detected", 0x119}, - {"detonate", 0x11A}, - {"device_id_high", 0x11B}, - {"device_id_low", 0x11C}, - {"deviceconnectionhistory", 0x11D}, - {"deviceusefrequency", 0x11E}, - {"diequietly", 0x11F}, - {"diffusefraction", 0x120}, - {"direct", 0x121}, - {"disable", 0x122}, - {"disableplayeradsloscheck", 0x123}, - {"dlight", 0x124}, - {"dmg", 0x125}, - {"dodamagetoall", 0x126}, - {"dodangerreact", 0x127}, - {"doffar", 0x128}, - {"dofnear", 0x129}, - {"dofphysicalfocusdistance", 0x12A}, - {"dofphysicalfstop", 0x12B}, - {"dog", 0x12C}, - {"doghandler", 0x12D}, - {"doingambush", 0x12E}, - {"done", 0x12F}, - {"dontavoidplayer", 0x130}, - {"dotofdeath", 0x131}, - {"down", 0x132}, - {"downaimlimit", 0x133}, - {"drawoncompass", 0x134}, - {"dropweapon", 0x135}, - {"duration", 0x136}, - {"eftarc", 0x137}, - {"empty", 0x138}, - {"empty_offhand", 0x139}, - {"enable", 0x13A}, - {"enablehudlighting", 0x13B}, - {"enableshadows", 0x13C}, - {"end_firing", 0x13D}, - {"end_firing_left", 0x13E}, - {"end_script", 0x13F}, - {"enddeaths", 0x140}, - {"endkills", 0x141}, - {"enemy", 0x142}, - {"enemy_sighted", 0x143}, - {"enemy_sighted_lost", 0x144}, - {"enemy_visible", 0x145}, - {"enemyname", 0x146}, - {"enemyplatform", 0x147}, - {"enemyradarmode", 0x148}, - {"enemyxuidhigh", 0x149}, - {"enemyxuidlow", 0x14A}, - {"energy_fire", 0x14B}, - {"engagemaxdist", 0x14C}, - {"engagemaxfalloffdist", 0x14D}, - {"engagemindist", 0x14E}, - {"engageminfalloffdist", 0x14F}, - {"enhanceable", 0x150}, - {"entity", 0x151}, - {"entitydeleted", 0x152}, - {"entityoverflow_max", 0x153}, - {"entityoverflow_worst", 0x154}, - {"equipment", 0x155}, - {"equipmentsetups", 0x156}, - {"escaped", 0x157}, - {"exclusive", 0x158}, - {"exo_ability_activate", 0x159}, - {"exo_adrenaline_fire", 0x15A}, - {"exo_boost", 0x15B}, - {"exo_dodge", 0x15C}, - {"exo_power", 0x15D}, - {"exo_slide", 0x15E}, - {"exo_slide_hit_player", 0x15F}, - {"exoattachment1", 0x160}, - {"exoattachment2", 0x161}, - {"experience", 0x162}, - {"explode", 0x163}, - {"exposedduration", 0x164}, - {"extracustomclassesentitlement", 0x165}, - {"extracustomclassesprestige", 0x166}, - {"extrascore0", 0x167}, - {"extrascore1", 0x168}, - {"face_angle", 0x169}, - {"face_angle_3d", 0x16A}, - {"face_angle_abs", 0x16B}, - {"face_angle_rel", 0x16C}, - {"face_current", 0x16D}, - {"face_default", 0x16E}, - {"face_direction", 0x16F}, - {"face_enemy", 0x170}, - {"face_enemy_or_motion", 0x171}, - {"face_goal", 0x172}, - {"face_motion", 0x173}, - {"face_point", 0x174}, - {"facemotion", 0x175}, - {"failed", 0x176}, - {"falling", 0x177}, - {"fast_radar", 0x178}, - {"favoriteenemy", 0x179}, - {"finalaccuracy", 0x17A}, - {"first_person", 0x17B}, - {"firstplayedsptime", 0x17C}, - {"fixednode", 0x17D}, - {"fixednodesaferadius", 0x17E}, - {"fl_rotor1", 0x17F}, - {"fl_rotor2", 0x180}, - {"fl_rotor3", 0x181}, - {"flash", 0x182}, - {"flashbang", 0x183}, - {"foley", 0x184}, - {"follow", 0x185}, - {"followmax", 0x186}, - {"followmin", 0x187}, - {"font", 0x188}, - {"fontscale", 0x189}, - {"foot_ik_active", 0x18A}, - {"foot_ik_blend_in", 0x18B}, - {"foot_ik_blend_out", 0x18C}, - {"foot_ik_inactive", 0x18D}, - {"footstepdetectdist", 0x18E}, - {"footstepdetectdistsprint", 0x18F}, - {"footstepdetectdistwalk", 0x190}, - {"force_off", 0x191}, - {"force_on", 0x192}, - {"force_fully_on", 0x193}, - {"forcepartyskillignore", 0x194}, - {"forceragdollimmediate", 0x195}, - {"forcespectatorclient", 0x196}, - {"foregrip_off", 0x197}, - {"foreground", 0x198}, - {"forward", 0x199}, - {"fov", 0x19A}, - {"fovcosine", 0x19B}, - {"fovcosinebusy", 0x19C}, - {"fovcosinez", 0x19D}, - {"fr_rotor1", 0x19E}, - {"fr_rotor2", 0x19F}, - {"fr_rotor3", 0x1A0}, - {"fraction", 0x1A1}, - {"frag", 0x1A2}, - {"free", 0x1A3}, - {"freecamera", 0x1A4}, - {"freelook", 0x1A5}, - {"frequency", 0x1A6}, - {"friendlyfire", 0x1A7}, - {"front_left", 0x1A8}, - {"front_right", 0x1A9}, - {"frontshieldanglecos", 0x1AA}, - {"fs_concrete", 0x1AB}, - {"fs_dirt", 0x1AC}, - {"fs_metal", 0x1AD}, - {"fs_wood", 0x1AE}, - {"game_extrainfo", 0x1AF}, - {"gamecount", 0x1B0}, - {"gamertag", 0x1B1}, - {"gamesplayed", 0x1B2}, - {"gametype", 0x1B3}, - {"gender", 0x1B4}, - {"ghostsprestige", 0x1B5}, - {"ghostsrank", 0x1B6}, - {"glass", 0x1B7}, - {"glass_damaged", 0x1B8}, - {"glass_destroyed", 0x1B9}, - {"globalcostume", 0x1BA}, - {"gloves", 0x1BB}, - {"glowalpha", 0x1BC}, - {"glowcolor", 0x1BD}, - {"goal", 0x1BE}, - {"goal_changed", 0x1BF}, - {"goal_reached", 0x1C0}, - {"goal_yaw", 0x1C1}, - {"goalheight", 0x1C2}, - {"goalpos", 0x1C3}, - {"goalradius", 0x1C4}, - {"goaltime", 0x1C5}, - {"goalweight", 0x1C6}, - {"goingtoruntopos", 0x1C7}, - {"gravity", 0x1C8}, - {"gravity_noclip", 0x1C9}, - {"grenade", 0x1CA}, - {"grenade_fire", 0x1CB}, - {"grenade_off", 0x1CC}, - {"grenade_on", 0x1CD}, - {"grenade_pullback", 0x1CE}, - {"grenade_return_hand_tag", 0x1CF}, - {"grenadeammo", 0x1D0}, - {"grenadeawareness", 0x1D1}, - {"grenadedanger", 0x1D2}, - {"grenadeweapon", 0x1D3}, - {"ground_slam", 0x1D4}, - {"ground_slam_hit_player", 0x1D5}, - {"groundentchanged", 0x1D6}, - {"groundtype", 0x1D7}, - {"gunblockedbywall", 0x1D8}, - {"gunshot", 0x1D9}, - {"gunshot_teammate", 0x1DA}, - {"hardcoremodeon", 0x1DB}, - {"hasdoublexpitem", 0x1DC}, - {"hasradar", 0x1DD}, - {"hasvalidcostumeselfieimage", 0x1DE}, - {"head", 0x1DF}, - {"headicon", 0x1E0}, - {"headiconteam", 0x1E1}, - {"headshots", 0x1E2}, - {"health", 0x1E3}, - {"healthregen", 0x1E4}, - {"height", 0x1E5}, - {"helmet", 0x1E6}, - {"hidein3rdperson", 0x1E7}, - {"hidewhendead", 0x1E8}, - {"hidewhenindemo", 0x1E9}, - {"hidewheninmenu", 0x1EA}, - {"high_priority", 0x1EB}, - {"highlyawareradius", 0x1EC}, - {"hindlegstraceoffset", 0x1ED}, - {"hintstring", 0x1EE}, - {"hit_by_missile", 0x1EF}, - {"horzalign", 0x1F0}, - {"host_sucks_end_game", 0x1F1}, - {"hostfailures", 0x1F2}, - {"hostquits", 0x1F3}, - {"hostsuccesses", 0x1F4}, - {"human", 0x1F5}, - {"iconnew", 0x1F6}, - {"iconunlocked", 0x1F7}, - {"ignoreall", 0x1F8}, - {"ignoreclosefoliage", 0x1F9}, - {"ignoreexplosionevents", 0x1FA}, - {"ignoreforfixednodesafecheck", 0x1FB}, - {"ignoreme", 0x1FC}, - {"ignorerandombulletdamage", 0x1FD}, - {"ignoresuppression", 0x1FE}, - {"ignoretriggers", 0x1FF}, - {"ikweight", 0x200}, - {"index", 0x201}, - {"infinite_energy", 0x202}, - {"info_notnull", 0x203}, - {"info_player_start", 0x204}, - {"not_init", 0x205}, - {"initstructs", 0x206}, - {"insolid", 0x207}, - {"init", 0x208}, - {"interval", 0x209}, - {"inuse", 0x20A}, - {"invalid_parent", 0x20B}, - {"invisible", 0x20C}, - {"isradarblocked", 0x20D}, - {"item", 0x20E}, - {"j_exo_rcket_arm02", 0x20F}, - {"j_exoclav04_l", 0x210}, - {"j_exoclav04_r", 0x211}, - {"j_exohip04_l", 0x212}, - {"j_exohip04_r", 0x213}, - {"j_eyeball_le", 0x214}, - {"j_eyeball_ri", 0x215}, - {"j_gun", 0x216}, - {"j_head", 0x217}, - {"j_hip_l", 0x218}, - {"j_hip_r", 0x219}, - {"j_knee_le", 0x21A}, - {"j_knee_ri", 0x21B}, - {"j_left_elbow", 0x21C}, - {"j_left_hand", 0x21D}, - {"j_left_shoulder", 0x21E}, - {"j_mainroot", 0x21F}, - {"j_neck", 0x220}, - {"j_right_elbow", 0x221}, - {"j_right_hand", 0x222}, - {"j_right_hand_placement", 0x223}, - {"j_right_shoulder", 0x224}, - {"j_rocket", 0x225}, - {"j_spine4", 0x226}, - {"j_spinelower", 0x227}, - {"j_spineupper", 0x228}, - {"jumpcost", 0x229}, - {"jumping", 0x22A}, - {"justclass", 0x22B}, - {"kdratio", 0x22C}, - {"keepclaimednode", 0x22D}, - {"keepclaimednodeifvalid", 0x22E}, - {"keepnodeduringscriptedanim", 0x22F}, - {"key1", 0x230}, - {"key2", 0x231}, - {"kill_timestamp", 0x232}, - {"killanimscript", 0x233}, - {"killcamentity", 0x234}, - {"killcamentitylookat", 0x235}, - {"kills", 0x236}, - {"killstreak", 0x237}, - {"killstreakcount", 0x238}, - {"killstreakrestricted", 0x239}, - {"killstreakunlocked", 0x23A}, - {"knife_off", 0x23B}, - {"knife_on", 0x23C}, - {"known_event", 0x23D}, - {"label", 0x23E}, - {"ladder_down", 0x23F}, - {"ladder_up", 0x240}, - {"land", 0x241}, - {"last_stand_count", 0x242}, - {"lastattacker", 0x243}, - {"lastenemysightpos", 0x244}, - {"lastplayedtime", 0x245}, - {"laststand", 0x246}, - {"leanamount", 0x247}, - {"ledge", 0x248}, - {"left", 0x249}, - {"leftaimlimit", 0x24A}, - {"leftarc", 0x24B}, - {"lethal", 0x24C}, - {"lifecount", 0x24D}, - {"light", 0x24E}, - {"lives", 0x24F}, - {"loadouts", 0x250}, - {"lockorientation", 0x251}, - {"lod", 0x252}, - {"look", 0x253}, - {"lookahead", 0x254}, - {"lookaheaddir", 0x255}, - {"lookaheaddist", 0x256}, - {"lookaheadhitsstairs", 0x257}, - {"lookforward", 0x258}, - {"lookright", 0x259}, - {"looktarget", 0x25A}, - {"lookup", 0x25B}, - {"loot", 0x25C}, - {"lootnew", 0x25D}, - {"loses", 0x25E}, - {"low_priority", 0x25F}, - {"lowresbackground", 0x260}, - {"luinotifyserver", 0x261}, - {"mag_eject", 0x262}, - {"mag_eject_left", 0x263}, - {"not_main", 0x264}, - {"manual", 0x265}, - {"manual_ai", 0x266}, - {"main", 0x267}, - {"map", 0x268}, - {"matchid", 0x269}, - {"matchmakingsettingsversion", 0x26A}, - {"matchmakingtesttype", 0x26B}, - {"max_time", 0x26C}, - {"maxfaceenemydist", 0x26D}, - {"maxhealth", 0x26E}, - {"maxrange", 0x26F}, - {"maxsightdistsqrd", 0x270}, - {"maxturnspeed", 0x271}, - {"maxvisibledist", 0x272}, - {"melee_fired", 0x273}, - {"melee_hit_react", 0x274}, - {"meleeattackdist", 0x275}, - {"menuresponse", 0x276}, - {"micro_dlc_bits_last_gen", 0x277}, - {"micro_dlc_bits_next_gen", 0x278}, - {"middle_left", 0x279}, - {"middle_right", 0x27A}, - {"migrateablequits", 0x27B}, - {"min_energy", 0x27C}, - {"min_time", 0x27D}, - {"minpaindamage", 0x27E}, - {"minusedistsq", 0x27F}, - {"missile_fire", 0x280}, - {"missile_passed_target", 0x281}, - {"missile_stuck", 0x282}, - {"mlgversion", 0x283}, - {"mod", 0x284}, - {"mod_crush", 0x285}, - {"mod_energy", 0x286}, - {"mod_explosive", 0x287}, - {"mod_explosive_bullet", 0x288}, - {"mod_falling", 0x289}, - {"mod_grenade", 0x28A}, - {"mod_grenade_splash", 0x28B}, - {"mod_head_shot", 0x28C}, - {"mod_impact", 0x28D}, - {"mod_melee", 0x28E}, - {"mod_melee_alien", 0x28F}, - {"mod_melee_alt", 0x290}, - {"mod_melee_dog", 0x291}, - {"mod_pistol_bullet", 0x292}, - {"mod_projectile", 0x293}, - {"mod_projectile_splash", 0x294}, - {"mod_rifle_bullet", 0x295}, - {"mod_suicide", 0x296}, - {"mod_trigger_hurt", 0x297}, - {"mod_unknown", 0x298}, - {"model", 0x299}, - {"modeprefix", 0x29A}, - {"modifiers", 0x29B}, - {"motiontrackerenabled", 0x29C}, - {"mounted_dlc_bits", 0x29D}, - {"movedone", 0x29E}, - {"movemode", 0x29F}, - {"munition", 0x2A0}, - {"munition_level", 0x2A1}, - {"mw3prestige", 0x2A2}, - {"mw3rank", 0x2A3}, - {"name", 0x2A4}, - {"namemodified", 0x2A5}, - {"near_goal", 0x2A6}, - {"nearz", 0x2A7}, - {"neutral", 0x2A8}, - {"never", 0x2A9}, - {"newenemyreactiondistsq", 0x2AA}, - {"newentitlement", 0x2AB}, - {"nextgen", 0x2AC}, - {"nextreadblackops2", 0x2AD}, - {"nextreadghosts0", 0x2AE}, - {"nextreadghosts1", 0x2AF}, - {"nextreadmw3", 0x2B0}, - {"night_vision_off", 0x2B1}, - {"night_vision_on", 0x2B2}, - {"no_bot_random_path", 0x2B3}, - {"no_cover", 0x2B4}, - {"no_gravity", 0x2B5}, - {"noattackeraccuracymod", 0x2B6}, - {"noclip", 0x2B7}, - {"node", 0x2B8}, - {"node_not_safe", 0x2B9}, - {"node_out_of_range", 0x2BA}, - {"node_relinquished", 0x2BB}, - {"node_taken", 0x2BC}, - {"nodeoffsetpos", 0x2BD}, - {"nododgemove", 0x2BE}, - {"nogravity", 0x2BF}, - {"nogrenadereturnthrow", 0x2C0}, - {"noncombat", 0x2C1}, - {"none", 0x2C2}, - {"nonmigrateablequits", 0x2C3}, - {"nophysics", 0x2C4}, - {"normal", 0x2C5}, - {"normal_radar", 0x2C6}, - {"northyaw", 0x2C7}, - {"notifyname", 0x2C8}, - {"notinsolid", 0x2C9}, - {"num0", 0x2CA}, - {"num1", 0x2CB}, - {"num2", 0x2CC}, - {"num3", 0x2CD}, - {"num4", 0x2CE}, - {"objective", 0x2CF}, - {"obstacle", 0x2D0}, - {"offense", 0x2D1}, - {"offense_level", 0x2D2}, - {"offhand", 0x2D3}, - {"offhand_end", 0x2D4}, - {"offhandweapon", 0x2D5}, - {"oldtime", 0x2D6}, - {"ondeactivate", 0x2D7}, - {"onenterstate", 0x2D8}, - {"only_sky", 0x2D9}, - {"onlygoodnearestnodes", 0x2DA}, - {"onwifi", 0x2DB}, - {"operationsdeadline", 0x2DC}, - {"oriented", 0x2DD}, - {"orientto_complete", 0x2DE}, - {"_not_origin", 0x2DF}, - {"other", 0x2E0}, - {"over", 0x2E1}, - {"origin", 0x2E2}, - {"pacifist", 0x2E3}, - {"pacifistwait", 0x2E4}, - {"owner", 0x2E5}, - {"pantssize", 0x2E6}, - {"parentindex", 0x2E7}, - {"parentname", 0x2E8}, - {"partyid", 0x2E9}, - {"pasttitledata", 0x2EA}, - {"patch", 0x2EB}, - {"patchbacking", 0x2EC}, - {"path_blocked", 0x2ED}, - {"path_changed", 0x2EE}, - {"path_dir_change", 0x2EF}, - {"path_enemy", 0x2F0}, - {"path_need_dodge", 0x2F1}, - {"path_set", 0x2F2}, - {"pathenemyfightdist", 0x2F3}, - {"pathenemylookahead", 0x2F4}, - {"pathgoalpos", 0x2F5}, - {"pathlookaheaddist", 0x2F6}, - {"pathrandompercent", 0x2F7}, - {"pc", 0x2F8}, - {"pccg", 0x2F9}, - {"pelvis", 0x2FA}, - {"perk1", 0x2FB}, - {"perk2", 0x2FC}, - {"perk3", 0x2FD}, - {"perk4", 0x2FE}, - {"perk5", 0x2FF}, - {"perk6", 0x300}, - {"perkclassrestricted", 0x301}, - {"perkrestricted", 0x302}, - {"perks", 0x303}, - {"perkslots", 0x304}, - {"_not_pers", 0x305}, - {"persistentperksunlocked", 0x306}, - {"persistentweaponsunlocked", 0x307}, - {"pers", 0x308}, - {"phone_on", 0x309}, - {"physics_finished", 0x30A}, - {"physics_impact", 0x30B}, - {"pickup", 0x30C}, - {"pickup_riotshield", 0x30D}, - {"pistol", 0x30E}, - {"pitchamount", 0x30F}, - {"pitchconvergencetime", 0x310}, - {"plane_waypoint", 0x311}, - {"playedblackops2", 0x312}, - {"playedghosts", 0x313}, - {"playedmw3", 0x314}, - {"player", 0x315}, - {"player_controller", 0x316}, - {"player_pushed", 0x317}, - {"playercardbackground", 0x318}, - {"playercardpatch", 0x319}, - {"playercardpatchbacking", 0x31A}, - {"playerconnectionhistory", 0x31B}, - {"playerid", 0x31C}, - {"playerip", 0x31D}, - {"playername", 0x31E}, - {"playerpositions", 0x31F}, - {"_not_players", 0x320}, - {"playerspread", 0x321}, - {"playerxuidhigh", 0x322}, - {"players", 0x323}, - {"playing", 0x324}, - {"points", 0x325}, - {"position", 0x326}, - {"positioninworld", 0x327}, - {"postsharpturnlookaheaddist", 0x328}, - {"precache", 0x329}, - {"predicted_projectile_impact", 0x32A}, - {"prestige", 0x32B}, - {"prestigedoublexp", 0x32C}, - {"prestigedoublexpmaxtimeplayed", 0x32D}, - {"prestigeshoptokens", 0x32E}, - {"prestigeshoptokensentitlement", 0x32F}, - {"prevanimdelta", 0x330}, - {"prevnode", 0x331}, - {"prevscript", 0x332}, - {"primary", 0x333}, - {"primaryattachment1", 0x334}, - {"primaryattachment2", 0x335}, - {"primaryattachment3", 0x336}, - {"primaryattachments", 0x337}, - {"primaryattachkit", 0x338}, - {"primarycamo", 0x339}, - {"primaryfurniturekit", 0x33A}, - {"primaryoffhand", 0x33B}, - {"primaryreticle", 0x33C}, - {"_not_primaryweapon", 0x33D}, - {"privatematchactivesquadmember", 0x33E}, - {"privatematchcustomclasses", 0x33F}, - {"primaryweapon", 0x340}, - {"projectile_impact", 0x341}, - {"projectile_impact_player", 0x342}, - {"prone", 0x343}, - {"proneok", 0x344}, - {"providecoveringfire", 0x345}, - {"ps3", 0x346}, - {"ps4", 0x347}, - {"psoffsettime", 0x348}, - {"pushable", 0x349}, - {"radaralwayson", 0x34A}, - {"radarmode", 0x34B}, - {"radarshowenemydirection", 0x34C}, - {"radarstrength", 0x34D}, - {"radius", 0x34E}, - {"ragdoll_early_result", 0x34F}, - {"raise_riotshield", 0x350}, - {"rank", 0x351}, - {"rate", 0x352}, - {"reached_end_node", 0x353}, - {"reached_wait_node", 0x354}, - {"reached_wait_speed", 0x355}, - {"reactiontargetpos", 0x356}, - {"realtimedelta", 0x357}, - {"receiver", 0x358}, - {"recipename", 0x359}, - {"reciprocality", 0x35A}, - {"reflection_clear_color", 0x35B}, - {"reinforcement", 0x35C}, - {"relativedir", 0x35D}, - {"relativeoffset", 0x35E}, - {"reload", 0x35F}, - {"reload_start", 0x360}, - {"remotemissilespawn", 0x361}, - {"rendertotexture", 0x362}, - {"reportindex", 0x363}, - {"reports", 0x364}, - {"reputation", 0x365}, - {"requestarrivalnotify", 0x366}, - {"requirement_beat100waves", 0x367}, - {"requirement_beat200waves", 0x368}, - {"requirement_beat50waves", 0x369}, - {"requirement_beatenzombies", 0x36A}, - {"requirement_maxarmorproficiency", 0x36B}, - {"requirement_maxweaponproficiency", 0x36C}, - {"requirement_playedallmaps", 0x36D}, - {"requirement_unlockedprison", 0x36E}, - {"requirement_unlockedtier2", 0x36F}, - {"requirement_unlockedtier3", 0x370}, - {"reserved", 0x371}, - {"respawndelay", 0x372}, - {"result", 0x373}, - {"reticle", 0x374}, - {"return_pitch", 0x375}, - {"reverse", 0x376}, - {"revives", 0x377}, - {"right", 0x378}, - {"rightaimlimit", 0x379}, - {"rightarc", 0x37A}, - {"riotshield_damaged", 0x37B}, - {"riotshield_hit", 0x37C}, - {"rocket", 0x37D}, - {"rocket_off", 0x37E}, - {"rocket_on", 0x37F}, - {"rotatedone", 0x380}, - {"rotation", 0x381}, - {"run", 0x382}, - {"runcost", 0x383}, - {"runto_arrived", 0x384}, - {"safetochangescript", 0x385}, - {"scavenger", 0x386}, - {"scope_cap", 0x387}, - {"scope_center", 0x388}, - {"scope_top", 0x389}, - {"_not_score", 0x38A}, - {"script", 0x38B}, - {"script_brushmodel", 0x38C}, - {"score", 0x38D}, - {"script_context", 0x38E}, - {"script_delay", 0x38F}, - {"script_goal_changed", 0x390}, - {"script_label", 0x391}, - {"script_lightset", 0x392}, - {"script_linkname", 0x393}, - {"script_model", 0x394}, - {"script_noteworthy", 0x395}, - {"script_origin", 0x396}, - {"script_parent", 0x397}, - {"script_parentname", 0x398}, - {"script_pushable", 0x399}, - {"script_vehicle", 0x39A}, - {"script_vehicle_collision", 0x39B}, - {"script_vehicle_collmap", 0x39C}, - {"script_vehicle_corpse", 0x39D}, - {"script_visionset", 0x39E}, - {"script_water", 0x39F}, - {"script_reverb", 0x3A0}, - {"script_zone", 0x3A1}, - {"scriptable", 0x3A2}, - {"scriptableactor", 0x3A3}, - {"scripted_viewmodel_anim", 0x3A4}, - {"scriptedarrivalent", 0x3A5}, - {"search_end", 0x3A6}, - {"secondary", 0x3A7}, - {"secondaryattachment1", 0x3A8}, - {"secondaryattachment2", 0x3A9}, - {"secondaryattachments", 0x3AA}, - {"secondaryattachkit", 0x3AB}, - {"secondarycamo", 0x3AC}, - {"secondaryfurniturekit", 0x3AD}, - {"secondaryoffhand", 0x3AE}, - {"secondaryreticle", 0x3AF}, - {"_not_secondaryweapon", 0x3B0}, - {"sentry", 0x3B1}, - {"sentry_manual", 0x3B2}, - {"secondaryweapon", 0x3B3}, - {"servertimecount", 0x3B4}, - {"servertimeexceedcount", 0x3B5}, - {"servertimemax", 0x3B6}, - {"servertimetotal", 0x3B7}, - {"servertimetotalexceed", 0x3B8}, - {"sessionstate", 0x3B9}, - {"sessionteam", 0x3BA}, - {"sharpturn", 0x3BB}, - {"sharpturnlookaheaddist", 0x3BC}, - {"sharpturnnotifydist", 0x3BD}, - {"sharpturntooclosetodestdist", 0x3BE}, - {"shirt", 0x3BF}, - {"showinkillcam", 0x3C0}, - {"showkillcam", 0x3C1}, - {"sightlatency", 0x3C2}, - {"silenced_shot", 0x3C3}, - {"skill_points", 0x3C4}, - {"skillbucket", 0x3C5}, - {"skillrating", 0x3C6}, - {"skillratingtype", 0x3C7}, - {"slidevelocity", 0x3C8}, - {"slowmo_active", 0x3C9}, - {"slowmo_passive", 0x3CA}, - {"smoke", 0x3CB}, - {"snd_channelvolprio_holdbreath", 0x3CC}, - {"snd_channelvolprio_pain", 0x3CD}, - {"snd_channelvolprio_shellshock", 0x3CE}, - {"snd_enveffectsprio_level", 0x3CF}, - {"snd_enveffectsprio_shellshock", 0x3D0}, - {"sort", 0x3D1}, - {"sound_blend", 0x3D2}, - {"soundeventdone", 0x3D3}, - {"space", 0x3D4}, - {"spawned", 0x3D5}, - {"spawner", 0x3D6}, - {"spawnflags", 0x3D7}, - {"spawnpos", 0x3D8}, - {"spawntime", 0x3D9}, - {"specialgrenade", 0x3DA}, - {"spectatekillcam", 0x3DB}, - {"spectating_cycle", 0x3DC}, - {"spectator", 0x3DD}, - {"speechcommand", 0x3DE}, - {"speed", 0x3DF}, - {"splatter", 0x3E0}, - {"splineplanereachednode", 0x3E1}, - {"sprint_begin", 0x3E2}, - {"sprint_end", 0x3E3}, - {"sprint_slide_begin", 0x3E4}, - {"sprint_slide_end", 0x3E5}, - {"squad_base", 0x3E6}, - {"squad_mode", 0x3E7}, - {"squad_name", 0x3E8}, - {"squadhq", 0x3E9}, - {"squadmembers", 0x3EA}, - {"squadmemxp", 0x3EB}, - {"squadname", 0x3EC}, - {"stairs", 0x3ED}, - {"stairsstate", 0x3EE}, - {"stand", 0x3EF}, - {"start_blend", 0x3F0}, - {"start_move", 0x3F1}, - {"start_ragdoll", 0x3F2}, - {"startdeaths", 0x3F3}, - {"startdeploy_riotshield", 0x3F4}, - {"startingoffsetforlife", 0x3F5}, - {"startkills", 0x3F6}, - {"state_changed", 0x3F7}, - {"statelocked", 0x3F8}, - {"stencil_disable", 0x3F9}, - {"stencil_onesided", 0x3FA}, - {"stencil_twosided", 0x3FB}, - {"stencilfunc_always", 0x3FC}, - {"stencilfunc_equal", 0x3FD}, - {"stencilfunc_greater", 0x3FE}, - {"stencilfunc_greaterequal", 0x3FF}, - {"stencilfunc_less", 0x400}, - {"stencilfunc_lessequal", 0x401}, - {"stencilfunc_never", 0x402}, - {"stencilfunc_notequal", 0x403}, - {"stencilop_decr", 0x404}, - {"stencilop_decrsat", 0x405}, - {"stencilop_incr", 0x406}, - {"stencilop_incrsat", 0x407}, - {"stencilop_invert", 0x408}, - {"stencilop_keep", 0x409}, - {"stencilop_replace", 0x40A}, - {"stencilop_zero", 0x40B}, - {"stop", 0x40C}, - {"stop_soon", 0x40D}, - {"stopanimdistsq", 0x40E}, - {"stopsoonnotifydist", 0x40F}, - {"streak", 0x410}, - {"streaktype", 0x411}, - {"suckedashost", 0x412}, - {"suncolor", 0x413}, - {"sundirection", 0x414}, - {"sunlight", 0x415}, - {"support", 0x416}, - {"support_level", 0x417}, - {"suppression", 0x418}, - {"suppression_end", 0x419}, - {"suppressionduration", 0x41A}, - {"suppressionmeter", 0x41B}, - {"suppressionstarttime", 0x41C}, - {"suppressiontime", 0x41D}, - {"suppressionwait", 0x41E}, - {"surfacetype", 0x41F}, - {"surprisedbymedistsq", 0x420}, - {"swimmer", 0x421}, - {"switched_var_grenade", 0x422}, - {"syncedmeleetarget", 0x423}, - {"tactical", 0x424}, - {"tag", 0x425}, - {"tag_ai_aim_target", 0x426}, - {"tag_aim", 0x427}, - {"tag_aim_animated", 0x428}, - {"tag_aim_pivot", 0x429}, - {"tag_barrel", 0x42A}, - {"tag_blade_off", 0x42B}, - {"tag_body", 0x42C}, - {"tag_brass", 0x42D}, - {"tag_brass_2", 0x42E}, - {"tag_butt", 0x42F}, - {"tag_camera", 0x430}, - {"tag_clip", 0x431}, - {"tag_clip_dual", 0x432}, - {"tag_clip_dual2", 0x433}, - {"tag_detach", 0x434}, - {"tag_engine_left", 0x435}, - {"tag_engine_right", 0x436}, - {"tag_eotech_reticle", 0x437}, - {"tag_eye", 0x438}, - {"tag_flash", 0x439}, - {"tag_flash_11", 0x43A}, - {"tag_flash_2", 0x43B}, - {"tag_flash_22", 0x43C}, - {"tag_flash_3", 0x43D}, - {"tag_flash_launcher", 0x43E}, - {"tag_flash_silenced", 0x43F}, - {"tag_fx", 0x440}, - {"tag_gasmask", 0x441}, - {"tag_gasmask2", 0x442}, - {"tag_ik_ankle_fl", 0x443}, - {"tag_ik_ankle_fr", 0x444}, - {"tag_ik_ankle_kl", 0x445}, - {"tag_ik_ankle_kr", 0x446}, - {"tag_ik_ankle_ml", 0x447}, - {"tag_ik_ankle_mr", 0x448}, - {"tag_ik_footflat_fl", 0x449}, - {"tag_ik_footflat_fr", 0x44A}, - {"tag_ik_footflat_kl", 0x44B}, - {"tag_ik_footflat_kr", 0x44C}, - {"tag_ik_footflat_ml", 0x44D}, - {"tag_ik_footflat_mr", 0x44E}, - {"tag_ik_hip_fl", 0x44F}, - {"tag_ik_hip_fr", 0x450}, - {"tag_ik_hip_kl", 0x451}, - {"tag_ik_hip_kr", 0x452}, - {"tag_ik_hip_ml", 0x453}, - {"tag_ik_hip_mr", 0x454}, - {"tag_ik_knee_fl", 0x455}, - {"tag_ik_knee_fr", 0x456}, - {"tag_ik_knee_kl", 0x457}, - {"tag_ik_knee_kr", 0x458}, - {"tag_ik_knee_ml", 0x459}, - {"tag_ik_knee_mr", 0x45A}, - {"tag_ik_loc_le", 0x45B}, - {"tag_ik_loc_le_foregrip", 0x45C}, - {"tag_ik_loc_le_launcher", 0x45D}, - {"tag_ik_loc_le_shotgun", 0x45E}, - {"tag_ik_target", 0x45F}, - {"tag_inhand", 0x460}, - {"tag_jetblast_fx", 0x461}, - {"tag_jetpack", 0x462}, - {"tag_knife_attach", 0x463}, - {"tag_knife_fx", 0x464}, - {"tag_laser", 0x465}, - {"tag_launcher", 0x466}, - {"tag_magnifier_eotech_reticle", 0x467}, - {"tag_mobile_cover_upright", 0x468}, - {"tag_motion_tracker_bl", 0x469}, - {"tag_motion_tracker_br", 0x46A}, - {"tag_motion_tracker_fx", 0x46B}, - {"tag_motion_tracker_tl", 0x46C}, - {"tag_origin", 0x46D}, - {"tag_player", 0x46E}, - {"tag_popout", 0x46F}, - {"tag_rail_master_off", 0x470}, - {"tag_rail_master_on", 0x471}, - {"tag_rail_side_off", 0x472}, - {"tag_rail_side_on", 0x473}, - {"tag_reticle_acog", 0x474}, - {"tag_reticle_default", 0x475}, - {"tag_reticle_default2", 0x476}, - {"tag_reticle_hamr", 0x477}, - {"tag_reticle_on", 0x478}, - {"tag_reticle_red_dot", 0x479}, - {"tag_reticle_reflex", 0x47A}, - {"tag_reticle_tavor_scope", 0x47B}, - {"tag_reticle_thermal_scope", 0x47C}, - {"tag_rider", 0x47D}, - {"tag_riot_shield", 0x47E}, - {"tag_rocket", 0x47F}, - {"tag_scope_ads_off", 0x480}, - {"tag_scope_ads_on", 0x481}, - {"tag_shield_back", 0x482}, - {"tag_shotgun", 0x483}, - {"tag_show_alt", 0x484}, - {"tag_sight_off", 0x485}, - {"tag_sight_on", 0x486}, - {"tag_stow_back_mid_attach", 0x487}, - {"_not_tag_stowed_back", 0x488}, - {"tag_stowed_hip_rear", 0x489}, - {"tag_sync", 0x48A}, - {"tag_stowed_back", 0x48B}, - {"tag_turret", 0x48C}, - {"tag_turret_base", 0x48D}, - {"tag_turret_pitch", 0x48E}, - {"tag_turret_yaw", 0x48F}, - {"tag_weapon", 0x490}, - {"tag_weapon_chest", 0x491}, - {"tag_weapon_left", 0x492}, - {"tag_weapon_right", 0x493}, - {"tag_wheel_back_left", 0x494}, - {"tag_wheel_back_right", 0x495}, - {"tag_wheel_front_left", 0x496}, - {"tag_wheel_front_right", 0x497}, - {"tag_wheel_middle_left", 0x498}, - {"tag_wheel_middle_right", 0x499}, - {"tag_wheel_spin_left01", 0x49A}, - {"tag_wheel_spin_left02", 0x49B}, - {"tag_wheel_spin_left03", 0x49C}, - {"tag_wheel_spin_right01", 0x49D}, - {"tag_wheel_spin_right02", 0x49E}, - {"tag_wheel_spin_right03", 0x49F}, - {"takedamage", 0x4A0}, - {"target", 0x4A1}, - {"target_script_trigger", 0x4A2}, - {"targetname", 0x4A3}, - {"_not_team", 0x4A4}, - {"team3", 0x4A5}, - {"teambalanced", 0x4A6}, - {"team", 0x4A7}, - {"teammode_ffa", 0x4A8}, - {"teammovewaittime", 0x4A9}, - {"their_score", 0x4AA}, - {"thermal", 0x4AB}, - {"thermalbodymaterial", 0x4AC}, - {"third_person", 0x4AD}, - {"threatbias", 0x4AE}, - {"threatbiasgroup", 0x4AF}, - {"threatsightdelayenabled", 0x4B0}, - {"threatsightdelayfalloff", 0x4B1}, - {"threshold", 0x4B2}, - {"throwingknife", 0x4B3}, - {"time", 0x4B4}, - {"timeplayedtotal", 0x4B5}, - {"titlenew", 0x4B6}, - {"titleunlocked", 0x4B7}, - {"top", 0x4B8}, - {"toparc", 0x4B9}, - {"totalxp", 0x4BA}, - {"touch", 0x4BB}, - {"touching_platform", 0x4BC}, - {"traverse_complete", 0x4BD}, - {"traverse_soon", 0x4BE}, - {"traversecost", 0x4BF}, - {"traversesoonnotifydist", 0x4C0}, - {"trend", 0x4C1}, - {"_not_trigger", 0x4C2}, - {"trigger_damage", 0x4C3}, - {"trigger_use", 0x4C4}, - {"trigger", 0x4C5}, - {"truck_cam", 0x4C6}, - {"turnrate", 0x4C7}, - {"turret_deactivate", 0x4C8}, - {"turret_fire", 0x4C9}, - {"turret_no_vis", 0x4CA}, - {"turret_not_on_target", 0x4CB}, - {"turret_on_target", 0x4CC}, - {"turret_on_vistarget", 0x4CD}, - {"turret_pitch_clamped", 0x4CE}, - {"turret_rotate_stopped", 0x4CF}, - {"turret_yaw_clamped", 0x4D0}, - {"turretinvulnerability", 0x4D1}, - {"turretownerchange", 0x4D2}, - {"turretstatechange", 0x4D3}, - {"type", 0x4D4}, - {"ucdidhigh", 0x4D5}, - {"ucdidlow", 0x4D6}, - {"unlockedcamo", 0x4D7}, - {"unlockedreticles", 0x4D8}, - {"unlockpoints", 0x4D9}, - {"unresolved_collision", 0x4DA}, - {"up", 0x4DB}, - {"upaimlimit", 0x4DC}, - {"upgradechallengeprogress", 0x4DD}, - {"upgradechallengestage", 0x4DE}, - {"upgradepoints", 0x4DF}, - {"upgradepurchased", 0x4E0}, - {"useable", 0x4E1}, - {"usechokepoints", 0x4E2}, - {"usecombatscriptatcover", 0x4E3}, - {"usedemblemslots", 0x4E4}, - {"useorcaavoidance", 0x4E5}, - {"usepathsmoothingvalues", 0x4E6}, - {"veh_boatbounce", 0x4E7}, - {"veh_boost_activated", 0x4E8}, - {"veh_boost_deactivated", 0x4E9}, - {"veh_brake", 0x4EA}, - {"veh_collision", 0x4EB}, - {"veh_contact", 0x4EC}, - {"veh_jolt", 0x4ED}, - {"veh_landed", 0x4EE}, - {"veh_leftground", 0x4EF}, - {"veh_pathdir", 0x4F0}, - {"veh_pathspeed", 0x4F1}, - {"veh_pathtype", 0x4F2}, - {"veh_predictedcollision", 0x4F3}, - {"veh_speed", 0x4F4}, - {"veh_throttle", 0x4F5}, - {"veh_topspeed", 0x4F6}, - {"veh_transmission", 0x4F7}, - {"vehicle_dismount", 0x4F8}, - {"vehicle_mount", 0x4F9}, - {"vehicletype", 0x4FA}, - {"velocity", 0x4FB}, - {"vertalign", 0x4FC}, - {"visionsetmissilecam", 0x4FD}, - {"visionsetmissilecamduration", 0x4FE}, - {"visionsetnaked", 0x4FF}, - {"visionsetnakedduration", 0x500}, - {"visionsetnight", 0x501}, - {"visionsetnightduration", 0x502}, - {"visionsetpain", 0x503}, - {"visionsetpainduration", 0x504}, - {"visionsetthermal", 0x505}, - {"visionsetthermalduration", 0x506}, - {"vote", 0x507}, - {"wait", 0x508}, - {"walk", 0x509}, - {"walkdist", 0x50A}, - {"walkdistfacingmotion", 0x50B}, - {"wastacticalinsertion", 0x50C}, - {"waypoint_reached", 0x50D}, - {"weapon", 0x50E}, - {"weapon_change", 0x50F}, - {"weapon_dropped", 0x510}, - {"weapon_fired", 0x511}, - {"weapon_model_change", 0x512}, - {"weapon_switch_invalid", 0x513}, - {"weapon_switch_started", 0x514}, - {"weapon_taken", 0x515}, - {"weaponchange", 0x516}, - {"weaponclassrestricted", 0x517}, - {"weaponinfo", 0x518}, - {"weaponrank", 0x519}, - {"weaponrestricted", 0x51A}, - {"weaponsetups", 0x51B}, - {"weaponstats", 0x51C}, - {"weeklychallengeid", 0x51D}, - {"weight", 0x51E}, - {"width", 0x51F}, - {"wildcard1", 0x520}, - {"wildcard2", 0x521}, - {"wildcard3", 0x522}, - {"wildcardslots", 0x523}, - {"win_streak", 0x524}, - {"winlossratio", 0x525}, - {"wins", 0x526}, - {"won_match", 0x527}, - {"world", 0x528}, - {"worldmodel", 0x529}, - {"worldspawn", 0x52A}, - {"x", 0x52B}, - {"xb3", 0x52C}, - {"xenon", 0x52D}, - {"xp", 0x52E}, - {"xp_multiplier", 0x52F}, - {"xpmaxmultipliertimeplayed", 0x530}, - {"xpmultiplier", 0x531}, - {"xuid", 0x532}, - {"y", 0x533}, - {"yawconvergencetime", 0x534}, - {"your_score", 0x535}, - {"z", 0x536}, - {"zonly_physics", 0x537}, - {"codescripts/delete", 0x53D}, - {"codescripts/struct", 0x53E}, - {"codescripts/message", 0x53F}, - {"maps/mp/gametypes/_callbacksetup", 0x540}, - {"_createfx", 0x575}, - {"_effect", 0x58F}, - {"_hasperk", 0x5CB}, - {"_objective_delete", 0x603}, - {"_unsetperk", 0x67B}, - {"ac130", 0x6CE}, - {"ac130player", 0x6D1}, - {"scorepercentagecutoff", 0x782}, - {"addspawnpoints", 0x82F}, - {"addstartspawnpoints", 0x831}, - {"addtocharactersarray", 0x848}, - {"addtoteam", 0x851}, - {"agent_funcs", 0x897}, - {"agent_gameparticipant", 0x898}, - {"agent_teamparticipant", 0x89F}, - {"agent_type", 0x8A0}, - {"agentarray", 0x8A1}, - {"airstrikeinprogress", 0x99C}, - {"allowuse", 0xAB2}, - {"allowvote", 0xAB4}, - {"anim_prop_models", 0xBEC}, - {"applyloadout", 0xCAE}, - {"artillerydangercenter", 0xD33}, - {"atbrinkofdeath", 0xD82}, - {"attackers", 0xE34}, - {"primaryprogressbartexty", 0xF88}, - {"audio", 0x10F0}, - {"avoidkillstreakonspawntimer", 0x11FC}, - {"basefontscale", 0x1309}, - {"bcsounds", 0x1358}, - {"beingrevived", 0x13AB}, - {"blockweapondrops", 0x14B5}, - {"bombsquadicons", 0x154C}, - {"bombsquadids", 0x154D}, - {"bot_funcs", 0x161B}, - {"breathingstoptime", 0x17E6}, - {"brinkofdeathkillstreak", 0x1818}, - {"greatestuniqueplayerkills", 0x18B1}, - {"c4explodethisframe", 0x1974}, - {"callback_playerdamage", 0x19F5}, - {"callbackplayerdamage", 0x19FE}, - {"candocombat", 0x1AC6}, - {"canperformclienttraces", 0x1AD6}, - {"carryflag", 0x1BB4}, - {"challengeinfo", 0x1C62}, - {"changingweapon", 0x1C87}, - {"characters", 0x1C8E}, - {"checkdynamicspawns", 0x1CFA}, - {"chopper", 0x1D48}, - {"class", 0x1E2E}, - {"classtweaks", 0x1E40}, - {"claymoredetectiondot", 0x1E44}, - {"claymoredetectiongraceperiod", 0x1E45}, - {"claymoredetectionmindist", 0x1E46}, - {"claymoredetonateradius", 0x1E47}, - {"clearonvictimdisconnect", 0x1EF9}, - {"clientid", 0x1F0F}, - {"clientmatchdataid", 0x1F10}, - {"clienttweakables", 0x1F12}, - {"combathigh", 0x20AB}, - {"concussionendtime", 0x20DF}, - {"conf_fx", 0x20E9}, - {"connecttime", 0x214F}, - {"console", 0x2153}, - {"createuseobject", 0x244C}, - {"curorigin", 0x24C8}, - {"curprogress", 0x24C9}, - {"currentweaponatspawn", 0x252E}, - {"damagedplayers", 0x259A}, - {"defaultvalue", 0x27A1}, - {"delayminetime", 0x27E9}, - {"deleteobjpoint", 0x2859}, - {"detectedexploit", 0x2991}, - {"detectexplosives", 0x2992}, - {"detectid", 0x2994}, - {"disabled", 0x2AFD}, - {"disabledoffhandweapons", 0x2B05}, - {"disabledusability", 0x2B0A}, - {"disabledweapon", 0x2B0B}, - {"disabledweaponswitch", 0x2B0C}, - {"disablespawning", 0x2B28}, - {"dogtags", 0x2CDF}, - {"doingfinalkillcamfx", 0x2CE6}, - {"doingsplash", 0x2CE9}, - {"dont_delete_grenades_on_next_spawn", 0x2D1E}, - {"drawfriend", 0x2DD7}, - {"droppeddeathweapon", 0x2F74}, - {"empendtime", 0x3082}, - {"entity_number", 0x3314}, - {"entityheadicons", 0x331A}, - {"finalkill", 0x373E}, - {"findboxcenter", 0x3779}, - {"flashduration", 0x38AE}, - {"flashendtime", 0x38B1}, - {"flashrumbleduration", 0x38C4}, - {"forfeitinprogress", 0x39DF}, - {"freeplayers", 0x3A2A}, - {"friendlydamage", 0x3A97}, - {"fx", 0x3B23}, - {"gameended", 0x3BDA}, - {"gameendtime", 0x3BDC}, - {"gamemodemodifyplayerdamage", 0x3BF6}, - {"gametweaks", 0x3C02}, - {"getnextobjid", 0x4041}, - {"getotherteam", 0x4067}, - {"getspawnpoint", 0x40D2}, - {"getspawnpoint_freeforall", 0x40D5}, - {"getteamspawnpoints", 0x411F}, - {"getweaponclass", 0x4167}, - {"giveloadout", 0x41E0}, - {"gotpullbacknotify", 0x428B}, - {"guid", 0x4450}, - {"gunner", 0x4473}, - {"hardcoremode", 0x46CA}, - {"hardpointtweaks", 0x46CE}, - {"hasdied", 0x4726}, - {"headmodel", 0x477D}, - {"healthoverlaycutoff", 0x478D}, - {"healthregendisabled", 0x478E}, - {"healthregenerationstreak", 0x4791}, - {"hits", 0x4926}, - {"hitsthismag", 0x4929}, - {"hostname", 0x4A3E}, - {"hud", 0x4AB3}, - {"hudtweaks", 0x4AFF}, - {"idflags", 0x4B56}, - {"idflags_no_knockback", 0x4B58}, - {"idflags_shield_explosive_impact", 0x4B5E}, - {"idflags_shield_explosive_impact_huge", 0x4B5F}, - {"idflags_shield_explosive_splash ", 0x4B60}, - {"idflags_stun", 0x4B61}, - {"idflagstime", 0x4B62}, - {"inc", 0x4C13}, - {"inframes", 0x4C67}, - {"ingraceperiod", 0x4C6D}, - {"init_animatedmodels", 0x4C77}, - {"initedentityheadicons", 0x4DB6}, - {"initializematchrules", 0x4DE0}, - {"initializetagpathvariables", 0x4DE3}, - {"initspawns", 0x4E26}, - {"inlaststand", 0x4E3C}, - {"inplayersmokescreen", 0x4E42}, - {"isactive", 0x50A6}, - {"isagent", 0x50AB}, - {"iscooked", 0x50E8}, - {"ishorde", 0x511D}, - {"iskillstreakweapon", 0x513D}, - {"isrocketcorpse", 0x5193}, - {"issniper", 0x51AB}, - {"istactical", 0x51C7}, - {"isteamspeaking", 0x51D0}, - {"joining_team", 0x528C}, - {"kill_streak", 0x533C}, - {"killcam", 0x534B}, - {"killcamlength", 0x534F}, - {"killedplayers", 0x5363}, - {"killstreakrounddelay", 0x53A2}, - {"killstreakspawnshield", 0x53A8}, - {"largeprojectiledamage", 0x54C0}, - {"lastclass", 0x5589}, - {"lastconcussedtime", 0x558B}, - {"lastkilldogtime", 0x558D}, - {"lastdamagewasfromenemy", 0x5591}, - {"lastdeathicon", 0x5592}, - {"lastdroppableweapon", 0x5598}, - {"lastflashedtime", 0x55A1}, - {"lastgrenadesuicidetime", 0x55A5}, - {"lasthittime", 0x55AB}, - {"lastkilledby", 0x55B1}, - {"lastkilltime", 0x55B6}, - {"lastprimaryweaponswaptime", 0x55CD}, - {"lastshotfiredtime", 0x55D9}, - {"laststatustime", 0x55FC}, - {"lastwave", 0x560E}, - {"leaving_team", 0x566D}, - {"lowertextfontsize", 0x58A8}, - {"lowertexty", 0x58A9}, - {"lowertextyalign", 0x58AA}, - {"plantedlethalequip", 0x5979}, - {"mapcenter", 0x5986}, - {"mapsize", 0x5990}, - {"matchbonus", 0x59DF}, - {"matchrules_damagemultiplier", 0x59E6}, - {"matchrules_vampirism", 0x59EB}, - {"maxclients", 0x5A29}, - {"maxevents", 0x5A37}, - {"maxfontscale", 0x5A39}, - {"maxkillstreaks", 0x5A3C}, - {"maxlives", 0x5A40}, - {"maxnumawardsperplayer", 0x5A41}, - {"maxlogclients", 0x5A42}, - {"maxnumchallengesperplayer", 0x5A45}, - {"maxperplayerexplosives", 0x5A4A}, - {"minedamagehalfheight", 0x5C51}, - {"minedamagemax", 0x5C53}, - {"minedamagemin", 0x5C54}, - {"minedamageradius", 0x5C56}, - {"minedetectiongraceperiod", 0x5C58}, - {"minedetectionheight", 0x5C59}, - {"minedetectionradius", 0x5C5A}, - {"mineselfdestructtime", 0x5C5F}, - {"missioncallbacks", 0x5CDC}, - {"modifyplayerdamage", 0x5D51}, - {"movespeedscaler", 0x5F7B}, - {"mp_createfx", 0x5FAC}, - {"multiteambased", 0x5FEC}, - {"objectivepointsmod", 0x6301}, - {"objectivescaler", 0x6303}, - {"objid", 0x6304}, - {"teamobjids", 0x6305}, - {"oldheadicon", 0x63D4}, - {"oldheadiconteam", 0x63D5}, - {"omaclasschanged", 0x6436}, - {"onforfeit", 0x64AF}, - {"onlinegame", 0x64B8}, - {"onnormaldeath", 0x64BF}, - {"onplayerconnectaudioinit", 0x64C9}, - {"onplayerscore", 0x64D5}, - {"onstartgametype", 0x64EC}, - {"onuse", 0x64F8}, - {"outframes", 0x65C4}, - {"participants", 0x669D}, - {"tookweaponfrom", 0x680B}, - {"placement", 0x6861}, - {"planemodel", 0x687C}, - {"playedstartingmusic", 0x6A41}, - {"player_speed", 0x6C19}, - {"playerhealth_regularregendelay", 0x6CC3}, - {"playertweaks", 0x6D74}, - {"bonusupdatetotal", 0x6E8A}, - {"primaryprogressbarfontsize", 0x6F85}, - {"primaryprogressbarheight", 0x6F86}, - {"primaryprogressbartextx", 0x6F87}, - {"primaryprogressbarwidth", 0x6F89}, - {"primaryprogressbarx", 0x6F8A}, - {"primaryprogressbary", 0x6F8B}, - {"qafinished", 0x7073}, - {"quickmessagetoall", 0x70A2}, - {"rankedmatch", 0x7137}, - {"ranktable", 0x713A}, - {"recentkillcount", 0x7260}, - {"recoilscale", 0x7268}, - {"regenspeed", 0x72D4}, - {"registerhalftimedvar", 0x72EF}, - {"registernumlivesdvar", 0x72F4}, - {"registerroundlimitdvar", 0x72F6}, - {"registerroundswitchdvar", 0x72F7}, - {"registerscorelimitdvar", 0x72F8}, - {"registertimelimitdvar", 0x72F9}, - {"registerwinlimitdvar", 0x72FE}, - {"reinitializematchrulesonmigration", 0x7307}, - {"removefromcharactersarray", 0x73A7}, - {"requiredmapaspectratio", 0x740C}, - {"reverb_settings", 0x74F1}, - {"riotshieldxpbullets", 0x7556}, - {"rules", 0x7674}, - {"scavenger_altmode", 0x785B}, - {"scavenger_secondary", 0x785C}, - {"script_accumulate", 0x792B}, - {"script_destructable_area", 0x799B}, - {"script_fxcommand", 0x79F0}, - {"script_fxid", 0x79F1}, - {"script_gametype_atdm", 0x79F5}, - {"script_gametype_ctf", 0x79F6}, - {"script_gametype_dm", 0x79F7}, - {"script_gametype_koth", 0x79F8}, - {"script_gametype_sd", 0x79FA}, - {"script_gametype_tdm", 0x79FB}, - {"script_threshold", 0x7AF4}, - {"setclass", 0x7F3B}, - {"setcommonrulesfrommatchrulesdata", 0x7F3F}, - {"setobjectivehinttext", 0x7FC3}, - {"setobjectivescoretext", 0x7FC4}, - {"setobjectivetext", 0x7FC5}, - {"setupcallbacks", 0x8301}, - {"setupminimap", 0x8324}, - {"setusetime", 0x834C}, - {"shieldbullethits", 0x84C5}, - {"shielddamage", 0x84C6}, - {"showingfinalkillcam", 0x8516}, - {"showtoteam", 0x8535}, - {"softlanding", 0x885F}, - {"softlandingtriggers", 0x8860}, - {"spamdelay", 0x88B9}, - {"spawndogtags", 0x899E}, - {"spawnmaxs", 0x89F3}, - {"spawnmins", 0x89F6}, - {"spawnpoints", 0x8A01}, - {"speakers", 0x8A19}, - {"spectateoverride", 0x8A4A}, - {"splashqueue", 0x8A6B}, - {"splitscreen", 0x8A7C}, - {"stingerlockstarttime", 0x8E48}, - {"stingerlostsightlinetime", 0x8E49}, - {"stingerstage", 0x8E59}, - {"stingertarget", 0x8E5A}, - {"stingeruseentered", 0x8E5C}, - {"stuckenemyentity", 0x8F6C}, - {"stunscaler", 0x8F77}, - {"suicides", 0x8FAF}, - {"switching_teams", 0x907E}, - {"tag_stowed_hip", 0x90D3}, - {"tagteamupdater", 0x910A}, - {"teambalance", 0x91E9}, - {"teambased", 0x91EB}, - {"teamkillsthisround", 0x91F3}, - {"teamnamelist", 0x91F7}, - {"teamprogressbarfontsize", 0x91FB}, - {"teamprogressbarheight", 0x91FC}, - {"teamprogressbartexty", 0x91FD}, - {"teamprogressbarwidth", 0x91FE}, - {"teamprogressbary", 0x91FF}, - {"teamspawnpoints", 0x9201}, - {"teamtweaks", 0x9205}, - {"throwinggrenade", 0x933E}, - {"timeplayed", 0x9372}, - {"trackingweaponname", 0x94FB}, - {"trigunderwater", 0x9822}, - {"tweakablesinitialized", 0x99E0}, - {"updateddmscores", 0x9B0F}, - {"userate", 0x9C10}, - {"usestartspawns", 0x9C14}, - {"usingremote", 0x9C34}, - {"v", 0x9C42}, - {"voice_count", 0x9D33}, - {"visuals", 0x9E9C}, - {"waitingtodeactivate", 0xA04B}, - {"wasaliveatmatchstart", 0xA1BE}, - {"waschained", 0xA1C0}, - {"wasdamaged", 0xA1C3}, - {"wasdamagedfrombulletpenetration", 0xA1C5}, - {"wasti", 0xA1D2}, - {"waswinning", 0xA1D4}, - {"waterdeletez", 0xA297}, - {"wavedelay", 0xA2AB}, - {"weaponattachments", 0xA2D3}, - {"weaponlist", 0xA2DD}, - {"weapontweaks", 0xA2F2}, - {"whizby_settings", 0xA315}, - {"scoreinfo", 0xA3A5}, - {"xpupdatetotal", 0xA3AB}, - {"character/character_sp_usmc_at4", 0xA4D6}, - {"character/character_sp_usmc_james", 0xA4D7}, - {"character/character_sp_usmc_ryan", 0xA4D8}, - {"character/character_sp_usmc_sami", 0xA4D9}, - {"character/character_sp_usmc_sami_goggles", 0xA4DA}, - {"character/character_sp_usmc_zach", 0xA4DB}, - {"character/character_sp_usmc_zach_goggles", 0xA4DC}, - {"character/character_us_marine_ar", 0xA4DD}, - {"character/character_us_marine_ar_lowlod", 0xA4DE}, - {"character/character_us_marine_dress", 0xA4DF}, - {"character/character_us_marine_dress_a", 0xA4E0}, - {"character/character_us_marine_dress_b", 0xA4E1}, - {"character/character_us_marine_dress_c", 0xA4E2}, - {"character/character_us_marine_dress_d", 0xA4E3}, - {"character/character_us_marine_dress_e", 0xA4E4}, - {"character/character_us_marine_dress_f", 0xA4E5}, - {"character/character_us_marine_dress_lowlod", 0xA4E6}, - {"character/character_us_marine_seofob_ar", 0xA4E7}, - {"character/character_us_marine_shotgun_lowlod", 0xA4E8}, - {"character/character_us_marine_smg", 0xA4E9}, - {"character/character_us_marine_smg_lowlod", 0xA4EA}, - {"character/character_us_marine_smg_seo", 0xA4EB}, - {"character/character_us_marine_smg_seointro", 0xA4EC}, - {"character/mp_character_cloak_test", 0xA4ED}, - {"character/mp_character_sentinel", 0xA4EE}, - {"codescripts/character", 0xA4EF}, - {"common_scripts/_artcommon", 0xA4F0}, - {"common_scripts/_bcs_location_trigs", 0xA4F1}, - {"common_scripts/_createfx", 0xA4F2}, - {"common_scripts/_createfxmenu", 0xA4F3}, - {"common_scripts/_destructible", 0xA4F4}, - {"common_scripts/_dynamic_world", 0xA4F5}, - {"common_scripts/_elevator", 0xA4F6}, - {"common_scripts/_exploder", 0xA4F7}, - {"common_scripts/_fx", 0xA4F8}, - {"common_scripts/_pipes", 0xA4F9}, - {"common_scripts/utility", 0xA4FA}, - {"destructible_scripts/computer_01_destp", 0xA4FB}, - {"destructible_scripts/container_plastic_72x56x48_01_destp", 0xA4FC}, - {"destructible_scripts/container_plastic_beige_med_01_destp", 0xA4FD}, - {"destructible_scripts/greece_spinning_displays", 0xA4FE}, - {"destructible_scripts/powerbox_112x64_01_green_destp", 0xA4FF}, - {"destructible_scripts/security_camera_scanner_destp", 0xA500}, - {"destructible_scripts/toy_chicken", 0xA501}, - {"destructible_scripts/toy_chicken_common", 0xA502}, - {"destructible_scripts/toy_electricbox4", 0xA503}, - {"destructible_scripts/toy_generator", 0xA504}, - {"destructible_scripts/toy_generator_on", 0xA505}, - {"destructible_scripts/toy_locker_double", 0xA506}, - {"destructible_scripts/vehicle_civ_domestic_sedan_01_glass", 0xA507}, - {"destructible_scripts/vehicle_civ_domestic_sedan_police_destpv", 0xA508}, - {"destructible_scripts/vehicle_civ_domestic_sedan_taxi_glass", 0xA509}, - {"destructible_scripts/vehicle_civ_smartcar_destpv", 0xA50A}, - {"destructible_scripts/vehicle_luxurysedan", 0xA50B}, - {"destructible_scripts/vehicle_luxurysedan_2008", 0xA50C}, - {"destructible_scripts/vehicle_pickup", 0xA50D}, - {"destructible_scripts/vehicle_suv_atlas_destpv", 0xA50E}, - {"destructible_scripts/wall_firebox_destp", 0xA50F}, - {"maps/_anim", 0xA510}, - {"maps/_animatedmodels", 0xA511}, - {"maps/_ar_view", 0xA512}, - {"maps/_art", 0xA513}, - {"maps/_autosave", 0xA514}, - {"maps/_bobbing_boats", 0xA515}, - {"maps/_breach", 0xA516}, - {"maps/_car_door_shield", 0xA517}, - {"maps/_cg_encounter_perf_monitor", 0xA518}, - {"maps/_chargeable_weapon", 0xA519}, - {"maps/_cloak", 0xA51A}, - {"maps/_cloak_enemy_behavior", 0xA51B}, - {"maps/_colors", 0xA51C}, - {"maps/_compass", 0xA51D}, - {"maps/_controlled_orbiting_drone", 0xA51E}, - {"maps/_controlled_sniperdrone", 0xA51F}, - {"maps/_coop", 0xA520}, - {"maps/_createfx", 0xA521}, - {"maps/_credits", 0xA522}, - {"maps/_credits_autogen", 0xA523}, - {"maps/_damagefeedback", 0xA524}, - {"maps/_dds", 0xA525}, - {"maps/_debug", 0xA526}, - {"maps/_deployablecoverai", 0xA527}, - {"maps/_detonategrenades", 0xA528}, - {"maps/_dog_control", 0xA529}, - {"maps/_dog_kinect", 0xA52A}, - {"maps/_drone", 0xA52B}, - {"maps/_drone_ai", 0xA52C}, - {"maps/_drone_base", 0xA52D}, - {"maps/_drone_civilian", 0xA52E}, - {"maps/_dshk_player", 0xA52F}, - {"maps/_endmission", 0xA530}, - {"maps/_exo_climb", 0xA531}, - {"maps/_exo_punch_door", 0xA532}, - {"maps/_exo_shield_sp", 0xA533}, - {"maps/_flashlight_cheap", 0xA534}, - {"maps/_foam_bomb", 0xA535}, - {"maps/_friendlyfire", 0xA536}, - {"maps/_gameskill", 0xA537}, - {"maps/_global_fx", 0xA538}, - {"maps/_global_fx_code", 0xA539}, - {"maps/_grapple", 0xA53A}, - {"maps/_grapple_anim", 0xA53B}, - {"maps/_grapple_traverse", 0xA53C}, - {"maps/_hand_signals", 0xA53D}, - {"maps/_helicopter_ai", 0xA53E}, - {"maps/_helicopter_globals", 0xA53F}, - {"maps/_high_speed_clouds", 0xA540}, - {"maps/_hms_ai_utility", 0xA541}, - {"maps/_hms_door_interact", 0xA542}, - {"maps/_hms_greece_civilian", 0xA543}, - {"maps/_hms_utility", 0xA544}, - {"maps/_hud", 0xA545}, - {"maps/_hud_util", 0xA546}, - {"maps/_idle", 0xA547}, - {"maps/_idle_phone", 0xA548}, - {"maps/_idle_smoke", 0xA549}, - {"maps/_intelligence", 0xA54A}, - {"maps/_introscreen", 0xA54B}, - {"maps/_inventory", 0xA54C}, - {"maps/_juggernaut", 0xA54D}, - {"maps/_lighting", 0xA54E}, - {"maps/_lights", 0xA54F}, - {"maps/_load", 0xA550}, - {"maps/_loadout", 0xA551}, - {"maps/_loadout_code", 0xA552}, - {"maps/_mark_and_execute", 0xA553}, - {"maps/_mech", 0xA554}, - {"maps/_mech_aud", 0xA555}, - {"maps/_mech_grapple", 0xA556}, - {"maps/_mg_penetration", 0xA557}, - {"maps/_mgturret", 0xA558}, - {"maps/_mgturret_auto_nonai", 0xA559}, - {"maps/_microdronelauncher", 0xA55A}, - {"maps/_microwave_grenade", 0xA55B}, - {"maps/_mocap_ar", 0xA55C}, - {"maps/_names", 0xA55D}, - {"maps/_nightvision", 0xA55E}, - {"maps/_patrol", 0xA55F}, - {"maps/_patrol_anims", 0xA560}, - {"maps/_patrol_anims_active", 0xA561}, - {"maps/_patrol_anims_casualkiller", 0xA562}, - {"maps/_patrol_anims_creepwalk", 0xA563}, - {"maps/_patrol_anims_patroljog", 0xA564}, - {"maps/_patrol_cold_anims", 0xA565}, - {"maps/_patrol_extended", 0xA566}, - {"maps/_player_boost_dash", 0xA567}, - {"maps/_player_boost_jump_anims", 0xA568}, - {"maps/_player_boost_jump_aud", 0xA569}, - {"maps/_player_death", 0xA56A}, - {"maps/_player_exo", 0xA56B}, - {"maps/_player_fastzip", 0xA56C}, - {"maps/_player_high_jump", 0xA56D}, - {"maps/_player_land_assist", 0xA56E}, - {"maps/_player_stats", 0xA56F}, - {"maps/_playermech_code", 0xA570}, - {"maps/_pmove", 0xA571}, - {"maps/_president", 0xA572}, - {"maps/_props", 0xA573}, - {"maps/_rambo", 0xA574}, - {"maps/_riotshield", 0xA575}, - {"maps/_sarray", 0xA576}, - {"maps/_shg_anim", 0xA577}, - {"maps/_shg_debug", 0xA578}, - {"maps/_shg_design_tools", 0xA579}, - {"maps/_shg_fx", 0xA57A}, - {"maps/_shg_utility", 0xA57B}, - {"maps/_slowmo_breach", 0xA57C}, - {"maps/_sniper_glint", 0xA57D}, - {"maps/_sniper_setup_ai", 0xA57E}, - {"maps/_sonicaoe", 0xA57F}, - {"maps/_sp_matchdata", 0xA580}, - {"maps/_spawner", 0xA581}, - {"maps/_stealth", 0xA582}, - {"maps/_stealth_accuracy_friendly", 0xA583}, - {"maps/_stealth_animation_funcs", 0xA584}, - {"maps/_stealth_anims", 0xA585}, - {"maps/_stealth_behavior_enemy", 0xA586}, - {"maps/_stealth_behavior_friendly", 0xA587}, - {"maps/_stealth_behavior_system", 0xA588}, - {"maps/_stealth_color_friendly", 0xA589}, - {"maps/_stealth_corpse_enemy", 0xA58A}, - {"maps/_stealth_corpse_system", 0xA58B}, - {"maps/_stealth_debug", 0xA58C}, - {"maps/_stealth_display", 0xA58D}, - {"maps/_stealth_event_enemy", 0xA58E}, - {"maps/_stealth_shared_utilities", 0xA58F}, - {"maps/_stealth_smartstance_friendly", 0xA590}, - {"maps/_stealth_threat_enemy", 0xA591}, - {"maps/_stealth_utility", 0xA592}, - {"maps/_stealth_visibility_enemy", 0xA593}, - {"maps/_stealth_visibility_friendly", 0xA594}, - {"maps/_stealth_visibility_system", 0xA595}, - {"maps/_stingerm7", 0xA596}, - {"maps/_stingerm7_greece", 0xA597}, - {"maps/_swim_ai", 0xA598}, - {"maps/_swim_ai_common", 0xA599}, - {"maps/_swim_player", 0xA59A}, - {"maps/_tagging", 0xA59B}, - {"maps/_target_lock", 0xA59C}, - {"maps/_treadfx", 0xA59D}, - {"maps/_trigger", 0xA59E}, - {"maps/_underwater", 0xA59F}, - {"maps/_upgrade_challenge", 0xA5A0}, - {"maps/_upgrade_perks", 0xA5A1}, - {"maps/_upgrade_system", 0xA5A2}, - {"maps/_urgent_walk", 0xA5A3}, - {"maps/_utility", 0xA5A4}, - {"maps/_utility_code", 0xA5A5}, - {"maps/_utility_dogs", 0xA5A6}, - {"maps/_variable_grenade", 0xA5A7}, - {"maps/_vehicle", 0xA5A8}, - {"maps/_vehicle_aianim", 0xA5A9}, - {"maps/_vehicle_code", 0xA5AA}, - {"maps/_vehicle_free_drive", 0xA5AB}, - {"maps/_vehicle_missile", 0xA5AC}, - {"maps/_vehicle_shg", 0xA5AD}, - {"maps/_vehicle_traffic", 0xA5AE}, - {"maps/_vignette_util", 0xA5AF}, - {"maps/_warzone_tactics", 0xA5B0}, - {"maps/_water", 0xA5B1}, - {"maps/_weapon_pdrone", 0xA5B2}, - {"maps/_weather", 0xA5B3}, - {"maps/betrayal_fx", 0xA5B4}, - {"maps/betrayal_precache", 0xA5B5}, - {"maps/captured_fx", 0xA5B6}, - {"maps/captured_precache", 0xA5B7}, - {"maps/crash_fx", 0xA5B8}, - {"maps/crash_precache", 0xA5B9}, - {"maps/credits_s1_fx", 0xA5BA}, - {"maps/credits_s1_precache", 0xA5BB}, - {"maps/detroit_fx", 0xA5BC}, - {"maps/detroit_precache", 0xA5BD}, - {"maps/df_baghdad_fx", 0xA5BE}, - {"maps/df_baghdad_precache", 0xA5BF}, - {"maps/df_fly_fx", 0xA5C0}, - {"maps/df_fly_precache", 0xA5C1}, - {"maps/finale_fx", 0xA5C2}, - {"maps/finale_precache", 0xA5C3}, - {"maps/fusion_fx", 0xA5C4}, - {"maps/fusion_precache", 0xA5C5}, - {"maps/greece_conf_center_fx", 0xA5C6}, - {"maps/greece_ending_fx", 0xA5C7}, - {"maps/greece_fx", 0xA5C8}, - {"maps/greece_precache", 0xA5C9}, - {"maps/greece_safehouse_fx", 0xA5CA}, - {"maps/greece_sniper_scramble_fx", 0xA5CB}, - {"maps/irons_estate_fx", 0xA5CC}, - {"maps/irons_estate_precache", 0xA5CD}, - {"maps/lab_fx", 0xA5CE}, - {"maps/lab_precache", 0xA5CF}, - {"maps/lagos_fx", 0xA5D0}, - {"maps/lagos_precache", 0xA5D1}, - {"maps/recovery_fx", 0xA5D2}, - {"maps/recovery_precache", 0xA5D3}, - {"maps/sanfran_b_fx", 0xA5D4}, - {"maps/sanfran_b_precache", 0xA5D5}, - {"maps/sanfran_fx", 0xA5D6}, - {"maps/sanfran_precache", 0xA5D7}, - {"maps/seoul_fx", 0xA5D8}, - {"maps/seoul_precache", 0xA5D9}, - {"mptype/mptype_cloak_test", 0xA5DA}, - {"soundscripts/_ambient", 0xA5DB}, - {"soundscripts/_audio", 0xA5DC}, - {"soundscripts/_audio_dynamic_ambi", 0xA5DD}, - {"soundscripts/_audio_mix_manager", 0xA5DE}, - {"soundscripts/_audio_music", 0xA5DF}, - {"soundscripts/_audio_presets_music", 0xA5E0}, - {"soundscripts/_audio_presets_vehicles", 0xA5E1}, - {"soundscripts/_audio_reverb", 0xA5E2}, - {"soundscripts/_audio_stream_manager", 0xA5E3}, - {"soundscripts/_audio_vehicle_manager", 0xA5E4}, - {"soundscripts/_audio_vehicles", 0xA5E5}, - {"soundscripts/_audio_whizby", 0xA5E6}, - {"soundscripts/_audio_zone_manager", 0xA5E7}, - {"soundscripts/_snd", 0xA5E8}, - {"soundscripts/_snd_common", 0xA5E9}, - {"soundscripts/_snd_debug_bayless", 0xA5EA}, - {"soundscripts/_snd_debug_bina", 0xA5EB}, - {"soundscripts/_snd_debug_blondin", 0xA5EC}, - {"soundscripts/_snd_debug_caisley", 0xA5ED}, - {"soundscripts/_snd_debug_gavazza", 0xA5EE}, - {"soundscripts/_snd_debug_kilborn", 0xA5EF}, - {"soundscripts/_snd_debug_loperfido", 0xA5F0}, - {"soundscripts/_snd_debug_mcsweeney", 0xA5F1}, - {"soundscripts/_snd_debug_mika", 0xA5F2}, - {"soundscripts/_snd_debug_naas", 0xA5F3}, - {"soundscripts/_snd_debug_nuniyants", 0xA5F4}, - {"soundscripts/_snd_debug_swenson", 0xA5F5}, - {"soundscripts/_snd_debug_veca", 0xA5F6}, - {"soundscripts/_snd_filters", 0xA5F7}, - {"soundscripts/_snd_foley", 0xA5F8}, - {"soundscripts/_snd_hud", 0xA5F9}, - {"soundscripts/_snd_pcap", 0xA5FA}, - {"soundscripts/_snd_playsound", 0xA5FB}, - {"soundscripts/_snd_timescale", 0xA5FC}, - {"soundscripts/so_aud", 0xA5FD}, - {"vehicle_scripts/_atlas_jet", 0xA5FE}, - {"vehicle_scripts/_atlas_piranha", 0xA5FF}, - {"vehicle_scripts/_atlas_suv", 0xA600}, - {"vehicle_scripts/_atlas_van", 0xA601}, - {"vehicle_scripts/_attack_drone", 0xA602}, - {"vehicle_scripts/_attack_drone_aud", 0xA603}, - {"vehicle_scripts/_attack_drone_common", 0xA604}, - {"vehicle_scripts/_attack_drone_controllable", 0xA605}, - {"vehicle_scripts/_attack_drone_individual", 0xA606}, - {"vehicle_scripts/_attack_drone_kamikaze", 0xA607}, - {"vehicle_scripts/_attack_drone_queen", 0xA608}, - {"vehicle_scripts/_attack_heli", 0xA609}, - {"vehicle_scripts/_chinese_brave_warrior", 0xA60A}, - {"vehicle_scripts/_civ_boat", 0xA60B}, - {"vehicle_scripts/_civ_boxtruck_ai", 0xA60C}, - {"vehicle_scripts/_civ_domestic_bus", 0xA60D}, - {"vehicle_scripts/_civ_domestic_economy_ai", 0xA60E}, - {"vehicle_scripts/_civ_domestic_minivan", 0xA60F}, - {"vehicle_scripts/_civ_domestic_sedan_01", 0xA610}, - {"vehicle_scripts/_civ_domestic_sedan_police", 0xA611}, - {"vehicle_scripts/_civ_domestic_sedan_taxi_01", 0xA612}, - {"vehicle_scripts/_civ_domestic_sportscar_01", 0xA613}, - {"vehicle_scripts/_civ_domestic_suv", 0xA614}, - {"vehicle_scripts/_civ_domestic_truck", 0xA615}, - {"vehicle_scripts/_civ_full_size_pickup_01_ai", 0xA616}, - {"vehicle_scripts/_civ_full_size_technical", 0xA617}, - {"vehicle_scripts/_civ_pickup_truck_01", 0xA618}, - {"vehicle_scripts/_civ_smartcar", 0xA619}, - {"vehicle_scripts/_civ_workvan", 0xA61A}, - {"vehicle_scripts/_cover_drone", 0xA61B}, - {"vehicle_scripts/_cover_drone_aud", 0xA61C}, - {"vehicle_scripts/_diveboat", 0xA61D}, - {"vehicle_scripts/_diveboat_aud", 0xA61E}, - {"vehicle_scripts/_empty", 0xA61F}, - {"vehicle_scripts/_ft101_tank", 0xA620}, - {"vehicle_scripts/_gaz", 0xA621}, - {"vehicle_scripts/_gaz_dshk", 0xA622}, - {"vehicle_scripts/_gaz_dshk_aud", 0xA623}, - {"vehicle_scripts/_generic_script_model_lagos", 0xA624}, - {"vehicle_scripts/_havoc_missile_scripted", 0xA625}, - {"vehicle_scripts/_hovertank", 0xA626}, - {"vehicle_scripts/_hovertank_aud", 0xA627}, - {"vehicle_scripts/_ind_semi_truck_fuel_tanker", 0xA628}, - {"vehicle_scripts/_jetbike", 0xA629}, - {"vehicle_scripts/_jetbike_aud", 0xA62A}, - {"vehicle_scripts/_littlebird", 0xA62B}, - {"vehicle_scripts/_littlebird_aud", 0xA62C}, - {"vehicle_scripts/_littlebird_landing", 0xA62D}, - {"vehicle_scripts/_littlebird_player", 0xA62E}, - {"vehicle_scripts/_mi17", 0xA62F}, - {"vehicle_scripts/_mi17_aud", 0xA630}, - {"vehicle_scripts/_mi17_noai", 0xA631}, - {"vehicle_scripts/_mig29", 0xA632}, - {"vehicle_scripts/_mig29_controllable", 0xA633}, - {"vehicle_scripts/_mil_cargo_truck", 0xA634}, - {"vehicle_scripts/_pdrone", 0xA635}, - {"vehicle_scripts/_pdrone_aud", 0xA636}, - {"vehicle_scripts/_pdrone_player", 0xA637}, - {"vehicle_scripts/_pdrone_player_aud", 0xA638}, - {"vehicle_scripts/_pdrone_security", 0xA639}, - {"vehicle_scripts/_pdrone_security_aud", 0xA63A}, - {"vehicle_scripts/_pdrone_tactical_picker", 0xA63B}, - {"vehicle_scripts/_pdrone_threat_sensor", 0xA63C}, - {"vehicle_scripts/_pitbull", 0xA63D}, - {"vehicle_scripts/_pitbull_aud", 0xA63E}, - {"vehicle_scripts/_razorback", 0xA63F}, - {"vehicle_scripts/_razorback_fx", 0xA640}, - {"vehicle_scripts/_s19", 0xA641}, - {"vehicle_scripts/_sentinel_survey_drone_hud", 0xA642}, - {"vehicle_scripts/_shrike", 0xA643}, - {"vehicle_scripts/_sidewinder_scripted", 0xA644}, - {"vehicle_scripts/_slamraam", 0xA645}, - {"vehicle_scripts/_sniper_drone", 0xA646}, - {"vehicle_scripts/_sniper_drone_aud", 0xA647}, - {"vehicle_scripts/_uk_delivery_truck", 0xA648}, - {"vehicle_scripts/_vehicle_missile_launcher_ai", 0xA649}, - {"vehicle_scripts/_vehicle_multiweapon_util", 0xA64A}, - {"vehicle_scripts/_vehicle_turret_ai", 0xA64B}, - {"vehicle_scripts/_vrap", 0xA64C}, - {"vehicle_scripts/_walker_tank", 0xA64D}, - {"vehicle_scripts/_x4walker_wheels", 0xA64E}, - {"vehicle_scripts/_x4walker_wheels_aud", 0xA64F}, - {"vehicle_scripts/_x4walker_wheels_turret", 0xA650}, - {"vehicle_scripts/_x4walker_wheels_turret_aud", 0xA651}, - {"vehicle_scripts/_x4walker_wheels_turret_closed", 0xA652}, - {"vehicle_scripts/_x4walker_wheels_turret_closed_aud", 0xA653}, - {"vehicle_scripts/_xh9_warbird", 0xA654}, - {"maps/createart/mp_vlobby_room_art", 0xA6F9}, - {"maps/createart/mp_vlobby_room_fog", 0xA6FA}, - {"maps/createart/mp_vlobby_room_fog_hdr", 0xA6FB}, - {"maps/mp/_adrenaline", 0xA720}, - {"maps/mp/_aerial_pathnodes", 0xA72A}, - {"maps/mp/_animatedmodels", 0xA72B}, - {"maps/mp/_areas", 0xA72C}, - {"maps/mp/_art", 0xA72D}, - {"maps/mp/_audio", 0xA72E}, - {"maps/mp/_awards", 0xA72F}, - {"maps/mp/_braggingrights", 0xA730}, - {"maps/mp/_compass", 0xA731}, - {"maps/mp/_createfx", 0xA732}, - {"maps/mp/_crib", 0xA733}, - {"maps/mp/_destructables", 0xA734}, - {"maps/mp/_dynamic_events", 0xA735}, - {"maps/mp/_empgrenade", 0xA736}, - {"maps/mp/_entityheadicons", 0xA737}, - {"maps/mp/_events", 0xA738}, - {"maps/mp/_exo_battery", 0xA739}, - {"maps/mp/_exo_cloak", 0xA73A}, - {"maps/mp/_exo_hover", 0xA73B}, - {"maps/mp/_exo_mute", 0xA73C}, - {"maps/mp/_exo_ping", 0xA73D}, - {"maps/mp/_exo_repulsor", 0xA73E}, - {"maps/mp/_exo_shield", 0xA73F}, - {"maps/mp/_exo_suit", 0xA740}, - {"maps/mp/_exocrossbow", 0xA741}, - {"maps/mp/_exoknife", 0xA742}, - {"maps/mp/_explosive_drone", 0xA743}, - {"maps/mp/_explosive_gel", 0xA744}, - {"maps/mp/_extrahealth", 0xA745}, - {"maps/mp/_fastheal", 0xA746}, - {"maps/mp/_flashgrenades", 0xA747}, - {"maps/mp/_fx", 0xA748}, - {"maps/mp/_global_fx", 0xA749}, - {"maps/mp/_global_fx_code", 0xA74A}, - {"maps/mp/_lasersight", 0xA74B}, - {"maps/mp/_load", 0xA74C}, - {"maps/mp/_lsrmissileguidance", 0xA74D}, - {"maps/mp/_matchdata", 0xA74E}, - {"maps/mp/_menus", 0xA74F}, - {"maps/mp/_microdronelauncher", 0xA750}, - {"maps/mp/_movers", 0xA751}, - {"maps/mp/_mp_lights", 0xA752}, - {"maps/mp/_mutebomb", 0xA753}, - {"maps/mp/_na45", 0xA754}, - {"maps/mp/_opticsthermal", 0xA755}, - {"maps/mp/_reinforcements", 0xA756}, - {"maps/mp/_riotshield", 0xA757}, - {"maps/mp/_scoreboard", 0xA758}, - {"maps/mp/_shutter", 0xA759}, - {"maps/mp/_snd_common_mp", 0xA75A}, - {"maps/mp/_stinger", 0xA75B}, - {"maps/mp/_stingerm7", 0xA75C}, - {"maps/mp/_stock", 0xA75D}, - {"maps/mp/_target_enhancer", 0xA75E}, - {"maps/mp/_teleport", 0xA75F}, - {"maps/mp/_threatdetection", 0xA760}, - {"maps/mp/_tracking_drone", 0xA761}, - {"maps/mp/_trackrounds", 0xA762}, - {"maps/mp/_tridrone", 0xA763}, - {"maps/mp/_utility", 0xA764}, - {"maps/mp/_vl_base", 0xA765}, - {"maps/mp/_vl_camera", 0xA766}, - {"maps/mp/_vl_firingrange", 0xA767}, - {"maps/mp/_vl_selfiebooth", 0xA768}, - {"maps/mp/_water", 0xA769}, - {"maps/mp/_zipline", 0xA76A}, - {"maps/mp/mp_comeback_fx", 0xA76B}, - {"maps/mp/mp_comeback_precache", 0xA76C}, - {"maps/mp/mp_detroit_fx", 0xA76D}, - {"maps/mp/mp_detroit_precache", 0xA76E}, - {"maps/mp/mp_greenband_precache", 0xA770}, - {"maps/mp/mp_instinct_fx", 0xA771}, - {"maps/mp/mp_instinct_precache", 0xA772}, - {"maps/mp/mp_lab2_fx", 0xA773}, - {"maps/mp/mp_lab2_precache", 0xA774}, - {"maps/mp/mp_laser2_fx", 0xA775}, - {"maps/mp/mp_laser2_precache", 0xA776}, - {"maps/mp/mp_levity_fx", 0xA777}, - {"maps/mp/mp_levity_precache", 0xA778}, - {"maps/mp/mp_prison_fx", 0xA779}, - {"maps/mp/mp_prison_precache", 0xA77A}, - {"maps/mp/mp_prison_z_fx", 0xA77B}, - {"maps/mp/mp_prison_z_precache", 0xA77C}, - {"maps/mp/mp_recovery_fx", 0xA77D}, - {"maps/mp/mp_recovery_precache", 0xA77E}, - {"maps/mp/mp_refraction_fx", 0xA77F}, - {"maps/mp/mp_refraction_precache", 0xA780}, - {"maps/mp/mp_solar_fx", 0xA781}, - {"maps/mp/mp_solar_precache", 0xA782}, - {"maps/mp/mp_terrace_fx", 0xA783}, - {"maps/mp/mp_terrace_precache", 0xA784}, - {"maps/mp/mp_venus_fx", 0xA785}, - {"maps/mp/mp_venus_precache", 0xA786}, - {"maps/mp/mp_vlobby_room_fx", 0xA787}, - {"maps/mp/mp_vlobby_room_precache", 0xA788}, - {"maps/mp/gametypes/_battlebuddy", 0xA789}, - {"maps/mp/gametypes/_battlechatter_mp", 0xA78A}, - {"maps/mp/gametypes/_class", 0xA78B}, - {"maps/mp/gametypes/_clientids", 0xA78C}, - {"maps/mp/gametypes/_damage", 0xA78D}, - {"maps/mp/gametypes/_damagefeedback", 0xA78E}, - {"maps/mp/gametypes/_deathicons", 0xA78F}, - {"maps/mp/gametypes/_dev", 0xA790}, - {"maps/mp/gametypes/_equipment", 0xA791}, - {"maps/mp/gametypes/_friendicons", 0xA792}, - {"maps/mp/gametypes/_gamelogic", 0xA793}, - {"maps/mp/gametypes/_gameobjects", 0xA794}, - {"maps/mp/gametypes/_gamescores", 0xA795}, - {"maps/mp/gametypes/_globalentities", 0xA796}, - {"maps/mp/gametypes/_globallogic", 0xA797}, - {"maps/mp/gametypes/_hardpoints", 0xA798}, - {"maps/mp/gametypes/_healthoverlay", 0xA799}, - {"maps/mp/gametypes/_high_jump_mp", 0xA79A}, - {"maps/mp/gametypes/_horde_armory", 0xA79B}, - {"maps/mp/gametypes/_horde_crates", 0xA79C}, - {"maps/mp/gametypes/_horde_dialog", 0xA79D}, - {"maps/mp/gametypes/_horde_drones", 0xA79E}, - {"maps/mp/gametypes/_horde_laststand", 0xA79F}, - {"maps/mp/gametypes/_horde_sentry", 0xA7A0}, - {"maps/mp/gametypes/_horde_smart_grenade", 0xA7A1}, - {"maps/mp/gametypes/_horde_util", 0xA7A2}, - {"maps/mp/gametypes/_horde_zombies", 0xA7A3}, - {"maps/mp/gametypes/_hostmigration", 0xA7A4}, - {"maps/mp/gametypes/_hud", 0xA7A5}, - {"maps/mp/gametypes/_hud_message", 0xA7A6}, - {"maps/mp/gametypes/_hud_util", 0xA7A7}, - {"maps/mp/gametypes/_killcam", 0xA7A8}, - {"maps/mp/gametypes/_menus", 0xA7A9}, - {"maps/mp/gametypes/_missions", 0xA7AA}, - {"maps/mp/gametypes/_music_and_dialog", 0xA7AB}, - {"maps/mp/gametypes/_objpoints", 0xA7AC}, - {"maps/mp/gametypes/_orbital", 0xA7AD}, - {"maps/mp/gametypes/_persistence", 0xA7AE}, - {"maps/mp/gametypes/_player_boost_jump_mp", 0xA7AF}, - {"maps/mp/gametypes/_playercards", 0xA7B0}, - {"maps/mp/gametypes/_playerlogic", 0xA7B1}, - {"maps/mp/gametypes/_portable_radar", 0xA7B2}, - {"maps/mp/gametypes/_quickmessages", 0xA7B3}, - {"maps/mp/gametypes/_rank", 0xA7B4}, - {"maps/mp/gametypes/_scrambler", 0xA7B5}, - {"maps/mp/gametypes/_serversettings", 0xA7B6}, - {"maps/mp/gametypes/_shellshock", 0xA7B7}, - {"maps/mp/gametypes/_spawnfactor", 0xA7B8}, - {"maps/mp/gametypes/_spawnlogic", 0xA7B9}, - {"maps/mp/gametypes/_spawnscoring", 0xA7BA}, - {"maps/mp/gametypes/_spectating", 0xA7BB}, - {"maps/mp/gametypes/_teams", 0xA7BC}, - {"maps/mp/gametypes/_tweakables", 0xA7BD}, - {"maps/mp/gametypes/_weapons", 0xA7BE}, - {"maps/mp/killstreaks/_aerial_utility", 0xA7BF}, - {"maps/mp/killstreaks/_agent_killstreak", 0xA7C0}, - {"maps/mp/killstreaks/_airdrop", 0xA7C1}, - {"maps/mp/killstreaks/_airstrike", 0xA7C2}, - {"maps/mp/killstreaks/_assaultdrone_ai", 0xA7C3}, - {"maps/mp/killstreaks/_autosentry", 0xA7C4}, - {"maps/mp/killstreaks/_coop_util", 0xA7C5}, - {"maps/mp/killstreaks/_dog_killstreak", 0xA7C6}, - {"maps/mp/killstreaks/_drone_assault", 0xA7C7}, - {"maps/mp/killstreaks/_drone_carepackage", 0xA7C8}, - {"maps/mp/killstreaks/_drone_common", 0xA7C9}, - {"maps/mp/killstreaks/_drone_recon", 0xA7CA}, - {"maps/mp/killstreaks/_emp", 0xA7CB}, - {"maps/mp/killstreaks/_juggernaut", 0xA7CC}, - {"maps/mp/killstreaks/_killstreaks", 0xA7CD}, - {"maps/mp/killstreaks/_killstreaks_init", 0xA7CE}, - {"maps/mp/killstreaks/_marking_util", 0xA7CF}, - {"maps/mp/killstreaks/_missile_strike", 0xA7D0}, - {"maps/mp/killstreaks/_nuke", 0xA7D1}, - {"maps/mp/killstreaks/_orbital_carepackage", 0xA7D2}, - {"maps/mp/killstreaks/_orbital_strike", 0xA7D3}, - {"maps/mp/killstreaks/_orbital_util", 0xA7D4}, - {"maps/mp/killstreaks/_orbitalsupport", 0xA7D5}, - {"maps/mp/killstreaks/_placeable", 0xA7D6}, - {"maps/mp/killstreaks/_remoteturret", 0xA7D7}, - {"maps/mp/killstreaks/_rippedturret", 0xA7D8}, - {"maps/mp/killstreaks/_teamammorefill", 0xA7D9}, - {"maps/mp/killstreaks/_uav", 0xA7DA}, - {"maps/mp/killstreaks/_warbird", 0xA7DB}, - {"maps/mp/killstreaks/streak_mp_comeback", 0xA7DC}, - {"maps/mp/killstreaks/streak_mp_detroit", 0xA7DD}, - {"maps/mp/killstreaks/streak_mp_instinct", 0xA7DE}, - {"maps/mp/killstreaks/streak_mp_laser2", 0xA7DF}, - {"maps/mp/killstreaks/streak_mp_prison", 0xA7E0}, - {"maps/mp/killstreaks/streak_mp_recovery", 0xA7E1}, - {"maps/mp/killstreaks/streak_mp_refraction", 0xA7E2}, - {"maps/mp/killstreaks/streak_mp_solar", 0xA7E3}, - {"maps/mp/killstreaks/streak_mp_terrace", 0xA7E4}, - {"maps/mp/perks/_perkfunctions", 0xA7E5}, - {"maps/mp/perks/_perks", 0xA7E6}, - }; -} diff --git a/src/client/game/scripting/functions.cpp b/src/client/game/scripting/functions.cpp index b4d67cb6..c7f697e8 100644 --- a/src/client/game/scripting/functions.cpp +++ b/src/client/game/scripting/functions.cpp @@ -1,57 +1,39 @@ #include #include "functions.hpp" +#include "../../component/console.hpp" +#include "../../component/gsc.hpp" + +#include +#include +#include + #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()) + auto first = xsk::gsc::h1::resolver::function_id; + auto second = xsk::gsc::h1::resolver::method_id; + if (!prefer_global) { - return function_entry->second; + std::swap(first, second); } - function_entry = secondary_map.find(target); - if (function_entry != secondary_map.end()) + const auto first_res = first(target); + if (first_res) { - return function_entry->second; + return first_res; + } + + const auto second_res = second(target); + if (second_res) + { + return second_res; } return -1; @@ -59,15 +41,12 @@ namespace scripting script_function get_function_by_index(const unsigned index) { - static const auto function_table = SELECT_VALUE(0xB8CC510_b, 0xAC83820_b); - static const auto method_table = SELECT_VALUE(0xB8CDD60_b, 0xAC85070_b); - - if (index < 0x30A) + if (index < 0x1000) { - return reinterpret_cast(function_table)[index - 1]; + return reinterpret_cast(gsc::func_table)[index - 1]; } - return reinterpret_cast(method_table)[index - 0x8000]; + return reinterpret_cast(gsc::meth_table)[index - 0x8000]; } unsigned int parse_token_id(const std::string& name) @@ -86,32 +65,17 @@ namespace scripting } } - std::vector find_token(unsigned int id) + std::string find_token(unsigned int id) { - std::vector results; - - results.push_back(utils::string::va("_id_%X", id)); - results.push_back(utils::string::va("_ID%i", id)); - - for (const auto& token : token_map) - { - if (token.second == id) - { - results.push_back(token.first); - break; - } - } - - return results; + return xsk::gsc::h1::resolver::token_name(static_cast(id)); } unsigned int find_token_id(const std::string& name) { - const auto result = token_map.find(name); - - if (result != token_map.end()) + const auto result = xsk::gsc::h1::resolver::token_id(name); + if (result) { - return result->second; + return result; } const auto parsed_id = parse_token_id(name); @@ -126,7 +90,10 @@ namespace scripting script_function find_function(const std::string& name, const bool prefer_global) { const auto index = find_function_index(name, prefer_global); - if (index < 0) return nullptr; + if (index < 0) + { + return nullptr; + } return get_function_by_index(index); } diff --git a/src/client/game/scripting/functions.hpp b/src/client/game/scripting/functions.hpp index 95c51763..0685a92e 100644 --- a/src/client/game/scripting/functions.hpp +++ b/src/client/game/scripting/functions.hpp @@ -3,13 +3,9 @@ namespace scripting { - extern std::unordered_map method_map; - extern std::unordered_map function_map; - extern std::unordered_map token_map; - using script_function = void(*)(game::scr_entref_t); - std::vector find_token(unsigned int id); + std::string find_token(unsigned int id); unsigned int find_token_id(const std::string& name); script_function find_function(const std::string& name, const bool prefer_global); diff --git a/src/client/game/scripting/lua/context.cpp b/src/client/game/scripting/lua/context.cpp index 0546a8c1..3acf9d9d 100644 --- a/src/client/game/scripting/lua/context.cpp +++ b/src/client/game/scripting/lua/context.cpp @@ -12,6 +12,10 @@ #include "../../../component/fastfiles.hpp" #include "../../../component/scheduler.hpp" +#include +#include +#include + #include #include #include @@ -215,9 +219,10 @@ namespace scripting::lua auto entity_type = state.new_usertype("entity"); - for (const auto& func : method_map) + for (const auto& func : xsk::gsc::h1::resolver::get_methods()) { - const auto name = utils::string::to_lower(func.first); + const auto func_name = std::string(func.first); + const auto name = utils::string::to_lower(func_name); entity_type[name.data()] = [name](const entity& entity, const sol::this_state s, sol::variadic_args va) { std::vector arguments{}; @@ -334,9 +339,10 @@ namespace scripting::lua auto game_type = state.new_usertype("game_"); state["game"] = game(); - for (const auto& func : function_map) + for (const auto& func : xsk::gsc::h1::resolver::get_functions()) { - const auto name = utils::string::to_lower(func.first); + const auto func_name = std::string(func.first); + const auto name = utils::string::to_lower(func_name); game_type[name] = [name](const game&, const sol::this_state s, sol::variadic_args va) { std::vector arguments{}; @@ -467,18 +473,18 @@ namespace scripting::lua const std::string function_name, const sol::protected_function& function) { const auto pos = get_function_pos(filename, function_name); - logfile::vm_execute_hooks[pos] = function; + logfile::set_lua_hook(pos, function); auto detour = sol::table::create(function.lua_state()); detour["disable"] = [pos]() { - logfile::vm_execute_hooks.erase(pos); + logfile::clear_hook(pos); }; - detour["enable"] = [pos, function]() + detour["enable"] = [&]() { - logfile::vm_execute_hooks[pos] = function; + logfile::set_lua_hook(pos, function); }; detour["invoke"] = sol::overload( diff --git a/src/client/game/scripting/lua/value_conversion.cpp b/src/client/game/scripting/lua/value_conversion.cpp index a12abc8e..3beb6fb3 100644 --- a/src/client/game/scripting/lua/value_conversion.cpp +++ b/src/client/game/scripting/lua/value_conversion.cpp @@ -120,11 +120,10 @@ namespace scripting::lua game::VariableValue convert_function(sol::lua_value value) { const auto function = value.as(); - const auto index = reinterpret_cast(logfile::vm_execute_hooks.size()); + const auto index = reinterpret_cast(logfile::get_hook_count() + 1); + logfile::set_lua_hook(index, function); - logfile::vm_execute_hooks[index] = function; - - game::VariableValue func; + game::VariableValue func{}; func.type = game::SCRIPT_FUNCTION; func.u.codePosValue = index; diff --git a/src/client/game/symbols.hpp b/src/client/game/symbols.hpp index 1bc6c1f2..5c0d94ac 100644 --- a/src/client/game/symbols.hpp +++ b/src/client/game/symbols.hpp @@ -108,6 +108,7 @@ namespace game WEAK symbol G_GivePlayerWeapon{0x2F24F0, 0x461600}; WEAK symbol G_InitializeAmmo{0x29D9E0, 0x41C170}; + WEAK symbol G_LogPrintf{0x5FEF0, 0x4215C0}; WEAK symbol G_SelectWeapon{0x2F2EA0, 0x462560}; WEAK symbol G_TakePlayerWeapon{0x2F3050, 0x462770}; @@ -150,6 +151,8 @@ namespace game WEAK symbol VM_Execute{0x3C9E50, 0x510EB0}; + WEAK symbol Scr_AddString{0x3C7B20, 0x50EC50}; + WEAK symbol Scr_NotifyId{0x3C92E0, 0x510340}; WEAK symbol Scr_AllocVector{0x3C42D0, 0x50B330}; @@ -160,6 +163,12 @@ namespace game WEAK symbol Scr_GetEntityIdRef{0x3C6760, 0x50D8E0}; WEAK symbol Scr_GetEntityId{0x3C66B0, 0x50D830}; WEAK symbol Scr_SetObjectField{0x2E8FC0, 0x459CD0}; + WEAK symbol Scr_ErrorInternal{0x3C7F60, 0x50F0D0}; + + WEAK symbol Scr_LoadScript{0x3BDF70, 0x504FA0}; + WEAK symbol Scr_GetFunctionHandle{0x3BDE00, 0x504E30}; + WEAK symbol Scr_ExecThread{0x3C7FE0, 0x50F150}; + WEAK symbol Scr_RegisterFunction{0x3BD860, 0x504840}; WEAK symbol ScrPlace_GetViewPlacement{0x1BCED0, 0x362840}; WEAK symbol ScrPlace_HiResGetScaleX{0x0, 0x362910}; @@ -171,6 +180,13 @@ namespace game WEAK symbol DB_GetXAssetTypeSize{0x0, 0x0}; WEAK symbol DB_FindXAssetHeader{0x1F1120, 0x3950C0}; + + WEAK symbol DB_IsXAssetDefault{0x1F25A0, 0x3968C0}; + WEAK symbol DB_XAssetExists{0x1F6290, 0x39B7B0}; + + WEAK symbol DB_GetRawFileLen{0x1F1F40, 0x3961B0}; + WEAK symbol DB_GetRawBuffer{0x1F1E00, 0x396080}; + WEAK symbol DB_FileExists{0x1F0D50, 0x394DC0}; WEAK symbol DB_LoadXAssets{0x1F31E0, 0x397500}; WEAK symbol DB_IsLocalized{0x1F23C0, 0x396790}; @@ -279,6 +295,8 @@ namespace game WEAK symbol threadIds{0xB896210, 0xAC80740}; + WEAK symbol level_time{0x56DBAA0, 0x7361F9C}; + namespace mp { WEAK symbol g_entities{0x0, 0x71F19E0}; diff --git a/src/common/utils/string.cpp b/src/common/utils/string.cpp index 42486cf3..422adc76 100644 --- a/src/common/utils/string.cpp +++ b/src/common/utils/string.cpp @@ -36,9 +36,9 @@ namespace utils::string std::string to_lower(std::string text) { - std::transform(text.begin(), text.end(), text.begin(), [](const char input) + std::transform(text.begin(), text.end(), text.begin(), [](const unsigned char input) { - return static_cast(tolower(input)); + return static_cast(std::tolower(input)); }); return text; @@ -46,9 +46,9 @@ namespace utils::string std::string to_upper(std::string text) { - std::transform(text.begin(), text.end(), text.begin(), [](const char input) + std::transform(text.begin(), text.end(), text.begin(), [](const unsigned char input) { - return static_cast(toupper(input)); + return static_cast(std::toupper(input)); }); return text; @@ -131,8 +131,6 @@ namespace utils::string *out = '\0'; } -#pragma warning(push) -#pragma warning(disable: 4100) std::string convert(const std::wstring& wstr) { std::string result; @@ -158,7 +156,6 @@ namespace utils::string return result; } -#pragma warning(pop) std::string replace(std::string str, const std::string& from, const std::string& to) {