diff --git a/.gitattributes b/.gitattributes index dfe0770..1ff0c42 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,63 @@ -# Auto detect text files and perform LF normalization +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### * text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..130a33a --- /dev/null +++ b/.gitignore @@ -0,0 +1,150 @@ +### Windows + +# Windows image file caches +Thumbs.db +ehthumbs.db + +# Folder config file +Desktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msm +*.msp + +# Shortcuts +*.lnk + +### OSX + +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + +# Thumbnails +._* + +# Files that might appear on external disk +.Spotlight-V100 +.Trashes + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### Visual Studio + +# User-specific files +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +build + +# Visual Studio 2015 cache/options directory +.vs/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +*_i.c +*_p.c +*_i.h +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.pfx +*.publishsettings + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +*.mdf +*.ldf + +### IDA +*.id0 +*.id1 +*.id2 +*.nam +*.til + +### Custom user files +# User scripts +user*.bat + +# Premake binary +#premake5.exe \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..f5fb961 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,12 @@ +[submodule "deps/minhook"] + path = deps/minhook + url = https://github.com/TsudaKageyu/minhook.git +[submodule "deps/GSL"] + path = deps/GSL + url = https://github.com/microsoft/GSL.git +[submodule "deps/sol2"] + path = deps/sol2 + url = https://github.com/ThePhD/sol2.git +[submodule "deps/lua"] + path = deps/lua + url = https://github.com/lua/lua.git diff --git a/README.md b/README.md new file mode 100644 index 0000000..4781ba2 --- /dev/null +++ b/README.md @@ -0,0 +1,111 @@ +# iw5-script + +Lua scripting support for Plutonium IW5 + +Works the same as it does in [IW6x](https://github.com/XLabsProject/iw6x-client/wiki/Scripting) + +# How + +* Download the latest version from the Releases tab +* Copy it to `%localappdata%/Plutonium/storage/iw5/plugins/` +* Create a `__init__.lua` file in a folder with a name of your choice in `%localappdata%/Plutonium/storage/iw5/scripts/` +* Example `%localappdata%/Plutonium/storage/iw5/scripts/myscript/__init__.lua` +* Run the server (preferably with the `-no-scripting` flag to disable ChaiScript) + +Below are some features that are not available or documented in IW6x + +# Chat notifies +```lua +level:onnotify("say", function(player, message) + print(player.name .. " said: " .. message) +end) +``` +or +```lua +level:onnotify("connected", function(player) + player:onnotify("say", function(message) + print(player.name .. " said: " .. message) + end) +end) +``` + +# Player damage/killed callbacks + +Callbacks can be added using the `game:onplayerkilled` or `game:onplayerdamage` functions: + +Damage can be changed by returning it + +Returning anything other than a number will not do anything (must be an integer) + +```lua +game:onplayerdamage(function(_self, inflictor, attacker, damage, dflags, mod, weapon, point, dir, hitloc) + damage = 0 + + return damage +end) +``` +```lua +game:onplayerkilled(function(_self, inflictor, attacker, damage, mod, weapon, dir, hitloc, timeoffset, deathanimduration) + print(attacker.name .. " killed " .. _self.name) +end) +``` + +# Arrays +GSC arrays are supported and can be accessed similarly to gsc: +```lua +local ents = game:getentarray() + +for i = 1, #ents do + print(ents[i]) +end + +``` + +# Structs +GSC structs are also supported similarly as the arrays. + +To get an entity's struct use the `getstruct` method: +```lua +local levelstruct = level:getstruct() + +levelstruct.inGracePeriod = 10000 +``` +Structs in other variables like arrays are automatically converted: +```lua +level:onnotify("connected", function(player) + player:onnotify("spawned_player", function() + player.pers.killstreaks[1].streakName = "ac130" + player.pers.killstreaks[1].available = 1 + end) +end) +``` + +Note: you cannot create new struct fields but only modify or read existing ones, same thing for arrays + +# Functions + +You can call (will not work for every function) functions and methods within the game's gsc scripts using the + +`scriptcall(filename, function, ...)` method: +```lua +level:onnotify("connected", function(player) + player:onnotify("spawned_player", function() + local hudelem = player:scriptcall("maps/mp/gametypes/_hud_utils", "createFontString", 1) + + hudelem:scriptcall("maps/mp/gametypes/_hud_util", "setPoint", "CENTER", nil, 100, 100) + hudelem.label = "&Hello world" + end) +end) +``` +Functions in variables such as structs or arrays will be automatically converted to a lua function. + +The first argument must always be the entity to call the function on (level, player...) +```lua +local levelstruct = level:getstruct() + +level:onnotify("connected", function(player) + player:onnotify("spawned_player", function() + levelstruct.killstreakFuncs["ac130"](player) + end) +end) +``` diff --git a/deps/GSL b/deps/GSL new file mode 160000 index 0000000..c1cbb41 --- /dev/null +++ b/deps/GSL @@ -0,0 +1 @@ +Subproject commit c1cbb41b428f15e53454682a45f03ea31f1da0a7 diff --git a/deps/minhook b/deps/minhook new file mode 160000 index 0000000..423d1e4 --- /dev/null +++ b/deps/minhook @@ -0,0 +1 @@ +Subproject commit 423d1e45af2ed2719a5c31e990e935ef301ed9c3 diff --git a/deps/premake/gsl.lua b/deps/premake/gsl.lua new file mode 100644 index 0000000..7a2daf6 --- /dev/null +++ b/deps/premake/gsl.lua @@ -0,0 +1,19 @@ +gsl = { + source = path.join(dependencies.basePath, "GSL"), +} + +function gsl.import() + gsl.includes() +end + +function gsl.includes() + includedirs { + path.join(gsl.source, "include") + } +end + +function gsl.project() + +end + +table.insert(dependencies, gsl) diff --git a/deps/premake/minhook.lua b/deps/premake/minhook.lua new file mode 100644 index 0000000..396d4d3 --- /dev/null +++ b/deps/premake/minhook.lua @@ -0,0 +1,31 @@ +minhook = { + source = path.join(dependencies.basePath, "minhook"), +} + +function minhook.import() + links { "minhook" } + minhook.includes() +end + +function minhook.includes() + includedirs { + path.join(minhook.source, "include") + } +end + +function minhook.project() + project "minhook" + language "C" + + minhook.includes() + + files { + path.join(minhook.source, "src/**.h"), + path.join(minhook.source, "src/**.c"), + } + + warnings "Off" + kind "StaticLib" +end + +table.insert(dependencies, minhook) diff --git a/generate.bat b/generate.bat new file mode 100644 index 0000000..58ba509 --- /dev/null +++ b/generate.bat @@ -0,0 +1,2 @@ +@echo off +tools\windows\premake5.exe vs2019 \ No newline at end of file diff --git a/premake5.lua b/premake5.lua new file mode 100644 index 0000000..be1423b --- /dev/null +++ b/premake5.lua @@ -0,0 +1,90 @@ +dependencies = { + basePath = "./deps" +} + +function dependencies.load() + dir = path.join(dependencies.basePath, "premake/*.lua") + deps = os.matchfiles(dir) + + for i, dep in pairs(deps) do + dep = dep:gsub(".lua", "") + require(dep) + end +end + +function dependencies.imports() + for i, proj in pairs(dependencies) do + if type(i) == 'number' then + proj.import() + end + end +end + +function dependencies.projects() + for i, proj in pairs(dependencies) do + if type(i) == 'number' then + proj.project() + end + end +end + +dependencies.load() + +workspace "iw5-gsc-utils" + location "./build" + objdir "%{wks.location}/obj/%{cfg.buildcfg}" + targetdir "%{wks.location}/bin/%{cfg.buildcfg}" + targetname "%{prj.name}" + + language "C++" + + architecture "x86" + + buildoptions "/std:c++latest" + systemversion "latest" + + flags + { + "NoIncrementalLink", + "MultiProcessorCompile", + } + + configurations { "Debug", "Release", } + + symbols "On" + + configuration "Release" + optimize "Full" + defines { "NDEBUG" } + configuration{} + + configuration "Debug" + optimize "Debug" + defines { "DEBUG", "_DEBUG" } + configuration {} + + startproject "iw5-gsc-utils" + + project "iw5-gsc-utils" + kind "SharedLib" + language "C++" + + pchheader "stdinc.hpp" + pchsource "src/stdinc.cpp" + + includedirs + { + "src" + } + + files + { + "src/**.h", + "src/**.hpp", + "src/**.cpp" + } + + dependencies.imports() + + group "Dependencies" + dependencies.projects() diff --git a/src/component/gsc.cpp b/src/component/gsc.cpp new file mode 100644 index 0000000..2f1cb44 --- /dev/null +++ b/src/component/gsc.cpp @@ -0,0 +1,244 @@ +#include +#include "loader/component_loader.hpp" +#include "scheduler.hpp" + +#include "game/scripting/event.hpp" +#include "game/scripting/execution.hpp" +#include "game/scripting/functions.hpp" + +namespace gsc +{ + using function_args = std::vector; + + using builtin_function = void(*)(); + using builtin_method = void(*)(game::scr_entref_t); + + using script_function = std::function; + using script_method = std::function; + + std::unordered_map functions; + std::unordered_map methods; + + namespace + { + void gsc_function_stub(game::scr_entref_t ent) + { + /*const auto function = scripting::script_value(*game::scr_VmPub->top); + + if (!function.is()) + { + return; + } + + const auto function_str = function.as(); + + if (gsc_functions.find(function_str) != gsc_functions.end()) + { + std::vector arguments; + + for (auto i = 1; i < game::scr_VmPub->outparamcount; i++) + { + const auto value = game::scr_VmPub->top[-i]; + + arguments.emplace_back(value); + } + + const auto value = gsc_functions[function_str](ent, arguments); + if (*reinterpret_cast(&value)) + { + game::Scr_ClearOutParams(); + scripting::push_value(value); + } + }*/ + } + + std::string method_name(unsigned int id) + { + const auto map = *game::plutonium::method_map_rev; + + for (const auto& function : map) + { + if (function.second == id) + { + return function.first; + } + } + + return {}; + } + + std::string function_name(unsigned int id) + { + const auto map = *game::plutonium::function_map_rev; + + for (const auto& function : map) + { + if (function.second == id) + { + return function.first; + } + } + + return {}; + } + + function_args get_arguments() + { + function_args args; + + const auto top = game::scr_VmPub->top; + + for (auto i = 0; i < game::scr_VmPub->outparamcount; i++) + { + const auto value = game::scr_VmPub->top[i]; + args.push_back(value); + } + + return args; + } + + auto function_map_start = 0x200; + auto method_map_start = 0x8400; + + void call_function(unsigned int id) + { + if (id >= 0x200) + { + try + { + const auto result = functions[id](get_arguments()); + scripting::push_value(result); + } + catch (std::exception e) + { + printf("************** Script execution error **************\n"); + printf("Error executing function %s\n", function_name(id).data()); + printf("%s\n", e.what()); + printf("****************************************************\n"); + } + + } + else + { + reinterpret_cast(0x1D6EB34)[id](); + } + } + + void call_method(game::scr_entref_t ent, unsigned int id) + { + if (id >= 0x8400) + { + try + { + const auto result = methods[id](ent, get_arguments()); + scripting::push_value(result); + } + catch (std::exception e) + { + printf("************** Script execution error **************\n"); + printf("Error executing method %s\n", method_name(id).data()); + printf("%s\n", e.what()); + printf("****************************************************\n"); + } + + } + else + { + reinterpret_cast(0x1D4F258)[id](ent); + } + } + + __declspec(naked) void call_builtin_stub() + { + __asm + { + push eax + + mov eax, 0x20B4A5C + mov [eax], esi + + mov eax, 0x20B4A90 + mov [eax], edx + + pop eax + + pushad + push eax + call call_function + pop eax + popad + + push 0x56C900 + retn + } + } + + __declspec(naked) void call_builtin_method_stub() + { + __asm + { + pushad + push ecx + push ebx + call call_method + pop ebx + pop ecx + popad + + push ebx + add esp, 0xC + + push 0x56CBE9 + retn + } + } + } + + namespace function + { + void add(const std::string& name, const script_function& func) + { + const auto index = function_map_start++; + + functions[index] = func; + (*game::plutonium::function_map_rev)[name] = index; + } + } + + namespace method + { + void add(const std::string& name, const script_method& func) + { + const auto index = method_map_start++; + + methods[index] = func; + (*game::plutonium::method_map_rev)[name] = index; + } + } + + class component final : public component_interface + { + public: + void post_unpack() override + { + function::add("lol", [](function_args args) -> scripting::script_value + { + const auto str = args[0].as(); + + return str; + }); + + method::add("test", [](game::scr_entref_t, function_args args) -> scripting::script_value + { + printf("here\n"); + + return {}; + }); + + utils::hook::jump(0x56C8EB, call_builtin_stub); + utils::hook::jump(0x56CBDC, call_builtin_method_stub); + } + }; +} + +REGISTER_COMPONENT(gsc::component) \ No newline at end of file diff --git a/src/component/notifies.cpp b/src/component/notifies.cpp new file mode 100644 index 0000000..0404e89 --- /dev/null +++ b/src/component/notifies.cpp @@ -0,0 +1,58 @@ +#include +#include "loader/component_loader.hpp" +#include "scheduler.hpp" + +#include "game/scripting/entity.hpp" +#include "game/scripting/execution.hpp" +#include "notifies.hpp" + +namespace notifies +{ + namespace + { + utils::hook::detour client_command_hook; + + utils::hook::detour scr_player_killed_hook; + utils::hook::detour scr_player_damage_hook; + + void client_command_stub(int clientNum) + { + char cmd[1024] = { 0 }; + + game::SV_Cmd_ArgvBuffer(0, cmd, 1024); + + if (cmd == "say"s) + { + std::string message = game::ConcatArgs(1); + message.erase(0, 1); + + scheduler::once([message, clientNum]() + { + const scripting::entity level{*game::levelEntityId}; + const auto _player = scripting::call("getEntByNum", {clientNum}); + + if (_player.get_raw().type == game::SCRIPT_OBJECT) + { + const auto player = _player.as(); + + scripting::notify(level, "say", {player, message}); + scripting::notify(player, "say", {message}); + } + }); + } + + return client_command_hook.invoke(clientNum); + } + } + + class component final : public component_interface + { + public: + void post_unpack() override + { + client_command_hook.create(0x502CB0, client_command_stub); + } + }; +} + +REGISTER_COMPONENT(notifies::component) \ No newline at end of file diff --git a/src/component/notifies.hpp b/src/component/notifies.hpp new file mode 100644 index 0000000..8663b8a --- /dev/null +++ b/src/component/notifies.hpp @@ -0,0 +1,5 @@ +#pragma once + +namespace notifies +{ +} \ No newline at end of file diff --git a/src/component/scheduler.cpp b/src/component/scheduler.cpp new file mode 100644 index 0000000..88f43f1 --- /dev/null +++ b/src/component/scheduler.cpp @@ -0,0 +1,83 @@ +#include +#include "loader/component_loader.hpp" + +namespace scheduler +{ + namespace + { + std::queue> tasks; + + struct task + { + std::function handler; + std::chrono::milliseconds interval{}; + std::chrono::high_resolution_clock::time_point last_call{}; + }; + + utils::concurrent_list callbacks; + + void execute() + { + for (auto callback : callbacks) + { + const auto now = std::chrono::high_resolution_clock::now(); + const auto diff = now - callback->last_call; + + if (diff < callback->interval) continue; + + callback->last_call = now; + + const auto res = callback->handler(); + if (res) + { + callbacks.remove(callback); + } + } + } + + void server_frame() + { + execute(); + reinterpret_cast(0x50C1E0)(); + } + } + + void schedule(const std::function& callback, const std::chrono::milliseconds delay) + { + task task; + task.handler = callback; + task.interval = delay; + task.last_call = std::chrono::high_resolution_clock::now(); + + callbacks.add(task); + } + + void loop(const std::function& callback, const std::chrono::milliseconds delay) + { + schedule([callback]() + { + callback(); + return false; + }, delay); + } + + void once(const std::function& callback, const std::chrono::milliseconds delay) + { + schedule([callback]() + { + callback(); + return true; + }, delay); + } + + class component final : public component_interface + { + public: + void post_unpack() override + { + utils::hook::call(0x50CEDC, server_frame); + } + }; +} + +REGISTER_COMPONENT(scheduler::component) \ No newline at end of file diff --git a/src/component/scheduler.hpp b/src/component/scheduler.hpp new file mode 100644 index 0000000..7014cd7 --- /dev/null +++ b/src/component/scheduler.hpp @@ -0,0 +1,10 @@ +#pragma once + +namespace scheduler +{ + void schedule(const std::function& callback, std::chrono::milliseconds delay = 0ms); + void loop(const std::function& callback, std::chrono::milliseconds delay = 0ms); + void once(const std::function& callback, std::chrono::milliseconds delay = 0ms); + + void init(); +} diff --git a/src/component/scripting.cpp b/src/component/scripting.cpp new file mode 100644 index 0000000..782de82 --- /dev/null +++ b/src/component/scripting.cpp @@ -0,0 +1,139 @@ +#include +#include "loader/component_loader.hpp" + +#include "scheduler.hpp" + +#include "game/scripting/event.hpp" +#include "game/scripting/execution.hpp" +#include "game/scripting/functions.hpp" + +namespace scripting +{ + std::unordered_map> fields_table; + std::unordered_map> script_function_table; + + namespace + { + utils::hook::detour vm_notify_hook; + utils::hook::detour scr_add_class_field_hook; + + utils::hook::detour scr_load_level_hook; + utils::hook::detour g_shutdown_game_hook; + + utils::hook::detour scr_emit_function_hook; + utils::hook::detour scr_end_load_scripts_hook; + + void vm_notify_stub(const unsigned int notify_list_owner_id, const unsigned int string_value, + game::VariableValue* top) + { + const auto* name = game::SL_ConvertToString(string_value); + + if (name) + { + event e; + e.name = name; + e.entity = notify_list_owner_id; + + for (auto* value = top; value->type != game::SCRIPT_END; --value) + { + e.arguments.emplace_back(*value); + } + + if (e.name == "connected") + { + scripting::clear_entity_fields(e.entity); + } + } + + vm_notify_hook.invoke(notify_list_owner_id, string_value, top); + } + + void scr_add_class_field_stub(unsigned int classnum, unsigned int _name, unsigned int canonicalString, unsigned int offset) + { + const auto name = game::SL_ConvertToString(_name); + + if (fields_table[classnum].find(name) == fields_table[classnum].end()) + { + fields_table[classnum][name] = offset; + } + + scr_add_class_field_hook.invoke(classnum, _name, canonicalString, offset); + } + + void scr_load_level_stub() + { + scr_load_level_hook.invoke(); + } + + void g_shutdown_game_stub(const int free_scripts) + { + g_shutdown_game_hook.invoke(free_scripts); + } + + char* function_pos(unsigned int filename, unsigned int name) + { + const auto scripts_pos = *reinterpret_cast(0x1D6EB14); + + const auto v2 = game::FindVariable(scripts_pos, filename); + + const auto v3 = game::FindObject(scripts_pos, v2); + const auto v4 = game::FindVariable(v3, name); + + if (!v2 || !v3 || !v4) + { + return 0; + } + + return utils::hook::invoke(0x5659C0, v3, v4); + } + + void scr_emit_function_stub(unsigned int filename, unsigned int threadName, char* codePos) + { + const auto* name = game::SL_ConvertToString(filename); + const auto filename_id = atoi(name); + + for (const auto& entry : scripting::file_list) + { + if (entry.first == filename_id) + { + if (script_function_table.find(entry.second) == script_function_table.end()) + { + script_function_table[entry.second] = {}; + } + + for (const auto& token : scripting::token_map) + { + if (token.second == threadName) + { + const auto pos = function_pos(filename, threadName); + + if (pos) + { + script_function_table[entry.second][token.first] = pos; + } + } + } + } + } + + scr_emit_function_hook.invoke(filename, threadName, codePos); + } + } + + class component final : public component_interface + { + public: + void post_unpack() override + { + scr_load_level_hook.create(0x527AF0, scr_load_level_stub); + g_shutdown_game_hook.create(0x50C100, g_shutdown_game_stub); + + scr_add_class_field_hook.create(0x567CD0, scr_add_class_field_stub); + //vm_notify_hook.create(0x569720, vm_notify_stub); + + //scr_emit_function_hook.create(0x561400, scr_emit_function_stub); + } + }; +} + +REGISTER_COMPONENT(scripting::component) \ No newline at end of file diff --git a/src/component/scripting.hpp b/src/component/scripting.hpp new file mode 100644 index 0000000..21e9445 --- /dev/null +++ b/src/component/scripting.hpp @@ -0,0 +1,7 @@ +#pragma once + +namespace scripting +{ + extern std::unordered_map> fields_table; + extern std::unordered_map> script_function_table; +} \ No newline at end of file diff --git a/src/dllmain.cpp b/src/dllmain.cpp new file mode 100644 index 0000000..207cb45 --- /dev/null +++ b/src/dllmain.cpp @@ -0,0 +1,12 @@ +#include +#include "loader/component_loader.hpp" + +BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) +{ + if (ul_reason_for_call == DLL_PROCESS_ATTACH) + { + component_loader::post_unpack(); + } + + return TRUE; +} \ No newline at end of file diff --git a/src/game/game.cpp b/src/game/game.cpp new file mode 100644 index 0000000..931724d --- /dev/null +++ b/src/game/game.cpp @@ -0,0 +1,6 @@ +#include + +namespace game +{ + +} diff --git a/src/game/game.hpp b/src/game/game.hpp new file mode 100644 index 0000000..e52eef9 --- /dev/null +++ b/src/game/game.hpp @@ -0,0 +1,34 @@ +#pragma once + +namespace game +{ + template + class symbol + { + public: + symbol(const size_t dedi) + : dedi_(reinterpret_cast(dedi)) + { + } + + T* get() const + { + return dedi_; + } + + operator T* () const + { + return this->get(); + } + + T* operator->() const + { + return this->get(); + } + + private: + T* dedi_; + }; +} + +#include "symbols.hpp" \ No newline at end of file diff --git a/src/game/scripting/entity.cpp b/src/game/scripting/entity.cpp new file mode 100644 index 0000000..6ded7df --- /dev/null +++ b/src/game/scripting/entity.cpp @@ -0,0 +1,115 @@ +#include +#include "entity.hpp" +#include "script_value.hpp" +#include "execution.hpp" + +namespace scripting +{ + entity::entity() + : entity(0) + { + } + + entity::entity(const entity& other) : entity(other.entity_id_) + { + } + + entity::entity(entity&& other) noexcept + { + this->entity_id_ = other.entity_id_; + other.entity_id_ = 0; + } + + entity::entity(const unsigned int entity_id) + : entity_id_(entity_id) + { + this->add(); + } + + entity::~entity() + { + this->release(); + } + + entity& entity::operator=(const entity& other) + { + if (&other != this) + { + this->release(); + this->entity_id_ = other.entity_id_; + this->add(); + } + + return *this; + } + + entity& entity::operator=(entity&& other) noexcept + { + if (&other != this) + { + this->release(); + this->entity_id_ = other.entity_id_; + other.entity_id_ = 0; + } + + return *this; + } + + unsigned int entity::get_entity_id() const + { + return this->entity_id_; + } + + game::scr_entref_t entity::get_entity_reference() const + { + if (!this->entity_id_) + { + const auto not_null = static_cast(~0ui16); + return game::scr_entref_t{not_null, not_null}; + } + + return game::Scr_GetEntityIdRef(this->get_entity_id()); + } + + bool entity::operator==(const entity& other) const noexcept + { + return this->get_entity_id() == other.get_entity_id(); + } + + bool entity::operator!=(const entity& other) const noexcept + { + return !this->operator==(other); + } + + void entity::add() const + { + if (this->entity_id_) + { + game::AddRefToValue(game::SCRIPT_OBJECT, {static_cast(this->entity_id_)}); + } + } + + void entity::release() const + { + if (this->entity_id_) + { + game::RemoveRefToValue(game::SCRIPT_OBJECT, {static_cast(this->entity_id_)}); + } + } + + void entity::set(const std::string& field, const script_value& value) const + { + set_entity_field(*this, field, value); + } + + template <> + script_value entity::get(const std::string& field) const + { + return get_entity_field(*this, field); + } + + script_value entity::call(const std::string& name, const std::vector& arguments) const + { + return call_function(name, *this, arguments); + } +} diff --git a/src/game/scripting/entity.hpp b/src/game/scripting/entity.hpp new file mode 100644 index 0000000..76fd66c --- /dev/null +++ b/src/game/scripting/entity.hpp @@ -0,0 +1,49 @@ +#pragma once +#include "game/game.hpp" +#include "script_value.hpp" + +namespace scripting +{ + class entity final + { + public: + entity(); + entity(unsigned int entity_id); + + entity(const entity& other); + entity(entity&& other) noexcept; + + ~entity(); + + entity& operator=(const entity& other); + entity& operator=(entity&& other) noexcept; + + void set(const std::string& field, const script_value& value) const; + + template + T get(const std::string& field) const; + + script_value call(const std::string& name, const std::vector& arguments = {}) const; + + unsigned int get_entity_id() const; + game::scr_entref_t get_entity_reference() const; + + bool operator ==(const entity& other) const noexcept; + bool operator !=(const entity& other) const noexcept; + + private: + unsigned int entity_id_; + + void add() const; + void release() const; + }; + + template <> + script_value entity::get(const std::string& field) const; + + template + T entity::get(const std::string& field) const + { + return this->get(field).as(); + } +} diff --git a/src/game/scripting/event.hpp b/src/game/scripting/event.hpp new file mode 100644 index 0000000..bc1d53e --- /dev/null +++ b/src/game/scripting/event.hpp @@ -0,0 +1,13 @@ +#pragma once +#include "script_value.hpp" +#include "entity.hpp" + +namespace scripting +{ + struct event + { + std::string name; + entity entity{}; + std::vector arguments; + }; +} diff --git a/src/game/scripting/execution.cpp b/src/game/scripting/execution.cpp new file mode 100644 index 0000000..8275dfa --- /dev/null +++ b/src/game/scripting/execution.cpp @@ -0,0 +1,278 @@ +#include +#include "execution.hpp" +#include "safe_execution.hpp" +#include "stack_isolation.hpp" +#include "event.hpp" + +#include "component/scripting.hpp" +#include "component/scheduler.hpp" + +namespace scripting +{ + namespace + { + game::VariableValue* allocate_argument() + { + game::VariableValue* value_ptr = ++game::scr_VmPub->top; + ++game::scr_VmPub->inparamcount; + return value_ptr; + } + + script_value get_return_value() + { + if (game::scr_VmPub->inparamcount == 0) + { + return {}; + } + + game::Scr_ClearOutParams(); + game::scr_VmPub->outparamcount = game::scr_VmPub->inparamcount; + game::scr_VmPub->inparamcount = 0; + + return script_value(game::scr_VmPub->top[1 - game::scr_VmPub->outparamcount]); + } + + int get_field_id(const int classnum, const std::string& field) + { + if (scripting::fields_table[classnum].find(field) != scripting::fields_table[classnum].end()) + { + return scripting::fields_table[classnum][field]; + } + + return -1; + } + + void scr_notify_id(int id, unsigned int stringValue, unsigned int paramcount) + { + if (game::scr_VmPub->outparamcount) + { + game::Scr_ClearOutParams(); + } + + auto v6 = game::scr_VmPub->top; + auto v7 = game::scr_VmPub->inparamcount - paramcount; + auto v8 = &game::scr_VmPub->top[-paramcount]; + + if (id) + { + const auto v9 = v8->type; + v8->type = game::scriptType_e::SCRIPT_END; + + game::scr_VmPub->inparamcount = 0; + game::VM_Notify(id, stringValue, game::scr_VmPub->top); + + v8->type = v9; + v6 = game::scr_VmPub->top; + } + + for (; v6 != v8; game::scr_VmPub->top = v6) + { + game::RemoveRefToValue(v6->type, v6->u); + v6 = game::scr_VmPub->top - 1; + } + + game::scr_VmPub->inparamcount = v7; + } + } + + void push_value(const script_value& value) + { + auto* value_ptr = allocate_argument(); + *value_ptr = value.get_raw(); + + game::AddRefToValue(value_ptr->type, value_ptr->u); + } + + void notify(const entity& entity, const std::string& event, const std::vector& arguments) + { + stack_isolation _; + for (auto i = arguments.rbegin(); i != arguments.rend(); ++i) + { + push_value(*i); + } + + const auto event_id = game::SL_GetString(event.data(), 0); + scr_notify_id(entity.get_entity_id(), event_id, game::scr_VmPub->inparamcount); + } + + script_value call_function(const std::string& name, const entity& entity, + const std::vector& arguments) + { + const auto entref = entity.get_entity_reference(); + + const auto is_method_call = *reinterpret_cast(&entref) != -1; + const auto function = find_function(name, !is_method_call); + if (!function) + { + throw std::runtime_error("Unknown function '" + name + "'"); + } + + stack_isolation _; + + for (auto i = arguments.rbegin(); i != arguments.rend(); ++i) + { + push_value(*i); + } + + game::scr_VmPub->outparamcount = game::scr_VmPub->inparamcount; + game::scr_VmPub->inparamcount = 0; + + if (!safe_execution::call(function, entref)) + { + throw std::runtime_error("Error executing function '" + name + "'"); + } + + return get_return_value(); + } + + script_value call_function(const std::string& name, const std::vector& arguments) + { + return call_function(name, entity(), arguments); + } + + template <> + script_value call(const std::string& name, const std::vector& arguments) + { + return call_function(name, arguments); + } + + script_value exec_ent_thread(const entity& entity, const char* pos, const std::vector& arguments) + { + const auto id = entity.get_entity_id(); + + for (auto i = arguments.rbegin(); i != arguments.rend(); ++i) + { + push_value(*i); + } + + game::AddReftoObject(id); + + const auto local_id = game::AllocThread(id); + const auto result = game::VM_Execute(local_id, pos, arguments.size()); + + const auto value = get_return_value(); + + game::RemoveRefToValue(game::scr_VmPub->top->type, game::scr_VmPub->top->u); + game::scr_VmPub->top->type = (game::scriptType_e)0; + + --game::scr_VmPub->top; + --game::scr_VmPub->inparamcount; + + return value; + } + + script_value call_script_function(const entity& entity, const std::string& filename, + const std::string& function, const std::vector& arguments) + { + if (scripting::script_function_table.find(filename) == scripting::script_function_table.end()) + { + throw std::runtime_error("File '" + filename + "' not found"); + }; + + const auto functions = scripting::script_function_table[filename]; + + if (functions.find(function) == functions.end()) + { + throw std::runtime_error("Function '" + function + "' in file '" + filename + "' not found"); + } + + const auto pos = functions.at(function); + + return exec_ent_thread(entity, pos, arguments); + } + + static std::unordered_map> custom_fields; + + script_value get_custom_field(const entity& entity, const std::string& field) + { + auto fields = custom_fields[entity.get_entity_id()]; + const auto _field = fields.find(field); + if (_field != fields.end()) + { + return _field->second; + } + return {}; + } + + void set_custom_field(const entity& entity, const std::string& field, const script_value& value) + { + const auto id = entity.get_entity_id(); + + if (custom_fields[id].find(field) != custom_fields[id].end()) + { + custom_fields[id][field] = value; + return; + } + + custom_fields[id].insert(std::make_pair(field, value)); + } + + void clear_entity_fields(const entity& entity) + { + const auto id = entity.get_entity_id(); + + if (custom_fields.find(id) != custom_fields.end()) + { + custom_fields[id].clear(); + } + } + + void clear_custom_fields() + { + custom_fields.clear(); + } + + void set_entity_field(const entity& entity, const std::string& field, const script_value& value) + { + const auto entref = entity.get_entity_reference(); + const int id = get_field_id(entref.classnum, field); + + if (id != -1) + { + stack_isolation _; + push_value(value); + + game::scr_VmPub->outparamcount = game::scr_VmPub->inparamcount; + game::scr_VmPub->inparamcount = 0; + + if (!safe_execution::set_entity_field(entref, id)) + { + throw std::runtime_error("Failed to set value for field '" + field + "'"); + } + } + else + { + set_custom_field(entity, field, value); + } + } + + script_value get_entity_field(const entity& entity, const std::string& field) + { + const auto entref = entity.get_entity_reference(); + const auto id = get_field_id(entref.classnum, field); + + if (id != -1) + { + stack_isolation _; + + game::VariableValue value{}; + if (!safe_execution::get_entity_field(entref, id, &value)) + { + throw std::runtime_error("Failed to get value for field '" + field + "'"); + } + + const auto __ = gsl::finally([value]() + { + game::RemoveRefToValue(value.type, value.u); + }); + + return value; + } + else + { + return get_custom_field(entity, field); + } + + return {}; + } +} \ No newline at end of file diff --git a/src/game/scripting/execution.hpp b/src/game/scripting/execution.hpp new file mode 100644 index 0000000..cc9b80c --- /dev/null +++ b/src/game/scripting/execution.hpp @@ -0,0 +1,37 @@ +#pragma once +#include "game/game.hpp" +#include "entity.hpp" +#include "script_value.hpp" + +namespace scripting +{ + void push_value(const script_value& value); + + script_value call_function(const std::string& name, const std::vector& arguments); + script_value call_function(const std::string& name, const entity& entity, + const std::vector& arguments); + + template + T call(const std::string& name, const std::vector& arguments = {}); + + template <> + script_value call(const std::string& name, const std::vector& arguments); + + template + T call(const std::string& name, const std::vector& arguments) + { + return call(name, arguments).as(); + } + + script_value exec_ent_thread(const entity& entity, const char* pos, const std::vector& arguments); + script_value call_script_function(const entity& entity, const std::string& filename, + const std::string& function, const std::vector& arguments); + + void clear_entity_fields(const entity& entity); + void clear_custom_fields(); + + void set_entity_field(const entity& entity, const std::string& field, const script_value& value); + script_value get_entity_field(const entity& entity, const std::string& field); + + void notify(const entity& entity, const std::string& event, const std::vector& arguments); +} diff --git a/src/game/scripting/function_tables.cpp b/src/game/scripting/function_tables.cpp new file mode 100644 index 0000000..2672fde --- /dev/null +++ b/src/game/scripting/function_tables.cpp @@ -0,0 +1,7483 @@ +#include + +// https://github.com/xensik/gsc-tool/blob/dev/src/iw5/xsk/resolver.cpp :) + +namespace scripting +{ + std::unordered_map function_map = + { + {"precacheturret", 0x001}, + {"getweaponarray", 0x002}, + {"createprintchannel", 0x003}, + {"updategamerprofileall", 0x004}, + {"clearlocalizedstrings", 0x005}, + {"setphysicsgravitydir", 0x006}, + {"gettimescale", 0x007}, + {"settimescale", 0x008}, + {"setslowmotionview", 0x009}, + {"forcesharedammo", 0x00A}, + {"refreshhudcompass", 0x00B}, + {"refreshhudammocounter", 0x00C}, + {"notifyoncommand", 0x00D}, + {"setprintchannel", 0x00E}, + {"print", 0x00F}, + {"println", 0x010}, + {"print3d", 0x011}, + {"line", 0x012}, + {"spawnturret", 0x013}, + {"canspawnturret", 0x014}, + {"assert", 0x015}, + {"pausecinematicingame", 0x016}, + {"drawcompassfriendlies", 0x017}, + {"bulletspread", 0x018}, + {"bullettracer", 0x019}, + {"badplace_delete", 0x01A}, + {"badplace_cylinder", 0x01B}, + {"badplace_arc", 0x01C}, + {"badplace_brush", 0x01D}, + {"clearallcorpses", 0x01E}, + {"setturretnode", 0x01F}, + {"unsetturretnode", 0x020}, + {"setnodepriority", 0x021}, + {"isnodeoccupied", 0x022}, + {"setdebugorigin", 0x023}, + {"setdebugangles", 0x024}, + {"updategamerprofile", 0x025}, + {"assertex", 0x026}, + {"assertmsg", 0x027}, + {"isdefined", 0x028}, + {"isstring", 0x029}, + {"setdvar", 0x02A}, + {"setdynamicdvar", 0x02B}, + {"setdvarifuninitialized", 0x02C}, + {"setdevdvar", 0x02D}, + {"setdevdvarifuninitialized", 0x02E}, + {"getdvar", 0x02F}, + {"getdvarint", 0x030}, + {"getdvarfloat", 0x031}, + {"getdvarvector", 0x032}, + {"gettime", 0x033}, + {"getentbynum", 0x034}, + {"getweaponmodel", 0x035}, + {"getculldist", 0x036}, + {"sethalfresparticles", 0x037}, + {"getmapsunlight", 0x038}, + {"setsunlight", 0x039}, + {"resetsunlight", 0x03A}, + {"getmapsundirection", 0x03B}, + {"getmapsunangles", 0x03C}, + {"setsundirection", 0x03D}, + {"lerpsundirection", 0x03E}, + {"lerpsunangles", 0x03F}, + {"resetsundirection", 0x040}, + {"enableforcedsunshadows", 0x041}, + {"enableforcednosunshadows", 0x042}, + {"disableforcedsunshadows", 0x043}, + {"enableouterspacemodellighting", 0x044}, + {"disableouterspacemodellighting", 0x045}, + {"remapstage", 0x046}, + {"changelevel", 0x047}, + {"missionsuccess", 0x048}, + {"missionfailed", 0x049}, + {"cinematic", 0x04A}, + {"cinematicingame", 0x04B}, + {"cinematicingamesync", 0x04C}, + {"cinematicingameloop", 0x04D}, + {"cinematicingameloopresident", 0x04E}, + {"iscinematicplaying", 0x04F}, + {"stopcinematicingame", 0x050}, + {"getweaponhidetags", 0x051}, + {"getanimlength", 0x052}, + {"animhasnotetrack", 0x053}, + {"getnotetracktimes", 0x054}, + {"spawn", 0x055}, + {"spawnloopsound", 0x056}, + {"spawnloopingsound", 0x057}, + {"bullettrace", 0x058}, + {"target_setmaxsize", 0x059}, + {"target_setcolor", 0x05A}, + {"target_setdelay", 0x05B}, + {"getstartorigin", 0x05C}, + {"getstartangles", 0x05D}, + {"getcycleoriginoffset", 0x05E}, + {"magicgrenade", 0x05F}, + {"magicgrenademanual", 0x060}, + {"setblur", 0x061}, + {"musicplay", 0x062}, + {"musicstop", 0x063}, + {"soundfade", 0x064}, + {"soundsettimescalefactor", 0x065}, + {"soundresettimescale", 0x066}, + {"setocclusionpreset", 0x067}, + {"levelsoundfade", 0x068}, + {"precachenightvisioncodeassets", 0x069}, + {"precachedigitaldistortcodeassets", 0x06A}, + {"precacheminimapsentrycodeassets", 0x06B}, + {"savegame", 0x06C}, + {"issavesuccessful", 0x06D}, + {"issaverecentlyloaded", 0x06E}, + {"savegamenocommit", 0x06F}, + {"commitsave", 0x070}, + {"commitwouldbevalid", 0x071}, + {"getfxvisibility", 0x072}, + {"setculldist", 0x073}, + {"bullettracepassed", 0x074}, + {"sighttracepassed", 0x075}, + {"physicstrace", 0x076}, + {"playerphysicstrace", 0x077}, + {"getgroundposition", 0x078}, + {"getmovedelta", 0x079}, + {"getangledelta", 0x07A}, + {"getnorthyaw", 0x07B}, + {"getcommandfromkey", 0x07C}, + {"getsticksconfig", 0x07D}, + {"weaponfightdist", 0x07E}, + {"weaponmaxdist", 0x07F}, + {"isturretactive", 0x080}, + {"target_alloc", 0x081}, + {"target_flush", 0x082}, + {"target_set", 0x083}, + {"target_remove", 0x084}, + {"target_setshader", 0x085}, + {"target_setoffscreenshader", 0x086}, + {"target_isinrect", 0x087}, + {"target_isincircle", 0x088}, + {"target_startreticlelockon", 0x089}, + {"target_clearreticlelockon", 0x08A}, + {"target_getarray", 0x08B}, + {"target_istarget", 0x08C}, + {"target_setattackmode", 0x08D}, + {"target_setjavelinonly", 0x08E}, + {"target_hidefromplayer", 0x08F}, + {"target_showtoplayer", 0x090}, + {"target_setscaledrendermode", 0x091}, + {"target_drawcornersonly", 0x092}, + {"target_drawsquare", 0x093}, + {"target_drawsingle", 0x094}, + {"target_setminsize", 0x095}, + {"setnorthyaw", 0x096}, + {"setslowmotion", 0x097}, + {"randomint", 0x098}, + {"randomfloat", 0x099}, + {"randomintrange", 0x09A}, + {"randomfloatrange", 0x09B}, + {"sin", 0x09C}, + {"cos", 0x09D}, + {"tan", 0x09E}, + {"asin", 0x09F}, + {"acos", 0x0A0}, + {"atan", 0x0A1}, + {"int", 0x0A2}, + {"float", 0x0A3}, + {"abs", 0x0A4}, + {"min", 0x0A5}, + {"objective_additionalcurrent", 0x0A6}, + {"objective_ring", 0x0A7}, + {"objective_setpointertextoverride", 0x0A8}, + {"getnode", 0x0A9}, + {"getnodearray", 0x0AA}, + {"getallnodes", 0x0AB}, + {"getnodesinradius", 0x0AC}, + {"getnodesinradiussorted", 0x0AD}, + {"getclosestnodeinsight", 0x0AE}, + {"getreflectionlocs", 0x0AF}, + {"getreflectionreferencelocs", 0x0B0}, + {"getvehicletracksegment", 0x0B1}, + {"getvehicletracksegmentarray", 0x0B2}, + {"getallvehicletracksegments", 0x0B3}, + {"isarray", 0x0B4}, + {"isai", 0x0B5}, + {"issentient", 0x0B6}, + {"isgodmode", 0x0B7}, + {"getdebugdvar", 0x0B8}, + {"getdebugdvarint", 0x0B9}, + {"getdebugdvarfloat", 0x0BA}, + {"setsaveddvar", 0x0BB}, + {"getfreeaicount", 0x0BC}, + {"getaicount", 0x0BD}, + {"getaiarray", 0x0BE}, + {"getaispeciesarray", 0x0BF}, + {"getspawnerarray", 0x0C0}, + {"getcorpsearray", 0x0C1}, + {"getspawnerteamarray", 0x0C2}, + {"getweaponclipmodel", 0x0C3}, + {"getbrushmodelcenter", 0x0C4}, + {"getkeybinding", 0x0C5}, + {"max", 0x0C6}, + {"floor", 0x0C7}, + {"ceil", 0x0C8}, + {"exp", 0x0C9}, + {"log", 0x0CA}, + {"sqrt", 0x0CB}, + {"squared", 0x0CC}, + {"clamp", 0x0CD}, + {"angleclamp", 0x0CE}, + {"angleclamp180", 0x0CF}, + {"vectorfromlinetopoint", 0x0D0}, + {"pointonsegmentnearesttopoint", 0x0D1}, + {"distance", 0x0D2}, + {"distance2d", 0x0D3}, + {"distancesquared", 0x0D4}, + {"length", 0x0D5}, + {"lengthsquared", 0x0D6}, + {"closer", 0x0D7}, + {"vectordot", 0x0D8}, + {"visionsetthermal", 0x0D9}, + {"visionsetpain", 0x0DA}, + {"endlobby", 0x0DB}, + {"setac130ambience", 0x0DC}, + {"getmapcustom", 0x0DD}, + {"updateskill", 0x0DE}, + {"spawnsighttrace", 0x0DF}, + {"incrementcounter", 0x0E0}, + {"getcountertotal", 0x0E1}, + {"getlevelticks", 0x0E2}, + {"perlinnoise2d", 0x0E3}, + {"calcrockingangles", 0x0E4}, + {"sethudlighting", 0x0E5}, + {"reconevent", 0x0E6}, + {"reconspatialevent", 0x0E7}, + {"setsunflareposition", 0x0E8}, + {"createthreatbiasgroup", 0x0E9}, + {"threatbiasgroupexists", 0x0EA}, + {"getthreatbias", 0x0EB}, + {"setthreatbias", 0x0EC}, + {"setthreatbiasagainstall", 0x0ED}, + {"setignoremegroup", 0x0EE}, + {"isenemyteam", 0x0EF}, + {"objective_additionalentity", 0x0F0}, + {"objective_state_nomessage", 0x0F1}, + {"objective_string", 0x0F2}, + {"objective_string_nomessage", 0x0F3}, + {"objective_additionalposition", 0x0F4}, + {"objective_current_nomessage", 0x0F5}, + {"vectornormalize", 0x0F6}, + {"vectortoangles", 0x0F7}, + {"vectortoyaw", 0x0F8}, + {"vectorlerp", 0x0F9}, + {"anglestoup", 0x0FA}, + {"anglestoright", 0x0FB}, + {"anglestoforward", 0x0FC}, + {"combineangles", 0x0FD}, + {"transformmove", 0x0FE}, + {"issubstr", 0x0FF}, + {"isendstr", 0x100}, + {"getsubstr", 0x101}, + {"tolower", 0x102}, + {"strtok", 0x103}, + {"stricmp", 0x104}, + {"ambientplay", 0x105}, + {"getuavstrengthmax", 0x106}, + {"getuavstrengthlevelneutral", 0x107}, + {"getuavstrengthlevelshowenemyfastsweep", 0x108}, + {"getuavstrengthlevelshowenemydirectional", 0x109}, + {"blockteamradar", 0x10A}, + {"unblockteamradar", 0x10B}, + {"isteamradarblocked", 0x10C}, + {"getassignedteam", 0x10D}, + {"setmatchdata", 0x10E}, + {"getmatchdata", 0x10F}, + {"sendmatchdata", 0x110}, + {"clearmatchdata", 0x111}, + {"setmatchdatadef", 0x112}, + {"setmatchclientip", 0x113}, + {"setmatchdataid", 0x114}, + {"setclientmatchdata", 0x115}, + {"getclientmatchdata", 0x116}, + {"setclientmatchdatadef", 0x117}, + {"sendclientmatchdata", 0x118}, + {"getbuildversion", 0x119}, + {"getbuildnumber", 0x11A}, + {"getsystemtime", 0x11B}, + {"getmatchrulesdata", 0x11C}, + {"isusingmatchrulesdata", 0x11D}, + {"kick", 0x11E}, + {"issplitscreen", 0x11F}, + {"setmapcenter", 0x120}, + {"setgameendtime", 0x121}, + {"visionsetnaked", 0x122}, + {"visionsetnight", 0x123}, + {"visionsetmissilecam", 0x124}, + {"ambientstop", 0x125}, + {"precachemodel", 0x126}, + {"precacheshellshock", 0x127}, + {"precacheitem", 0x128}, + {"precacheshader", 0x129}, + {"precachestring", 0x12A}, + {"precachemenu", 0x12B}, + {"precacherumble", 0x12C}, + {"precachelocationselector", 0x12D}, + {"precacheleaderboards", 0x12E}, + {"loadfx", 0x12F}, + {"playfx", 0x130}, + {"playfxontag", 0x131}, + {"stopfxontag", 0x132}, + {"playloopedfx", 0x133}, + {"spawnfx", 0x134}, + {"triggerfx", 0x135}, + {"playfxontagforclients", 0x136}, + {"setwinningteam", 0x137}, + {"announcement", 0x138}, + {"clientannouncement", 0x139}, + {"getteamscore", 0x13A}, + {"setteamscore", 0x13B}, + {"setclientnamemode", 0x13C}, + {"updateclientnames", 0x13D}, + {"getteamplayersalive", 0x13E}, + {"logprint", 0x13F}, + {"worldentnumber", 0x140}, + {"obituary", 0x141}, + {"positionwouldtelefrag", 0x142}, + {"canspawn", 0x143}, + {"getstarttime", 0x144}, + {"precachestatusicon", 0x145}, + {"precacheheadicon", 0x146}, + {"precacheminimapicon", 0x147}, + {"precachempanim", 0x148}, + {"map_restart", 0x149}, + {"exitlevel", 0x14A}, + {"addtestclient", 0x14B}, + {"makedvarserverinfo", 0x14C}, + {"setarchive", 0x14D}, + {"allclientsprint", 0x14E}, + {"clientprint", 0x14F}, + {"mapexists", 0x150}, + {"isvalidgametype", 0x151}, + {"matchend", 0x152}, + {"setplayerteamrank", 0x153}, + {"endparty", 0x154}, + {"setteamradar", 0x155}, + {"getteamradar", 0x156}, + {"setteamradarstrength", 0x157}, + {"getteamradarstrength", 0x158}, + {"getuavstrengthmin", 0x159}, + {"physicsexplosionsphere", 0x15A}, + {"physicsexplosioncylinder", 0x15B}, + {"physicsjolt", 0x15C}, + {"physicsjitter", 0x15D}, + {"setexpfog", 0x15E}, + {"isexplosivedamagemod", 0x15F}, + {"radiusdamage", 0x160}, + {"setplayerignoreradiusdamage", 0x161}, + {"glassradiusdamage", 0x162}, + {"earthquake", 0x163}, + {"getnumparts", 0x164}, + {"objective_onentity", 0x165}, + {"objective_team", 0x166}, + {"objective_player", 0x167}, + {"objective_playerteam", 0x168}, + {"objective_playerenemyteam", 0x169}, + {"iprintln", 0x16A}, + {"iprintlnbold", 0x16B}, + {"logstring", 0x16C}, + {"getent", 0x16D}, + {"getentarray", 0x16E}, + {"spawnplane", 0x16F}, + {"spawnstruct", 0x170}, + {"spawnhelicopter", 0x171}, + {"isalive", 0x172}, + {"isspawner", 0x173}, + {"missile_createattractorent", 0x174}, + {"missile_createattractororigin", 0x175}, + {"missile_createrepulsorent", 0x176}, + {"missile_createrepulsororigin", 0x177}, + {"missile_deleteattractor", 0x178}, + {"playsoundatpos", 0x179}, + {"newhudelem", 0x17A}, + {"newclienthudelem", 0x17B}, + {"newteamhudelem", 0x17C}, + {"resettimeout", 0x17D}, + {"precachefxteamthermal", 0x17E}, + {"isplayer", 0x17F}, + {"isplayernumber", 0x180}, + {"setwinningplayer", 0x181}, + {"getpartname", 0x182}, + {"weaponfiretime", 0x183}, + {"weaponclipsize", 0x184}, + {"weaponisauto", 0x185}, + {"weaponissemiauto", 0x186}, + {"weaponisboltaction", 0x187}, + {"weaponinheritsperks", 0x188}, + {"weaponburstcount", 0x189}, + {"weapontype", 0x18A}, + {"weaponclass", 0x18B}, + {"getnextarraykey", 0x18C}, + {"sortbydistance", 0x18D}, + {"tablelookup", 0x18E}, + {"tablelookupbyrow", 0x18F}, + {"tablelookupistring", 0x190}, + {"tablelookupistringbyrow", 0x191}, + {"tablelookuprownum", 0x192}, + {"getmissileowner", 0x193}, + {"magicbullet", 0x194}, + {"getweaponflashtagname", 0x195}, + {"averagepoint", 0x196}, + {"averagenormal", 0x197}, + {"vehicle_getspawnerarray", 0x198}, + {"playrumbleonposition", 0x199}, + {"playrumblelooponposition", 0x19A}, + {"stopallrumbles", 0x19B}, + {"soundexists", 0x19C}, + {"openfile", 0x19D}, + {"closefile", 0x19E}, + {"fprintln", 0x19F}, + {"fprintfields", 0x1A0}, + {"freadln", 0x1A1}, + {"fgetarg", 0x1A2}, + {"setminimap", 0x1A3}, + {"setthermalbodymaterial", 0x1A4}, + {"getarraykeys", 0x1A5}, + {"getfirstarraykey", 0x1A6}, + {"getglass", 0x1A7}, + {"getglassarray", 0x1A8}, + {"getglassorigin", 0x1A9}, + {"isglassdestroyed", 0x1AA}, + {"destroyglass", 0x1AB}, + {"deleteglass", 0x1AC}, + {"getentchannelscount", 0x1AD}, + {"getentchannelname", 0x1AE}, + {"objective_add", 0x1AF}, + {"objective_delete", 0x1B0}, + {"objective_state", 0x1B1}, + {"objective_icon", 0x1B2}, + {"objective_position", 0x1B3}, + {"objective_current", 0x1B4}, + {"weaponinventorytype", 0x1B5}, + {"weaponstartammo", 0x1B6}, + {"weaponmaxammo", 0x1B7}, + {"weaponaltweaponname", 0x1B8}, + {"isweaponcliponly", 0x1B9}, + {"isweapondetonationtimed", 0x1BA}, + {"weaponhasthermalscope", 0x1BB}, + {"getvehiclenode", 0x1BC}, + {"getvehiclenodearray", 0x1BD}, + {"getallvehiclenodes", 0x1BE}, + {"getnumvehicles", 0x1BF}, + {"precachevehicle", 0x1C0}, + {"spawnvehicle", 0x1C1}, + {"vehicle_getarray", 0x1C2}, + {"gettimesincelastpaused", 0x1C3}, + {"setlasermaterial", 0x1C4}, + {"precachefxontag", 0x1C5}, + {"precachetag", 0x1C6}, + {"precachesound", 0x1C7}, + }; + + std::unordered_map method_map = + { + {"thermaldrawdisable", 0x8000}, + {"setturretdismountorg", 0x8001}, + {"setdamagestate", 0x8002}, + {"playsoundtoteam", 0x8003}, + {"playsoundtoplayer", 0x8004}, + {"playerhide", 0x8005}, + {"showtoplayer", 0x8006}, + {"enableplayeruse", 0x8007}, + {"disableplayeruse", 0x8008}, + {"makescrambler", 0x8009}, + {"makeportableradar", 0x800A}, + {"maketrophysystem", 0x800B}, + {"placespawnpoint", 0x800C}, + {"setteamfortrigger", 0x800D}, + {"clientclaimtrigger", 0x800E}, + {"clientreleasetrigger", 0x800F}, + {"releaseclaimedtrigger", 0x8010}, + {"isusingonlinedataoffline", 0x8011}, + {"getrestedtime", 0x8012}, + {"sendleaderboards", 0x8013}, + {"isonladder", 0x8014}, + {"getcorpseanim", 0x8015}, + {"playerforcedeathanim", 0x8016}, + {"attach", 0x8017}, + {"attachshieldmodel", 0x8018}, + {"getlightfovinner", 0x8019}, + {"getlightfovouter", 0x801A}, + {"setlightfovrange", 0x801B}, + {"getlightexponent", 0x801C}, + {"setlightexponent", 0x801D}, + {"startragdoll", 0x801E}, + {"startragdollfromimpact", 0x801F}, + {"logstring", 0x8020}, + {"laserhidefromclient", 0x8021}, + {"stopsoundchannel", 0x8022}, + {"thermaldrawenable", 0x8023}, + {"detach", 0x8024}, + {"detachshieldmodel", 0x8025}, + {"moveshieldmodel", 0x8026}, + {"detachall", 0x8027}, + {"getattachsize", 0x8028}, + {"getattachmodelname", 0x8029}, + {"getattachtagname", 0x802A}, + {"setturretcanaidetach", 0x802B}, + {"setturretfov", 0x802C}, + {"lerpfov", 0x802D}, + {"getvalidcoverpeekouts", 0x802E}, + {"gethighestnodestance", 0x802F}, + {"doesnodeallowstance", 0x8030}, + {"getgunangles", 0x8031}, + {"magicgrenade", 0x8032}, + {"magicgrenademanual", 0x8033}, + {"setfriendlychain", 0x8034}, + {"getentnum", 0x8035}, + {"launch", 0x8036}, + {"setsoundblend", 0x8037}, + {"makefakeai", 0x8038}, + {"spawndrone", 0x8039}, + {"setcorpseremovetimer", 0x803A}, + {"setlookattext", 0x803B}, + {"setspawnerteam", 0x803C}, + {"addaieventlistener", 0x803D}, + {"removeaieventlistener", 0x803E}, + {"getlightcolor", 0x803F}, + {"setlightcolor", 0x8040}, + {"getlightradius", 0x8041}, + {"setlightradius", 0x8042}, + {"getattachignorecollision", 0x8043}, + {"hidepart", 0x8044}, + {"hidepart_allinstances", 0x8045}, + {"hideallparts", 0x8046}, + {"showpart", 0x8047}, + {"showallparts", 0x8048}, + {"linkto", 0x8049}, + {"linktoblendtotag", 0x804A}, + {"unlink", 0x804B}, + {"setnormalhealth", 0x804C}, + {"dodamage", 0x804D}, + {"kill", 0x804E}, + {"show", 0x804F}, + {"hide", 0x8050}, + {"showonclient", 0x8051}, + {"hideonclient", 0x8052}, + {"laserforceon", 0x8053}, + {"laserforceoff", 0x8054}, + {"disconnectpaths", 0x8055}, + {"connectpaths", 0x8056}, + {"startusingheroonlylighting", 0x8057}, + {"stopusingheroonlylighting", 0x8058}, + {"startusinglessfrequentlighting", 0x8059}, + {"stopusinglessfrequentlighting", 0x805A}, + {"setthermalfog", 0x805B}, + {"setnightvisionfog", 0x805C}, + {"clearthermalfog", 0x805D}, + {"clearnightvisionfog", 0x805E}, + {"digitaldistortsetparams", 0x805F}, + {"setmode", 0x8060}, + {"getmode", 0x8061}, + {"setturretignoregoals", 0x8062}, + {"islinked", 0x8063}, + {"enablelinkto", 0x8064}, + {"playsoundatviewheight", 0x8065}, + {"prefetchsound", 0x8066}, + {"setpitch", 0x8067}, + {"scalepitch", 0x8068}, + {"setvolume", 0x8069}, + {"scalevolume", 0x806A}, + {"setspeakermapmonotostereo", 0x806B}, + {"setspeakermapmonoto51", 0x806C}, + {"setdistributed2dsound", 0x806D}, + {"playsoundasmaster", 0x806E}, + {"playloopsound", 0x806F}, + {"eqon", 0x8070}, + {"eqoff", 0x8071}, + {"haseq", 0x8072}, + {"iswaitingonsound", 0x8073}, + {"getnormalhealth", 0x8074}, + {"playerlinkto", 0x8075}, + {"playerlinktodelta", 0x8076}, + {"playerlinkweaponviewtodelta", 0x8077}, + {"playerlinktoabsolute", 0x8078}, + {"playerlinktoblend", 0x8079}, + {"playerlinkedoffsetenable", 0x807A}, + {"setwaypointedgestyle_secondaryarrow", 0x807B}, + {"setwaypointiconoffscreenonly", 0x807C}, + {"fadeovertime", 0x807D}, + {"scaleovertime", 0x807E}, + {"moveovertime", 0x807F}, + {"reset", 0x8080}, + {"destroy", 0x8081}, + {"setpulsefx", 0x8082}, + {"setplayernamestring", 0x8083}, + {"changefontscaleovertime", 0x8084}, + {"startignoringspotlight", 0x8085}, + {"stopignoringspotlight", 0x8086}, + {"dontcastshadows", 0x8087}, + {"castshadows", 0x8088}, + {"setstablemissile", 0x8089}, + {"playersetgroundreferenceent", 0x808A}, + {"dontinterpolate", 0x808B}, + {"dospawn", 0x808C}, + {"stalingradspawn", 0x808D}, + {"getorigin", 0x808E}, + {"getcentroid", 0x808F}, + {"getshootatpos", 0x8090}, + {"getdebugeye", 0x8091}, + {"useby", 0x8092}, + {"playsound", 0x8093}, + {"playerlinkedoffsetdisable", 0x8094}, + {"playerlinkedsetviewznear", 0x8095}, + {"playerlinkedsetusebaseangleforviewclamp", 0x8096}, + {"lerpviewangleclamp", 0x8097}, + {"setviewangleresistance", 0x8098}, + {"geteye", 0x8099}, + {"istouching", 0x809A}, + {"stoploopsound", 0x809B}, + {"stopsounds", 0x809C}, + {"playrumbleonentity", 0x809D}, + {"playrumblelooponentity", 0x809E}, + {"stoprumble", 0x809F}, + {"delete", 0x80A0}, + {"setmodel", 0x80A1}, + {"laseron", 0x80A2}, + {"laseroff", 0x80A3}, + {"laseraltviewon", 0x80A4}, + {"laseraltviewoff", 0x80A5}, + {"thermalvisionon", 0x80A6}, + {"thermalvisionoff", 0x80A7}, + {"thermalvisionfofoverlayon", 0x80A8}, + {"thermalvisionfofoverlayoff", 0x80A9}, + {"autospotoverlayon", 0x80AA}, + {"autospotoverlayoff", 0x80AB}, + {"setcontents", 0x80AC}, + {"makeusable", 0x80AD}, + {"makeunusable", 0x80AE}, + {"setwhizbyprobabilities", 0x80AF}, + {"visionsetnakedforplayer_lerp", 0x80B0}, + {"setwaitnode", 0x80B1}, + {"returnplayercontrol", 0x80B2}, + {"vehphys_starttrack", 0x80B3}, + {"vehphys_clearautodisable", 0x80B4}, + {"vehicleusealtblendedaudio", 0x80B5}, + {"settext", 0x80B6}, + {"clearalltextafterhudelem", 0x80B7}, + {"setshader", 0x80B8}, + {"settargetent", 0x80B9}, + {"cleartargetent", 0x80BA}, + {"settimer", 0x80BB}, + {"settimerup", 0x80BC}, + {"settimerstatic", 0x80BD}, + {"settenthstimer", 0x80BE}, + {"settenthstimerup", 0x80BF}, + {"settenthstimerstatic", 0x80C0}, + {"setclock", 0x80C1}, + {"setclockup", 0x80C2}, + {"setvalue", 0x80C3}, + {"setwaypoint", 0x80C4}, + {"setwaypointedgestyle_rotatingicon", 0x80C5}, + {"setcursorhint", 0x80C6}, + {"sethintstring", 0x80C7}, + {"forceusehinton", 0x80C8}, + {"forceusehintoff", 0x80C9}, + {"makesoft", 0x80CA}, + {"makehard", 0x80CB}, + {"willneverchange", 0x80CC}, + {"startfiring", 0x80CD}, + {"stopfiring", 0x80CE}, + {"isfiringturret", 0x80CF}, + {"startbarrelspin", 0x80D0}, + {"stopbarrelspin", 0x80D1}, + {"getbarrelspinrate", 0x80D2}, + {"remotecontrolturret", 0x80D3}, + {"remotecontrolturretoff", 0x80D4}, + {"shootturret", 0x80D5}, + {"getturretowner", 0x80D6}, + {"enabledeathshield", 0x80D7}, + {"nightvisiongogglesforceon", 0x80D8}, + {"nightvisiongogglesforceoff", 0x80D9}, + {"enableinvulnerability", 0x80DA}, + {"disableinvulnerability", 0x80DB}, + {"enablebreaching", 0x80DC}, + {"disablebreaching", 0x80DD}, + {"forceviewmodelanimation", 0x80DE}, + {"disableturretdismount", 0x80DF}, + {"enableturretdismount", 0x80E0}, + {"uploadscore", 0x80E1}, + {"uploadtime", 0x80E2}, + {"uploadleaderboards", 0x80E3}, + {"giveachievement", 0x80E4}, + {"hidehud", 0x80E5}, + {"showhud", 0x80E6}, + {"mountvehicle", 0x80E7}, + {"dismountvehicle", 0x80E8}, + {"enableslowaim", 0x80E9}, + {"disableslowaim", 0x80EA}, + {"usehintsinvehicle", 0x80EB}, + {"vehicleattackbuttonpressed", 0x80EC}, + {"setwhizbyoffset", 0x80ED}, + {"setsentryowner", 0x80EE}, + {"setsentrycarrier", 0x80EF}, + {"setturretminimapvisible", 0x80F0}, + {"settargetentity", 0x80F1}, + {"snaptotargetentity", 0x80F2}, + {"cleartargetentity", 0x80F3}, + {"getturrettarget", 0x80F4}, + {"setplayerspread", 0x80F5}, + {"setaispread", 0x80F6}, + {"setsuppressiontime", 0x80F7}, + {"setflaggedanimknobrestart", 0x80F8}, + {"setflaggedanimknoblimitedrestart", 0x80F9}, + {"setflaggedanimknoball", 0x80FA}, + {"setflaggedanimknoballrestart", 0x80FB}, + {"setflaggedanim", 0x80FC}, + {"setflaggedanimlimited", 0x80FD}, + {"setflaggedanimrestart", 0x80FE}, + {"setflaggedanimlimitedrestart", 0x80FF}, + {"useanimtree", 0x8100}, + {"stopuseanimtree", 0x8101}, + {"setanimtime", 0x8102}, + {"showviewmodel", 0x8103}, + {"hideviewmodel", 0x8104}, + {"allowstand", 0x8105}, + {"allowcrouch", 0x8106}, + {"allowprone", 0x8107}, + {"allowlean", 0x8108}, + {"setocclusion", 0x8109}, + {"deactivateocclusion", 0x810A}, + {"isocclusionenabled", 0x810B}, + {"iseqenabled", 0x810C}, + {"seteq", 0x810D}, + {"seteqbands", 0x810E}, + {"deactivateeq", 0x810F}, + {"seteqlerp", 0x8110}, + {"islookingat", 0x8111}, + {"isthrowinggrenade", 0x8112}, + {"isfiring", 0x8113}, + {"ismeleeing", 0x8114}, + {"setautopickup", 0x8115}, + {"allowmelee", 0x8116}, + {"allowfire", 0x8117}, + {"enablehealthshield", 0x8118}, + {"setconvergencetime", 0x8119}, + {"setconvergenceheightpercent", 0x811A}, + {"setturretteam", 0x811B}, + {"maketurretsolid", 0x811C}, + {"maketurretoperable", 0x811D}, + {"maketurretinoperable", 0x811E}, + {"makeentitysentient", 0x811F}, + {"freeentitysentient", 0x8120}, + {"isindoor", 0x8121}, + {"getdroptofloorposition", 0x8122}, + {"isbadguy", 0x8123}, + {"animscripted", 0x8124}, + {"animscriptedthirdperson", 0x8125}, + {"animrelative", 0x8126}, + {"stopanimscripted", 0x8127}, + {"clearanim", 0x8128}, + {"setanimknob", 0x8129}, + {"setanimknoblimited", 0x812A}, + {"setanimknobrestart", 0x812B}, + {"setanimknoblimitedrestart", 0x812C}, + {"setanimknoball", 0x812D}, + {"setanimknoballlimited", 0x812E}, + {"setanimknoballrestart", 0x812F}, + {"setanimknoballlimitedrestart", 0x8130}, + {"setanim", 0x8131}, + {"setanimlimited", 0x8132}, + {"setanimrestart", 0x8133}, + {"setanimlimitedrestart", 0x8134}, + {"getanimtime", 0x8135}, + {"getanimweight", 0x8136}, + {"getanimassettype", 0x8137}, + {"setflaggedanimknob", 0x8138}, + {"setflaggedanimknoblimited", 0x8139}, + {"setturretaccuracy", 0x813A}, + {"setrightarc", 0x813B}, + {"setleftarc", 0x813C}, + {"settoparc", 0x813D}, + {"setbottomarc", 0x813E}, + {"setautorotationdelay", 0x813F}, + {"setdefaultdroppitch", 0x8140}, + {"restoredefaultdroppitch", 0x8141}, + {"turretfiredisable", 0x8142}, + {"getfixednodesafevolume", 0x8143}, + {"clearfixednodesafevolume", 0x8144}, + {"isingoal", 0x8145}, + {"setruntopos", 0x8146}, + {"nearnode", 0x8147}, + {"nearclaimnode", 0x8148}, + {"nearclaimnodeandangle", 0x8149}, + {"atdangerousnode", 0x814A}, + {"getenemyinfo", 0x814B}, + {"clearenemy", 0x814C}, + {"setentitytarget", 0x814D}, + {"clearentitytarget", 0x814E}, + {"setpotentialthreat", 0x814F}, + {"clearpotentialthreat", 0x8150}, + {"setflashbanged", 0x8151}, + {"setengagementmindist", 0x8152}, + {"setengagementmaxdist", 0x8153}, + {"isknownenemyinradius", 0x8154}, + {"isknownenemyinvolume", 0x8155}, + {"settalktospecies", 0x8156}, + {"laseralton", 0x8157}, + {"laseraltoff", 0x8158}, + {"invisiblenotsolid", 0x8159}, + {"visiblesolid", 0x815A}, + {"setdefaultaimlimits", 0x815B}, + {"initriotshieldhealth", 0x815C}, + {"getenemysqdist", 0x815D}, + {"getclosestenemysqdist", 0x815E}, + {"setthreatbiasgroup", 0x815F}, + {"getthreatbiasgroup", 0x8160}, + {"turretfireenable", 0x8161}, + {"setturretmodechangewait", 0x8162}, + {"usetriggerrequirelookat", 0x8163}, + {"getstance", 0x8164}, + {"setstance", 0x8165}, + {"itemweaponsetammo", 0x8166}, + {"getammocount", 0x8167}, + {"gettagorigin", 0x8168}, + {"gettagangles", 0x8169}, + {"shellshock", 0x816A}, + {"stunplayer", 0x816B}, + {"stopshellshock", 0x816C}, + {"fadeoutshellshock", 0x816D}, + {"setdepthoffield", 0x816E}, + {"setviewmodeldepthoffield", 0x816F}, + {"setmotionblurmovescale", 0x8170}, + {"pickupgrenade", 0x8171}, + {"useturret", 0x8172}, + {"stopuseturret", 0x8173}, + {"canuseturret", 0x8174}, + {"traversemode", 0x8175}, + {"animmode", 0x8176}, + {"orientmode", 0x8177}, + {"getmotionangle", 0x8178}, + {"shouldfacemotion", 0x8179}, + {"getanglestolikelyenemypath", 0x817A}, + {"setturretanim", 0x817B}, + {"getturret", 0x817C}, + {"getgroundenttype", 0x817D}, + {"animcustom", 0x817E}, + {"isinscriptedstate", 0x817F}, + {"canattackenemynode", 0x8180}, + {"getnegotiationstartnode", 0x8181}, + {"getnegotiationendnode", 0x8182}, + {"getdoorpathnode", 0x8183}, + {"comparenodedirtopathdir", 0x8184}, + {"checkprone", 0x8185}, + {"pushplayer", 0x8186}, + {"checkgrenadethrowpos", 0x8187}, + {"setgoalnode", 0x8188}, + {"setgoalpos", 0x8189}, + {"setgoalentity", 0x818A}, + {"setgoalvolume", 0x818B}, + {"setgoalvolumeauto", 0x818C}, + {"getgoalvolume", 0x818D}, + {"cleargoalvolume", 0x818E}, + {"setfixednodesafevolume", 0x818F}, + {"setmotionblurturnscale", 0x8190}, + {"setmotionblurzoomscale", 0x8191}, + {"viewkick", 0x8192}, + {"localtoworldcoords", 0x8193}, + {"getentitynumber", 0x8194}, + {"getentityvelocity", 0x8195}, + {"enablegrenadetouchdamage", 0x8196}, + {"disablegrenadetouchdamage", 0x8197}, + {"enableaimassist", 0x8198}, + {"setlookatyawlimits", 0x8199}, + {"stoplookat", 0x819A}, + {"getmuzzlepos", 0x819B}, + {"getmuzzleangle", 0x819C}, + {"getmuzzlesideoffsetpos", 0x819D}, + {"getaimangle", 0x819E}, + {"canshoot", 0x819F}, + {"canshootenemy", 0x81A0}, + {"cansee", 0x81A1}, + {"seerecently", 0x81A2}, + {"lastknowntime", 0x81A3}, + {"lastknownpos", 0x81A4}, + {"dropweapon", 0x81A5}, + {"maymovetopoint", 0x81A6}, + {"maymovefrompointtopoint", 0x81A7}, + {"teleport", 0x81A8}, + {"forceteleport", 0x81A9}, + {"safeteleport", 0x81AA}, + {"withinapproxpathdist", 0x81AB}, + {"ispathdirect", 0x81AC}, + {"allowedstances", 0x81AD}, + {"isstanceallowed", 0x81AE}, + {"issuppressionwaiting", 0x81AF}, + {"issuppressed", 0x81B0}, + {"ismovesuppressed", 0x81B1}, + {"isgrenadepossafe", 0x81B2}, + {"checkgrenadethrow", 0x81B3}, + {"checkgrenadelaunch", 0x81B4}, + {"checkgrenadelaunchpos", 0x81B5}, + {"throwgrenade", 0x81B6}, + {"disableaimassist", 0x81B7}, + {"radiusdamage", 0x81B8}, + {"detonate", 0x81B9}, + {"damageconetrace", 0x81BA}, + {"sightconetrace", 0x81BB}, + {"missile_settargetent", 0x81BC}, + {"missile_settargetpos", 0x81BD}, + {"missile_cleartarget", 0x81BE}, + {"missile_setflightmodedirect", 0x81BF}, + {"missile_setflightmodetop", 0x81C0}, + {"getlightintensity", 0x81C1}, + {"setlightintensity", 0x81C2}, + {"isragdoll", 0x81C3}, + {"setmovespeedscale", 0x81C4}, + {"cameralinkto", 0x81C5}, + {"cameraunlink", 0x81C6}, + {"startcoverarrival", 0x81C7}, + {"starttraversearrival", 0x81C8}, + {"checkcoverexitposwithpath", 0x81C9}, + {"shoot", 0x81CA}, + {"shootblank", 0x81CB}, + {"melee", 0x81CC}, + {"updateplayersightaccuracy", 0x81CD}, + {"findshufflecovernode", 0x81CE}, + {"findnearbycovernode", 0x81CF}, + {"findcovernode", 0x81D0}, + {"findbestcovernode", 0x81D1}, + {"getcovernode", 0x81D2}, + {"usecovernode", 0x81D3}, + {"iscovervalidagainstenemy", 0x81D4}, + {"reacquirestep", 0x81D5}, + {"findreacquiredirectpath", 0x81D6}, + {"trimpathtoattack", 0x81D7}, + {"reacquiremove", 0x81D8}, + {"findreacquireproximatepath", 0x81D9}, + {"flagenemyunattackable", 0x81DA}, + {"enterprone", 0x81DB}, + {"exitprone", 0x81DC}, + {"setproneanimnodes", 0x81DD}, + {"updateprone", 0x81DE}, + {"clearpitchorient", 0x81DF}, + {"setlookatanimnodes", 0x81E0}, + {"setlookat", 0x81E1}, + {"setlookatentity", 0x81E2}, + {"controlslinkto", 0x81E3}, + {"controlsunlink", 0x81E4}, + {"makevehiclesolidcapsule", 0x81E5}, + {"makevehiclesolidsphere", 0x81E6}, + {"makevehiclesolid", 0x81E7}, + {"remotecontrolvehicle", 0x81E8}, + {"remotecontrolvehicleoff", 0x81E9}, + {"isfiringvehicleturret", 0x81EA}, + {"drivevehicleandcontrolturret", 0x81EB}, + {"drivevehicleandcontrolturretoff", 0x81EC}, + {"getplayersetting", 0x81ED}, + {"getlocalplayerprofiledata", 0x81EE}, + {"setlocalplayerprofiledata", 0x81EF}, + {"remotecamerasoundscapeon", 0x81F0}, + {"remotecamerasoundscapeoff", 0x81F1}, + {"radarjamon", 0x81F2}, + {"radarjamoff", 0x81F3}, + {"setmotiontrackervisible", 0x81F4}, + {"getmotiontrackervisible", 0x81F5}, + {"worldpointinreticle_circle", 0x81F6}, + {"getpointinbounds", 0x81F7}, + {"transfermarkstonewscriptmodel", 0x81F8}, + {"setwatersheeting", 0x81F9}, + {"setweaponhudiconoverride", 0x81FA}, + {"getweaponhudiconoverride", 0x81FB}, + {"setempjammed", 0x81FC}, + {"playersetexpfog", 0x81FD}, + {"isitemunlocked", 0x81FE}, + {"getplayerdata", 0x81FF}, + {"vehicleturretcontroloff", 0x8200}, + {"isturretready", 0x8201}, + {"vehicledriveto", 0x8202}, + {"dospawn", 0x8203}, + {"isphysveh", 0x8204}, + {"phys_crash", 0x8205}, + {"phys_launch", 0x8206}, + {"phys_disablecrashing", 0x8207}, + {"phys_enablecrashing", 0x8208}, + {"phys_setspeed", 0x8209}, + {"phys_setconveyerbelt", 0x820A}, + {"freehelicopter", 0x820B}, + {"playerlinkedturretanglesenable", 0x820C}, + {"playerlinkedturretanglesdisable", 0x820D}, + {"playersetstreamorigin", 0x820E}, + {"playerclearstreamorigin", 0x820F}, + {"nightvisionviewon", 0x8210}, + {"nightvisionviewoff", 0x8211}, + {"painvisionon", 0x8212}, + {"painvisionoff", 0x8213}, + {"getplayerintelisfound", 0x8214}, + {"setplayerintelfound", 0x8215}, + {"newpip", 0x8216}, + {"sethuddynlight", 0x8217}, + {"startscriptedanim", 0x8218}, + {"startcoverbehavior", 0x8219}, + {"setplayerdata", 0x821A}, + {"trackerupdate", 0x821B}, + {"pingplayer", 0x821C}, + {"buttonpressed", 0x821D}, + {"sayall", 0x821E}, + {"sayteam", 0x821F}, + {"showscoreboard", 0x8220}, + {"setspawnweapon", 0x8221}, + {"dropitem", 0x8222}, + {"dropscavengerbag", 0x8223}, + {"setjitterparams", 0x8224}, + {"sethoverparams", 0x8225}, + {"joltbody", 0x8226}, + {"freevehicle", 0x8227}, + {"getwheelsurface", 0x8228}, + {"getvehicleowner", 0x8229}, + {"setvehiclelookattext", 0x822A}, + {"setvehicleteam", 0x822B}, + {"setneargoalnotifydist", 0x822C}, + {"setvehgoalpos", 0x822D}, + {"setgoalyaw", 0x822E}, + {"cleargoalyaw", 0x822F}, + {"settargetyaw", 0x8230}, + {"cleartargetyaw", 0x8231}, + {"vehicle_helisetai", 0x8232}, + {"setturrettargetvec", 0x8233}, + {"setturrettargetent", 0x8234}, + {"clearturrettarget", 0x8235}, + {"vehicle_canturrettargetpoint", 0x8236}, + {"setlookatent", 0x8237}, + {"clearlookatent", 0x8238}, + {"setvehweapon", 0x8239}, + {"fireweapon", 0x823A}, + {"vehicleturretcontrolon", 0x823B}, + {"finishplayerdamage", 0x823C}, + {"suicide", 0x823D}, + {"closeingamemenu", 0x823E}, + {"iprintln", 0x823F}, + {"iprintlnbold", 0x8240}, + {"spawn", 0x8241}, + {"setentertime", 0x8242}, + {"cloneplayer", 0x8243}, + {"istalking", 0x8244}, + {"allowspectateteam", 0x8245}, + {"getguid", 0x8246}, + {"physicslaunchserver", 0x8247}, + {"physicslaunchserveritem", 0x8248}, + {"clonebrushmodeltoscriptmodel", 0x8249}, + {"scriptmodelplayanim", 0x824A}, + {"scriptmodelclearanim", 0x824B}, + {"vehicle_teleport", 0x824C}, + {"attachpath", 0x824D}, + {"getattachpos", 0x824E}, + {"startpath", 0x824F}, + {"setswitchnode", 0x8250}, + {"setwaitspeed", 0x8251}, + {"vehicle_finishdamage", 0x8252}, + {"vehicle_setspeed", 0x8253}, + {"vehicle_setspeedimmediate", 0x8254}, + {"vehicle_rotateyaw", 0x8255}, + {"vehicle_getspeed", 0x8256}, + {"vehicle_getvelocity", 0x8257}, + {"vehicle_getbodyvelocity", 0x8258}, + {"vehicle_getsteering", 0x8259}, + {"vehicle_getthrottle", 0x825A}, + {"vehicle_turnengineoff", 0x825B}, + {"vehicle_turnengineon", 0x825C}, + {"getgoalspeedmph", 0x825D}, + {"setacceleration", 0x825E}, + {"setdeceleration", 0x825F}, + {"resumespeed", 0x8260}, + {"setyawspeed", 0x8261}, + {"setyawspeedbyname", 0x8262}, + {"setmaxpitchroll", 0x8263}, + {"setairresistance", 0x8264}, + {"setturningability", 0x8265}, + {"getxuid", 0x8266}, + {"ishost", 0x8267}, + {"getspectatingplayer", 0x8268}, + {"predictstreampos", 0x8269}, + {"updatescores", 0x826A}, + {"updatedmscores", 0x826B}, + {"setrank", 0x826C}, + {"setcardtitle", 0x826D}, + {"weaponlocknoclearance", 0x826E}, + {"visionsyncwithplayer", 0x826F}, + {"showhudsplash", 0x8270}, + {"setperk", 0x8271}, + {"hasperk", 0x8272}, + {"clearperks", 0x8273}, + {"unsetperk", 0x8274}, + {"noclip", 0x8275}, + {"ufo", 0x8276}, + {"moveto", 0x8277}, + {"movex", 0x8278}, + {"movey", 0x8279}, + {"movez", 0x827A}, + {"movegravity", 0x827B}, + {"moveslide", 0x827C}, + {"stopmoveslide", 0x827D}, + {"rotateto", 0x827E}, + {"rotatepitch", 0x827F}, + {"rotateyaw", 0x8280}, + {"rotateroll", 0x8281}, + {"addpitch", 0x8282}, + {"addyaw", 0x8283}, + {"addroll", 0x8284}, + {"vibrate", 0x8285}, + {"rotatevelocity", 0x8286}, + {"solid", 0x8287}, + {"notsolid", 0x8288}, + {"setcandamage", 0x8289}, + {"setcanradiusdamage", 0x828A}, + {"physicslaunchclient", 0x828B}, + {"setcardicon", 0x828C}, + {"setcardnameplate", 0x828D}, + {"setcarddisplayslot", 0x828E}, + {"kc_regweaponforfxremoval", 0x828F}, + {"laststandrevive", 0x8290}, + {"setspectatedefaults", 0x8291}, + {"getthirdpersoncrosshairoffset", 0x8292}, + {"disableweaponpickup", 0x8293}, + {"enableweaponpickup", 0x8294}, + {"issplitscreenplayer", 0x8295}, + {"getweaponslistoffhands", 0x8296}, + {"getweaponslistitems", 0x8297}, + {"getweaponslistexclusives", 0x8298}, + {"getweaponslist", 0x8299}, + {"canplayerplacesentry", 0x829A}, + {"canplayerplacetank", 0x829B}, + {"visionsetnakedforplayer", 0x829C}, + {"visionsetnightforplayer", 0x829D}, + {"visionsetmissilecamforplayer", 0x829E}, + {"visionsetthermalforplayer", 0x829F}, + {"visionsetpainforplayer", 0x82A0}, + {"setblurforplayer", 0x82A1}, + {"getplayerweaponmodel", 0x82A2}, + {"getplayerknifemodel", 0x82A3}, + {"updateplayermodelwithweapons", 0x82A4}, + {"notifyonplayercommand", 0x82A5}, + {"canmantle", 0x82A6}, + {"forcemantle", 0x82A7}, + {"ismantling", 0x82A8}, + {"playfx", 0x82A9}, + {"player_recoilscaleon", 0x82AA}, + {"player_recoilscaleoff", 0x82AB}, + {"weaponlockstart", 0x82AC}, + {"weaponlockfinalize", 0x82AD}, + {"weaponlockfree", 0x82AE}, + {"weaponlocktargettooclose", 0x82AF}, + {"issplitscreenplayerprimary", 0x82B0}, + {"getviewmodel", 0x82B1}, + {"fragbuttonpressed", 0x82B2}, + {"secondaryoffhandbuttonpressed", 0x82B3}, + {"getcurrentweaponclipammo", 0x82B4}, + {"setvelocity", 0x82B5}, + {"getplayerviewheight", 0x82B6}, + {"getnormalizedmovement", 0x82B7}, + {"setchannelvolumes", 0x82B8}, + {"deactivatechannelvolumes", 0x82B9}, + {"playlocalsound", 0x82BA}, + {"stoplocalsound", 0x82BB}, + {"setweaponammoclip", 0x82BC}, + {"setweaponammostock", 0x82BD}, + {"getweaponammoclip", 0x82BE}, + {"getweaponammostock", 0x82BF}, + {"anyammoforweaponmodes", 0x82C0}, + {"setclientdvar", 0x82C1}, + {"setclientdvars", 0x82C2}, + {"allowads", 0x82C3}, + {"allowjump", 0x82C4}, + {"allowsprint", 0x82C5}, + {"setspreadoverride", 0x82C6}, + {"resetspreadoverride", 0x82C7}, + {"setaimspreadmovementscale", 0x82C8}, + {"setactionslot", 0x82C9}, + {"setviewkickscale", 0x82CA}, + {"getviewkickscale", 0x82CB}, + {"getweaponslistall", 0x82CC}, + {"getweaponslistprimaries", 0x82CD}, + {"getnormalizedcameramovement", 0x82CE}, + {"giveweapon", 0x82CF}, + {"takeweapon", 0x82D0}, + {"takeallweapons", 0x82D1}, + {"getcurrentweapon", 0x82D2}, + {"getcurrentprimaryweapon", 0x82D3}, + {"getcurrentoffhand", 0x82D4}, + {"hasweapon", 0x82D5}, + {"switchtoweapon", 0x82D6}, + {"switchtoweaponimmediate", 0x82D7}, + {"switchtooffhand", 0x82D8}, + {"setoffhandsecondaryclass", 0x82D9}, + {"getoffhandsecondaryclass", 0x82DA}, + {"beginlocationselection", 0x82DB}, + {"endlocationselection", 0x82DC}, + {"disableweapons", 0x82DD}, + {"enableweapons", 0x82DE}, + {"disableoffhandweapons", 0x82DF}, + {"enableoffhandweapons", 0x82E0}, + {"disableweaponswitch", 0x82E1}, + {"enableweaponswitch", 0x82E2}, + {"openpopupmenu", 0x82E3}, + {"openpopupmenunomouse", 0x82E4}, + {"closepopupmenu", 0x82E5}, + {"openmenu", 0x82E6}, + {"closemenu", 0x82E7}, + {"freezecontrols", 0x82E9}, + {"disableusability", 0x82EA}, + {"enableusability", 0x82EB}, + {"setwhizbyspreads", 0x82EC}, + {"setwhizbyradii", 0x82ED}, + {"setreverb", 0x82EE}, + {"deactivatereverb", 0x82EF}, + {"setvolmod", 0x82F0}, + {"setchannelvolume", 0x82F1}, + {"givestartammo", 0x82F2}, + {"givemaxammo", 0x82F3}, + {"getfractionstartammo", 0x82F4}, + {"getfractionmaxammo", 0x82F5}, + {"isdualwielding", 0x82F6}, + {"isreloading", 0x82F7}, + {"isswitchingweapon", 0x82F8}, + {"setorigin", 0x82F9}, + {"getvelocity", 0x82FA}, + {"setplayerangles", 0x82FB}, + {"getplayerangles", 0x82FC}, + {"usebuttonpressed", 0x82FD}, + {"attackbuttonpressed", 0x82FE}, + {"adsbuttonpressed", 0x82FF}, + {"meleebuttonpressed", 0x8300}, + {"playerads", 0x8301}, + {"isonground", 0x8302}, + {"isusingturret", 0x8303}, + {"setviewmodel", 0x8304}, + {"setoffhandprimaryclass", 0x8305}, + {"getoffhandprimaryclass", 0x8306}, + {"startac130", 0x8307}, + {"stopac130", 0x8308}, + {"enablemousesteer", 0x8309}, + {"setscriptmoverkillcam", 0x830A}, + {"setmapnamestring", 0x830B}, + {"setgametypestring", 0x830C}, + }; + + std::unordered_map token_map + { + {"pl#", 1}, + {"teamHasRemoteUAV", 17}, // was introduced in an IW patch, made up name + {"carriedRemoteUAV", 18}, // was introduced in an IW patch, made up name + {"imsBombSquadModel", 19}, // was introduced in an IW patch, made up name + {"zonesCycling", 20}, + {"_unk_field_ID54", 54}, // was introduced in an IW patch, used in _nuke.gsc and _rank.gsc + {"isBuffEquippedOnWeapon", 55}, + {"onDisconnect", 56}, + {"gun_prevGuns", 369}, + {"gun_curGun", 370}, + {"getNextGun", 371}, + {"addAttachments", 372}, + {"gun_attachments", 373}, + {"logKillsConfirmed", 416}, + {"logKillsDenied", 417}, + {"isPainted", 418}, + {"lightWeightScalar", 419}, + {"painted", 420}, + {"hideCarryIconOnGameEnd", 421}, + {"empTimeRemaining", 422}, + {"juggRemoveRadarOnGameEnded", 423}, // was introduced in an IW patch, made up name, no way of knowing its official name + {"airstrikessfx", 424}, + {"airstrikeexplosion", 425}, // an educated name guess based off of opaque strings + {"keepEMPTimeRemaining", 426}, + {"nukeEmpTimeRemaining", 427}, + {"keepNukeEMPTimeRemaining", 428}, + {"handleToggleZoom", 429}, + {"remote_mortar_toggleZoom", 430}, + {"hintPickUp", 431}, + {"pickup_message_deleted", 432}, + {"getCustomClassLoc", 433}, + {"isInUnlockTable", 434}, + {"getChallengeFilter", 435}, + {"getChallengeTable", 436}, + {"getTierFromTable", 437}, + {"getWeaponFromChallenge", 438}, + {"getWeaponAttachmentFromChallenge", 439}, + {"isKillstreakChallenge", 440}, + {"getKillstreakFromChallenge", 441}, + {"cac_getCustomClassLoc", 442}, + {"reInitializeMatchRulesOnMigration", 443}, + {"initializeMatchRules", 444}, + {"matchRules_oneShotKill", 445}, + {"matchRules_randomize", 447}, + {"reInitializeScoreLimitOnMigration", 448}, + {"gun_nextGuns", 449}, + {"grnd_wasSpectator", 464}, + {"grnd_previousCrateTypes", 467}, + {"spawningAfterRemoteDeath", 520}, + {"hideWorldIconOnGameEnd", 521}, + {"fauxVehicleCount", 522}, + {"incrementFauxVehicleCount", 523}, + {"decrementFauxVehicleCount", 524}, + {"crateTeamModelUpdater", 525}, + {"getHighestProgressedPlayers", 950}, + {"gun_progressDisplay", 951}, + {"delay_createfx_seconds", 1023}, + {"lastVecToTarget", 1027}, + {"markForDetete", 1028}, +// ... + {"initFX", 1648}, + {"func", 1649}, + {"main", 1650}, + {"CodeCallback_StartGameType", 1651}, + {"CodeCallback_PlayerConnect", 1652}, + {"CodeCallback_PlayerDisconnect", 1653}, + {"CodeCallback_PlayerDamage", 1654}, + {"CodeCallback_PlayerKilled", 1655}, + {"CodeCallback_VehicleDamage", 1656}, + {"CodeCallback_CodeEndGame", 1657}, + {"CodeCallback_PlayerLastStand", 1658}, + {"CodeCallback_PlayerMigrated", 1659}, + {"CodeCallback_HostMigration", 1660}, + {"InitStructs", 1661}, + {"CreateStruct", 1662}, + {"init", 1664}, + {"precache", 1665}, + {"spawner", 1666}, + {"code_classname", 1667}, // entity fields + {"classname", 1668}, + {"origin", 1669}, + {"model", 1670}, + {"spawnflags", 1671}, + {"target", 1672}, + {"targetname", 1673}, + {"count", 1674}, + {"health", 1675}, + {"dmg", 1676}, + {"angles", 1677}, + {"birthtime", 1678}, + {"script_linkname", 1679}, + {"slidevelocity", 1680}, + {"name", 1681}, // client fields + {"sessionteam", 1682}, + {"sessionstate", 1683}, + {"maxHealth", 1684}, +// ... + {"bouncefraction", 1705}, +// ... + {"score", 1725}, + {"deaths", 1726}, + {"statusicon", 1727}, + {"headicon", 1728}, + {"headiconteam", 1729}, + {"canclimbladders", 1730}, + {"kills", 1731}, + {"assists", 1732}, + {"hasradar", 1733}, + {"isradarblocked", 1734}, + {"radarstrength", 1735}, + {"radarshowenemydirection", 1736}, + {"radarmode", 1737}, + {"forcespectatorclient", 1738}, + {"killcamentity", 1739}, + {"archivetime", 1740}, + {"psoffsettime", 1741}, + {"pers", 1742}, + {"x", 1743}, + {"y", 1744}, + {"z", 1745}, + {"fontScale", 1746}, + {"font", 1747}, + {"alignx", 1748}, + {"aligny", 1749}, + {"horzalign", 1750}, + {"vertalign", 1751}, + {"color", 1752}, + {"alpha", 1753}, + {"label", 1754}, + {"sort", 1755}, + {"foreground", 1756}, + {"lowresbackground", 1757}, + {"hidewhendead", 1758}, + {"hidewheninmenu", 1759}, + {"splatter", 1760}, + {"glowcolor", 1761}, + {"glowalpha", 1762}, + {"archived", 1763}, + {"hidein3rdperson", 1764}, + {"hidewhenindemo", 1765}, + {"veh_speed", 1766}, + {"veh_pathspeed", 1767}, + {"veh_transmission", 1768}, + {"veh_pathdir", 1769}, + {"veh_pathtype", 1770}, + {"veh_topspeed", 1771}, + {"veh_brake", 1772}, + {"veh_throttle", 1773}, + {"script_noteworthy", 1774}, + {"speed", 1775}, + {"lookahead", 1776}, + {"ambienttrack", 1777}, + {"ambienttrack_ac130", 1778}, + {"message", 1779}, + {"northyaw", 1780}, + {"wait", 1781}, + {"radius", 1782}, + {"height", 1783}, + {"accumulate", 1784}, + {"threshold", 1785}, + {"cursorhint", 1786}, + {"hintstring", 1787}, + {"script_delay", 1788}, + {"script_visionset", 1789}, + {"script_zone", 1790}, + {"rightarc", 1791}, + {"leftarc", 1792}, + {"toparc", 1793}, + {"bottomarc", 1794}, + {"yawconvergencetime", 1795}, + {"pitchconvergencetime", 1796}, + {"suppressionTime", 1797}, + {"maxrange", 1798}, + {"aiSpread", 1799}, + {"damage", 1800}, + {"playerSpread", 1801}, + {"convergencetime", 1802}, + {"weaponinfo", 1803}, + {"vehicletype", 1804}, + {"type", 1805}, + {"accuracy", 1806}, + {"lookforward", 1807}, + {"lookright", 1808}, + {"lookup", 1809}, + {"fovcosine", 1810}, + {"fovcosinebusy", 1811}, + {"upaimlimit", 1812}, + {"downaimlimit", 1813}, + {"rightaimlimit", 1814}, + {"leftaimlimit", 1815}, + {"maxsightdistsqrd", 1816}, + {"sightlatency", 1817}, + {"ignoreclosefoliage", 1818}, + {"followmin", 1819}, + {"followmax", 1820}, + {"chainfallback", 1821}, + {"chainnode", 1822}, + {"interval", 1823}, + {"teammovewaittime", 1824}, + {"damagetaken", 1825}, + {"damagedir", 1826}, + {"damageyaw", 1827}, + {"damagelocation", 1828}, + {"damageweapon", 1829}, + {"damagemod", 1830}, + {"proneok", 1831}, + {"walkdistfacingmotion", 1832}, + {"killcamentitylookat", 1833}, + {"walkdist", 1834}, + {"desiredangle", 1835}, + {"pacifist", 1836}, + {"pacifistwait", 1837}, + {"footstepdetectdist", 1838}, + {"footstepdetectdistwalk", 1839}, + {"footstepdetectdistsprint", 1840}, + {"reactiontargetpos", 1841}, + {"newenemyreactiondistsq", 1842}, + {"ignoreexplosionevents", 1843}, + {"ignoresuppression", 1844}, + {"suppressionwait", 1845}, + {"suppressionduration", 1846}, + {"suppressionstarttime", 1847}, + {"suppressionmeter", 1848}, + {"weapon", 1849}, + {"dontavoidplayer", 1850}, + {"grenadeawareness", 1851}, + {"grenade", 1852}, + {"grenadeweapon", 1853}, + {"grenadeammo", 1854}, + {"favoriteenemy", 1855}, + {"highlyawareradius", 1856}, + {"minpaindamage", 1857}, + {"allowpain", 1858}, + {"allowdeath", 1859}, + {"delayeddeath", 1860}, + {"diequietly", 1861}, + {"forceragdollimmediate", 1862}, + {"providecoveringfire", 1863}, + {"doingambush", 1864}, + {"combatmode", 1865}, + {"alertlevel", 1866}, + {"alertlevelint", 1867}, + {"useable", 1868}, + {"ignoretriggers", 1869}, + {"pushable", 1870}, + {"script_pushable", 1871}, + {"dropweapon", 1872}, + {"drawoncompass", 1873}, + {"groundtype", 1874}, + {"anim_pose", 1875}, + {"goalradius", 1876}, + {"goalheight", 1877}, + {"goalpos", 1878}, + {"nodeoffsetpos", 1879}, + {"ignoreforfixednodesafecheck", 1880}, + {"fixednode", 1881}, + {"fixednodesaferadius", 1882}, + {"pathgoalpos", 1883}, + {"pathrandompercent", 1884}, + {"usechokepoints", 1885}, + {"stopanimdistsq", 1886}, + {"lastenemysightpos", 1887}, + {"pathenemylookahead", 1888}, + {"pathenemyfightdist", 1889}, + {"meleeattackdist", 1890}, + {"movemode", 1891}, + {"usecombatscriptatcover", 1892}, + {"safetochangescript", 1893}, + {"keepclaimednode", 1894}, + {"keepclaimednodeifvalid", 1895}, + {"keepnodeduringscriptedanim", 1896}, + {"dodangerreact", 1897}, + {"dangerreactduration", 1898}, + {"nododgemove", 1899}, + {"leanamount", 1900}, + {"turnrate", 1901}, + {"badplaceawareness", 1902}, + {"damageshield", 1903}, + {"nogrenadereturnthrow", 1904}, + {"noattackeraccuracymod", 1905}, + {"frontshieldanglecos", 1906}, + {"lookaheaddir", 1907}, + {"lookaheaddist", 1908}, + {"lookaheadhitsstairs", 1909}, + {"velocity", 1910}, + {"prevanimdelta", 1911}, + {"exposedduration", 1912}, + {"requestarrivalnotify", 1913}, + {"scriptedarrivalent", 1914}, + {"goingtoruntopos", 1915}, + {"engagemindist", 1916}, + {"engageminfalloffdist", 1917}, + {"engagemaxdist", 1918}, + {"engagemaxfalloffdist", 1919}, + {"finalaccuracy", 1920}, + {"facemotion", 1921}, + {"gunblockedbywall", 1921}, + {"relativedir", 1923}, + {"lockorientation", 1924}, + {"maxfaceenemydist", 1925}, + {"stairsstate", 1926}, + {"script", 1927}, + {"prevscript", 1928}, + {"threatbias", 1929}, + {"syncedmeleetarget", 1930}, + {"ignoreme", 1931}, + {"ignoreall", 1932}, + {"maxvisibledist", 1933}, + {"surprisedbymedistsq", 1934}, + {"ignorerandombulletdamage", 1935}, + {"dodamagetoall", 1936}, + {"turretinvulnerability", 1937}, + {"onlygoodnearestnodes", 1938}, + {"takedamage", 1938}, + {"playername", 1940}, + {"deathinvulnerabletime", 1941}, + {"criticalbulletdamagedist", 1942}, + {"attackercount", 1943}, + {"damagemultiplier", 1944}, + {"laststand", 1945}, + {"motiontrackerenabled", 1946}, + {"team", 1947}, + {"threatbiasgroup", 1948}, + {"node", 1949}, + {"prevnode", 1950}, + {"enemy", 1951}, + {"lastattacker", 1952}, + {"attackeraccuracy", 1953}, + {"width", 1954}, + {"enable", 1955}, + {"freecamera", 1956}, + {"fov", 1957}, + {"dofnear", 1958}, + {"doffar", 1959}, + {"look", 1960}, + {"up", 1961}, + {"right", 1962}, + {"thermalbodymaterial", 1963}, + {"entity", 1964}, + {"tag", 1965}, + {"nearz", 1966}, + {"blurradius", 1967}, + {"lod", 1968}, + {"clipdistance", 1969}, + {"enableshadows", 1970}, + {"visionsetnakedduration", 1971}, + {"visionsetnaked", 1972}, + {"visionsetnightduration", 1973}, + {"visionsetnight", 1974}, + {"visionsetmissilecamduration", 1975}, + {"visionsetmissilecam", 1976}, + {"visionsetthermalduration", 1977}, + {"visionsetthermal", 1978}, + {"visionsetpainduration", 1979}, + {"visionsetpain", 1980}, + {"activevisionset", 1981}, + {"activevisionsetduration", 1982}, + {"animscript", 1983}, + {"anglelerprate", 1984}, + {"activator", 1985}, + {"gravity", 1986}, + {"ambient", 1987}, + {"diffusefraction", 1988}, + {"sunlight", 1989}, + {"suncolor", 1990}, + {"sundirection", 1991}, + {"reflection_clear_color", 1992}, + {"minusedistsq", 1993}, + {"owner", 1994}, +// symbols + {"create_lock", 1995}, + {"exploder_before_load", 1996}, + {"exploderFunction", 1997}, + {"exploder_after_load", 1998}, + {"server_culled_sounds", 1999}, + {"createFX_enabled", 2000}, + {"createFXent", 2001}, + {"set_forward_and_up_vectors", 2002}, + {"v", 2003}, + {"print_org", 2004}, + {"OneShotfx", 2005}, + {"exploderfx", 2006}, + {"createExploder", 2007}, + {"createFXexploders", 2008}, + {"script_exploder", 2009}, + {"script_fxid", 2010}, + {"script_firefx", 2011}, + {"script_firefxdelay", 2012}, + {"script_firefxsound", 2013}, + {"script_sound", 2014}, + {"script_earthquake", 2015}, + {"script_damage", 2016}, + {"script_radius", 2017}, + {"script_soundalias", 2018}, + {"script_firefxtimeout", 2019}, + {"script_repeat", 2020}, + {"script_delay_min", 2021}, + {"script_delay_max", 2022}, + {"script_exploder_group", 2023}, + {"targetPos", 2024}, + {"_script_exploders", 2025}, + {"createfx_showOrigin", 2026}, + {"loopfx", 2027}, + {"createLoopEffect", 2028}, + {"create_looper", 2029}, + {"_effect", 2030}, + {"looper", 2031}, + {"create_loopsound", 2032}, + {"loop_fx_sound", 2033}, + {"create_interval_sound", 2034}, + {"loop_fx_sound_interval", 2035}, + {"loopfxthread", 2036}, + {"waitframe", 2037}, + {"fxStart", 2038}, + {"timeOut", 2039}, + {"fxStop", 2040}, + {"loopfxChangeID", 2041}, + {"loopfxChangeOrg", 2042}, + {"loopfxChangeDelay", 2043}, + {"loopfxDeletion", 2044}, + {"loopfxStop", 2045}, + {"loopSound", 2046}, + {"loopSoundthread", 2047}, + {"gunfireloopfx", 2048}, + {"gunfireloopfxthread", 2049}, + {"gunfireloopfxVec", 2050}, + {"gunfireloopfxVecthread", 2051}, + {"fxfireloopmod", 2052}, + {"setfireloopmod", 2053}, + {"setup_fx", 2054}, + {"script_fxcommand", 2055}, + {"script_fxstart", 2056}, + {"script_fxstop", 2057}, + {"burnville_paratrooper_hack", 2058}, + {"burnville_paratrooper_hack_loop", 2059}, + {"create_triggerfx", 2060}, + {"verify_effects_assignment", 2061}, + {"_missing_FX", 2062}, + {"verify_effects_assignment_print", 2063}, + {"OneShotfxthread", 2064}, + {"menu", 2065}, + {"create_fx_menu", 2066}, + {"setmenu", 2067}, + {"button_is_clicked", 2068}, + {"createLoopSound", 2069}, + {"createNewExploder", 2070}, + {"createIntervalSound", 2071}, + {"last_displayed_ent", 2072}, + {"clear_settable_fx", 2073}, + {"clear_fx_hudElements", 2074}, + {"_exit_menu", 2075}, + {"clear_entity_selection", 2076}, + {"update_selected_entities", 2077}, + {"get_last_selected_entity", 2078}, + {"selected_fx_ents", 2079}, + {"menu_fx_creation", 2080}, + {"func_get_level_fx", 2081}, + {"effect_list_offset", 2082}, + {"effect_list_offset_max", 2083}, + {"createOneshotEffect", 2084}, + {"finish_creating_entity", 2085}, + {"post_entity_creation_function", 2086}, + {"select_last_entity", 2087}, + {"move_selection_to_cursor", 2088}, + {"menu_init", 2089}, + {"createFX_options", 2090}, + {"mp_createfx", 2091}, + {"createfxMasks", 2092}, + {"get_last_selected_ent", 2093}, + {"entities_are_selected", 2094}, + {"menu_change_selected_fx", 2095}, + {"prepare_option_for_change", 2096}, + {"createfx_centerprint", 2097}, + {"createfx_inputlocked", 2098}, + {"createFxHudElements", 2099}, + {"menu_fx_option_set", 2100}, + {"apply_option_to_selected_fx", 2101}, + {"set_option_index", 2102}, + {"selected_fx_option_index", 2103}, + {"get_selected_option", 2104}, + {"mask", 2105}, + {"addOption", 2106}, + {"get_option", 2107}, + {"display_fx_info", 2108}, + {"set_fx_hudElement", 2109}, + {"createFx_hudElements", 2110}, + {"display_fx_add_options", 2111}, + {"add_option_to_selected_entities", 2112}, + {"menuNone", 2113}, + {"draw_effects_list", 2114}, + {"increment_list_offset", 2115}, + {"createEffect", 2116}, + {"drawn", 2117}, + {"createFXbyFXID", 2118}, + {"getLoopEffectDelayDefault", 2119}, + {"getOneshotEffectDelayDefault", 2120}, + {"getExploderDelayDefault", 2121}, + {"getIntervalSoundDelayMinDefault", 2122}, + {"getIntervalSoundDelayMaxDefault", 2123}, + {"add_effect", 2124}, + {"createExploderEx", 2125}, + {"set_origin_and_angles", 2126}, + {"createfx_common", 2127}, + {"flag_init", 2128}, + {"createFX", 2129}, + {"createfx_loopcounter", 2130}, + {"createFxLogic", 2131}, + {"get_template_level", 2132}, + {"func_position_player", 2133}, + {"location", 2134}, + {"clearTextMarker", 2135}, + {"selectedMove_up", 2136}, + {"selectedMove_forward", 2137}, + {"selectedMove_right", 2138}, + {"selectedRotate_pitch", 2139}, + {"selectedRotate_roll", 2140}, + {"selectedRotate_yaw", 2141}, + {"selected_fx", 2142}, + {"createfx_lockedList", 2143}, + {"createfx_draw_enabled", 2144}, + {"buttonIsHeld", 2145}, + {"player", 2146}, + {"fx_rotating", 2147}, + {"createfx_selecting", 2148}, + {"createfxCursor", 2149}, + {"buttonClick", 2150}, + {"button_is_kb", 2151}, + {"fx_highLightedEnt", 2152}, + {"func_process_fx_rotater", 2153}, + {"func_position_player_get", 2154}, + {"copy_angles_of_selected_ents", 2155}, + {"reset_axis_of_selected_ents", 2156}, + {"last_selected_entity_has_changed", 2157}, + {"drop_selection_to_ground", 2158}, + {"set_off_exploders", 2159}, + {"exploder", 2160}, + {"draw_distance", 2161}, + {"createfx_autosave", 2162}, + {"flag_waitopen", 2163}, + {"rotate_over_time", 2164}, + {"delete_pressed", 2165}, + {"remove_selected_option", 2166}, + {"remove_option", 2167}, + {"delete_selection", 2168}, + {"insert_effect", 2169}, + {"show_help", 2170}, + {"select_all_exploders_of_currently_selected", 2171}, + {"copy_ents", 2172}, + {"stored_ents", 2173}, + {"textAlpha", 2174}, + {"paste_ents", 2175}, + {"add_and_select_entity", 2176}, + {"get_center_of_array", 2177}, + {"ent_draw_axis", 2178}, + {"rotation_is_occuring", 2179}, + {"print_fx_options", 2180}, + {"createfxDefaults", 2181}, + {"entity_highlight_disable", 2182}, + {"entity_highlight_enable", 2183}, + {"toggle_createfx_drawing", 2184}, + {"manipulate_createfx_ents", 2185}, + {"reset_fx_hud_colors", 2186}, + {"button_is_held", 2187}, + {"toggle_entity_selection", 2188}, + {"select_entity", 2189}, + {"ent_is_highlighted", 2190}, + {"deselect_entity", 2191}, + {"index_is_selected", 2192}, + {"ent_is_selected", 2193}, + {"draw_axis", 2194}, + {"fxHudElements", 2195}, + {"createfx_centerprint_thread", 2196}, + {"buttonDown", 2197}, + {"buttonPressed_internal", 2198}, + {"get_selected_move_vector", 2199}, + {"process_button_held_and_clicked", 2200}, + {"locked", 2201}, + {"kb_locked", 2202}, + {"add_button", 2203}, + {"add_kb_button", 2204}, + {"set_anglemod_move_vector", 2205}, + {"cfxprintlnStart", 2206}, + {"fileprint_launcher_start_file", 2207}, + {"cfxprintln", 2208}, + {"fileprint_launcher", 2209}, + {"cfxprintlnEnd", 2210}, + {"fileprint_launcher_end_file", 2211}, + {"func_updatefx", 2212}, + {"hack_start", 2213}, + {"get_player", 2214}, + {"createfx_orgranize_array", 2215}, + {"stop_fx_looper", 2216}, + {"stop_loopsound", 2217}, + {"_effect_keys", 2218}, + {"alphabetize", 2219}, + {"restart_fx_looper", 2220}, + {"process_fx_rotater", 2221}, + {"generate_fx_log", 2222}, + {"scriptPrintln", 2223}, + {"debugPrintln", 2224}, + {"draw_debug_line", 2225}, + {"waittillend", 2226}, + {"noself_func", 2227}, + {"self_func", 2228}, + {"randomvector", 2229}, + {"randomvectorrange", 2230}, + {"angle_dif", 2231}, + {"sign", 2232}, + {"track", 2233}, + {"current_target", 2234}, + {"get_enemy_team", 2235}, + {"clear_exception", 2236}, + {"exception", 2237}, + {"defaultException", 2238}, + {"set_exception", 2239}, + {"set_all_exceptions", 2240}, + {"cointoss", 2241}, + {"choose_from_weighted_array", 2242}, + {"get_cumulative_weights", 2243}, + {"waittill_string", 2244}, + {"waittill_multiple", 2245}, + {"threads", 2246}, + {"waittill_multiple_ents", 2247}, + {"waittill_any_return", 2248}, + {"waittill_any_timeout", 2249}, + {"_timeout", 2250}, + {"waittill_any", 2251}, + {"waittill_any_ents", 2252}, + {"isFlashed", 2253}, + {"flashEndTime", 2254}, + {"flag_exist", 2255}, + {"flag", 2256}, + {"init_flags", 2257}, + {"flags_lock", 2258}, + {"generic_index", 2259}, + {"sp_stat_tracking_func", 2260}, + {"flag_struct", 2261}, + {"trigger_flags", 2262}, + {"empty_init_func", 2263}, + {"issuffix", 2264}, + {"flag_set", 2265}, + {"assign_unique_id", 2266}, + {"unique_id", 2267}, + {"flag_wait", 2268}, + {"flag_clear", 2269}, + {"waittill_either", 2270}, + {"array_thread", 2271}, + {"array_call", 2272}, + {"array_thread4", 2273}, + {"array_thread5", 2274}, + {"trigger_on", 2275}, + {"trigger_on_proc", 2276}, + {"realOrigin", 2277}, + {"trigger_off", 2278}, + {"trigger_off_proc", 2279}, + {"set_trigger_flag_permissions", 2280}, + {"update_trigger_based_on_flags", 2281}, + {"script_flag_true", 2282}, + {"script_flag_false", 2283}, + {"trigger_func", 2284}, + {"create_flags_and_return_tokens", 2285}, + {"init_trigger_flags", 2286}, + {"getstruct", 2287}, + {"struct_class_names", 2288}, + {"getstructarray", 2289}, + {"struct_class_init", 2290}, + {"struct", 2291}, + {"fileprint_start", 2292}, + {"fileprint_map_start", 2293}, + {"fileprint_map_header", 2294}, + {"fileprint_map_keypairprint", 2295}, + {"fileprint_map_entity_start", 2296}, + {"fileprint_map_entity_end", 2297}, + {"fileprint_radiant_vec", 2298}, + {"array_remove", 2299}, + {"array_remove_array", 2300}, + {"array_removeUndefined", 2301}, + {"array_levelthread", 2302}, + {"array_levelcall", 2303}, + {"add_to_array", 2304}, + {"flag_assert", 2305}, + {"flag_wait_either", 2306}, + {"flag_wait_either_return", 2307}, + {"flag_wait_any", 2308}, + {"flag_wait_any_return", 2309}, + {"flag_wait_all", 2310}, + {"flag_wait_or_timeout", 2311}, + {"flag_waitopen_or_timeout", 2312}, + {"wait_for_flag_or_time_elapses", 2313}, + {"delayCall", 2314}, + {"delayCall_proc", 2315}, + {"noself_delayCall", 2316}, + {"noself_delayCall_proc", 2317}, + {"isSP", 2318}, + {"isSP_TowerDefense", 2319}, + {"string_starts_with", 2320}, + {"plot_points", 2321}, + {"draw_line_for_time", 2322}, + {"array_combine", 2323}, + {"flat_angle", 2324}, + {"flat_origin", 2325}, + {"draw_arrow_time", 2326}, + {"get_linked_ents", 2327}, + {"script_linkto", 2328}, + {"get_linked_vehicle_nodes", 2329}, + {"get_linked_ent", 2330}, + {"get_linked_vehicle_node", 2331}, + {"get_links", 2332}, + {"run_thread_on_targetname", 2333}, + {"getNodeArrayFunction", 2334}, + {"run_thread_on_noteworthy", 2335}, + {"draw_arrow", 2336}, + {"getfx", 2337}, + {"fxExists", 2338}, + {"print_csv_asset", 2339}, + {"csv_lines", 2340}, + {"fileprint_csv_start", 2341}, + {"_loadfx", 2342}, + {"getLastWeapon", 2343}, + {"saved_lastWeapon", 2344}, + {"PlayerUnlimitedAmmoThread", 2345}, + {"isUsabilityEnabled", 2346}, + {"disabledUsability", 2347}, + {"_disableUsability", 2348}, + {"_enableUsability", 2349}, + {"resetUsability", 2350}, + {"_disableWeapon", 2351}, + {"disabledWeapon", 2352}, + {"_enableWeapon", 2353}, + {"isWeaponEnabled", 2354}, + {"_disableWeaponSwitch", 2355}, + {"disabledWeaponSwitch", 2356}, + {"_enableWeaponSwitch", 2357}, + {"isWeaponSwitchEnabled", 2358}, + {"_disableOffhandWeapons", 2359}, + {"disabledOffhandWeapons", 2360}, + {"_enableOffhandWeapons", 2361}, + {"isOffhandWeaponEnabled", 2362}, + {"random", 2363}, + {"spawn_tag_origin", 2364}, + {"waittill_notify_or_timeout", 2365}, + {"fileprintlauncher_linecount", 2366}, + {"launcher_write_clipboard", 2367}, + {"isDestructible", 2368}, + {"destructible_type", 2369}, + {"pauseEffect", 2370}, + {"activate_individual_exploder", 2371}, + {"brush_delete", 2372}, + {"connectPathsFunction", 2373}, + {"exploded", 2374}, + {"brush_throw", 2375}, + {"get_target_ent", 2376}, + {"getNodeFunction", 2377}, + {"brush_show", 2378}, + {"script_modelname", 2379}, + {"brush_shown", 2380}, + {"disconnect_paths", 2381}, + {"disconnectPathsFunction", 2382}, + {"exploder_earthquake", 2383}, + {"do_earthquake", 2384}, + {"earthquake", 2385}, + {"exploder_rumble", 2386}, + {"exploder_delay", 2387}, + {"exploder_damage", 2388}, + {"effect_loopsound", 2389}, + {"loopsound_ent", 2390}, + {"play_loopsound_in_space", 2391}, + {"sound_effect", 2392}, + {"effect_soundalias", 2393}, + {"play_sound_in_space", 2394}, + {"cannon_effect", 2395}, + {"exploder_playSound", 2396}, + {"fire_effect", 2397}, + {"first_frame", 2398}, + {"loop_sound_delete", 2399}, + {"activate_exploder", 2400}, + {"is_later_in_alphabet", 2401}, + {"alphabet_compare", 2402}, + {"play_loop_sound_on_entity", 2403}, + {"stop_loop_sound_on_entity", 2404}, + {"delete_on_death", 2405}, + {"error", 2406}, + {"create_dvar", 2407}, + {"void", 2408}, + {"tag_project", 2409}, + {"ter_op", 2410}, + {"lock", 2411}, + {"max_count", 2412}, + {"is_locked", 2413}, + {"unlock_wait", 2414}, + {"unlock", 2415}, + {"unlock_thread", 2416}, + {"template_script", 2417}, + {"setParent", 2418}, + {"parent", 2419}, + {"point", 2420}, + {"yOffset", 2421}, + {"xOffset", 2422}, + {"relativePoint", 2423}, + {"getParent", 2424}, + {"addChild", 2425}, + {"children", 2426}, + {"index", 2427}, + {"removeChild", 2428}, + {"setPoint", 2429}, + {"uiParent", 2430}, + {"elemType", 2431}, + {"setPointBar", 2432}, + {"bar", 2433}, + {"padding", 2434}, + {"frac", 2435}, + {"updateBar", 2436}, + {"shader", 2437}, + {"hidebar", 2438}, + {"orig_alpha", 2439}, + {"createFontString", 2440}, + {"fontHeight", 2441}, + {"createServerClientFontString", 2442}, + {"createClientTimer", 2443}, + {"createServerFontString", 2444}, + {"createServerTimer", 2445}, + {"createIcon", 2446}, + {"createClientIcon", 2447}, + {"createIcon_Hudelem", 2448}, + {"createBar", 2449}, + {"flashFrac", 2450}, + {"createClientProgressBar", 2451}, + {"createClientBar", 2452}, + {"setFlashFrac", 2453}, + {"fade_over_time", 2454}, + {"flashThread", 2455}, + {"destroyElem", 2456}, + {"setIconShader", 2457}, + {"setWidth", 2458}, + {"setHeight", 2459}, + {"setSize", 2460}, + {"updateChildren", 2461}, + {"stance_carry_icon_enamble", 2462}, + {"stance_carry", 2463}, + {"console", 2464}, +// ... + {"delayThread", 2556}, + {"gameskill", 2562}, + {"player_damage", 2574}, + + {"players", 2577}, +// ... + {"stats", 2609}, + {"isPrimaryWeapon", 2623}, + {"forward", 2664}, +// ... + {"attacker", 2700}, + {"updateOrigin", 2703}, + {"A", 2711}, + {"voice", 2738}, + {"getRank", 2755}, + {"priority", 2764}, +// ... + {"sunradiosity", 2810}, + {"skycolor", 2811}, + {"skylight", 2812}, + {"_color", 2813}, + {"ltOrigin", 2814}, + {"gndlt", 2815}, + {"sound_csv_include", 2816}, + {"csv_include", 2817}, + {"precache_script", 2818}, +// {2819, ""}, + {"maxbounces", 2820}, + {"radiosityscale", 2821}, +// {2822, ""}, + {"def", 2823}, + {"exponent", 2824}, + {"fov_inner", 2825}, + {"fov_outer", 2826}, + {"__smorigin", 2827}, + {"__smangles", 2828}, + {"__smname", 2829}, + {"__smid", 2830}, +// {2831, ""}, +// {2832, ""}, +// {2833, ""}, +// {2834, ""}, +// {2835, ""}, + {"contrastGain", 2836}, // MAYBE +// ... + {"isTeamSpeaking", 2944}, // animscripts/battlechater_ai + + {"string", 2961}, +// ... + {"getVectorRightAngle", 3075}, + {"within_fov", 3105}, + + {"primaryWeapon", 3226}, +// ... + {"isSniper", 3297}, +// ... + {"lastCarExplosionTime", 3360}, + {"lastCarExplosionRange", 3361}, + {"lastCarExplosionDamageLocation", 3362}, + {"lastCarExplosionLocation", 3363}, + + {"playDeathSound", 3445}, + {"makeType", 3460}, + {"getInfoIndex", 3461}, + {"destructible_create", 3463}, + {"destructible_state", 3464}, + {"destructible_anim", 3465}, + {"destructible_fx", 3466}, + {"destructible_explode", 3467}, + {"prop_ac_prs_enm_con_digger_a", 3469}, + {"prop_ac_prs_enm_con_dump_truck_a", 3470}, + {"prop_ac_prs_enm_fuel_tank_a", 3471}, + {"prop_ac_prs_enm_hanger_a", 3472}, + {"prop_ac_prs_enm_maz_a", 3473}, + {"prop_ac_prs_enm_mi26_halo_a", 3474}, + {"prop_ac_prs_enm_mstas_a", 3475}, + {"prop_ac_prs_enm_radar_maz_a", 3476}, + {"prop_ac_prs_enm_s300v_a", 3477}, + {"prop_ac_prs_enm_truck_a", 3484}, + {"prop_ac_prs_enm_mobile_crane_a", 3491}, + {"prop_ac_prs_enm_landing_craft_a", 3492}, + {"prop_ac_prs_enm_speed_boat_a", 3493}, + {"prop_ac_prs_prp_satellite_dish_a_dish", 3494}, +// ... + {"prop_ac_prs_enm_missile_boat_a", 3509}, + {"toy_glass", 3510}, + {"destructible_splash_damage_scaler", 3511}, + {"destructible_sound", 3512}, + {"destructible_part", 3513}, + {"toy_dt_mirror", 3514}, + {"toy_icbm_consolemonitor", 3515}, + {"toy_tubetv_", 3516}, + {"toy_tvs_flatscreen", 3517}, + {"toy_tvs_flatscreen_sturdy", 3518}, + {"toy_transformer_ratnest01", 3519}, + {"destructible_loopfx", 3520}, + {"destructible_loopsound", 3521}, + {"destructible_healthdrain", 3522}, + {"toy_transformer_small01", 3523}, + {"toy_generator", 3524}, + {"toy_generator_on", 3525}, + {"toy_oxygen_tank", 3526}, + {"toy_electricbox2", 3527}, + {"toy_electricbox4", 3528}, + {"toy_airconditioner", 3529}, + {"toy_ceiling_fan", 3530}, + {"toy_wall_fan", 3531}, + {"toy_propane_tank02", 3532}, + {"destructible_physics", 3533}, + {"toy_propane_tank02_small", 3534}, + {"toy_copier", 3535}, + {"toy_firehydrant", 3536}, + {"toy_parkingmeter", 3537}, + {"damage_not", 3538}, + {"toy_mailbox", 3539}, + {"toy_mailbox2", 3540}, + {"toy_newspaper_stand_red", 3541}, + {"toy_newspaper_stand_blue", 3542}, + {"toy_filecabinet", 3543}, + {"toy_trashbin_01", 3544}, + {"toy_trashbin_02", 3545}, + {"toy_trashbag1", 3546}, + {"toy_recyclebin_01", 3547}, + {"toy_trashcan_metal_closed", 3548}, + {"toy_water_collector", 3549}, + {"toy_foliage_tree_oak_1", 3550}, + {"toy_paris_tree_plane_large", 3551}, + {"toy_usa_gas_station_trash_bin_01", 3552}, + {"toy_usa_gas_station_trash_bin_02", 3553}, + {"toy_light_ceiling_round", 3554}, + {"destructible_lights_out", 3555}, + {"toy_light_ceiling_fluorescent", 3556}, + {"toy_light_ceiling_fluorescent_spotlight", 3557}, + {"destructible_spotlight", 3558}, + {"toy_light_ceiling_fluorescent_single", 3559}, + {"toy_light_ceiling_fluorescent_single_spotlight", 3560}, + {"toy_bookstore_bookstand4_books", 3561}, + {"toy_locker_double", 3562}, + {"toy_dubai_fish_sculpture", 3563}, + {"toy_intro_concrete_chipaway", 3564}, + {"toy_chicken", 3565}, + {"toy_hide_with_fx", 3566}, + {"vehicle_ac130_80s_sedan1", 3567}, + {"vehicle_bus_destructible", 3568}, + {"vehicle_80s_sedan1", 3569}, + {"vehicle_80s_hatch1", 3570}, + {"vehicle_80s_hatch2", 3571}, + {"vehicle_80s_wagon1", 3572}, + {"vehicle_civ_car_a", 3573}, + {"vehicle_small_hatch", 3574}, + {"vehicle_london_cab_black", 3575}, + {"vehicle_pickup", 3576}, + {"vehicle_hummer", 3577}, + {"vehicle_gaz", 3578}, + {"vehicle_gaz_harbor", 3579}, + {"vehicle_bm21", 3580}, + {"vehicle_moving_truck", 3581}, + {"vehicle_subway_cart", 3582}, + {"create_vehicle_subway_cart_window_single", 3583}, + {"vehicle_subway_cart_windows", 3584}, + {"vehicle_subway_cart_windows_small", 3585}, + {"vehicle_luxurysedan", 3586}, + {"destructible_car_alarm", 3587}, + {"vehicle_mig29_landed", 3588}, + {"vehicle_mack_truck_short", 3589}, + {"vehicle_semi_truck", 3590}, + {"vehicle_motorcycle", 3591}, + {"vehicle_scooter", 3592}, + {"vehicle_subcompact", 3593}, + {"vehicle_van", 3594}, + {"vehicle_uaz_van", 3595}, + {"vehicle_van_iw5", 3596}, + {"vehicle_delivery_theme_park_truck_destructible", 3597}, + {"vehicle_suburban", 3598}, + {"vehicle_snowmobile", 3599}, + {"destructible_gaspump", 3600}, + {"destructible_electrical_transformer_large", 3601}, + {"get_precached_anim", 3602}, + {"_destructible_preanims", 3603}, + {"get_precached_animtree", 3604}, + {"_destructible_preanimtree", 3605}, + {"vehicle_coupe", 3606}, + {"vehicle_mini", 3607}, + {"vehicle_uk_truck", 3608}, + {"vehicle_uk_police_estate", 3609}, + {"vehicle_uaz_winter", 3610}, + {"vehicle_uaz_fabric", 3611}, + {"vehicle_uaz_hardtop", 3612}, + {"vehicle_jeep", 3613}, + {"vehicle_jeep_dusty", 3614}, + {"vehicle_uaz_open", 3615}, + {"vehicle_india_compact_destructible", 3616}, + {"vehicle_india_rickshaw", 3617}, + {"vehicle_tuk_tuk", 3618}, + {"vehicle_india_suv", 3619}, + {"vehicle_policecar", 3620}, + {"vehicle_policecar_russia", 3621}, + {"vehicle_taxi", 3622}, + {"random_dynamic_attachment", 3623}, + {"vehicle_taxi_dubai", 3624}, + {"toy_security_camera", 3625}, + {"toy_building_collapse_paris_ac130", 3626}, + {"toy_poison_gas_attack", 3627}, + {"toy_arcade_machine", 3628}, + {"toy_pinball_machine", 3629}, + {"toy_fortune_machine", 3630}, + {"toy_trashcan_clown", 3631}, + {"toy_afrShanty1", 3632}, + {"vehicle_slava_ny_harbor_zonea", 3633}, + {"rooftop_skylight_destructible", 3634}, + {"satellite_dish_big_destructible", 3635}, + {"dest_onestate", 3636}, + {"dest_pb_planter", 3637}, + {"berlin_hotel_lights_ceiling1", 3638}, + {"rus_vx_gas_canister", 3639}, + {"destructibleSpawnedEntsLimit", 3640}, + {"destructibleSpawnedEnts", 3641}, + {"currentCarAlarms", 3642}, + {"commonStartTime", 3643}, + {"fast_destructible_explode", 3644}, + {"warn_about_old_destructible", 3645}, + {"find_destructibles", 3646}, + {"setup_destructibles", 3647}, + {"modeldummyon", 3648}, + {"destructibleInfo", 3649}, + {"parts", 3650}, + {"destructible_parts", 3651}, + {"modeldummy", 3652}, + {"add_key_to_destructible", 3653}, + {"add_keypairs_to_destructible", 3654}, + {"add_array_to_destructible", 3655}, + {"destructible_info", 3656}, + {"precache_destructibles", 3657}, + {"add_destructible_fx", 3658}, + {"canDamageDestructible", 3659}, + {"destructibles", 3660}, + {"destructible_think", 3661}, + {"damageOwner", 3662}, + {"gunner", 3663}, + {"is_shotgun_damage", 3664}, + {"enable_ai_shotgun_destructible_damage", 3665}, + {"getPartAndStateIndex", 3666}, + {"destructible_update_part", 3667}, + {"non_player_damage", 3668}, + {"waiting_for_queue", 3669}, + {"exploding", 3670}, + {"loopingSoundStopNotifies", 3671}, + {"damage_type", 3672}, + {"destructible_splash_rotatation", 3673}, + {"destructible_splash_damage", 3674}, + {"getAllActiveParts", 3675}, + {"setDistanceOnParts", 3676}, + {"getLowestPartDistance", 3677}, + {"isValidSoundCause", 3678}, + {"isAttackerValid", 3679}, + {"forceExploding", 3680}, + {"dontAllowExplode", 3681}, + {"damageIsFromPlayer", 3682}, + {"isAIfunc", 3683}, + {"isValidDamageCause", 3684}, + {"godmode", 3685}, + {"script_bulletshield", 3686}, + {"getDamageType", 3687}, + {"damage_mirror", 3688}, + {"add_damage_owner_recorder", 3689}, + {"car_damage_owner_recorder", 3690}, + {"loopfx_onTag", 3691}, + {"health_drain", 3692}, + {"destructible_badplace_radius_multiplier", 3693}, + {"destructible_health_drain_amount_multiplier", 3694}, + {"healthDrain", 3695}, + {"disable_destructible_bad_places", 3696}, + {"disableBadPlace", 3697}, + {"badplace_cylinder_func", 3698}, + {"badplace_remove", 3699}, + {"badplace_delete_func", 3700}, + {"physics_launch", 3701}, + {"physics_object_remove", 3702}, + {"explode", 3703}, + {"destructible_explosion_radius_multiplier", 3704}, + {"destructible_protection_func", 3705}, + {"cleanupVars", 3706}, + {"animsapplied", 3707}, + {"caralarm", 3708}, + {"destructible_cleans_up_more", 3709}, + {"script_noflip", 3710}, + {"car_alarm_org", 3711}, + {"set_disable_friendlyfire_value_delayed", 3712}, + {"friendlyFireDisabledForDestructible", 3713}, + {"connectTraverses", 3714}, + {"disconnectTraverses", 3715}, + {"get_traverse_disconnect_brush", 3716}, + {"script_destruct_collision", 3717}, + {"hideapart", 3718}, + {"showapart", 3719}, + {"disable_explosion", 3720}, + {"force_explosion", 3721}, + {"get_dummy", 3722}, + {"play_loop_sound_on_destructible", 3723}, + {"force_stop_sound", 3724}, + {"notifyDamageAfterFrame", 3725}, + {"play_sound", 3726}, + {"toString", 3727}, + {"do_car_alarm", 3728}, + {"lastCarAlarmTime", 3729}, + {"car_alarm_timeout", 3730}, + {"should_do_car_alarm", 3731}, + {"do_random_dynamic_attachment", 3732}, + {"get_closest_with_targetname", 3733}, + {"player_touching_post_clip", 3734}, + {"get_player_touching", 3735}, + {"is_so", 3736}, + {"destructible_handles_collision_brushes", 3737}, + {"collision_brush_pre_explosion", 3738}, + {"collision_brush_post_explosion", 3739}, + {"func_destructible_crush_player", 3740}, + {"debug_player_in_post_clip", 3741}, + {"destructible_get_my_breakable_light", 3742}, + {"breakable_light", 3743}, + {"break_nearest_light", 3744}, + {"debug_radiusdamage_circle", 3745}, + {"debug_circle_drawlines", 3746}, + {"debug_line", 3747}, + {"spotlight_tag_origin_cleanup", 3748}, + {"spotlight_fizzles_out", 3749}, + {"destructible_spotlight_think", 3750}, + {"is_valid_damagetype", 3751}, + {"destructible_sound_think", 3752}, + {"destructible_fx_think", 3753}, + {"destructible_animation_think", 3754}, + {"no_destructible_animation", 3755}, + {"clear_anims", 3756}, + {"init_destroyed_count", 3757}, + {"destroyedCount", 3758}, + {"destroyedCountTimeout", 3759}, + {"init_destroyed_count", 3760}, + {"add_to_destroyed_count", 3761}, + {"get_destroyed_count", 3762}, + {"get_max_destroyed_count", 3763}, + {"init_destructible_frame_queue", 3764}, + {"destructibleFrameQueue", 3765}, + {"add_destructible_to_frame_queue", 3766}, + {"entNum", 3767}, + {"destructible", 3768}, + {"totalDamage", 3769}, + {"nearDistance", 3770}, + {"fxCost", 3771}, + {"handle_destructible_frame_queue", 3772}, + {"sort_destructible_frame_queue", 3773}, + {"get_better_destructible", 3774}, + {"get_part_FX_cost_for_action_state", 3775}, +// ... + {"hatModel", 3791}, + + {"vehicle", 3844}, + + {"rockets", 3974}, + + {"secondaryWeapon", 4095}, + {"startPos", 4116}, + {"winner", 4145}, + + {"scr_sound", 4538}, + {"play_sound_on_entity", 4570}, + {"play_sound_on_tag", 4595}, + {"script_bombmode_original", 4630}, + + {"challenge_targetVal", 4778}, + {"challenge_rewardVal", 4779}, + {"getChallengeStatus", 4780}, + {"challengeData", 4781}, + {"ch_getProgress", 4782}, + {"ch_getState", 4783}, + {"ch_setProgress", 4784}, + {"ch_setState", 4785}, + {"ch_getTarget", 4786}, + {"buildChallengeTableInfo", 4787}, + {"challengeInfo", 4788}, + {"challengeSplashNotify", 4790}, + {"optionalNumber", 4791}, + {"sound", 4792}, + {"slot", 4793}, + {"actionNotify", 4794}, + {"updateChallenges", 4795}, + {"giveRankXpAfterWait", 4797}, + {"processChallenge", 4799}, + {"initNotifyMessage", 4800}, + {"notifyTitle", 4802}, + {"notifyText", 4803}, + {"notifyText2", 4804}, + {"notifyIcon", 4805}, + {"doingSplash", 4808}, + {"splashQueue", 4809}, + {"maxRank", 4810}, + {"rankTable", 4811}, + {"scoreInfo", 4823}, + {"xpScale", 4824}, + {"fontPulseInit", 4839}, + {"baseFontScale", 4840}, + {"maxFontScale", 4841}, + {"inFrames", 4842}, + {"outFrames", 4843}, + {"fontPulse", 4844}, + {"updateRank", 4845}, + {"updateRankAnnounceHUD", 4847}, + {"titleText", 4848}, + {"iconName", 4849}, + {"duration", 4850}, + {"textLabel", 4851}, + {"notifyMessage", 4854}, + {"stringToFloat", 4855}, + {"actionNotifyMessage", 4856}, + {"removeTypeFromQueue", 4857}, + {"showNotifyMessage", 4858}, + {"titleLabel", 4859}, + {"titleIsString", 4860}, + {"text2Label", 4861}, + {"resetOnCancel", 4862}, + {"waitRequireVisibility", 4863}, + {"canReadText", 4864}, + {"isFlashbanged", 4865}, + {"dispatchNotify", 4866}, + {"registerScoreInfo", 4867}, + {"getScoreInfoValue", 4868}, + {"getRankInfoMinXP", 4869}, + {"getRankInfoXPAmt", 4870}, + {"getRankInfoMaxXp", 4871}, + {"getRankInfoFull", 4872}, + {"getRankInfoIcon", 4873}, + {"getRankForXp", 4874}, + {"getRankXP", 4875}, + + {"intensity", 5170}, + {"start", 5176}, + {"end", 5177}, + {"time", 5179}, + {"fx", 5182}, + {"delayThread_proc", 5192}, + {"currentNode", 5197}, + {"prev", 5243}, + {"mode", 5329}, + {"offset", 5614}, + {"_unk_field_ID5711", 5711}, // was introduced in an IW patch, used in _destructible.gsc + {"_unk_field_ID5797", 5797}, // was introduced in an IW patch, used in _destructible.gsc + {"inUse", 5801}, + {"pos", 5972}, + {"delay", 5980}, +// ... + {"points", 6070}, + {"icon", 6296}, + {"ps3", 6415}, + {"hud_damagefeedback", 6695}, + {"updateDamageFeedback", 6702}, + {"hidden", 6797}, + {"artStartVisionFileExport", 6858}, + {"artEndVisionFileExport", 6859}, + {"artStartFogFileExport", 6860}, + {"artEndFogFileExport", 6861}, + {"artCommonfxprintln", 6862}, + {"setfogsliders", 6863}, + {"translateFogSlidersToScript", 6864}, + {"fogexphalfplane", 6865}, + {"fognearplane", 6866}, + {"fogcolor", 6867}, + {"fogmaxopacity", 6868}, + {"sunFogEnabled", 6869}, + {"sunFogColor", 6870}, + {"sunFogDir", 6871}, + {"sunFogBeginFadeAngle", 6872}, + {"sunFogEndFadeAngle", 6873}, + {"sunFogScale", 6874}, + {"limit", 6875}, + {"updateFogFromScript", 6876}, + {"artfxprintlnFog", 6877}, + {"tweakart", 6886}, + {"startdist", 6890}, + {"halfwaydist", 6891}, + {"red", 6892}, + {"green", 6893}, + {"blue", 6894}, + {"maxopacity", 6895}, + {"fovslidercheck", 6923}, + {"create_vision_set_fog", 6930}, + {"transitionTime", 6931}, + {"dumpsettings", 6932}, + {"scale", 6943}, + {"vision_set_fog_changes", 6973}, +// ... + {"timeLimitOverride", 7122}, + {"func_loopfxthread", 7156}, + {"func_oneshotfxthread", 7157}, + {"func_create_loopsound", 7158}, + {"global_FX", 7159}, + {"global_FX_create", 7162}, + {"watchGrenadeUsage", 7163}, + {"c4explodethisframe", 7164}, + {"c4array", 7165}, + {"throwingGrenade", 7166}, + {"beginGrenadeTracking", 7177}, + {"grenade_earthQuake", 7178}, + {"beginC4Tracking", 7180}, + {"watchC4", 7181}, + {"c4Death", 7182}, + {"array_remove_nokeys", 7183}, + {"watchClaymores", 7184}, + {"claymoreDetonation", 7187}, + {"deleteOnDeath", 7190}, + {"watchC4Detonation", 7191}, + {"watchC4AltDetonation", 7192}, + {"waitAndDetonate", 7193}, + {"c4Damage", 7194}, + {"resetC4ExplodeThisFrame", 7195}, + {"saydamaged", 7196}, + {"getDamageableEnts", 7200}, + {"isPlayer", 7201}, + {"isADestructable", 7202}, + {"damageCenter", 7203}, + {"weaponDamageTracePassed", 7204}, + {"damageEnt", 7205}, + {"damageOrigin", 7206}, + {"callbackPlayerDamage", 7207}, + {"debugline", 7208}, + {"onWeaponDamage", 7209}, + {"watchC4AltDetonate", 7210}, + {"elevators", 7352}, + {"elevator_callbutton_link_v", 7353}, + {"elevator_callbutton_link_h", 7354}, + {"elevator_update_global_dvars", 7355}, + {"elevator_accel", 7356}, + {"elevator_decel", 7357}, + {"elevator_music", 7358}, + {"elevator_speed", 7359}, + {"elevator_innerdoorspeed", 7360}, + {"elevator_outterdoorspeed", 7361}, + {"elevator_return", 7362}, + {"elevator_waittime", 7363}, + {"elevator_aggressive_call", 7364}, + {"elevator_debug", 7365}, + {"elevator_motion_detection", 7366}, + {"elevator_think", 7367}, + {"elevator_call", 7368}, + {"elevator_callbuttons", 7369}, + {"floor_override", 7370}, + {"overrider", 7371}, + {"elevator_fsm", 7372}, + {"eState", 7373}, + {"moveto_floor", 7374}, + {"motion_trigger", 7375}, + {"elevator_interrupted", 7376}, + {"monitor_callbutton", 7377}, + {"e", 7378}, + {"call_elevator", 7379}, + {"get_floor", 7380}, + {"elevator_interrupt", 7381}, + {"elevator_floor_update", 7382}, + {"elevator_sound_think", 7383}, + {"listen_for", 7384}, + {"position_elevators", 7385}, + {"elevator_move", 7386}, + {"close_inner_doors", 7387}, + {"open_inner_doors", 7388}, + {"close_outer_doors", 7389}, + {"open_outer_doors", 7390}, + {"build_elevators", 7391}, + {"build_call_buttons", 7392}, + {"setup_hints", 7393}, + {"make_discrete_trigger", 7394}, + {"enabled", 7395}, + {"discrete_waittill", 7396}, + {"discrete_enable_triggerwaittill", 7397}, + {"disable_trigger", 7398}, + {"disable_trigger_helper", 7399}, + {"get_outer_doorset", 7400}, + {"get_outer_doorsets", 7401}, + {"get_outer_closedpos", 7402}, + {"get_outer_leftdoor", 7403}, + {"get_outer_rightdoor", 7404}, + {"get_outer_leftdoor_openedpos", 7405}, + {"get_outer_rightdoor_openedpos", 7406}, + {"get_housing_children", 7407}, + {"get_housing_mainframe", 7408}, + {"get_housing_models", 7409}, + {"get_housing_primarylight", 7410}, + {"get_housing_musak_model", 7411}, + {"get_housing_door_trigger", 7412}, + {"get_housing_inside_trigger", 7413}, + {"get_housing_closedpos", 7414}, + {"get_housing_leftdoor", 7415}, + {"get_housing_rightdoor", 7416}, + {"get_housing_leftdoor_opened_pos", 7417}, + {"get_housing_rightdoor_opened_pos", 7418}, + {"get_curFloor", 7419}, + {"get_initFloor", 7420}, + {"waittill_finish_moving", 7421}, + {"isInbound", 7422}, + {"isInBoundingSpere", 7423}, + {"waittill_or_timeout", 7424}, + {"elevator_get_dvar_int", 7425}, + {"elevator_get_dvar", 7426}, + {"_pipe_fx_time", 7427}, + {"_pipes", 7428}, + {"num_pipe_fx", 7429}, + {"pipesetup", 7430}, + {"pipe_fx_array", 7431}, + {"B", 7432}, + {"pipe_wait_loop", 7433}, + {"pipe_logic", 7434}, + {"_pipe_methods", 7435}, + {"pipefx", 7436}, + {"fx_time", 7437}, + {"_sound", 7438}, + {"pipe_damage", 7439}, + {"_dmg", 7440}, + {"allow_pipe_damage", 7441}, + {"pipesDamage", 7442}, + {"methodsInit", 7443}, + {"pipe_calc_ballistic", 7444}, + {"pipe_calc_splash", 7445}, + {"pipe_calc_nofx", 7446}, + {"precacheFX", 7447}, + {"onPlayerConnect", 7448}, + {"player_init", 7449}, + {"touchTriggers", 7450}, + {"ai_init", 7451}, + {"civilian_jet_flyby", 7452}, + {"jet_init", 7453}, + {"jet_parts", 7454}, + {"jet_flyto", 7455}, + {"engine_fxs", 7456}, + {"flash_fxs", 7457}, + {"jet_engine_fx", 7458}, + {"jet_flash_fx_red", 7459}, + {"jet_flash_fx_green", 7460}, + {"jet_flash_fx_blink", 7461}, + {"civilianJetFlyBy", 7462}, + {"old_origin", 7463}, + {"jet_fly_vec", 7464}, + {"jet_flight_time", 7465}, + {"jet_reset", 7466}, + {"jet_timer", 7467}, + {"civilianJetFlyBy_timer", 7468}, + {"airstrikeInProgress", 7469}, + {"ac130player", 7470}, + {"chopper", 7471}, + {"remoteMissileInProgress", 7472}, + {"getTimeInterval", 7473}, + {"getWatchedDvar", 7474}, + {"gameType", 7475}, + {"overrideWatchDvars", 7476}, + {"watchDvars", 7477}, + {"value", 7478}, + {"jet_flyby", 7479}, + {"mapCenter", 7480}, + {"jet_planeSound", 7481}, + {"playsound_float", 7482}, + {"playsound_loop_on_ent", 7483}, + {"targetIsInFront", 7484}, + {"targetIsClose", 7485}, + {"vending_machine", 7486}, + {"vm_normal", 7487}, + {"vm_launch_from", 7488}, + {"vm_launch_to", 7489}, + {"vm_fx_loc", 7490}, + {"vm_normal_model", 7491}, + {"vm_damaged_model", 7492}, + {"vm_soda_model", 7493}, + {"vm_soda_start_pos", 7494}, + {"vm_soda_start_angle", 7495}, + {"vm_soda_stop_pos", 7496}, + {"vm_soda_stop_angle", 7497}, + {"soda_array", 7498}, + {"soda_count", 7499}, + {"soda_slot", 7500}, + {"hp", 7501}, + {"vending_machine_damage_monitor", 7502}, + {"spawn_soda", 7503}, + {"soda_can_drop", 7504}, + {"soda_can_eject", 7505}, + {"ejected", 7506}, + {"freefall", 7507}, + {"metal_detector", 7508}, + {"alarm_interval", 7509}, + {"alarm_playing", 7510}, + {"alarm_annoyance", 7511}, + {"tolerance", 7512}, + {"playsound_and_light", 7513}, + {"annoyance_tracker", 7514}, + {"waittill_any_or_timeout", 7515}, + {"metal_detector_weapons", 7516}, + {"waittill_weapon_placed", 7517}, + {"weapon_notify_loop", 7518}, + {"isInBound_single", 7519}, + {"metal_detector_dmg_monitor", 7520}, + {"metal_detector_touch_monitor", 7521}, + {"alarm_validate_damage", 7522}, + {"creaky_board", 7523}, + {"do_creak", 7524}, + {"motion_light", 7525}, + {"moveTracker", 7526}, + {"lightsOn", 7527}, + {"lightRigs", 7528}, + {"touchList", 7529}, + {"distMoved", 7530}, + {"motion_light_timeout", 7531}, + {"outdoor_motion_dlight", 7532}, + {"outdoor_motion_light", 7533}, + {"lightEnt", 7534}, + {"outdoor_motion_dlight_timeout", 7535}, + {"dog_bark", 7536}, + {"trigger_door", 7537}, + {"doorEnt", 7538}, + {"doorAngle", 7539}, + {"baseYaw", 7540}, + {"doorOpen", 7541}, + {"doorClose", 7542}, + {"getDoorSide", 7543}, + {"use_toggle", 7544}, + {"bird_startle", 7545}, + {"photo_copier_init", 7546}, + {"copier", 7547}, + {"copy_bar", 7548}, + {"start_pos", 7549}, + {"light", 7550}, + {"end_pos", 7551}, + {"get_photo_copier", 7552}, + {"waittill_copier_copies", 7553}, + {"photo_copier", 7554}, + {"photo_copier_no_light", 7555}, + {"reset_copier", 7556}, + {"photo_copier_copy_bar_goes", 7557}, + {"photo_copier_light_on", 7558}, + {"photo_copier_stop", 7559}, + {"photo_light_flicker", 7560}, + {"fan_blade_rotate", 7561}, + {"triggerTouchThink", 7562}, + {"finished_spawning", 7563}, + {"playerTouchTriggerThink", 7564}, + {"guid", 7565}, + {"moveTrackers", 7566}, + {"gameEnded", 7567}, + {"movementTracker", 7568}, + {"DisablemovementTracker", 7569}, + {"anythingTouchingTrigger", 7570}, + {"playerTouchingTrigger", 7571}, + + {"inc", 7621}, + {"startYaw", 7622}, + {"windController", 7623}, + {"shutterWanderLeft", 7629}, + {"shutterWanderRight", 7630}, + {"wireWander", 7632}, + {"breakables_fx", 7644}, + {"barrelExpSound", 7647}, + {"barrelHealth", 7649}, + {"precachemodeltype", 7650}, + {"barrelExplodingThisFrame", 7651}, + {"breakables_clip", 7652}, + {"_breakable_utility_modelarray", 7656}, + {"_breakable_utility_modelindex", 7657}, + {"_breakable_utility_maxnum", 7658}, + {"oil_spill_think", 7674}, + {"barrel", 7675}, + {"oilspill", 7676}, + {"extra", 7677}, + {"oil_spill_burn_after", 7678}, + {"oil_spill_burn", 7679}, + {"oil_spill_burn_section", 7680}, + {"explodable_barrel_think", 7681}, + {"explodable_barrel_burn", 7682}, + {"explodable_barrel_explode", 7683}, + {"remove", 7684}, + {"flags", 7697}, + + {"breakable_clip", 7706}, + {"modelscale", 7712}, + {"getClosestEnt", 7714}, + {"item", 7724}, + {"anim_prop_models", 7743}, + {"weight", 7748}, + {"animateModel", 7752}, + {"script_print_fx", 7755}, + {"script_playfx", 7756}, + {"script_playfxontag", 7757}, + {"GrenadeExplosionfx", 7758}, + {"soundfx", 7759}, + {"soundfxDelete", 7760}, + {"blendDelete", 7763}, + {"setModelFromArray", 7765}, + {"precacheModelArray", 7766}, + {"attachHead", 7767}, + {"character_head_index", 7768}, + {"script_char_index", 7769}, + {"headModel", 7770}, + {"attachHat", 7771}, + {"character_hat_index", 7772}, + {"new", 7773}, + {"anim_gunHand", 7774}, + {"PutGunInHand", 7775}, + {"save", 7776}, + {"anim_gunInHand", 7777}, + {"load", 7778}, + {"get_random_character", 7779}, + {"script_char_group", 7780}, + {"character_index_cache", 7781}, + {"get_least_used_index", 7782}, + {"initialize_character_group", 7783}, + {"get_random_weapon", 7784}, + {"setupMiniMap", 7785}, + {"_loadStarted", 7787}, + {"mapSize", 7791}, + {"createClientFontString_func", 7809}, + {"HUDsetPoint_func", 7810}, + {"laserOn_func", 7813}, + {"laserOff_func", 7814}, + {"playerHealthRegen", 7829}, + {"script_prefab_exploder", 7864}, + {"script_accel", 7876}, + {"exploder_load", 7889}, + {"script_chance", 7890}, + {"script_disconnectpaths", 7900}, + {"setupExploders", 7902}, + {"script_ender", 7907}, +// ... + {"watchWeaponChange", 8106}, + {"friendlyfire", 8160}, + {"stance", 8366}, + {"monitorFlash", 8377}, + {"onDeath", 8440}, + {"oldRadius", 8677}, + {"debugprint", 8745}, + + {"export", 8809}, + {"deathtime", 8813}, + {"is_in_array", 8908}, + {"playerHealth_RegularRegenDelay", 8951}, + {"healthOverlayCutoff", 8954}, + {"text", 9005}, + {"mgTurret", 9469}, + {"script_team", 9482}, + {"draw_line", 9808}, + {"array_remove_index", 9844}, + {"flashRumbleLoop", 9870}, +// ... + {"xenon", 10039}, + {"endOnDeath", 10226}, + {"dirtEffect", 10234}, + {"entityHeadIconOffset", 10302}, + {"entityHeadIcon", 10304}, + {"script_targetoffset_z", 10338}, + {"currentWeapon", 10346}, + {"cobra_missile_models", 10351}, + {"fire_missile", 10352}, + {"cosine", 10359}, + {"attractor", 10372}, + {"turretType", 10381}, + {"turrets", 10389}, + {"script_airspeed", 10396}, + {"heli_damage_monitor", 10437}, + {"_unk_field_ID10635", 10635}, // was introduced in an IW patch, used in _destructible.gsc + {"_unk_field_ID10637", 10637}, // was introduced in an IW patch, used in _destructible.gsc + {"notifyString", 10732}, + {"init_animatedmodels", 11038}, + {"animation", 11039}, + {"strip_suffix", 11082}, + {"updateBarScale", 11083}, + {"rateOfChange", 11084}, + {"lastUpdateTime", 11085}, + {"createTimer", 11086}, + {"baseWidth", 11087}, + {"baseHeight", 11088}, + {"createServerIcon", 11089}, + {"createServerBar", 11090}, + {"getCurrentFraction", 11091}, + {"createPrimaryProgressBar", 11092}, + {"primaryProgressBarHeight", 11093}, + {"primaryProgressBarWidth", 11094}, + {"primaryProgressBarY", 11095}, + {"primaryProgressBarX", 11096}, + {"createPrimaryProgressBarText", 11097}, + {"primaryProgressBarFontSize", 11098}, + {"primaryProgressBarTextY", 11099}, + {"primaryProgressBarTextX", 11100}, + {"createTeamProgressBar", 11101}, + {"teamProgressBarHeight", 11102}, + {"teamProgressBarWidth", 11103}, + {"teamProgressBarY", 11104}, + {"createTeamProgressBarText", 11105}, + {"teamProgressBarFontSize", 11106}, + {"teamProgressBarTextY", 11107}, + {"hideElem", 11108}, + {"showElem", 11109}, + {"getIconShader", 11110}, + {"setIconSize", 11111}, + {"transitionReset", 11112}, + {"transitionZoomIn", 11113}, + {"transitionPulseFXIn", 11114}, + {"transitionSlideIn", 11115}, + {"transitionSlideOut", 11116}, + {"transitionZoomOut", 11117}, + {"transitionFadeIn", 11118}, + {"maxAlpha", 11119}, + {"transitionFadeOut", 11120}, + {"getWeeklyRef", 11121}, + {"getDailyRef", 11122}, + {"hud", 11123}, + {"splitscreen", 11124}, + {"lowerTextYAlign", 11125}, + {"lowerTextY", 11126}, + {"lowerTextFontSize", 11127}, + {"getHighestScoringPlayer", 11128}, + {"placement", 11129}, + {"getLosingPlayers", 11130}, + {"givePlayerScore", 11131}, + {"rankingEnabled", 11132}, + {"hardcoreMode", 11133}, + {"xpPointsPopup", 11134}, + {"statAdd", 11135}, + {"statSetChild", 11136}, + {"teamBased", 11137}, + {"checkPlayerScoreLimitSoon", 11138}, + {"checkScoreLimit", 11139}, + {"onPlayerScore", 11140}, + {"objectivePointsMod", 11141}, + {"_getPlayerScore", 11142}, + {"_setPlayerScore", 11143}, + {"giveTeamScoreForObjective", 11144}, + {"otherTeam", 11145}, + {"wasWinning", 11146}, + {"lastStatusTime", 11147}, + {"getScoreLimit", 11148}, + {"leaderDialog", 11149}, + {"getWinningTeam", 11150}, + {"_setTeamScore", 11151}, + {"overtimeScoreWinOverride", 11152}, + {"onScoreLimit", 11153}, + {"checkTeamScoreLimitSoon", 11154}, + {"updateTeamScore", 11155}, + {"isRoundBased", 11156}, + {"isObjectiveBased", 11157}, + {"_getTeamScore", 11158}, + {"sendUpdatedTeamScores", 11159}, + {"WaitTillSlowProcessAllowed", 11160}, + {"sendUpdatedDMScores", 11161}, + {"updatedDMScores", 11162}, + {"removeDisconnectedPlayerFromPlacement", 11163}, + {"updatePlacement", 11164}, + {"connectedPostGame", 11165}, + {"getBetterPlayer", 11166}, + {"updateTeamPlacement", 11167}, + {"initialDMScoreUpdate", 11168}, + {"processAssist", 11169}, + {"onXPEvent", 11170}, + {"incPersStat", 11171}, + {"getPersStat", 11172}, + {"incPlayerStat", 11173}, + {"giveAdrenaline", 11174}, + {"playerAssist", 11175}, + {"processShieldAssist", 11176}, + {"splashNotifyDelayed", 11177}, + {"getTweakableDVarValue", 11178}, + {"rules", 11179}, + {"dVar", 11180}, + {"gameTweaks", 11181}, + {"teamTweaks", 11182}, + {"playerTweaks", 11183}, + {"classTweaks", 11184}, + {"weaponTweaks", 11185}, + {"hardpointTweaks", 11186}, + {"hudTweaks", 11187}, + {"getTweakableDVar", 11188}, + {"getTweakableValue", 11189}, + {"getTweakableLastValue", 11190}, + {"lastValue", 11191}, + {"setTweakableValue", 11192}, + {"setTweakableLastValue", 11193}, + {"registerTweakable", 11194}, + {"clientTweakables", 11195}, + {"tweakablesInitialized", 11196}, + {"minefields", 11197}, + {"minefield_think", 11198}, + {"minefield_kill", 11199}, + {"minefield", 11200}, + {"radiation", 11201}, + {"numAreas", 11202}, + {"playerEnterArea", 11203}, + {"playerLeaveArea", 11204}, + {"poison", 11205}, + {"radiationOverlay", 11206}, + {"soundWatcher", 11207}, + {"radiationEffect", 11208}, + {"radiationSound", 11209}, + {"blackout", 11210}, + {"doRadiationDamage", 11211}, + {"fadeinBlackOut", 11212}, + {"fadeoutBlackOut", 11213}, + {"destructable_think", 11214}, + {"script_accumulate", 11215}, + {"script_threshold", 11216}, + {"script_destructable_area", 11217}, + {"destructable_destruct", 11218}, + {"blockArea", 11219}, + {"blockEntsInArea", 11220}, + {"blockedoff", 11221}, + {"unblockArea", 11222}, + {"unblockEntsInArea", 11223}, + {"Callback_HostMigration", 11224}, + {"hostMigrationReturnedPlayerCount", 11225}, + {"hostMigrationTimer", 11226}, + {"UpdateTimerPausedness", 11227}, + {"updateGameEvents", 11228}, + {"hostMigrationWait", 11229}, + {"inGracePeriod", 11230}, + {"matchStartTimer", 11231}, + {"hostMigrationWaitForPlayers", 11232}, + {"hostMigrationTimerThink_Internal", 11233}, + {"hostMigrationControlsFrozen", 11234}, + {"isReallyAlive", 11235}, + {"freezeControlsWrapper", 11236}, + {"hostMigrationTimerThink", 11237}, + {"waitTillHostMigrationDone", 11238}, + {"waitTillHostMigrationDone", 11239}, + {"waitLongDurationWithHostMigrationPause", 11240}, + {"waitLongDurationWithGameEndTimeUpdate", 11241}, + {"teamBalance", 11242}, + {"maxClients", 11243}, + {"freeplayers", 11244}, + {"initScoreBoard", 11245}, + {"onFreePlayerConnect", 11246}, + {"onJoinedTeam", 11247}, + {"onJoinedSpectators", 11248}, + {"trackPlayedTime", 11249}, + {"timePlayed", 11250}, + {"gameFlagWait", 11251}, + {"updatePlayerTimes", 11252}, + {"rankedmatch", 11253}, + {"updatePlayedTime", 11254}, + {"statAddBuffered", 11255}, + {"statAddChildBuffered", 11256}, + {"bufferedChildStatsMax", 11257}, + {"statAddChildBufferedWithMax", 11258}, + {"bufferedStatsMax", 11259}, + {"statAddBufferedWithMax", 11260}, + {"updateTeamTime", 11261}, + {"updateTeamBalanceDvar", 11262}, + {"updateTeamBalance", 11263}, + {"teamLimit", 11264}, + {"getTeamBalance", 11265}, + {"balanceTeams", 11266}, + {"dont_auto_balance", 11267}, + {"axis", 11268}, + {"allies", 11269}, + {"setGhillieModels", 11270}, + {"environment", 11271}, + {"setTeamModels", 11272}, + {"setPlayerModels", 11273}, + {"playerModelForWeapon", 11274}, + {"isJuggernaut", 11275}, + {"CountPlayers", 11276}, + {"trackFreePlayedTime", 11277}, + {"updateFreePlayerTimes", 11278}, + {"updateFreePlayedTime", 11279}, + {"getJoinTeamPermissions", 11280}, + {"onPlayerSpawned", 11281}, + {"getTeamName", 11282}, + {"getTeamShortName", 11283}, + {"getTeamForfeitedString", 11284}, + {"getTeamEliminatedString", 11285}, + {"getTeamIcon", 11286}, + {"getTeamHudIcon", 11287}, + {"getTeamHeadIcon", 11288}, + {"getTeamVoicePrefix", 11289}, + {"getTeamSpawnMusic", 11290}, + {"getTeamWinMusic", 11291}, + {"getTeamFlagModel", 11292}, + {"getTeamFlagCarryModel", 11293}, + {"getTeamFlagIcon", 11294}, + {"getTeamFlagFX", 11295}, + {"getTeamColor", 11296}, + {"getTeamCrateModel", 11297}, + {"getTeamDeployModel", 11298}, + {"initedEntityHeadIcons", 11299}, + {"setHeadIcon", 11300}, + {"entityHeadIcons", 11301}, + {"getPlayerForGuid", 11302}, + {"destroyOnOwnerDisconnect", 11303}, + {"destroyIconsOnDeath", 11304}, + {"keepPositioned", 11305}, + {"setTeamHeadIcon", 11306}, + {"entityHeadIconTeam", 11307}, + {"setPlayerHeadIcon", 11308}, + {"keepIconPositioned", 11309}, + {"destroyHeadIconsOnDeath", 11310}, + {"updateHeadIconOrigin", 11311}, + {"watchTrophyUsage", 11312}, + {"trophyArray", 11313}, + {"maxPerPlayerExplosives", 11314}, + {"createBombSquadModel", 11315}, + {"weaponName", 11316}, + {"trophyRemainingAmmo", 11317}, + {"ammo", 11318}, + {"trigger", 11319}, + {"c4EMPKillstreakWait", 11320}, + {"trophyUseListener", 11321}, + {"setSelfUsable", 11322}, + {"notUsableForJoiningPlayers", 11323}, + {"givePerk", 11324}, + {"trophyPlayerSpawnWaiter", 11325}, + {"trophyDisconnectWaiter", 11326}, + {"trophyActive", 11327}, + {"grenades", 11328}, + {"missiles", 11329}, + {"disabled", 11330}, + {"combineArrays", 11331}, + {"sentry_fire", 11332}, + {"projectileExplode", 11333}, + {"empGrenadeExplode", 11334}, + {"mine_explode", 11335}, + {"trophyDamage", 11336}, + {"friendlyFireCheck", 11337}, + {"iDFLAGS_PENETRATION", 11338}, + {"wasDamagedFromBulletPenetration", 11339}, + {"wasDamaged", 11340}, + {"trophyBreak", 11341}, + {"startMonitoringFlash", 11342}, + {"stopMonitoringFlash", 11343}, + {"usingRemote", 11344}, + {"stunScaler", 11345}, + {"applyFlash", 11346}, + {"flashDuration", 11347}, + {"flashRumbleDuration", 11348}, + {"monitorEMPGrenade", 11349}, + {"empEndTime", 11350}, + {"_hasPerk", 11351}, + {"applyEMP", 11352}, + {"empDuration", 11353}, + {"empGrenaded", 11354}, + {"empGrenadeDeathWaiter", 11355}, + {"checkToTurnOffEmp", 11356}, + {"teamEMPed", 11357}, + {"EMPPlayer", 11358}, + {"empRumbleLoop", 11359}, + {"isEMPGrenaded", 11360}, + {"InitStingerUsage", 11361}, + {"stingerStage", 11362}, + {"stingerTarget", 11363}, + {"stingerLockStartTime", 11364}, + {"stingerLostSightlineTime", 11365}, + {"stingerTargets", 11366}, + {"ResetStingerLocking", 11367}, + {"stingerUseEntered", 11368}, + {"ResetStingerLockingOnDeath", 11369}, + {"StillValidStingerLock", 11370}, + {"ac130", 11371}, + {"planemodel", 11372}, + {"LoopStingerLockingFeedback", 11373}, + {"LoopStingerLockedFeedback", 11374}, + {"LockSightTest", 11375}, + {"StingerDebugDraw", 11376}, + {"SoftSightTest", 11377}, + {"GetTargetList", 11378}, + {"harriers", 11379}, + {"uavmodels", 11380}, + {"littleBirds", 11381}, + {"ugvs", 11382}, + {"StingerUsageLoop", 11383}, + {"InitJavelinUsage", 11384}, + {"javelinStage", 11385}, + {"javelinPoints", 11386}, + {"javelinNormals", 11387}, + {"javelinLockMisses", 11388}, + {"javelinTargetPoint", 11389}, + {"javelinTargetNormal", 11390}, + {"javelinLockStartTime", 11391}, + {"ResetJavelinLocking", 11392}, + {"javelinUseEntered", 11393}, + {"currentlyLocking", 11394}, + {"currentlyLocked", 11395}, + {"javelinTarget", 11396}, + {"EyeTraceForward", 11397}, + {"LockMissesReset", 11398}, + {"LockMissesIncr", 11399}, + {"LockMissesPassedThreshold", 11400}, + {"TargetPointTooClose", 11401}, + {"LoopLocalSeekSound", 11402}, + {"TopAttackPasses", 11403}, + {"JavelinUsageLoop", 11404}, + {"isEMPed", 11405}, + {"javelinLostSightlineTime", 11406}, + {"DebugSightLine", 11407}, + {"VehicleLockSightTest", 11408}, + {"javelinLockVehicle", 11409}, + {"StillValidJavelinLock", 11410}, + {"shellshockOnDamage", 11411}, + {"shellShockReduction", 11412}, + {"isUsingRemote", 11413}, + {"bloodEffect", 11414}, + {"c4_earthQuake", 11415}, + {"barrel_earthQuake", 11416}, + {"artillery_earthQuake", 11417}, + {"attachmentGroup", 11418}, + {"getAttachmentList", 11419}, + {"scavenger_altmode", 11420}, + {"scavenger_secondary", 11421}, + {"getIntProperty", 11422}, + {"riotShieldXPBullets", 11423}, + {"weaponList", 11424}, + {"claymoreDetectionDot", 11425}, + {"claymoreDetectionMinDist", 11426}, + {"claymoreDetectionGracePeriod", 11427}, + {"claymoreDetonateRadius", 11428}, + {"mineDetectionGracePeriod", 11429}, + {"mineDetectionRadius", 11430}, + {"mineDetectionHeight", 11431}, + {"mineDamageRadius", 11432}, + {"mineDamageMin", 11433}, + {"mineDamageMax", 11434}, + {"mineDamageHalfHeight", 11435}, + {"mineSelfDestructTime", 11436}, + {"mine_launch", 11437}, + {"mine_spin", 11438}, + {"mine_beacon", 11439}, + {"delayMineTime", 11440}, + {"stingerFXid", 11441}, + {"primary_weapon_array", 11442}, + {"side_arm_array", 11443}, + {"grenade_array", 11444}, + {"missile_array", 11445}, + {"inventory_array", 11446}, + {"mines", 11447}, + {"dumpIt", 11448}, + {"bombSquadWaiter", 11449}, + {"bombSquadVisibilityUpdater", 11450}, + {"hits", 11451}, + {"hasDoneCombat", 11452}, + {"currentWeaponAtSpawn", 11453}, + {"concussionEndTime", 11454}, + {"trackingWeaponName", 11455}, + {"trackingWeaponShots", 11456}, + {"trackingWeaponKills", 11457}, + {"trackingWeaponHits", 11458}, + {"trackingWeaponHeadShots", 11459}, + {"trackingWeaponDeaths", 11460}, + {"trackRiotShield", 11461}, + {"lastHitTime", 11462}, + {"droppedDeathWeapon", 11463}, + {"tookWeaponFrom", 11464}, + {"sniperDustWatcher", 11465}, + {"getWeaponClass", 11466}, + {"WatchStingerUsage", 11467}, + {"WatchJavelinUsage", 11468}, + {"lastDroppableWeapon", 11469}, + {"hitsThisMag", 11470}, + {"isCACPrimaryWeapon", 11471}, + {"bothBarrels", 11472}, + {"isKillstreakWeapon", 11473}, + {"changingWeapon", 11474}, + {"class_num", 11475}, + {"loadoutPrimaryBuff", 11476}, + {"cac_getWeapon", 11477}, + {"_unsetPerk", 11478}, + {"loadoutSecondaryBuff", 11479}, + {"watchStartWeaponChange", 11480}, + {"watchWeaponReload", 11481}, + {"watchRangerUsage", 11482}, + {"isHackWeapon", 11483}, + {"mayDropWeapon", 11484}, + {"dropWeaponForDeath", 11485}, + {"blockWeaponDrops", 11486}, + {"ownersattacker", 11487}, + {"detachIfAttached", 11488}, + {"deletePickupAfterAWhile", 11489}, + {"getItemWeaponName", 11490}, + {"watchPickup", 11491}, + {"itemRemoveAmmoFromAltModes", 11492}, + {"handleScavengerBagPickup", 11493}, + {"dropScavengerForDeath", 11494}, + {"getWeaponBasedGrenadeCount", 11495}, + {"getWeaponBasedSmokeGrenadeCount", 11496}, + {"getFragGrenadeCount", 11497}, + {"getSmokeGrenadeCount", 11498}, + {"setWeaponStat", 11499}, + {"watchWeaponUsage", 11500}, + {"statGetBuffered", 11501}, + {"statSetBuffered", 11502}, + {"lastStandParams", 11503}, + {"lastStandStartTime", 11504}, + {"updateMagShots", 11505}, + {"checkHitsThisMag", 11506}, + {"genericChallenge", 11507}, + {"checkHit", 11508}, + {"attackerCanDamageItem", 11509}, + {"gotPullbackNotify", 11510}, + {"claymorearray", 11511}, + {"bouncingbettyArray", 11512}, + {"isCooked", 11513}, + {"originalOwner", 11514}, + {"watchSmokeExplode", 11515}, + {"inPlayerSmokeScreen", 11516}, + {"waitSmokeTime", 11517}, + {"AddMissileToSightTraces", 11518}, + {"missilesForSightTraces", 11519}, + {"watchMissileUsage", 11520}, + {"setAltSceneObj", 11521}, + {"watchSentryUsage", 11522}, + {"empExplodeWaiter", 11523}, + {"watchForThrowbacks", 11524}, + {"threwBack", 11525}, + {"activated", 11526}, + {"c4EMPDamage", 11527}, + {"setClaymoreTeamHeadIcon", 11528}, + {"equipmentWatchUse", 11529}, + {"shouldAffectClaymore", 11530}, + {"c4Activate", 11531}, + {"deleteC4AndClaymoresOnDisconnect", 11532}, + {"wasChained", 11533}, + {"waitTillEnabled", 11534}, + {"c4DetectionTrigger", 11535}, + {"detectId", 11536}, + {"bombSquadIcon", 11537}, + {"claymoreDetectionTrigger", 11538}, + {"detectIconWaiter", 11539}, + {"detectExplosives", 11540}, + {"bombSquadIds", 11541}, + {"setupBombSquad", 11542}, + {"bombSquadIcons", 11543}, + {"showHeadIcon", 11544}, + {"get_damageable_player_pos", 11545}, + {"get_damageable_player", 11546}, + {"get_damageable_grenade_pos", 11547}, + {"get_damageable_grenade", 11548}, + {"get_damageable_sentry", 11549}, + {"get_damageable_mine", 11550}, + {"getEMPDamageEnts", 11551}, + {"debugcircle", 11552}, + {"isAltModeWeapon", 11553}, + {"isInventoryWeapon", 11554}, + {"isRiotShield", 11555}, + {"isOffhandWeapon", 11556}, + {"isSideArm", 11557}, + {"isGrenade", 11558}, + {"updateSavedLastWeapon", 11559}, + {"updateWeaponRank", 11560}, + {"getWeaponRank", 11561}, + {"isDeathStreakWeapon", 11562}, + {"clearEMPOnDeath", 11563}, + {"updateMoveSpeedScale", 11564}, + {"getBaseWeaponName", 11565}, + {"weaponSpeed", 11566}, + {"moveSpeedScaler", 11567}, + {"stanceRecoilAdjuster", 11568}, + {"setRecoilScale", 11569}, + {"buildWeaponData", 11570}, + {"baseName", 11571}, + {"assetName", 11572}, + {"variants", 11573}, + {"monitorSemtex", 11574}, + {"isStuck", 11575}, + {"stuckEnemyEntity", 11576}, + {"playerCardSplashNotify", 11577}, + {"splashNotify", 11578}, + {"turret_monitorUse", 11579}, + {"turret_playerThread", 11580}, + {"spawnMine", 11581}, + {"killCamOffset", 11582}, + {"killCamEnt", 11583}, + {"equipmentMines", 11584}, + {"killstreakMines", 11585}, + {"mineDamageMonitor", 11586}, + {"mineProximityTrigger", 11587}, + {"mineDeleteTrigger", 11588}, + {"mineSelfDestruct", 11589}, + {"mineBounce", 11590}, + {"mineExplode", 11591}, + {"playSpinnerFX", 11592}, + {"mineDamageDebug", 11593}, + {"mineDamageHeightPassed", 11594}, + {"getStanceCenter", 11595}, + {"watchMineUsage", 11596}, + {"mineThrown", 11598}, + {"mineBeacon", 11599}, + {"mineBeaconTeamUpdater", 11600}, + {"MaxLives", 11601}, + {"MaxNameLength", 11602}, + {"MaxEvents", 11603}, + {"MaxKillstreaks", 11604}, + {"MaxLogClients", 11605}, + {"MaxNumChallengesPerPlayer", 11606}, + {"MaxNumAwardsPerPlayer", 11607}, + {"getMatchDateTime", 11608}, + {"logKillstreakEvent", 11609}, + {"clientid", 11610}, + {"logGameEvent", 11611}, + {"logKillEvent", 11612}, + {"logMultiKill", 11613}, + {"logPlayerLife", 11614}, + {"spawnPos", 11615}, + {"wasTI", 11616}, + {"spawnTime", 11617}, + {"logPlayerXP", 11618}, + {"logLoadout", 11619}, + {"curClass", 11620}, + {"getClassIndex", 11621}, + {"cac_getWeaponAttachment", 11622}, + {"cac_getWeaponAttachmentTwo", 11623}, + {"cac_getOffhand", 11624}, + {"cac_getPerk", 11625}, + {"cac_getDeathstreak", 11626}, + {"cac_getWeaponBuff", 11627}, + {"cac_getKillstreak", 11628}, + {"classTableName", 11629}, + {"table_getWeapon", 11630}, + {"table_getWeaponAttachment", 11631}, + {"table_getOffhand", 11632}, + {"table_getEquipment", 11633}, + {"table_getPerk", 11634}, + {"table_getDeathstreak", 11635}, + {"table_getWeaponBuff", 11636}, + {"table_getKillstreak", 11637}, + {"validateAttachment", 11638}, + {"logPlayerDeath", 11639}, + {"isAttachment", 11640}, + {"logPlayerData", 11641}, + {"endOfGameSummaryLogger", 11642}, + {"weaponsUsed", 11643}, + {"weaponXpEarned", 11644}, + {"challengesCompleted", 11645}, + {"doubleBubbleSort", 11646}, + {"gameEndListener", 11647}, + {"getNextLifeId", 11648}, + {"canLogClient", 11649}, + {"canLogEvent", 11650}, + {"canLogKillstreak", 11651}, + {"canLogLife", 11652}, + {"logWeaponStat", 11653}, + {"logAttachmentStat", 11654}, + {"buildBaseWeaponList", 11655}, + {"logChallenge", 11656}, + {"logAward", 11657}, + {"killstreakFuncs", 11658}, + {"tryUseAllPerks", 11659}, + {"tryUseBlindEye", 11660}, + {"tryUsePaint", 11661}, + {"tryUseAssists", 11662}, + {"tryUseSteadyAim", 11663}, + {"tryUseStalker", 11664}, + {"tryUseExtremeConditioning", 11665}, + {"tryUseSleightOfHand", 11666}, + {"tryUseScavenger", 11667}, + {"tryUseHardline", 11668}, + {"setStreakCountToNext", 11669}, + {"tryUseColdBlooded", 11670}, + {"tryUseQuickdraw", 11671}, + {"tryUseBlastshield", 11672}, + {"tryUseSitRep", 11673}, + {"tryUseIronLungs", 11674}, + {"tryUseAssassin", 11675}, + {"tryUseDeadSilence", 11676}, + {"doPerkFunctions", 11677}, + {"watchDeath", 11678}, + {"_unsetExtraPerks", 11679}, + {"checkForPerkUpgrade", 11680}, + {"getPerkUpgrade", 11681}, + {"isPerkStreakOn", 11682}, + {"streakName", 11683}, + {"available", 11684}, + {"setScrambler", 11685}, + {"_giveWeapon", 11686}, + {"unsetScrambler", 11687}, + {"deleteScrambler", 11688}, + {"inPlayerScrambler", 11689}, + {"deployedScrambler", 11690}, + {"scramblers", 11691}, + {"cleanArray", 11692}, + {"monitorScramblerUse", 11693}, + {"scramblerSetup", 11694}, + {"scramblerWatchOwner", 11695}, + {"scramblerBeepSounds", 11696}, + {"scramblerDamageListener", 11697}, + {"deathEffect", 11698}, + {"scramblerUseListener", 11699}, + {"scramblerProximityTracker", 11700}, + {"scramProxyActive", 11701}, + {"scramProxyPerk", 11702}, + {"setPortableRadar", 11703}, + {"unsetPortableRadar", 11704}, + {"deletePortableRadar", 11705}, + {"inPlayerPortableRadar", 11706}, + {"deployedPortableRadar", 11707}, + {"monitorPortableRadarUse", 11708}, + {"portableRadarSetup", 11709}, + {"portableRadarWatchOwner", 11710}, + {"portableRadarBeepSounds", 11711}, + {"portableRadarDamageListener", 11712}, + {"portableRadarUseListener", 11713}, + {"portableRadarProximityTracker", 11714}, + {"perkFuncs", 11715}, + {"precacheModel", 11716}, + {"spawnGlow", 11717}, + {"spawnFire", 11718}, + {"scriptPerks", 11719}, + {"perkSetFuncs", 11720}, + {"perkUnsetFuncs", 11721}, + {"fauxPerks", 11722}, + {"setBlastShield", 11723}, + {"unsetBlastShield", 11724}, + {"setSiege", 11725}, + {"unsetSiege", 11726}, + {"setFreefall", 11727}, + {"unsetFreefall", 11728}, + {"setLocalJammer", 11729}, + {"unsetLocalJammer", 11730}, + {"setThermal", 11731}, + {"unsetThermal", 11732}, + {"setBlackBox", 11733}, + {"unsetBlackBox", 11734}, + {"setLightWeight", 11735}, + {"unsetLightWeight", 11736}, + {"setSteelNerves", 11737}, + {"unsetSteelNerves", 11738}, + {"setDelayMine", 11739}, + {"unsetDelayMine", 11740}, + {"setChallenger", 11741}, + {"unsetChallenger", 11742}, + {"setSaboteur", 11743}, + {"unsetSaboteur", 11744}, + {"setEndGame", 11745}, + {"unsetEndGame", 11746}, + {"setRearView", 11747}, + {"unsetRearView", 11748}, + {"setAC130", 11749}, + {"unsetAC130", 11750}, + {"setSentryMinigun", 11751}, + {"unsetSentryMinigun", 11752}, + {"setPredatorMissile", 11753}, + {"unsetPredatorMissile", 11754}, + {"setTank", 11755}, + {"unsetTank", 11756}, + {"setPrecision_airstrike", 11757}, + {"unsetPrecision_airstrike", 11758}, + {"setHelicopterMinigun", 11759}, + {"unsetHelicopterMinigun", 11760}, + {"setOneManArmy", 11761}, + {"unsetOneManArmy", 11762}, + {"setLittlebirdSupport", 11763}, + {"unsetLittlebirdSupport", 11764}, + {"setTacticalInsertion", 11765}, + {"unsetTacticalInsertion", 11766}, + {"setSteadyAimPro", 11767}, + {"unsetSteadyAimPro", 11768}, + {"setStunResistance", 11769}, + {"unsetStunResistance", 11770}, + {"setMarksman", 11771}, + {"unsetMarksman", 11772}, + {"setDoubleLoad", 11773}, + {"unsetDoubleLoad", 11774}, + {"setSharpFocus", 11775}, + {"unsetSharpFocus", 11776}, + {"setHardShell", 11777}, + {"unsetHardShell", 11778}, + {"setRegenSpeed", 11779}, + {"unsetRegenSpeed", 11780}, + {"setAutoSpot", 11781}, + {"unsetAutoSpot", 11782}, + {"setEmpImmune", 11783}, + {"unsetEmpImmune", 11784}, + {"setOverkillPro", 11785}, + {"unsetOverkillPro", 11786}, + {"setCombatHigh", 11787}, + {"unsetCombatHigh", 11788}, + {"setLightArmor", 11789}, + {"unsetLightArmor", 11790}, + {"setRevenge", 11791}, + {"unsetRevenge", 11792}, + {"setC4Death", 11793}, + {"unsetC4Death", 11794}, + {"setFinalStand", 11795}, + {"unsetFinalStand", 11796}, + {"setJuiced", 11797}, + {"unsetJuiced", 11798}, + {"setCarePackage", 11799}, + {"unsetCarePackage", 11800}, + {"setStoppingPower", 11801}, + {"unsetStoppingPower", 11802}, + {"setUAV", 11803}, + {"unsetUAV", 11804}, + {"precacheShaders", 11805}, + {"validatePerk", 11806}, + {"perks", 11807}, + {"omaClassChanged", 11808}, + {"playerProximityTracker", 11809}, + {"proximityActive", 11810}, + {"drawLine", 11811}, + {"cac_modified_damage", 11812}, + {"xpScaler", 11813}, + {"isBulletDamage", 11814}, + {"setPainted", 11816}, + {"bulletDamageMod", 11817}, + {"armorVestMod", 11818}, + {"explosiveDamageMod", 11819}, + {"blastShieldMod", 11820}, + {"dangerCloseMod", 11821}, + {"hasLightArmor", 11822}, + {"damageBlockedTotal", 11823}, + {"initPerkDvars", 11824}, + {"armorVestDefMod", 11825}, + {"armorPiercingMod", 11826}, + {"riotShieldMod", 11827}, + {"cac_selector", 11828}, + {"specialty", 11829}, + {"gambitUseTracker", 11830}, + {"giveBlindEyeAfterSpawn", 11831}, + {"avoidKillstreakOnSpawnTimer", 11832}, + {"objPointNames", 11833}, + {"objPoints", 11834}, + {"objPointSize", 11835}, + {"objpoint_alpha_default", 11836}, + {"objPointScale", 11837}, + {"createTeamObjpoint", 11838}, + {"isFlashing", 11839}, + {"isShown", 11840}, + {"baseAlpha", 11841}, + {"deleteObjPoint", 11842}, + {"setOriginByName", 11843}, + {"getObjPointByName", 11844}, + {"getObjPointByIndex", 11845}, + {"startFlashing", 11846}, + {"stopFlashing", 11847}, + {"script_gameobjectname", 11848}, + {"numGametypeReservedObjectives", 11849}, + {"objIDStart", 11850}, + {"carryObject", 11851}, + {"claimTrigger", 11852}, + {"canPickupObject", 11853}, + {"killedInUse", 11854}, + {"onPlayerDisconnect", 11855}, + {"createCarryObject", 11856}, + {"curOrigin", 11857}, + {"ownerTeam", 11858}, + {"triggerType", 11859}, + {"baseOrigin", 11860}, + {"useWeapon", 11861}, + {"offset3d", 11862}, + {"baseAngles", 11863}, + {"visuals", 11864}, + {"compassIcons", 11865}, + {"objIDAllies", 11866}, + {"objIDAxis", 11867}, + {"objIDPingFriendly", 11868}, + {"objIDPingEnemy", 11869}, + {"carrier", 11870}, + {"isResetting", 11871}, + {"interactTeam", 11872}, + {"allowWeapons", 11873}, + {"worldIcons", 11874}, + {"carrierVisible", 11875}, + {"visibleTeam", 11876}, + {"carryIcon", 11877}, + {"onDrop", 11878}, + {"onPickup", 11879}, + {"onReset", 11880}, + {"curProgress", 11881}, + {"useTime", 11882}, + {"useRate", 11883}, + {"teamUseTimes", 11884}, + {"teamUseTexts", 11885}, + {"numTouching", 11886}, + {"claimTeam", 11887}, + {"claimPlayer", 11888}, + {"lastClaimTeam", 11889}, + {"lastClaimTime", 11890}, + {"carryObjectUseThink", 11891}, + {"carryObjectProxThink", 11892}, + {"carryObjectProxThinkInstant", 11893}, + {"carryObjectProxThinkDelayed", 11894}, + {"onEndUse", 11895}, + {"onUseUpdate", 11896}, + {"pickupObjectDelay", 11897}, + {"setPickedUp", 11898}, + {"onPickupFailed", 11899}, + {"updateCarryObjectOrigin", 11900}, + {"wait_endon", 11901}, + {"giveObject", 11902}, + {"returnHome", 11903}, + {"isHome", 11904}, + {"setPosition", 11905}, + {"onPlayerLastStand", 11906}, + {"setDropped", 11907}, + {"body", 11908}, + {"safeOrigin", 11909}, + {"setCarrier", 11910}, + {"clearCarrier", 11911}, + {"pickupTimeout", 11912}, + {"autoResetTime", 11913}, + {"takeObject", 11914}, + {"trackCarrier", 11915}, + {"manualDropThink", 11916}, + {"deleteUseObject", 11917}, + {"_objective_delete", 11918}, + {"createUseObject", 11919}, + {"keyObject", 11920}, + {"onUse", 11921}, + {"onCantUse", 11922}, + {"useText", 11923}, + {"setKeyObject", 11924}, + {"useObjectUseThink", 11925}, + {"onBeginUse", 11926}, + {"cantUseHintThink", 11927}, + {"getEarliestClaimPlayer", 11928}, + {"startTime", 11929}, + {"useObjectProxThink", 11930}, + {"proxTriggerThink", 11931}, + {"carryFlag", 11932}, + {"proxTriggerLOS", 11933}, + {"requiresLOS", 11934}, + {"setClaimTeam", 11935}, + {"getClaimTeam", 11936}, + {"noUseBar", 11937}, + {"updateProxBar", 11938}, + {"proxBar", 11939}, + {"proxBarText", 11940}, + {"lastUseRate", 11941}, + {"lastHostMigrationState", 11942}, + {"updateUseRate", 11943}, + {"objectiveScaler", 11944}, + {"isArena", 11945}, + {"attachUseModel", 11946}, + {"attachedUseModel", 11947}, + {"useHoldThink", 11948}, + {"lastNonUseWeapon", 11949}, + {"detachUseModels", 11950}, + {"takeUseWeapon", 11951}, + {"useHoldThinkLoop", 11952}, + {"personalUseBar", 11953}, + {"updateTrigger", 11954}, + {"updateWorldIcons", 11955}, + {"updateWorldIcon", 11956}, + {"updateTimer", 11957}, + {"updateCompassIcons", 11958}, + {"updateCompassIcon", 11959}, + {"shouldPingObject", 11960}, + {"getUpdateTeams", 11961}, + {"shouldShowCompassDueToRadar", 11962}, + {"updateVisibilityAccordingToRadar", 11963}, + {"setOwnerTeam", 11964}, + {"getOwnerTeam", 11965}, + {"setUseTime", 11966}, + {"setUseText", 11967}, + {"setTeamUseTime", 11968}, + {"setTeamUseText", 11969}, + {"setUseHintText", 11970}, + {"allowCarry", 11971}, + {"allowUse", 11972}, + {"setVisibleTeam", 11973}, + {"setModelVisibility", 11974}, + {"_suicide", 11975}, + {"makeSolid", 11976}, + {"setCarrierVisible", 11977}, + {"setCanUse", 11978}, + {"useTeam", 11979}, + {"set2DIcon", 11980}, + {"set3DIcon", 11981}, + {"set3DUseIcon", 11982}, + {"worldUseIcons", 11983}, + {"setCarryIcon", 11984}, + {"disableObject", 11985}, + {"enableObject", 11986}, + {"getRelativeTeam", 11987}, + {"isFriendlyTeam", 11988}, + {"canInteractWith", 11989}, + {"isTeam", 11990}, + {"isRelativeTeam", 11991}, + {"getEnemyTeam", 11992}, + {"getNextObjID", 11993}, + {"reclaimedReservedObjectives", 11994}, + {"getLabel", 11995}, + {"script_label", 11996}, + {"autoSpotDeathWatcher", 11997}, + {"autoSpotAdsWatcher", 11998}, + {"recoilScale", 11999}, + {"blastshieldUseTracker", 12000}, + {"perkUseDeathTracker", 12001}, + {"_usePerkEnabled", 12002}, + {"endGame", 12003}, + {"attackerTable", 12004}, + {"endGameTimer", 12005}, + {"endGameIcon", 12006}, + {"revertVisionSet", 12007}, + {"nukeDetonated", 12008}, + {"nukeVisionSet", 12009}, + {"endGameDeath", 12010}, + {"trackSiegeEnable", 12011}, + {"trackSiegeDissable", 12012}, + {"stanceStateListener", 12013}, + {"jumpStateListener", 12014}, + {"killStreakScaler", 12015}, + {"setBackShield", 12016}, + {"unsetBackShield", 12017}, + {"killstreakThink", 12018}, + {"giveKillstreak", 12019}, + {"killstreakSplashNotify", 12020}, + {"oneManArmyWeaponChangeTracker", 12021}, + {"isOneManArmyMenu", 12022}, + {"selectOneManArmyClass", 12023}, + {"closeOMAMenuOnDeath", 12024}, + {"giveOneManArmyClass", 12025}, + {"giveLoadout", 12026}, + {"omaUseBar", 12027}, + {"clearPreviousTISpawnpoint", 12028}, + {"setSpawnpoint", 12029}, + {"updateTISpawnPosition", 12030}, + {"TISpawnPosition", 12031}, + {"isValidTISpawnPosition", 12032}, + {"monitorTIUse", 12033}, + {"touchingBadTrigger", 12034}, + {"enemyTrigger", 12035}, + {"playerSpawnPos", 12036}, + {"GlowStickSetupAndWaitForDeath", 12037}, + {"GlowStickTeamUpdater", 12038}, + {"GlowStickDamageListener", 12039}, + {"leaderDialogOnPlayer", 12040}, + {"GlowStickUseListener", 12041}, + {"updateEnemyUse", 12042}, + {"deleteTI", 12043}, + {"dummyGlowStickDelete", 12044}, + {"GlowStickEnemyUseListener", 12045}, + {"makeEnemyUsable", 12046}, + {"getOtherTeam", 12047}, + {"watchPaintedDeath", 12048}, + {"unsetPainted", 12049}, + {"watchStoppingPowerKill", 12050}, + {"juicedTimer", 12052}, + {"juicedIcon", 12053}, + {"unsetJuicedOnRide", 12054}, + {"unsetJuicedOnDeath", 12055}, + {"combatHighOverlay", 12056}, + {"combatHighTimer", 12057}, + {"combatHighIcon", 12058}, + {"unsetCombatHighOnDeath", 12059}, + {"unsetCombatHighOnRide", 12060}, + {"giveLightArmor", 12061}, + {"previousMaxHealth", 12062}, + {"removeLightArmorOnDeath", 12063}, + {"removeLightArmor", 12064}, + {"lastKilledBy", 12065}, + {"showTo", 12066}, + {"constantSize", 12067}, + {"pinToScreenEdge", 12068}, + {"fadeOutPinnedIcon", 12069}, + {"is3D", 12070}, + {"revengeParams", 12071}, + {"watchRevengeDeath", 12072}, + {"watchRevengeKill", 12073}, + {"watchRevengeDisconnected", 12074}, + {"watchStopRevenge", 12075}, + {"watchRevengeVictimDisconnected", 12076}, + {"objIdFriendly", 12077}, + {"spectateOverride", 12078}, + {"onSpectatingClient", 12079}, + {"updateSpectateSettings", 12080}, + {"setSpectatePermissions", 12081}, + {"gameEndTime", 12082}, + {"allowFreeSpectate", 12083}, + {"allowEnemySpectate", 12084}, + {"registerAdrenalineInfo", 12085}, + {"numKills", 12086}, + {"killedPlayers", 12087}, + {"killedPlayersCurrent", 12088}, + {"killedBy", 12089}, + {"greatestUniquePlayerKills", 12090}, + {"recentKillCount", 12091}, + {"lastKillTime", 12092}, + {"damagedPlayers", 12093}, + {"damagedPlayer", 12094}, + {"killedPlayer", 12095}, + {"lastKilledPlayer", 12096}, + {"modifiers", 12097}, + {"attackers", 12098}, + {"attackerData", 12099}, + {"firstTimeDamaged", 12100}, + {"xpEventPopup", 12101}, + {"assistedSuicide", 12102}, + {"attackerPosition", 12103}, + {"killstreaks", 12104}, + {"setPlayerStat", 12105}, + {"isLongShot", 12106}, + {"checkMatchDataKills", 12107}, + {"iDFlags", 12108}, + {"inFinalStand", 12109}, + {"loadoutPrimary", 12110}, + {"loadoutSecondary", 12111}, + {"matchMakingGame", 12112}, + {"setPlayerStatIfLower", 12113}, + {"setPlayerStatIfGreater", 12114}, + {"checkMatchDataWeaponKills", 12115}, + {"checkMatchDataEquipmentKills", 12116}, + {"camperCheck", 12117}, + {"lastKillWasCamping", 12118}, + {"lastKillLocation", 12119}, + {"lastCampKillTime", 12120}, + {"consolation", 12121}, + {"proximityAssist", 12122}, + {"giveRankXP", 12123}, + {"proximityKill", 12124}, + {"longshot", 12125}, + {"execution", 12126}, + {"headShot", 12127}, + {"avengedPlayer", 12128}, + {"defendedPlayer", 12129}, + {"postDeathKill", 12130}, + {"backStab", 12131}, + {"revenge", 12132}, + {"multiKill", 12133}, + {"teamPlayerCardSplash", 12134}, + {"firstBlood", 12135}, + {"winningShot", 12136}, + {"buzzKill", 12137}, + {"comeBack", 12138}, + {"disconnected", 12139}, + {"monitorHealed", 12140}, + {"updateRecentKills", 12141}, + {"monitorCrateJacking", 12142}, + {"monitorObjectives", 12143}, + {"quickcommands", 12144}, + {"spamdelay", 12145}, + {"quickstatements", 12146}, + {"quickresponses", 12147}, + {"doQuickMessage", 12148}, + {"QuickMessageToAll", 12149}, + {"saveHeadIcon", 12150}, + {"oldheadicon", 12151}, + {"oldheadiconteam", 12152}, + {"restoreHeadIcon", 12153}, + {"isOptionsMenu", 12154}, + {"onMenuResponse", 12155}, + {"forceEnd", 12156}, + {"autoassign", 12157}, + {"spectator", 12158}, + {"selectedClass", 12159}, + {"class", 12160}, + {"getTeamAssignment", 12161}, + {"menuAutoAssign", 12162}, + {"closeMenus", 12163}, + {"switching_teams", 12164}, + {"joining_team", 12165}, + {"leaving_team", 12166}, + {"beginClassChoice", 12167}, + {"allowClassChoice", 12168}, + {"predictAboutToSpawnPlayerOverTime", 12169}, + {"bypassClassChoice", 12170}, + {"beginTeamChoice", 12171}, + {"showMainMenuForTeam", 12172}, + {"menuAllies", 12173}, + {"hasSpawned", 12174}, + {"menuAxis", 12175}, + {"menuSpectator", 12176}, + {"spawnSpectator", 12177}, + {"menuClass", 12178}, + {"getClassChoice", 12179}, + {"getWeaponChoice", 12180}, + {"lastClass", 12181}, + {"setClass", 12182}, + {"tag_stowed_back", 12183}, + {"tag_stowed_hip", 12184}, + {"isInKillcam", 12185}, + {"spawnClient", 12186}, + {"addToTeam", 12187}, + {"removeFromTeamCount", 12188}, + {"allowTeamChoice", 12189}, + {"addToTeamCount", 12190}, + {"updateObjectiveText", 12191}, + {"updateMainMenu", 12192}, + {"TimeUntilWaveSpawn", 12193}, + {"lastWave", 12194}, + {"waveDelay", 12195}, + {"respawnTimerStartTime", 12196}, + {"waveSpawnIndex", 12197}, + {"TeamKillDelay", 12198}, + {"maxAllowedTeamKills", 12199}, + {"TimeUntilSpawn", 12200}, + {"onRespawnDelay", 12201}, + {"tiSpawnDelay", 12202}, + {"maySpawn", 12203}, + {"getGametypeNumLives", 12204}, + {"disableSpawning", 12205}, + {"gameHasStarted", 12206}, + {"setLowerMessage", 12207}, + {"isLastRound", 12208}, + {"waitingToSpawn", 12209}, + {"waitAndSpawnClient", 12210}, + {"clearLowerMessage", 12211}, + {"wavePlayerSpawnIndex", 12212}, + {"waitForTimeOrNotify", 12213}, + {"wantSafeSpawn", 12214}, + {"waitRespawnButton", 12215}, + {"removeSpawnMessageShortly", 12216}, + {"lastStandRespawnPlayer", 12217}, + {"dieHardMode", 12218}, + {"revived", 12219}, + {"standardmaxHealth", 12220}, + {"freezePlayerForRoundEnd", 12221}, + {"getDeathSpawnPoint", 12222}, + {"showSpawnNotifies", 12223}, + {"defconSplashNotify", 12224}, + {"isRested", 12225}, + {"predictedSpawnPoint", 12226}, + {"predictedSpawnPointTime", 12227}, + {"predictAboutToSpawnPlayer", 12228}, + {"getSpawnpoint_Random", 12229}, + {"getSpawnPoint", 12230}, + {"checkPredictedSpawnpointCorrectness", 12231}, + {"percentage", 12232}, + {"printPredictedSpawnpointCorrectness", 12233}, + {"getSpawnOrigin", 12234}, + {"alternates", 12235}, + {"tiValidationCheck", 12236}, + {"spawnPlayer", 12237}, + {"fauxDead", 12238}, + {"killsThisLife", 12239}, + {"ClearKillcamState", 12240}, + {"cancelKillcam", 12241}, + {"friendlydamage", 12242}, + {"afk", 12243}, + {"inC4Death", 12244}, + {"inLastStand", 12245}, + {"clampedHealth", 12246}, + {"shieldDamage", 12247}, + {"shieldBulletHits", 12248}, + {"recentShieldXP", 12249}, + {"wasAliveAtMatchStart", 12250}, + {"getTimeLimit", 12251}, + {"getTimePassed", 12252}, + {"finalizeSpawnpointChoice", 12253}, + {"lastspawntime", 12254}, + {"onSpawnPlayer", 12255}, + {"playerSpawned", 12256}, + {"setThirdPersonDOF", 12257}, + {"gameFlag", 12258}, + {"getObjectiveHintText", 12259}, + {"oldNotifyMessage", 12260}, + {"hidePerksAfterTime", 12261}, + {"hidePerksOnDeath", 12262}, + {"hidePerksOnKill", 12263}, + {"respawn_asSpectator", 12264}, + {"in_spawnSpectator", 12265}, + {"getPlayerFromClientNum", 12266}, + {"onSpawnSpectator", 12267}, + {"spawnIntermission", 12268}, + {"clearLowerMessages", 12269}, + {"postGamePromotion", 12270}, + {"postGameNotifies", 12271}, + {"spawnEndOfGame", 12272}, + {"setSpawnVariables", 12273}, + {"notifyConnecting", 12274}, + {"Callback_PlayerDisconnect", 12275}, + {"connected", 12276}, + {"removePlayerOnDisconnect", 12277}, + {"initClientDvars", 12278}, + {"hitlocInited", 12279}, + {"getLowestAvailableClientId", 12280}, + {"Callback_PlayerConnect", 12281}, + {"usingOnlineDataOffline", 12282}, + {"resetAdrenaline", 12283}, + {"leaderDialogQueue", 12284}, + {"leaderDialogActive", 12285}, + {"leaderDialogGroups", 12286}, + {"leaderDialogGroup", 12287}, + {"statGet", 12288}, + {"kill_streak", 12289}, + {"lastGrenadeSuicideTime", 12290}, + {"teamkillsThisRound", 12291}, + {"saved_actionSlotData", 12292}, + {"updateLossStats", 12293}, + {"OnPlayerConnectAudioInit", 12294}, + {"isValidClass", 12295}, + {"Callback_PlayerMigrated", 12296}, + {"AddLevelsToExperience", 12297}, + {"GetRestXPCap", 12298}, + {"setRestXPGoal", 12299}, + {"forceSpawn", 12300}, + {"kickIfDontSpawn", 12301}, + {"kickWait", 12302}, + {"updateSessionState", 12303}, + {"initPlayerStats", 12304}, + {"initBufferedStats", 12305}, + {"initPersStat", 12306}, + {"suicides", 12307}, + {"headshots", 12308}, + {"captures", 12309}, + {"returns", 12310}, + {"defends", 12311}, + {"plants", 12312}, + {"defuses", 12313}, + {"destructions", 12314}, + {"confirmed", 12315}, + {"denied", 12316}, + {"statSetChildBuffered", 12317}, + {"teamCount", 12318}, + {"addToAliveCount", 12319}, + {"aliveCount", 12320}, + {"maxPlayerCount", 12321}, + {"removeFromAliveCount", 12322}, + {"addToLivesCount", 12323}, + {"livesCount", 12324}, + {"removeFromLivesCount", 12325}, + {"removeAllFromLivesCount", 12326}, + {"callbackStartGameType", 12327}, + {"callbackPlayerConnect", 12328}, + {"callbackPlayerDisconnect", 12329}, + {"callbackPlayerKilled", 12330}, + {"callbackCodeEndGame", 12331}, + {"callbackPlayerLastStand", 12332}, + {"callbackPlayerMigrated", 12333}, + {"ufo_mode", 12334}, + {"initGameFlags", 12335}, + {"initLevelFlags", 12336}, + {"requiredMapAspectRatio", 12337}, + {"leaderDialogOnPlayer_func", 12338}, + {"init_audio", 12339}, + {"setMapCenterForReflections", 12340}, + {"lanterns", 12341}, + {"hurtPlayersThink", 12342}, + {"setupDestructibleKillCamEnts", 12343}, + {"deleteDestructibleKillCamEnt", 12344}, + {"sendMatchData", 12345}, + {"allowvote", 12346}, + {"updateServerSettings", 12347}, + {"constrainGameType", 12348}, + {"script_gametype_dm", 12349}, + {"script_gametype_tdm", 12350}, + {"script_gametype_ctf", 12351}, + {"script_gametype_hq", 12352}, + {"script_gametype_sd", 12353}, + {"script_gametype_koth", 12354}, + {"killcam", 12355}, + {"showingFinalKillcam", 12356}, + {"killcamlength", 12357}, + {"kc_timer", 12358}, + {"kc_skiptext", 12359}, + {"kc_othertext", 12360}, + {"kc_icon", 12361}, + {"doFinalKillCamFX", 12362}, + {"doingFinalKillcamFx", 12363}, + {"calculateKillCamTime", 12364}, + {"waittillKillcamOver", 12365}, + {"setKillCamEntity", 12366}, + {"waitSkipKillcamButton", 12367}, + {"waitKCCopyCatButton", 12368}, + {"waitDeathCopyCatButton", 12369}, + {"waitCopyCatButton", 12370}, + {"waitSkipKillcamSafeSpawnButton", 12371}, + {"endKillcamIfNothingToShow", 12372}, + {"spawnedKillcamCleanup", 12373}, + {"endedKillcamCleanup", 12374}, + {"killcamCleanup", 12375}, + {"cancelKillCamOnUse", 12376}, + {"cancelKillCamUseButton", 12377}, + {"cancelKillCamSafeSpawnButton", 12378}, + {"cancelKillCamCallback", 12379}, + {"cancelKillCamSafeSpawnCallback", 12380}, + {"cancelKillCamOnUse_specificButton", 12381}, + {"initKCElements", 12382}, + {"selfDeathIcons", 12383}, + {"updateDeathIconsEnabled", 12384}, + {"addDeathIcon", 12385}, + {"lastDeathIcon", 12386}, + {"destroySlowly", 12387}, + {"connectTime", 12388}, + {"targets", 12389}, + {"onPlayerDisconnect", 12390}, + {"onWeaponFired", 12391}, + {"processKill", 12392}, + {"heli_types", 12393}, + {"heli_start_nodes", 12394}, + {"heli_loop_nodes", 12395}, + {"heli_leave_nodes", 12396}, + {"heli_crash_nodes", 12397}, + {"heli_missile_rof", 12398}, + {"heli_maxhealth", 12399}, + {"heli_debug", 12400}, + {"heli_targeting_delay", 12401}, + {"heli_turretReloadTime", 12402}, + {"heli_turretClipSize", 12403}, + {"heli_visual_range", 12404}, + {"heli_target_spawnprotection", 12405}, + {"heli_target_recognition", 12406}, + {"heli_missile_friendlycare", 12407}, + {"heli_missile_target_cone", 12408}, + {"heli_armor_bulletdamage", 12409}, + {"heli_attract_strength ", 12410}, + {"heli_attract_range", 12411}, + {"heli_angle_offset", 12412}, + {"heli_forced_wait", 12413}, + {"chopper_fx", 12414}, + {"fx_heli_dust", 12415}, + {"fx_heli_water", 12416}, + {"heliDialog", 12417}, + {"lastHeliDialogTime", 12418}, + {"queueCreate", 12419}, + {"makeHeliType", 12420}, + {"lightFxFunc", 12421}, + {"addAirExplosion", 12422}, + {"pavelowLightFx", 12423}, + {"defaultLightFX", 12424}, + {"useHelicopter", 12425}, + {"useHelicopterBlackbox", 12426}, + {"useHelicopterFlares", 12427}, + {"useHelicopterMinigun", 12428}, + {"useHelicopterMK19", 12429}, + {"tryUseHelicopter", 12430}, + {"isAirDenied", 12431}, + {"updateKillstreaks", 12432}, + {"lifeId", 12433}, + {"heliType", 12434}, + {"queueAdd", 12435}, + {"setUsingRemote", 12438}, + {"currentActiveVehicleCount", 12436}, + {"maxVehiclesAllowed", 12437}, + {"initRideKillstreak", 12439}, + {"clearUsingRemote", 12440}, + {"deleteOnEntNotify", 12441}, + {"startHelicopter", 12442}, + {"precacheHelicopter", 12443}, + {"heli_sound", 12444}, + {"spawn_helicopter", 12445}, + {"heli_type", 12446}, + {"zOffset", 12447}, + {"heliRide", 12448}, + {"heliRideLifeId", 12449}, + {"thermalVision", 12450}, + {"enhanced_vision", 12451}, + {"thermal_vision", 12452}, + {"weaponLockThink", 12453}, + {"heliTargetOrigin", 12454}, + {"remoteHeliLOS", 12455}, + {"endRide", 12456}, + {"getKillstreakWeapon", 12457}, + {"endRideOnHelicopterDone", 12458}, + {"getPosNearEnemies", 12459}, + {"remoteHeliDist", 12460}, + {"updateAreaNodes", 12461}, + {"validPlayers", 12462}, + {"nodeScore", 12463}, + {"heli_think", 12464}, + {"targeting_delay", 12465}, + {"primaryTarget", 12466}, + {"secondaryTarget", 12467}, + {"currentstate", 12468}, + {"makeGunShip", 12469}, + {"mgTurretLeft", 12470}, + {"mgTurretRight", 12471}, + {"deleteTurretsWhenDone", 12472}, + {"sentry_attackTargets", 12473}, + {"sentry_burstFireStart", 12474}, + {"sentry_burstFireStop", 12475}, + {"heli_existance", 12476}, + {"queueRemoveFirst", 12477}, + {"usedKillstreak", 12478}, + {"heli_targeting", 12479}, + {"canTarget_turret", 12480}, + {"getBestPrimaryTarget", 12481}, + {"threatlevel", 12482}, + {"update_player_threat", 12483}, + {"antithreat", 12484}, + {"heli_reset", 12485}, + {"addRecentDamage", 12486}, + {"recentDamageAmount", 12487}, + {"largeProjectileDamage", 12488}, + {"vehicleKilled", 12489}, + {"heli_health", 12490}, + {"laststate", 12491}, + {"heli_crash", 12492}, + {"heli_secondary_explosions", 12493}, + {"heli_spin", 12494}, + {"spinSoundShortly", 12495}, + {"heli_explode", 12496}, + {"check_owner", 12497}, + {"heli_leave_on_disconnect", 12498}, + {"heli_leave_on_changeTeams", 12499}, + {"heli_leave_on_spawned", 12500}, + {"heli_leave_on_gameended", 12501}, + {"heli_leave_on_timeout", 12502}, + {"attack_targets", 12503}, + {"attack_secondary", 12504}, + {"missileTarget", 12505}, + {"missile_target_sight_check", 12506}, + {"missile_support", 12507}, + {"attack_primary", 12508}, + {"waitOnTargetOrDeath", 12509}, + {"fireMissile", 12510}, + {"getOriginOffsets", 12511}, + {"travelToNode", 12512}, + {"heli_fly_simple_path", 12513}, + {"heli_fly_loop_path", 12514}, + {"desired_speed", 12515}, + {"desired_accel", 12516}, + {"heli_loop_speed_control", 12517}, + {"heli_is_threatened", 12518}, + {"heli_fly_well", 12519}, + {"get_best_area_attack_node", 12520}, + {"heli_leave", 12521}, + {"pathGoal", 12522}, + {"wait_and_delete", 12523}, + {"debug_print3d", 12524}, + {"debug_print3d_simple", 12525}, + {"draw_text", 12526}, + {"addToHeliList", 12527}, + {"helis", 12528}, + {"removeFromHeliList", 12529}, + {"addToLittleBirdList", 12530}, + {"removeFromLittleBirdListOnDeath", 12531}, + {"exceededMaxLittlebirds", 12532}, + {"playFlareFx", 12533}, + {"deployFlares", 12534}, + {"heli_flares_monitor", 12535}, + {"numFlares", 12536}, + {"handleIncomingStinger", 12537}, + {"watchStingerProximity", 12538}, + {"handleIncomingSAM", 12539}, + {"watchSAMProximity", 12540}, + {"deleteAfterTime", 12541}, + {"pavelowMadeSelectionVO", 12542}, + {"RemoteUAV_fx", 12543}, + {"RemoteUAV_dialog", 12544}, + {"RemoteUAV_lastDialogTime", 12545}, + {"RemoteUAV_noDeployZones", 12546}, + {"remote_uav", 12547}, + {"useRemoteUAV", 12548}, + {"tryUseRemoteUAV", 12549}, + {"nukeIncoming", 12550}, + {"isCarrying", 12551}, + {"giveCarryRemoteUAV", 12552}, + {"createCarryRemoteUAV", 12553}, + {"sentryType", 12554}, + {"canBePlaced", 12555}, + {"inHeliProximity", 12556}, + {"rangeTrigger", 12557}, + {"maxHeight", 12558}, + {"maxDistance", 12559}, + {"setCarryingRemoteUAV", 12560}, + {"carriedBy", 12561}, + {"carryRemoteUAV_setCarried", 12562}, + {"isInRemoteNoDeploy", 12563}, + {"updateCarryRemoteUAVPlacement", 12564}, + {"carryRemoteUAV_handleExistence", 12565}, + {"removeRemoteWeapon", 12566}, + {"startRemoteUAV", 12567}, + {"remoteUAV_clearRideIntro", 12568}, + {"lockPlayerForRemoteUAVLaunch", 12569}, + {"clearPlayerLockFromRemoteUAVLaunch", 12570}, + {"createRemoteUAV", 12571}, + {"destroyed", 12572}, + {"specialDamageCallback", 12573}, + {"scrambler", 12574}, + {"smoking", 12575}, + {"markedPlayers", 12576}, + {"hasIncoming", 12577}, + {"incomingMissiles", 12578}, + {"remoteUAV_Ride", 12579}, + {"playerLinked", 12580}, + {"restoreAngles", 12581}, + {"juggernautOverlay", 12582}, + {"remote_uav_rideLifeId", 12583}, + {"remoteUAV", 12584}, + {"remoteUAV_delayLaunchDialog", 12585}, + {"remoteUAV_endride", 12586}, + {"remoteUAV_freezeBuffer", 12587}, + {"remoteUAV_playerExit", 12588}, + {"remoteUAV_Track", 12589}, + {"lastTrackingDialogTime", 12590}, + {"lockedTarget", 12591}, + {"trace", 12592}, + {"remoteUAV_trackEntities", 12593}, + {"uavType", 12594}, + {"UAVRemoteMarkedBy", 12595}, + {"isLeaving", 12596}, + {"remoteUAV_canTargetUAV", 12597}, + {"remoteUAV_Fire", 12598}, + {"remoteUAV_Rumble", 12599}, + {"remoteUAV_markPlayer", 12600}, + {"birth_time", 12601}, + {"remoteUAVMarkedObjID01", 12602}, + {"remoteUAVMarkedObjID02", 12603}, + {"remoteUAVMarkedObjID03", 12604}, + {"remoteUAV_processTaggedAssist", 12605}, + {"remoteUAV_unmarkRemovedPlayer", 12606}, + {"remoteUAV_clearMarkedForOwner", 12607}, + {"remoteUAV_operationRumble", 12608}, + {"remoteUAV_watch_distance", 12609}, + {"centerRef", 12610}, + {"rangeCountdownActive", 12611}, + {"heliInProximity", 12612}, + {"remoteUAV_in_range", 12613}, + {"remoteUAV_staticFade", 12614}, + {"remoteUAV_rangeCountdown", 12615}, + {"remoteUAV_explode_on_disconnect", 12616}, + {"remoteUAV_explode_on_changeTeams", 12617}, + {"remoteUAV_clear_marked_on_gameEnded", 12618}, + {"remoteUAV_leave_on_timeout", 12619}, + {"remoteUAV_leave", 12620}, + {"remoteUAV_explode_on_death", 12621}, + {"remoteUAV_cleanup", 12622}, + {"remoteUAV_light_fx", 12623}, + {"remoteUAV_handleIncomingStinger", 12624}, + {"remoteUAV_handleIncomingSAM", 12625}, + {"remoteUAV_clearIncomingWarning", 12626}, + {"missile_isIncoming", 12627}, + {"remoteUAV_watchHeliProximity", 12628}, + {"remoteUAV_handleDamage", 12629}, + {"Callback_VehicleDamage", 12630}, + {"speakers", 12631}, + {"bcSounds", 12632}, + {"grenadeProximityTracking", 12633}, + {"suppressingFireTracking", 12634}, + {"suppressWaiter", 12635}, + {"claymoreTracking", 12636}, + {"reloadTracking", 12637}, + {"grenadeTracking", 12638}, + {"sayLocalSoundDelayed", 12639}, + {"sayLocalSound", 12640}, + {"doSound", 12641}, + {"timeHack", 12642}, + {"isSpeakerInRange", 12643}, + {"addSpeaker", 12644}, + {"removeSpeaker", 12645}, + {"isSwitchingTeams", 12646}, + {"isTeamSwitchBalanced", 12647}, + {"isFriendlyFire", 12648}, + {"killedSelf", 12649}, + {"isHeadShot", 12650}, + {"isEnvironmentWeapon", 12651}, + {"handleTeamChangeDeath", 12652}, + {"handleWorldDeath", 12653}, + {"onNormalDeath", 12654}, + {"handleSuicideDeath", 12655}, + {"handleFriendlyFireDeath", 12656}, + {"gracePeriod", 12657}, + {"handleNormalDeath", 12658}, + {"updatePersRatio", 12659}, + {"cloneLoadout", 12660}, + {"streakType", 12661}, + {"killShouldAddToKillstreak", 12662}, + {"setPersStat", 12663}, + {"statGetChild", 12664}, + {"statSet", 12665}, + {"lastAttackedShieldPlayer", 12666}, + {"lastAttackedShieldTime", 12667}, + {"isPlayerWeapon", 12668}, + {"Callback_PlayerKilled", 12669}, + {"QueueShieldForRemoval", 12670}, + {"shieldTrashArray", 12671}, + {"LaunchShield", 12672}, + {"hasRiotShield", 12673}, + {"hasRiotShieldEquipped", 12674}, + {"PlayerKilled_internal", 12675}, + {"useLastStandParams", 12676}, + {"eInflictor", 12677}, + {"iDamage", 12678}, + {"sMeansOfDeath", 12679}, + {"sWeapon", 12680}, + {"sPrimaryWeapon", 12681}, + {"vDir", 12682}, + {"sHitLoc", 12683}, + {"lasttimedamaged", 12684}, + {"nuked", 12685}, + {"playerKilled", 12686}, + {"previousPrimary", 12687}, + {"trackLeaderBoardDeathStats", 12688}, + {"trackAttackerLeaderBoardDeathStats", 12689}, + {"lastDeathPos", 12690}, + {"sameShotDamage", 12691}, + {"streakTypeResetsOnDeath", 12692}, + {"onPlayerKilled", 12693}, + {"timeUntilRoundEnd", 12694}, + {"checkForceBleedout", 12695}, + {"checkKillSteal", 12696}, + {"attackerEnt", 12697}, + {"initFinalKillCam", 12698}, + {"finalKillCam_delay", 12699}, + {"finalKillCam_victim", 12700}, + {"finalKillCam_attacker", 12701}, + {"finalKillCam_attackerNum", 12702}, + {"finalKillCam_killCamEntityIndex", 12703}, + {"finalKillCam_killCamEntityStartTime", 12704}, + {"finalKillCam_sWeapon", 12705}, + {"finalKillCam_deathTimeOffset", 12706}, + {"finalKillCam_psOffsetTime", 12707}, + {"finalKillCam_timeRecorded", 12708}, + {"finalKillCam_timeGameEnded", 12709}, + {"finalKillCam_winner", 12710}, + {"recordFinalKillCam", 12711}, + {"getSecondsPassed", 12712}, + {"eraseFinalKillCam", 12713}, + {"doFinalKillcam", 12714}, + {"finalKill", 12715}, + {"anyPlayersInKillcam", 12716}, + {"resetPlayerVariables", 12717}, + {"getKillcamEntity", 12718}, + {"samTurret", 12719}, + {"imsKillCamEnt", 12720}, + {"attackerInRemoteKillstreak", 12721}, + {"remote_mortar", 12722}, + {"using_remote_turret", 12723}, + {"using_remote_tank", 12724}, + {"HitlocDebug", 12725}, + {"damageInfo", 12726}, + {"hitloc", 12727}, + {"bp", 12728}, + {"jugg", 12729}, + {"colorIndex", 12730}, + {"damageInfoColorIndex", 12731}, + {"damageInfoVictim", 12732}, + {"giveRecentShieldXP", 12733}, + {"Callback_PlayerDamage_internal", 12734}, + {"iDFLAGS_STUN", 12735}, + {"iDFLAGS_SHIELD_EXPLOSIVE_IMPACT", 12736}, + {"iDFLAGS_SHIELD_EXPLOSIVE_IMPACT_HUGE", 12737}, + {"iDFLAGS_SHIELD_EXPLOSIVE_SPLASH", 12738}, + {"modifyPlayerDamage", 12739}, + {"iDFlagsTime", 12740}, + {"canDoCombat", 12741}, + {"iDFLAGS_NO_KNOCKBACK", 12742}, + {"killstreakSpawnShield", 12743}, + {"iDFLAGS_NO_PROTECTION", 12744}, + {"lastspawnpoint", 12745}, + {"explosiveInfo", 12746}, + {"setInflictorStat", 12747}, + {"lastDamageWasFromEnemy", 12748}, + {"lastLegitimateAttacker", 12749}, + {"wasCooked", 12750}, + {"playerDamaged", 12751}, + {"useStartSpawn", 12752}, + {"shouldWeaponFeedback", 12753}, + {"checkVictimStutter", 12754}, + {"findIsFacing", 12755}, + {"stutterStep", 12756}, + {"inStutter", 12757}, + {"addAttacker", 12758}, + {"isPrimary", 12759}, + {"vPoint", 12760}, + {"resetAttackerList", 12761}, + {"Callback_PlayerDamage", 12762}, + {"finishPlayerDamageWrapper", 12763}, + {"Callback_PlayerLastStand", 12764}, + {"dieAfterTime", 12765}, + {"detonateOnUse", 12766}, + {"detonateOnDeath", 12767}, + {"c4DeathDetonate", 12768}, + {"c4DeathEffect", 12769}, + {"enableLastStandWeapons", 12770}, + {"lastStandTimer", 12771}, + {"maxHealthOverlay", 12772}, + {"lastStandBleedOut", 12773}, + {"beingRevived", 12774}, + {"lastStandAllowSuicide", 12775}, + {"lastStandKeepOverlay", 12776}, + {"lastStandWaittillDeath", 12777}, + {"mayDoLastStand", 12778}, + {"ensureLastStandParamsValidity", 12779}, + {"getHitLocHeight", 12780}, + {"delayStartRagdoll", 12781}, + {"noRagdollEnts", 12782}, + {"getMostKilledBy", 12783}, + {"getMostKilled", 12784}, + {"damageShellshockAndRumble", 12785}, + {"reviveSetup", 12786}, + {"deleteOnReviveOrDeathOrDisconnect", 12787}, + {"updateUsableByTeam", 12788}, + {"trackTeamChanges", 12789}, + {"trackLastStandChanges", 12790}, + {"reviveTriggerThink", 12791}, + {"Callback_KillingBlow", 12792}, + {"combatHigh", 12793}, + {"emitFallDamage", 12794}, + {"isFlankKill", 12795}, + {"_obituary", 12796}, + {"logPrintPlayerDeath", 12797}, + {"destroyOnReviveEntDeath", 12798}, + {"gamemodeModifyPlayerDamage", 12799}, + {"matchRules_damageMultiplier", 12800}, + {"matchRules_vampirism", 12801}, + {"healthRegenDisabled", 12802}, + {"healthRegenLevel", 12803}, + {"regenSpeed", 12804}, + {"atBrinkOfDeath", 12805}, + {"breathingManager", 12806}, + {"breathingStopTime", 12807}, + {"healthRegeneration", 12808}, + {"healthRegenerated", 12809}, + {"wait_for_not_using_remote", 12810}, + {"playerPainBreathingSound", 12811}, + {"playedStartingMusic", 12812}, + {"onLastAlive", 12813}, + {"onRoundSwitch", 12814}, + {"onGameEnded", 12815}, + {"playSoundOnPlayers", 12816}, + {"roundWinnerDialog", 12817}, + {"roundEndDelay", 12818}, + {"gameWinnerDialog", 12819}, + {"postRoundTime", 12820}, + {"musicController", 12821}, + {"leaderDialogOnPlayers", 12822}, + {"suspenseMusic", 12823}, + {"finalKillcamMusic", 12824}, + {"giveHighlight", 12825}, + {"clientMatchDataId", 12826}, + {"awards", 12827}, + {"defaultvalue", 12828}, + {"initPlayerStat", 12829}, + {"prevPos", 12830}, + {"previousDeaths", 12831}, + {"altitudePolls", 12832}, + {"totalAltitudeSum", 12833}, + {"usedWeapons", 12834}, + {"initAwards", 12835}, + {"initGametypeAwards", 12836}, + {"initBaseAward", 12837}, + {"winners", 12838}, + {"exclusive", 12839}, + {"initAwardProcess", 12840}, + {"process", 12841}, + {"var1", 12842}, + {"var2", 12843}, + {"initStat", 12844}, + {"initStatAward", 12845}, + {"initDerivedAward", 12846}, + {"initAwardFlag", 12847}, + {"initMultiAward", 12848}, + {"award1_ref", 12849}, + {"award2_ref", 12850}, + {"initThresholdAward", 12851}, + {"setMatchRecordIfGreater", 12852}, + {"getPlayerStat", 12853}, + {"getPlayerStatTime", 12854}, + {"setMatchRecordIfLower", 12855}, + {"getDecodedRatio", 12856}, + {"setPersonalBestIfGreater", 12857}, + {"setPersonalBestIfLower", 12858}, + {"incPlayerRecord", 12859}, + {"addAwardWinner", 12860}, + {"getAwardWinners", 12861}, + {"clearAwardWinners", 12862}, + {"setAwardRecord", 12863}, + {"getAwardRecord", 12864}, + {"getAwardRecordTime", 12865}, + {"assignAwards", 12866}, + {"playerForClientId", 12867}, + {"assignAward", 12868}, + {"getAwardType", 12869}, + {"isMultiAward", 12870}, + {"isStatAward", 12871}, + {"isThresholdAward", 12872}, + {"isAwardFlag", 12873}, + {"isAwardExclusive", 12874}, + {"hasDisplayValue", 12875}, + {"giveAward", 12876}, + {"getFormattedValue", 12877}, + {"limitDecimalPlaces", 12878}, + {"highestWins", 12879}, + {"lowestWins", 12880}, + {"lowestWithHalfPlayedTime", 12881}, + {"statValueChanged", 12882}, + {"isAtleast", 12883}, + {"isAtMost", 12884}, + {"isAtMostWithHalfPlayedTime", 12885}, + {"setRatio", 12886}, + {"getKillstreakAwardRef", 12887}, + {"monitorReloads", 12888}, + {"monitorShotsFired", 12889}, + {"monitorSwaps", 12890}, + {"monitorMovementDistance", 12891}, + {"monitorPositionCamping", 12892}, + {"lastCampChecked", 12893}, + {"positionArray", 12894}, + {"encodeRatio", 12895}, + {"getRatioHiVal", 12896}, + {"getRatioLoVal", 12897}, + {"monitorEnemyDistance", 12898}, + {"monitorExplosionsSurvived", 12900}, + {"monitorShieldBlocks", 12901}, + {"monitorFlashHits", 12902}, + {"monitorStunHits", 12903}, + {"monitorStanceTime", 12904}, + {"softLandingTriggers", 12905}, + {"script_type", 12906}, + {"softLanding", 12907}, + {"playerEnterSoftLanding", 12908}, + {"playerLeaveSoftLanding", 12909}, + {"softLandingWaiter", 12910}, + {"defconMode", 12911}, + {"defconStreakAdd", 12912}, + {"defconPointMod", 12913}, + {"defconKillstreakWait", 12914}, + {"defconKillstreakThread", 12915}, + {"updateDefcon", 12916}, + {"juggSettings", 12917}, + {"splashUsedName", 12918}, + {"overlay", 12920}, + {"giveJuggernaut", 12921}, + {"isJuggernautRecon", 12922}, + {"personalRadar", 12923}, + {"matchRules_showJuggRadarIcon", 12924}, + {"objIdEnemy", 12925}, + {"clearKillstreaks", 12926}, + {"juggernautSounds", 12927}, + {"radarMover", 12928}, + {"juggRemover", 12929}, + {"isJuggernautDef", 12930}, + {"isJuggernautGL", 12931}, + {"juggRemoveOnGameEnded", 12932}, + {"sentrySettings", 12933}, + {"burstMin", 12934}, + {"burstMax", 12935}, + {"pauseMin", 12936}, + {"pauseMax", 12937}, + {"sentryModeOn", 12938}, + {"sentryModeOff", 12939}, + {"spinupTime", 12940}, + {"overheatTime", 12941}, + {"cooldownTime", 12942}, + {"fxTime", 12943}, + {"modelBase", 12944}, + {"modelPlacement", 12945}, + {"modelPlacementFailed", 12946}, + {"modelDestroyed", 12947}, + {"teamSplash", 12948}, + {"shouldSplash", 12949}, + {"voDestroyed", 12950}, + {"ownerHintString", 12951}, + {"tryUseAutoSentry", 12952}, + {"tryUseSAM", 12953}, + {"giveSentry", 12954}, + {"validateUseStreak", 12955}, + {"last_sentry", 12956}, + {"setCarryingSentry", 12957}, + {"removeWeapons", 12958}, + {"restoreWeapon", 12959}, + {"removePerks", 12960}, + {"restorePerk", 12961}, + {"restoreWeapons", 12962}, + {"restorePerks", 12963}, + {"waitRestorePerks", 12964}, + {"createSentryForPlayer", 12965}, + {"sentry_initSentry", 12966}, + {"laser_on", 12967}, + {"momentum", 12968}, + {"heatLevel", 12969}, + {"overheated", 12970}, + {"cooldownWaitTime", 12971}, + {"sentry_handleDamage", 12972}, + {"sentry_watchDisabled", 12973}, + {"sentry_handleDeath", 12974}, + {"ownerTrigger", 12975}, + {"forceDisable", 12976}, + {"inUseBy", 12977}, + {"turret_overheat_bar", 12978}, + {"sentry_handleUse", 12979}, + {"turret_handlePickup", 12980}, + {"turret_handleUse", 12981}, + {"sentry_handleOwnerDisconnect", 12982}, + {"sentry_setOwner", 12983}, + {"sentry_setPlaced", 12984}, + {"sentry_setCancelled", 12985}, + {"sentry_setCarried", 12986}, + {"updateSentryPlacement", 12987}, + {"sentry_onCarrierDeath", 12988}, + {"sentry_onCarrierDisconnect", 12989}, + {"sentry_onCarrierChangedTeam", 12990}, + {"sentry_onGameEnded", 12991}, + {"sentry_setActive", 12992}, + {"sentry_setInactive", 12993}, + {"sentry_makeSolid", 12994}, + {"sentry_makeNotSolid", 12995}, + {"isFriendlyToSentry", 12996}, + {"addToTurretList", 12997}, + {"removeFromTurretList", 12998}, + {"sentry_timeOut", 12999}, + {"sentry_targetLockSound", 13000}, + {"sentry_spinUp", 13001}, + {"sentry_spinDown", 13002}, + {"turret_shotMonitor", 13003}, + {"sentry_heatMonitor", 13004}, + {"turret_heatMonitor", 13005}, + {"turret_coolMonitor", 13006}, + {"PlayHeatFX", 13007}, + {"playSmokeFX", 13008}, + {"sentry_beepSounds", 13009}, + {"sam_attackTargets", 13010}, + {"samTargetEnt", 13011}, + {"samMissileGroups", 13012}, + {"sam_acquireTarget", 13013}, + {"ac130InUse", 13014}, + {"sam_fireOnTarget", 13015}, + {"samMissileGroup", 13016}, + {"sam_watchLineOfSight", 13017}, + {"sam_watchLaser", 13018}, + {"sam_watchCrashing", 13019}, + {"sam_watchLeaving", 13020}, + {"airDropCrates", 13021}, + {"oldAirDropCrates", 13022}, + {"airDropCrateCollision", 13023}, + {"numDropCrates", 13024}, + {"crateTypes", 13025}, + {"crateMaxVal", 13026}, + {"lowSpawn", 13027}, + {"addCrateType", 13028}, + {"crateFuncs", 13029}, + {"getRandomCrateType", 13030}, + {"getCrateTypeForDropType", 13031}, + {"tryUseAssaultAirdrop", 13032}, + {"tryUseSupportAirdrop", 13033}, + {"tryUseAirdropPredatorMissile", 13034}, + {"tryUseAirdropSentryMinigun", 13035}, + {"tryUseJuggernautAirdrop", 13036}, + {"tryUseJuggernautGLAirdrop", 13037}, + {"tryUseJuggernautReconAirdrop", 13038}, + {"tryUseJuggernautDefAirdrop", 13039}, + {"tryUseTrophyAirdrop", 13040}, + {"tryUseMegaAirdrop", 13041}, + {"tryUseAirdropTrap", 13042}, + {"tryUseAirdropRemoteTank", 13043}, + {"tryUseAmmo", 13044}, + {"tryUseExplosiveAmmo", 13045}, + {"tryUseLightArmor", 13046}, + {"tryUseAirdrop", 13047}, + {"watchDisconnect", 13048}, + {"beginAirdropViaMarker", 13049}, + {"threwAirDropMarker", 13050}, + {"watchAirDropWeaponChange", 13051}, + {"isChangingWeapon", 13052}, + {"watchAirDropMarkerUsage", 13053}, + {"watchAirDropMarker", 13054}, + {"beginAirDropMarkerTracking", 13055}, + {"airDropMarkerActivate", 13056}, + {"finishSupportEscortUsage", 13057}, + {"initAirDropCrate", 13058}, + {"collision", 13059}, + {"deleteOnOwnerDeath", 13060}, + {"crateModelTeamUpdater", 13061}, + {"crateModelPlayerUpdater", 13062}, + {"crateUseTeamUpdater", 13063}, + {"crateUseJuggernautUpdater", 13064}, + {"crateType", 13065}, + {"crateUsePostJuggernautUpdater", 13066}, + {"createAirDropCrate", 13067}, + {"dropType", 13068}, + {"friendlyModel", 13069}, + {"enemyModel", 13070}, + {"dropCrateExistence", 13071}, + {"trap_createBombSquadModel", 13072}, + {"crateSetupForUse", 13073}, + {"setUsableByTeam", 13074}, + {"dropTheCrate", 13075}, + {"waitForDropCrateMsg", 13076}, + {"physicsWaiter", 13077}, + {"dropTimeOut", 13078}, + {"getPathStart", 13079}, + {"getPathEnd", 13080}, + {"getFlyHeightOffset", 13081}, + {"airstrikeHeightScale", 13082}, + {"doFlyBy", 13083}, + {"leaving", 13084}, + {"doMegaFlyBy", 13085}, + {"doC130FlyBy", 13086}, + {"doMegaC130FlyBy", 13087}, + {"dropNuke", 13088}, + {"stopLoopAfter", 13089}, + {"playloopOnEnt", 13090}, + {"c130Setup", 13091}, + {"c130", 13092}, + {"heliSetup", 13093}, + {"isAirdrop", 13094}, + {"watchTimeOut", 13095}, + {"heli_existence", 13096}, + {"heli_handleDamage", 13097}, + {"alreadyDead", 13098}, + {"heliDestroyed", 13099}, + {"lbExplode", 13100}, + {"lbSpin", 13101}, + {"nukeCaptureThink", 13102}, + {"crateOtherCaptureThink", 13103}, + {"isCapturingCrate", 13104}, + {"crateOwnerCaptureThink", 13105}, + {"validateOpenConditions", 13106}, + {"killstreakCrateThink", 13107}, + {"getKillstreakCrateIcon", 13108}, + {"getStreakCost", 13109}, + {"nukeCrateThink", 13110}, + {"gtnw", 13111}, + {"capturedNuke", 13112}, + {"trophyCrateThink", 13113}, + {"juggernautCrateThink", 13114}, + {"sentryCrateThink", 13115}, + {"trapNullFunc", 13116}, + {"trapCrateThink", 13117}, + {"bomb", 13118}, + {"detonateTrap", 13119}, + {"deleteCrate", 13120}, + {"sentryUseTracker", 13121}, + {"giveLocalTrophy", 13122}, + {"activeTrophy", 13123}, + {"trophyAmmo", 13124}, + {"hijackNotify", 13125}, + {"refillAmmo", 13126}, + {"isAirdropMarker", 13127}, + {"createUseEnt", 13128}, + {"deleteUseEnt", 13129}, + {"airdropDetonateOnStuck", 13130}, + {"personalTrophyActive", 13131}, + {"ospreySettings", 13132}, + {"modelBlades", 13133}, + {"tagHatchL", 13134}, + {"tagHatchR", 13135}, + {"tagDropCrates", 13136}, + {"prompt", 13137}, + {"air_support_locs", 13138}, + {"tryUseEscortAirdrop", 13139}, + {"tryUseOspreyGunner", 13140}, + {"finishOspreyGunnerUsage", 13141}, + {"stopSelectionWatcher", 13142}, + {"selectDropLocation", 13143}, + {"_beginLocationSelection", 13144}, + {"stopLocationSelection", 13145}, + {"showIcons", 13146}, + {"locationObjectives", 13147}, + {"createAirship", 13148}, + {"ospreyType", 13149}, + {"airshipFX", 13150}, + {"useSupportEscortAirdrop", 13151}, + {"useOspreyGunner", 13152}, + {"rideGunner", 13153}, + {"waitSetThermal", 13154}, + {"showDefendPrompt", 13155}, + {"escort_prompt", 13156}, + {"airShipPitchPropsUp", 13157}, + {"airShipPitchPropsDown", 13158}, + {"airShipPitchHatchUp", 13159}, + {"airShipPitchHatchDown", 13160}, + {"getBestHeight", 13161}, + {"bestHeight", 13162}, + {"airshipFlyDefense", 13163}, + {"killGuysNearCrates", 13164}, + {"aiShootPlayer", 13165}, + {"targetDeathWaiter", 13166}, + {"waitForConfirmation", 13167}, + {"airshipFlyGunner", 13168}, + {"ospreyDropCratesLowImpulse", 13169}, + {"ospreyDropCrates", 13170}, + {"endRideOnAirshipDone", 13171}, + {"match_events_fx", 13172}, + {"matchEvents", 13173}, + {"matchEventStarted", 13174}, + {"getMapCenter", 13175}, + {"getStartSpawns", 13176}, + {"doMortar", 13177}, + {"playSoundinSpace", 13178}, + {"doSmoke", 13179}, + {"doAirstrike", 13180}, + {"doAirstrikeFlyBy", 13181}, + {"spawnpoints", 13182}, + {"playPlaneFx", 13183}, + {"fx_airstrike_afterburner", 13184}, + {"fx_airstrike_contrail", 13185}, + {"doPavelow", 13186}, + {"doHeliInsertion", 13187}, + {"doOspreyInsertion", 13188}, + {"drawfriend", 13189}, + {"showFriendIcon", 13190}, + {"updateFriendIconSettings", 13191}, + {"updateFriendIcons", 13192}, + {"processLobbyScoreboards", 13193}, + {"setPlayerScoreboardInfo", 13194}, + {"buildScoreboardType", 13195}, + {"onForfeit", 13196}, + {"forfeitInProgress", 13197}, + {"forfeit_aborted", 13198}, + {"forcedEnd", 13199}, + {"forfeitWaitforAbort", 13200}, + {"matchForfeitTimer", 13201}, + {"matchForfeitText", 13202}, + {"matchForfeitTimer_Internal", 13203}, + {"default_onDeadEvent", 13204}, + {"default_onOneLeftEvent", 13205}, + {"getLastLivingPlayer", 13206}, + {"default_onTimeLimit", 13207}, + {"default_onHalfTime", 13208}, + {"hostForcedEnd", 13209}, + {"onDeadEvent", 13210}, + {"oneLeftTime", 13211}, + {"onOneLeftEvent", 13212}, + {"getPotentialLivingPlayers", 13213}, + {"waittillFinalKillcamDone", 13214}, + {"timeLimitClock_Intermission", 13215}, + {"waitForPlayers", 13216}, + {"prematchPeriod", 13217}, + {"hintMessage", 13218}, + {"gameFlagSet", 13219}, + {"updateWinStats", 13220}, + {"updateTieStats", 13221}, + {"updateWinLossStats", 13222}, + {"privateMatch", 13223}, + {"wasLastRound", 13224}, + {"updateMatchBonusScores", 13225}, + {"endGameUpdate", 13226}, + {"getSPM", 13227}, + {"matchBonus", 13228}, + {"giveMatchBonus", 13229}, + {"setXenonRanks", 13230}, + {"checkTimeLimit", 13231}, + {"getHalfTime", 13232}, + {"onHalfTime", 13233}, + {"onTimeLimit", 13234}, + {"checkHalfTime", 13235}, + {"getTimeRemaining", 13236}, + {"scoreLimitOverride", 13237}, + {"updateGametypeDvars", 13238}, + {"matchStartTimerPC", 13239}, + {"prematchPeriodEnd", 13240}, + {"matchStartTimer_Internal", 13241}, + {"matchStartTimerSkip", 13242}, + {"halftimeSubCaption", 13243}, + {"halftimeType", 13244}, + {"checkRoundSwitch", 13245}, + {"roundSwitch", 13246}, + {"timePaused", 13247}, + {"freeGameplayHudElems", 13248}, + {"perkicon", 13249}, + {"perkname", 13250}, + {"lowerMessage", 13251}, + {"lowerTimer", 13252}, + {"getHostPlayer", 13253}, + {"hostIdledOut", 13254}, + {"roundEndWait", 13255}, + {"isDoingSplash", 13256}, + {"roundEndDoF", 13257}, + {"Callback_StartGameType", 13258}, + {"levelFlagInit", 13259}, + {"intermission", 13260}, + {"onPrecacheGameType", 13261}, + {"killstreakRewards", 13262}, + {"alivePlayers", 13263}, + {"activePlayers", 13264}, + {"gameFlagInit", 13265}, + {"halftimeRoundEndDelay", 13266}, + {"onStartGameType", 13267}, + {"updateWatchedDvars", 13268}, + {"Callback_CodeEndGame", 13269}, + {"timeLimitThread", 13270}, + {"updateUIScoreLimit", 13271}, + {"playTickingSound", 13272}, + {"bombTimer", 13273}, + {"stopTickingSound", 13274}, + {"timeLimitClock", 13275}, + {"timerStopped", 13276}, + {"gameTimer", 13277}, + {"discardTime", 13278}, + {"timerStoppedForGameMode", 13279}, + {"timerPauseTime", 13280}, + {"pauseTimer", 13281}, + {"resumeTimer", 13282}, + {"startGame", 13283}, + {"spawnPerFrameUpdate", 13284}, + {"roundBegin", 13285}, + {"waveSpawnTimer", 13286}, + {"getBetterTeam", 13287}, + {"rankedMatchUpdates", 13288}, + {"displayRoundEnd", 13289}, + {"teamOutcomeNotify", 13290}, + {"outcomeNotify", 13291}, + {"displayGameEnd", 13292}, + {"displayRoundSwitch", 13293}, + {"endGameOvertime", 13294}, + {"endGameHalfTime", 13295}, + {"levelFlagSet", 13296}, + {"wasOnlyRound", 13297}, + {"levelFlagClear", 13298}, + {"roundEnd", 13299}, + {"updateEndReasonText", 13300}, + {"hitRoundLimit", 13301}, + {"hitWinLimit", 13302}, + {"estimatedTimeTillScoreLimit", 13303}, + {"getScorePerMinute", 13304}, + {"getScorePerRemaining", 13305}, + {"giveLastOnTeamWarning", 13306}, + {"waitTillRecoveredHealth", 13307}, + {"processLobbyData", 13308}, + {"incrementWeaponStat", 13309}, + {"updateWeaponBufferedStats", 13310}, + {"incrementAttachmentStat", 13311}, + {"playerAffectedArray", 13312}, + {"threadedSetWeaponStatByName", 13313}, + {"checkForPersonalBests", 13314}, + {"xpGains", 13315}, + {"checkForBestWeapon", 13316}, + {"gametypestarted", 13317}, + {"damageCallback", 13318}, + {"callbackHostMigration", 13319}, + {"SetupDamageFlags", 13320}, + {"iDFLAGS_RADIUS", 13321}, + {"iDFLAGS_NO_ARMOR", 13322}, + {"iDFLAGS_NO_TEAM_PROTECTION", 13323}, + {"iDFLAGS_PASSTHRU", 13324}, + {"SetupCallbacks", 13325}, + {"SetDefaultCallbacks", 13326}, + {"AbortLevel", 13327}, + {"callbackVoid", 13328}, + {"beginHarrier", 13329}, + {"getCorrectHeight", 13330}, + {"spawnDefensiveHarrier", 13331}, + {"accel", 13332}, + {"defendLoc", 13333}, + {"defendLocation", 13334}, + {"closeToGoalCheck", 13335}, + {"engageGround", 13336}, + {"harrierLeave", 13337}, + {"airPlane", 13338}, + {"harrierDelete", 13339}, + {"harrierTimer", 13340}, + {"randomHarrierMovement", 13341}, + {"getNewPoint", 13342}, + {"bestTarget", 13343}, + {"traceNewPoint", 13344}, + {"traceGroundPoint", 13345}, + {"playHarrierFx", 13346}, + {"harrier_afterburnerfx", 13347}, + {"stopHarrierWingFx", 13348}, + {"startHarrierWingFx", 13349}, + {"fireOnTarget", 13350}, + {"isReadyToFire", 13351}, + {"acquireGroundTarget", 13352}, + {"backToDefendLocation", 13353}, + {"wouldCollide", 13354}, + {"watchTargetDeath", 13355}, + {"watchTargetLOS", 13356}, + {"breakTarget", 13357}, + {"harrierGetTargets", 13358}, + {"nonTarget", 13359}, + {"isTarget", 13360}, + {"getBestTarget", 13361}, + {"targetEnt", 13362}, + {"checkForFriendlies", 13363}, + {"playDamageEfx", 13364}, + {"harrier_smoke", 13365}, + {"harrierDestroyed", 13366}, + {"harrierExplode", 13367}, + {"harrier_deathfx", 13368}, + {"harrierSpin", 13369}, + {"engageVehicle", 13370}, + {"fireOnVehicleTarget", 13371}, + {"acquireVehicleTarget", 13372}, + {"watchVehTargetCrash", 13373}, + {"watchVehTargetDeath", 13374}, + {"breakVehTarget", 13375}, + {"evasiveManuverOne", 13376}, + {"removeFromHeliListOnDeath", 13377}, + {"onfirefx", 13378}, + {"airstrikefx", 13379}, + {"mortareffect", 13380}, + {"bombstrike", 13381}, + {"stealthbombfx", 13382}, + {"planes", 13383}, + {"dangerMaxRadius", 13384}, + {"dangerMinRadius", 13385}, + {"dangerForwardPush", 13386}, + {"dangerOvalScale", 13387}, + {"artilleryDangerCenters", 13388}, + {"tryUseDefaultAirstrike", 13389}, + {"tryUsePrecisionAirstrike", 13390}, + {"tryUseSuperAirstrike", 13391}, + {"tryUseHarrierAirstrike", 13392}, + {"tryUseStealthAirstrike", 13393}, + {"tryUseAirstrike", 13394}, + {"clearProgress", 13395}, + {"getAirstrikeDanger", 13396}, + {"getSingleAirstrikeDanger", 13397}, + {"pointIsInAirstrikeArea", 13398}, + {"losRadiusDamage", 13399}, + {"isSentry", 13400}, + {"airStrikeDamagedEntsCount", 13401}, + {"airStrikeDamagedEnts", 13402}, + {"airstrikeDamageEntsThread", 13403}, + {"airstrikeDamagedEntsIndex", 13404}, + {"radiusArtilleryShellshock", 13405}, + {"artilleryShellshock", 13406}, + {"beingArtilleryShellshocked", 13407}, + {"doBomberStrike", 13408}, + {"bomberDropBombs", 13409}, + {"playBombFx", 13410}, + {"stealthBomber_killCam", 13411}, + {"airstrikeType", 13412}, + {"callStrike_bomb", 13413}, + {"doPlaneStrike", 13414}, + {"handleDeath", 13415}, + {"addPlaneToList", 13416}, + {"removePlaneFromList", 13417}, + {"callStrike_bombEffect", 13418}, + {"spawnbomb", 13419}, + {"callStrike", 13420}, + {"getExplodeDistance", 13421}, + {"targetGetDist", 13422}, + {"waitForAirstrikeCancel", 13423}, + {"selectAirstrikeLocation", 13424}, + {"finishAirstrikeUsage", 13425}, + {"useAirstrike", 13426}, + {"handleEMP", 13427}, + {"airstrikeMadeSelectionVO", 13428}, + {"findBoxCenter", 13429}, + {"expandMins", 13430}, + {"expandMaxs", 13431}, + {"addSpawnPoints", 13432}, + {"teamSpawnPoints", 13433}, + {"inited", 13434}, + {"spawnMins", 13435}, + {"spawnMaxs", 13436}, + {"placeSpawnPoints", 13437}, + {"startSpawnPoints", 13438}, + {"getSpawnpointArray", 13439}, + {"extraspawnpoints", 13440}, + {"expandSpawnpointBounds", 13441}, + {"spawnPointInit", 13442}, + {"sightTracePoint", 13443}, + {"lastspawnedplayer", 13444}, + {"outside", 13445}, + {"AddAlternateSpawnpoint", 13446}, + {"getTeamSpawnPoints", 13447}, + {"getSpawnpoint_Final", 13448}, + {"getBestWeightedSpawnpoint", 13449}, + {"sights", 13450}, + {"lastSightTraceTime", 13451}, + {"getAllOtherPlayers", 13452}, + {"initWeights", 13453}, + {"getSpawnpoint_NearTeam", 13454}, + {"numPlayersAtLastUpdate", 13455}, + {"weightedDistSum", 13456}, + {"distSum", 13457}, + {"favorCloseSpawnEnt", 13458}, + {"favorCloseSpawnScalar", 13459}, + {"getSpawnpoint_SafeSpawn", 13460}, + {"minDist", 13461}, + {"safeSpawnDangerDist", 13462}, + {"getSpawnpoint_DM", 13463}, + {"Spawnlogic_Begin", 13464}, + {"spawnlogic_deaths", 13465}, + {"spawnlogic_spawnkills", 13466}, + {"pipebombs", 13467}, + {"tanks", 13468}, + {"ims", 13469}, + {"safespawns", 13470}, + {"sightCheckCost", 13471}, + {"watchSpawnProfile", 13472}, + {"spawnProfile", 13473}, + {"spawnGraphCheck", 13474}, + {"spawnGraph", 13475}, + {"secondfloor", 13476}, + {"fake", 13477}, + {"drawSpawnGraph", 13478}, + {"setupSpawnGraphPoint", 13479}, + {"visible", 13480}, + {"spawnGraphLine", 13481}, + {"loopbotspawns", 13482}, + {"trackGrenades", 13483}, + {"trackMissiles", 13484}, + {"isPointVulnerable", 13485}, + {"claymoremodelcenteroffset", 13486}, + {"claymoreDetectionRadius", 13487}, + {"claymoreDetectionConeAngle", 13488}, + {"avoidWeaponDamage", 13489}, + {"adjustSightValue", 13490}, + {"spawnPointUpdate", 13491}, + {"getFloatProperty", 13492}, + {"nearbyPenalty", 13493}, + {"attackHeightPos", 13494}, + {"getLosPenalty", 13495}, + {"lastMinuteSightTraces", 13496}, + {"getRevengeSpawnPenalty", 13497}, + {"getRevengeSpawnDistanceSq", 13498}, + {"avoidRevengeSpawn", 13499}, + {"avoidRevengeSpawnStage2", 13500}, + {"avoidVisibleEnemies", 13501}, + {"forceSpawnNearTeammates", 13502}, + {"avoidSpawnReuse", 13503}, + {"avoidSameSpawn", 13504}, + {"SetupKillstreakSpawnShield", 13505}, + {"ac130_use_duration", 13506}, + {"ac130_num_flares", 13507}, + {"radioForcedTransmissionQueue", 13508}, + {"enemiesKilledInTimeWindow", 13509}, + {"lastRadioTransmission", 13510}, + {"HUDItem", 13511}, + {"physicsSphereRadius", 13512}, + {"physicsSphereForce", 13513}, + {"weaponReloadTime", 13514}, + {"ac130_Speed", 13515}, + {"ac130Queue", 13516}, + {"tryUseAC130", 13517}, + {"crashed", 13564}, + {"init_sounds", 13565}, + {"add_context_sensative_dialog", 13566}, + {"played", 13567}, + {"sounds", 13568}, + {"add_context_sensative_timeout", 13569}, + {"context_sensative_dialog_timeouts", 13570}, + {"groups", 13571}, + {"deleteOnAC130PlayerRemoved", 13572}, + {"setAC130Player", 13573}, + {"incomingMissile", 13574}, + {"playAC130Effects", 13575}, + {"AC130_AltScene", 13576}, + {"cameraModel", 13577}, + {"removeAC130PlayerOnGameEnd", 13578}, + {"removeAC130PlayerOnGameCleanup", 13579}, + {"removeAC130PlayerOnDeath", 13580}, + {"removeAC130PlayerOnCrash", 13581}, + {"removeAC130PlayerOnDisconnect", 13582}, + {"removeAC130PlayerOnChangeTeams", 13583}, + {"removeAC130PlayerOnSpectate", 13584}, + {"removeAC130PlayerAfterTime", 13585}, + {"removeAC130Player", 13586}, + {"darkScreenOverlay", 13587}, + {"damageTracker", 13588}, + {"ac130_spawn", 13589}, + {"overlay_coords", 13590}, + {"updateAimingCoords", 13591}, + {"ac130ShellShock", 13592}, + {"rotatePlane", 13593}, + {"attachPlayer", 13594}, + {"changeWeapons", 13595}, + {"weaponFiredThread", 13596}, + {"weaponReload", 13597}, + {"clouds", 13598}, + {"clouds_create", 13599}, + {"playerWeapon", 13600}, + {"gun_fired_and_ready_105mm", 13601}, + {"shotFired", 13602}, + {"shotFiredPhysicsSphere", 13603}, + {"shotFiredDarkScreenOverlay", 13604}, + {"add_beacon_effect", 13605}, + {"context_Sensative_Dialog", 13606}, + {"context_Sensative_Dialog_Guy_In_Sight", 13607}, + {"context_Sensative_Dialog_Guy_In_Sight_Check", 13608}, + {"context_Sensative_Dialog_Guy_Crawling", 13609}, + {"context_Sensative_Dialog_Guy_Pain", 13610}, + {"context_Sensative_Dialog_Secondary_Explosion_Vehicle", 13611}, + {"enemy_killed_thread", 13612}, + {"context_Sensative_Dialog_Kill", 13613}, + {"context_Sensative_Dialog_Kill_Thread", 13614}, + {"context_Sensative_Dialog_Locations", 13615}, + {"context_Sensative_Dialog_Locations_Thread", 13616}, + {"context_Sensative_Dialog_Locations_Add_Notify_Event", 13617}, + {"context_Sensative_Dialog_VehicleSpawn", 13618}, + {"context_Sensative_Dialog_VehicleDeath", 13619}, + {"context_Sensative_Dialog_Filler", 13620}, + {"radio_in_use", 13621}, + {"context_Sensative_Dialog_Play_Random_Group_Sound", 13622}, + {"context_Sensative_Dialog_Timedout", 13623}, + {"playSoundOverRadio", 13624}, + {"playAliasOverRadio", 13625}, + {"debug_circle", 13626}, + {"stingerProximityDetonate", 13627}, + {"samProximityDetonate", 13628}, + {"crashPlane", 13629}, + {"angelFlarePrecache", 13630}, + {"angel_flare", 13631}, + {"missileRemoteLaunchVert", 13632}, + {"missileRemoteLaunchHorz", 13633}, + {"missileRemoteLaunchTargetDist", 13634}, + {"remotemissile_fx", 13635}, + {"tryUsePredatorMissile", 13636}, + {"getBestSpawnPoint", 13637}, + {"spawnScore", 13638}, + {"_fire", 13639}, + {"_fire_noplayer", 13640}, + {"MissileEyes", 13641}, + {"delayedFOFOverlay", 13642}, + {"staticEffect", 13643}, + {"archive", 13644}, + {"Player_CleanupOnTeamChange", 13645}, + {"Rocket_CleanupOnDeath", 13646}, + {"Player_CleanupOnGameEnded", 13647}, + {"radarViewTime", 13648}, + {"uavBlockTime", 13649}, + {"uav_fx", 13650}, + {"killstreakSetupFuncs", 13651}, + {"UAVRig", 13652}, + {"activeUAVs", 13653}, + {"activeCounterUAVs", 13654}, + {"rotateUAVRig", 13655}, + {"launchUAV", 13656}, + {"timeToAdd", 13657}, + {"spawnFxDelay", 13658}, + {"monitorUAVStrike", 13659}, + {"showLazeMessage", 13660}, + {"waitForLazeDiscard", 13661}, + {"waitForLazedTarget", 13662}, + {"waitFxEntDie", 13663}, + {"waittill_notify_or_timeout_hostmigration_pause", 13664}, + {"updateUAVModelVisibility", 13665}, + {"tryUseUAV", 13666}, + {"tryUseUAVSupport", 13667}, + {"tryUseDoubleUAV", 13668}, + {"tryUseTripleUAV", 13669}, + {"tryUseCounterUAV", 13670}, + {"UAVStrikeSetup", 13671}, + {"usedStrikeUAV", 13672}, + {"tryUseUAVStrike", 13673}, + {"tryUseDirectionalUAV", 13674}, + {"useUAV", 13675}, + {"UAVTracker", 13676}, + {"_getRadarStrength", 13677}, + {"updateTeamUAVStatus", 13678}, + {"updatePlayersUAVStatus", 13679}, + {"blockPlayerUAV", 13680}, + {"updateTeamUAVType", 13681}, + {"usePlayerUAV", 13682}, + {"setTeamRadarWrapper", 13683}, + {"addUAVModel", 13684}, + {"removeUAVModel", 13685}, + {"addActiveUAV", 13686}, + {"addActiveCounterUAV", 13687}, + {"removeActiveUAV", 13688}, + {"removeActiveCounterUAV", 13689}, + {"tryUseLbFlock", 13690}, + {"selectLbStrikeLocation", 13691}, + {"littlebirdMadeSelectionVO", 13692}, + {"finishLbStrikeUsage", 13693}, + {"getFlightPath", 13695}, + {"doLbStrike", 13696}, + {"spawnAttackLittleBird", 13697}, + {"killCount", 13698}, + {"mgTurret1", 13699}, + {"monitorKills", 13700}, + {"startLbFiring1", 13701}, + {"flock_handleDamage", 13702}, + {"trail_fx", 13703}, + {"removeLittlebird", 13704}, + {"lbStrike", 13705}, + {"heliGuardSettings", 13706}, + {"weaponInfo", 13707}, + {"weaponModelLeft", 13708}, + {"weaponModelRight", 13709}, + {"weaponTagLeft", 13710}, + {"weaponTagRight", 13711}, + {"sentryMode", 13712}, + {"tryUseLBSupport", 13713}, + {"littlebirdGuard", 13714}, + {"air_node_mesh", 13715}, + {"createLBGuard", 13716}, + {"followSpeed", 13717}, + {"heliGuardType", 13718}, + {"targettingRadius", 13719}, + {"attract_strength", 13720}, + {"attract_range", 13721}, + {"hasDodged", 13722}, + {"lbSupport_lightFX", 13723}, + {"startLBSupport", 13724}, + {"lbSupport_followPlayer", 13725}, + {"lbSupport_moveToPlayer", 13726}, + {"inTransit", 13727}, + {"lbSupport_watchDeath", 13728}, + {"lbSupport_watchTimeout", 13729}, + {"lbSupport_watchOwnerLoss", 13730}, + {"lbSupport_watchOwnerDamage", 13731}, + {"lbSupport_watchRoundEnd", 13732}, + {"lbSupport_leave", 13733}, + {"lbSupport_handleDamage", 13734}, + {"marker", 13735}, + {"lbSupport_watchSAMProximity", 13736}, + {"lbSupport_getClosestStartNode", 13737}, + {"air_start_nodes", 13738}, + {"lbSupport_getClosestNode", 13739}, + {"lbSupport_getClosestLinkedNode", 13740}, + {"neighbors", 13741}, + {"lbSupport_arrayContains", 13742}, + {"lbSupport_getLinkedStructs", 13743}, + {"lbSupport_setAirStartNodes", 13744}, + {"lbSupport_setAirNodeMesh", 13745}, + {"lbSupport_attackTargets", 13746}, + {"lbSupport_burstFireStart", 13747}, + {"lbSupport_burstFireStop", 13748}, + {"empTimeout", 13749}, + {"EMP_Use", 13750}, + {"EMP_JamTeam", 13751}, + {"EMP_JamPlayers", 13752}, + {"empPlayerFFADisconnect", 13753}, + {"empEffects", 13754}, + {"empEffect", 13755}, + {"EMP_TeamTracker", 13756}, + {"EMP_PlayerTracker", 13757}, + {"destroyActiveVehicles", 13758}, + {"nukeTimer", 13759}, + {"cancelMode", 13760}, + {"teamNukeEMPed", 13761}, + {"nukeEmpTimeout", 13762}, + {"nukeInfo", 13763}, + {"tryUseNuke", 13764}, + {"delaythread_nuke", 13765}, + {"doNuke", 13766}, + {"cancelNukeOnDeath", 13767}, + {"nukeSoundIncoming", 13768}, + {"nukeSoundExplosion", 13769}, + {"nukeEffects", 13770}, + {"nukeEffect", 13771}, + {"nukeAftermathEffect", 13772}, + {"nukeSlowMo", 13773}, + {"nukeVision", 13774}, + {"nukeVisionInProgress", 13775}, + {"nukeDeath", 13776}, + {"nukeEarthquake", 13777}, + {"nuke_EMPJam", 13778}, + {"nuke_EMPTeamTracker", 13779}, + {"update_ui_timers", 13780}, + {"remote_mortar_fx", 13781}, + {"tryUseRemoteMortar", 13782}, + {"startRemoteMortar", 13783}, + {"spawnRemote", 13784}, + {"lookCenter", 13785}, + {"remoteRide", 13786}, + {"remoteTargeting", 13787}, + {"remoteFiring", 13788}, + {"firingReaper", 13789}, + {"remoteZoom", 13790}, + {"zoomed", 13791}, + {"remoteMissileDistance", 13792}, + {"remoteMissileLife", 13793}, + {"remoteEndRide", 13794}, + {"handleTimeout", 13795}, + {"handleOwnerChangeTeam", 13796}, + {"handleOwnerDisconnect", 13797}, + {"removeRemote", 13798}, + {"remoteLeave", 13799}, + {"boxSettings", 13800}, + {"capturingString", 13801}, + {"eventString", 13802}, + {"splashName", 13803}, + {"shaderName", 13804}, + {"lifeSpan", 13805}, + {"xp", 13806}, + {"tryUseDeployableVest", 13807}, + {"beginDeployableViaMarker", 13808}, + {"watchMarkerUsage", 13809}, + {"watchMarker", 13810}, + {"takeWeaponOnStuck", 13811}, + {"beginMarkerTracking", 13812}, + {"markerActivate", 13813}, + {"isMarker", 13814}, + {"createBoxForPlayer", 13815}, + {"boxType", 13816}, + {"box_setActive", 13817}, + {"isUsable", 13818}, + {"box_playerConnected", 13819}, + {"box_playerJoinedTeam", 13820}, + {"box_setInactive", 13821}, + {"box_handleDamage", 13822}, + {"box_handleDeath", 13823}, + {"box_handleOwnerDisconnect", 13824}, + {"boxThink", 13825}, + {"doubleDip", 13826}, + {"boxCaptureThink", 13827}, + {"isFriendlyToBox", 13828}, + {"box_timeOut", 13829}, + {"box_ModelTeamUpdater", 13830}, + {"boxParams", 13831}, + {"disableWhenJuggernaut", 13832}, + {"imsSettings", 13833}, + {"modelBombSquad", 13834}, + {"placeString", 13835}, + {"cannotPlaceString", 13836}, + {"attacks", 13837}, + {"modelExplosive1", 13838}, + {"modelExplosive2", 13839}, + {"modelExplosive3", 13840}, + {"modelExplosive4", 13841}, + {"modelLid1", 13842}, + {"modelLid2", 13843}, + {"modelLid3", 13844}, + {"modelLid4", 13845}, + {"tagExplosive1", 13846}, + {"tagExplosive2", 13847}, + {"tagExplosive3", 13848}, + {"tagExplosive4", 13849}, + {"tagLid1", 13850}, + {"tagLid2", 13851}, + {"tagLid3", 13852}, + {"tagLid4", 13853}, + {"tryUseIMS", 13854}, + {"imsList", 13855}, + {"giveIMS", 13856}, + {"setCarryingIMS", 13857}, + {"createIMSForPlayer", 13858}, + {"imsType", 13859}, + {"createIMS", 13860}, + {"lid1", 13861}, + {"lid2", 13862}, + {"lid3", 13863}, + {"lid4", 13864}, + {"explosive1", 13865}, + {"explosive2", 13866}, + {"explosive3", 13867}, + {"explosive4", 13868}, + {"ims_createBombSquadModel", 13869}, + {"ims_handleDamage", 13870}, + {"ims_handleDeath", 13871}, + {"ims_handleUse", 13872}, + {"ims_handleOwnerDisconnect", 13873}, + {"ims_setPlaced", 13874}, + {"ims_setCancelled", 13875}, + {"ims_setCarried", 13876}, + {"updateIMSPlacement", 13877}, + {"ims_onCarrierDeath", 13878}, + {"ims_onCarrierDisconnect", 13879}, + {"ims_onGameEnded", 13880}, + {"ims_setActive", 13881}, + {"attackTrigger", 13882}, + {"attackMoveTime", 13883}, + {"ims_playerConnected", 13884}, + {"ims_playerJoinedTeam", 13885}, + {"ims_blinky_light", 13886}, + {"ims_setInactive", 13887}, + {"isFriendlyToIMS", 13888}, + {"ims_attackTargets", 13889}, + {"fire_sensor", 13890}, + {"ims_timeOut", 13891}, + {"addToIMSList", 13892}, + {"removeFromIMSList", 13893}, + {"ims_hideAllParts", 13894}, + {"ims_showAllParts", 13895}, + {"turretSettings", 13896}, + {"hintEnter", 13897}, + {"hintExit", 13898}, + {"laptopInfo", 13899}, + {"remoteInfo", 13900}, + {"tryUseRemoteMGTurret", 13901}, + {"takeKillstreakWeapons", 13902}, + {"takeKillstreakWeaponIfNoDupe", 13903}, + {"tryUseRemoteTurret", 13904}, + {"setCarryingTurret", 13905}, + {"restoreWeaponClipAmmo", 13906}, + {"restoreWeaponStockAmmo", 13907}, + {"waitRestoreWeapons", 13908}, + {"turret_setPlaced", 13909}, + {"turret_setCancelled", 13910}, + {"turret_setCarried", 13911}, + {"updateTurretPlacement", 13912}, + {"turret_onCarrierDeath", 13913}, + {"turret_onCarrierDisconnect", 13914}, + {"turret_onCarrierChangedTeam", 13915}, + {"turret_onGameEnded", 13916}, + {"createTurretForPlayer", 13917}, + {"stunned", 13918}, + {"stunnedTime", 13919}, + {"damageFade", 13920}, + {"turret_setActive", 13921}, + {"remoteTurretList", 13922}, + {"startUsingRemoteTurret", 13923}, + {"stopUsingRemoteTurret", 13924}, + {"using_remote_turret_when_died", 13925}, + {"watchOwnerMessageOnDeath", 13926}, + {"watchEnterAndExit", 13927}, + {"enter_message_deleted", 13928}, + {"turret_blinky_light", 13929}, + {"turret_setInactive", 13930}, + {"clearRideIntro", 13931}, + {"turret_handleOwnerDisconnect", 13932}, + {"turret_timeOut", 13933}, + {"turret_handleDeath", 13934}, + {"target_ent", 13935}, + {"turret_handleDamage", 13936}, + {"turret_incrementDamageFade", 13937}, + {"turret_watchLowHealth", 13938}, + {"turret_stun", 13939}, + {"tankSettings", 13940}, + {"mgTurretInfo", 13941}, + {"glTurretInfo", 13942}, + {"modelMGTurret", 13943}, + {"stringPlace", 13944}, + {"stringCannotPlace", 13945}, + {"remote_tank_armor_bulletdamage", 13946}, + {"tryUseRemoteTank", 13947}, + {"giveTank", 13948}, + {"createTankForPlayer", 13949}, + {"tankType", 13950}, + {"setCarryingTank", 13951}, + {"tank_setCarried", 13952}, + {"updateTankPlacement", 13953}, + {"tank_onCarrierDeath", 13954}, + {"tank_onCarrierDisconnect", 13955}, + {"tank_onGameEnded", 13956}, + {"tank_setCancelled", 13957}, + {"tank_setPlaced", 13958}, + {"tank_giveWeaponOnPlaced", 13959}, + {"createTank", 13960}, + {"tank", 13961}, + {"tank_setActive", 13962}, + {"startUsingTank", 13963}, + {"tank_blinkyLightAntenna", 13964}, + {"tank_blinkyLightCamera", 13965}, + {"tank_setInactive", 13966}, + {"tank_freezeBuffer", 13967}, + {"tank_handleDisconnect", 13968}, + {"tank_handleChangeTeams", 13969}, + {"tank_handleTimeout", 13970}, + {"tank_handleDeath", 13971}, + {"tank_incrementDamageFade", 13972}, + {"tank_watchLowHealth", 13973}, + {"tank_handleDamage", 13974}, + {"tank_turret_handleDamage", 13975}, + {"tank_WatchFiring", 13976}, + {"tank_FireMissiles", 13977}, + {"tank_Earthquake", 13978}, + {"addToUGVList", 13979}, + {"removeFromUGVList", 13980}, + {"tank_playerExit", 13981}, + {"killstreakWeapons", 13982}, + {"killstreakWeildWeapons", 13983}, + {"killstreakChainingWeapons", 13984}, + {"killstreakRoundDelay", 13985}, + {"initKillstreakData", 13986}, + {"curDefValue", 13987}, + {"spUpdateTotal", 13988}, + {"earnedStreakLevel", 13989}, + {"adrenaline", 13990}, + {"initPlayerKillstreaks", 13991}, + {"earned", 13992}, + {"awardxp", 13993}, + {"kID", 13994}, + {"isGimme", 13995}, + {"isSpecialist", 13996}, + {"nextSlot", 13997}, + {"updateStreakCount", 13998}, + {"previousAdrenaline", 13999}, + {"resetStreakCount", 14000}, + {"getNextStreakName", 14001}, + {"getMaxStreakCost", 14002}, + {"updateStreakSlots", 14003}, + {"killstreakIndexWeapon", 14004}, + {"waitForChangeTeam", 14005}, + {"isRideKillstreak", 14006}, + {"isCarryKillstreak", 14007}, + {"deadlyKillstreak", 14008}, + {"killstreakUsePressed", 14009}, + {"selectingLocation", 14010}, + {"useHardpoint", 14011}, + {"updateSpecialistKillstreaks", 14012}, + {"getFirstPrimaryWeapon", 14013}, + {"killstreakUseWaiter", 14014}, + {"lastKillStreak", 14015}, + {"waitTakeKillstreakWeapon", 14016}, + {"shouldSwitchWeaponPostKillstreak", 14017}, + {"finishDeathWaiter", 14018}, + {"checkStreakReward", 14019}, + {"killstreakEarned", 14020}, + {"firstKillstreakEarned", 14021}, + {"earnKillstreak", 14022}, + {"isPerkUpgraded", 14023}, + {"giveKillstreakWeapon", 14024}, + {"_setActionSlot", 14025}, + {"isAssaultKillstreak", 14026}, + {"isSupportKillstreak", 14027}, + {"isSpecialistKillstreak", 14028}, + {"getKillstreakHint", 14029}, + {"getKillstreakInformEnemy", 14030}, + {"getKillstreakSound", 14031}, + {"getKillstreakDialog", 14032}, + {"getKillstreakIcon", 14033}, + {"getKillstreakDpadIcon", 14034}, + {"getKillstreakIndex", 14035}, + {"giveOwnedKillstreakItem", 14036}, + {"initRideKillstreak_internal", 14037}, + {"isNuked", 14038}, + {"giveSelectedKillstreakItem", 14039}, + {"showSelectedStreakHint", 14040}, + {"leaderSound", 14041}, + {"leaderSoundGroup", 14042}, + {"getKillstreakCount", 14043}, + {"shuffleKillstreaksUp", 14044}, + {"shuffleKillstreaksDown", 14045}, + {"streakSelectUpTracker", 14046}, + {"streakSelectDownTracker", 14047}, + {"streakNotifyTracker", 14048}, + {"adrenalineInfo", 14049}, + {"giveAllPerks", 14050}, + {"setAdrenaline", 14051}, + {"notifyOverlay", 14052}, + {"promotionSplashNotify", 14053}, + {"weaponPromotionSplashNotify", 14054}, + {"textGlowColor", 14055}, + {"iconOverlay", 14056}, + {"playerCardPlayer", 14058}, + {"resetOnDeath", 14059}, + {"resetNotify", 14060}, + {"hintMessageDeathThink", 14061}, + {"lowerMessageThink", 14062}, + {"lowerMessages", 14063}, + {"outcomeOverlay", 14064}, + {"matchOutcomeNotify", 14065}, + {"resetOutcomeNotify", 14066}, + {"resetTeamOutcomeNotify", 14067}, + {"updateOutcome", 14068}, + {"canShowSplash", 14069}, + {"missionCallbacks", 14070}, + {"createPerkMap", 14071}, + {"perkMap", 14072}, + {"mayProcessChallenges", 14073}, + {"patientZeroName", 14074}, + {"infected", 14075}, + {"plague", 14076}, + {"monitorScavengerPickup", 14077}, + {"monitorStreakReward", 14078}, + {"monitorBlastShieldSurvival", 14079}, + {"monitorTacInsertionsDestroyed", 14080}, + {"monitorFinalStandSurvival", 14081}, + {"initMissionData", 14082}, + {"registerMissionCallback", 14083}, + {"ch_assists", 14084}, + {"ch_hardpoints", 14085}, + {"hardpointType", 14086}, + {"ch_vehicle_kills", 14087}, + {"victim", 14088}, + {"ch_vehicle_killed", 14089}, + {"clearIDShortly", 14090}, + {"explosiveKills", 14091}, + {"MGKill", 14092}, + {"endMGStreakWhenLeaveMG", 14093}, + {"endMGStreak", 14094}, + {"killedBestEnemyPlayer", 14095}, + {"isHighestScoringPlayer", 14096}, + {"ch_kills", 14097}, + {"isCACSecondaryWeapon", 14098}, + {"brinkOfDeathKillStreak", 14099}, + {"isStrStart", 14100}, + {"getWeaponAttachments", 14101}, + {"anglesOnDeath", 14102}, + {"anglesOnKill", 14103}, + {"isBuffUnlockedForWeapon", 14104}, + {"holdingBreath", 14105}, + {"adsTime", 14106}, + {"isPlanting", 14107}, + {"isDefusing", 14108}, + {"isBombCarrier", 14109}, + {"dd", 14110}, + {"lastPrimaryWeaponSwapTime", 14111}, + {"lastFlashedTime", 14112}, + {"lastConcussedTime", 14113}, + {"lastSprintEndTime", 14114}, + {"ch_bulletDamageCommon", 14115}, + {"victimOnGround", 14116}, + {"attackerOnGround", 14117}, + {"attackerStance", 14118}, + {"ch_roundplayed", 14119}, + {"place", 14120}, + {"ch_roundwin", 14121}, + {"attackerInLastStand", 14122}, + {"waitAndProcessPlayerKilledCallback", 14123}, + {"processingKilledChallenges", 14124}, + {"doMissionCallback", 14125}, + {"monitorSprintDistance", 14126}, + {"sprintDistThisSprint", 14127}, + {"monitorSingleSprintDistance", 14128}, + {"monitorSprintTime", 14129}, + {"monitorFallDistance", 14130}, + {"lastManSD", 14131}, + {"monitorBombUse", 14132}, + {"monitorLiveTime", 14133}, + {"survivalistChallenge", 14134}, + {"monitorStreaks", 14135}, + {"monitorMisc", 14136}, + {"monitorMiscSingle", 14137}, + {"monitorMiscCallback", 14138}, + {"healthRegenerationStreak", 14139}, + {"resetBrinkOfDeathKillStreakShortly", 14140}, + {"playerDied", 14141}, + {"isAtBrinkOfDeath", 14142}, + {"getMarksmanUnlockAttachment", 14143}, + {"getWeaponAttachment", 14144}, + {"masteryChallengeProcess", 14145}, + {"isAttachmentUnlocked", 14146}, + {"buildChallegeInfo", 14147}, + {"monitorProcessChallenge", 14148}, + {"monitorKillstreakProgress", 14149}, + {"monitorKilledKillstreak", 14150}, + {"playerHasAmmo", 14151}, + {"monitorADSTime", 14152}, + {"monitorHoldBreath", 14153}, + {"monitorMantle", 14154}, + {"mantling", 14155}, + {"monitorWeaponSwap", 14156}, + {"monitorFlashbang", 14157}, + {"monitorConcussion", 14158}, + {"monitorMineTriggering", 14159}, + {"waitDelayMineTime", 14160}, + {"weaponRankTable", 14161}, + {"maxPrestige", 14162}, + {"patientZeroWaiter", 14163}, + {"isRegisteredEvent", 14164}, + {"getScoreInfoLabel", 14165}, + {"getWeaponRankInfoMinXP", 14166}, + {"getWeaponRankInfoXPAmt", 14167}, + {"getWeaponRankInfoMaxXp", 14168}, + {"getRankInfoLevel", 14169}, + {"xpUpdateTotal", 14170}, + {"bonusUpdateTotal", 14171}, + {"hud_xpPointsPopup", 14172}, + {"hud_xpEventPopup", 14173}, + {"prestigeDoubleXp", 14174}, + {"prestigeDoubleWeaponXp", 14175}, + {"setGamesPlayed", 14176}, + {"roundUp", 14177}, + {"weaponShouldGetXP", 14178}, + {"levelFlag", 14179}, + {"updateWeaponRankAnnounceHUD", 14180}, + {"createXpPointsPopup", 14181}, + {"createXpEventPopup", 14182}, + {"removeRankHUD", 14183}, + {"levelForExperience", 14184}, + {"weaponLevelForExperience", 14185}, + {"getCurrentWeaponXP", 14186}, + {"getWeaponRankForXp", 14187}, + {"getPrestigeLevel", 14188}, + {"getWeaponRankXP", 14189}, + {"getWeaponMaxRankXP", 14190}, + {"isWeaponMaxRank", 14191}, + {"incRankXP", 14192}, + {"isCheater", 14193}, + {"getRestXPAward", 14194}, + {"isLastRestXPAward", 14195}, + {"syncXPStat", 14196}, + {"isWeaponChallenge", 14197}, + {"isValidPrimary", 14198}, + {"isValidSecondary", 14199}, + {"classMap", 14200}, + {"defaultClass", 14201}, + {"logClassChoice", 14202}, + {"cac_getWeaponCamo", 14203}, + {"cac_getWeaponReticle", 14204}, + {"recipe_getKillstreak", 14205}, + {"table_getWeaponCamo", 14206}, + {"table_getWeaponReticle", 14207}, + {"table_getTeamPerk", 14208}, + {"loadoutFakePerks", 14209}, + {"getLoadoutStreakTypeFromStreakType", 14210}, + {"recipeClassApplyJuggernaut", 14211}, + {"classTableNum", 14212}, + {"loadoutPrimaryCamo", 14213}, + {"loadoutSecondaryCamo", 14214}, + {"loadoutPrimaryReticle", 14215}, + {"loadoutSecondaryReticle", 14216}, + {"_clearPerks", 14217}, + {"_detachAll", 14218}, + {"loadoutAllPerks", 14219}, + {"loadoutPerk1", 14220}, + {"loadoutPerk2", 14221}, + {"loadoutPerk3", 14222}, + {"loadoutPerkEquipment", 14223}, + {"tryAttach", 14224}, + {"tryDetach", 14225}, + {"buildWeaponName", 14226}, + {"letterToNumber", 14227}, + {"getAttachmentType", 14228}, + {"buildWeaponNameCamo", 14229}, + {"buildWeaponNameReticle", 14230}, + {"makeLettersToNumbers", 14231}, + {"setKillstreaks", 14232}, + {"replenishLoadout", 14233}, + {"classGrenades", 14234}, + {"onPlayerConnecting", 14235}, + {"fadeAway", 14236}, + {"getPerkForClass", 14237}, + {"classHasPerk", 14238}, + {"isValidAttachment", 14239}, + {"isValidWeaponBuff", 14240}, + {"isWeaponBuffUnlocked", 14241}, + {"isValidCamo", 14242}, + {"isValidReticle", 14243}, + {"isCamoUnlocked", 14244}, + {"isValidEquipment", 14245}, + {"isValidOffhand", 14246}, + {"isValidPerk1", 14247}, + {"isValidPerk2", 14248}, + {"isValidPerk3", 14249}, + {"isValidDeathStreak", 14250}, + {"isValidWeapon", 14251}, + {"weaponRefs", 14252}, + {"isValidKillstreak", 14253}, + {"persistentDataInfo", 14254}, + {"bufferedStats", 14255}, + {"bufferedChildStats", 14256}, + {"statAddChild", 14257}, + {"statGetChildBuffered", 14258}, + {"updateBufferedStats", 14259}, + {"writeBufferedStats", 14260}, + {"uploadGlobalStatCounters", 14261}, + {"exploder_sound", 14262}, + {"streakMsg", 14263}, + {"endSelectionOnEMP", 14264}, + {"endSelectionOnAction", 14265}, + {"endSelectionOnEndGame", 14266}, + {"getPlant", 14267}, + {"orientToNormal", 14268}, + {"deletePlacedEntity", 14269}, + {"sortLowerMessages", 14270}, + {"addLowerMessage", 14271}, + {"addTime", 14272}, + {"showTimer", 14273}, + {"shouldFade", 14274}, + {"fadeToAlpha", 14275}, + {"fadeToAlphaTime", 14276}, + {"removeLowerMessage", 14277}, + {"getLowerMessage", 14278}, + {"updateLowerMessage", 14279}, + {"clearOnDeath", 14280}, + {"clearAfterFade", 14281}, + {"printOnTeam", 14282}, + {"printBoldOnTeam", 14283}, + {"printBoldOnTeamArg", 14284}, + {"printOnTeamArg", 14285}, + {"printOnPlayers", 14286}, + {"printAndSoundOnEveryone", 14287}, + {"printAndSoundOnTeam", 14288}, + {"printAndSoundOnPlayer", 14289}, + {"_playLocalSound", 14290}, + {"dvarIntValue", 14291}, + {"dvarFloatValue", 14292}, + {"updatePersRatioBuffered", 14293}, + {"lastSlowProcessFrame", 14294}, + {"isExcluded", 14295}, + {"leaderDialogBothTeams", 14296}, + {"playLeaderDialogOnPlayer", 14297}, + {"leaderDialogLocalSound", 14298}, + {"setObjectiveText", 14299}, + {"setObjectiveScoreText", 14300}, + {"setObjectiveHintText", 14301}, + {"getObjectiveText", 14302}, + {"getObjectiveScoreText", 14303}, + {"getMinutesPassed", 14304}, + {"getValueInRange", 14305}, + {"waitForTimeOrNotifies", 14306}, + {"logXPGains", 14307}, + {"registerRoundSwitchDvar", 14308}, + {"roundswitchDvar", 14309}, + {"roundswitchMin", 14310}, + {"roundswitchMax", 14311}, + {"registerRoundLimitDvar", 14312}, + {"registerWinLimitDvar", 14313}, + {"registerScoreLimitDvar", 14314}, + {"registerTimeLimitDvar", 14315}, + {"registerHalfTimeDvar", 14316}, + {"registerNumLivesDvar", 14317}, + {"setOverTimeLimitDvar", 14318}, + {"getDvarVec", 14319}, + {"_takeWeaponsExcept", 14320}, + {"saveData", 14321}, + {"offhandClass", 14322}, + {"actionSlots", 14323}, + {"weapons", 14324}, + {"clipAmmoR", 14325}, + {"clipAmmoL", 14326}, + {"stockAmmo", 14327}, + {"script_saveData", 14328}, + {"restoreData", 14329}, + {"isFloat", 14330}, + {"registerWatchDvarInt", 14331}, + {"registerWatchDvarFloat", 14332}, + {"registerWatchDvar", 14333}, + {"setOverrideWatchDvar", 14334}, + {"onlyRoundOverride", 14335}, + {"hitScoreLimit", 14336}, + {"getRoundsWon", 14337}, + {"objectiveBased", 14338}, + {"bombexploded", 14339}, + {"ddTimeToAdd", 14340}, + {"inOvertime", 14341}, + {"getAverageOrigin", 14342}, + {"getLivingPlayers", 14343}, + {"getRemoteName", 14344}, + {"queues", 14345}, + {"_setPerk", 14346}, + {"_setExtraPerks", 14347}, + {"quickSort", 14348}, + {"quickSortMid", 14349}, + {"swap", 14350}, + {"onlinegame", 14351}, + {"endSceneOnDeath", 14352}, + {"giveCombatHigh", 14353}, + {"arrayInsertion", 14354}, + {"getProperty", 14355}, + {"statusMenu", 14356}, + {"_statusMenu", 14357}, // a typo by IW should be statusMenu + {"streakShouldChain", 14358}, + {"fixAkimboString", 14359}, + {"roundDecimalPlaces", 14360}, + {"makeTeamUsable", 14361}, + {"_updateTeamUsable", 14362}, + {"_updateEnemyUsable", 14363}, + {"gameFlagClear", 14364}, + {"isPrimaryDamage", 14365}, + {"levelFlags", 14366}, + {"levelFlagWait", 14367}, + {"levelFlagWaitOpen", 14368}, + {"killTrigger", 14369}, + {"setCommonRulesFromMatchRulesData", 14370}, + {"matchRules_allowCustomClasses", 14371}, + {"GetMatchRulesSpecialClass", 14372}, + {"audio", 14374}, + {"init_reverb", 14375}, + {"add_reverb", 14376}, + {"reverb_settings", 14377}, + {"is_roomtype_valid", 14378}, + {"apply_reverb", 14379}, + {"init_whizby", 14380}, + {"whizby_settings", 14381}, + {"set_whizby_radius", 14382}, + {"set_whizby_spread", 14383}, + {"apply_whizby", 14384}, + {"radial_button_definitions", 14385}, + {"radial_init", 14386}, + {"radial_button_group", 14387}, + {"pos_angle", 14388}, + {"end_angle", 14389}, + {"start_angle", 14390}, + {"debug_toggle", 14391}, + {"crib_debug", 14392}, + {"observer", 14393}, + {"return_hud", 14394}, + {"readyPlayer", 14395}, + {"get_right_stick_angle", 14396}, + {"rs_angle", 14397}, + {"newRadialButtonGroup", 14398}, + {"radial_button_group_info", 14399}, + {"newRadialButton", 14400}, + {"font_size", 14401}, + {"font_color", 14402}, + {"action_func", 14403}, + {"radius_pos", 14404}, + {"updateSelectedButton", 14405}, + {"radial_button_current_group", 14406}, + {"active_button", 14407}, + {"watchSelectButtonPress", 14408}, + {"watchBackButtonPress", 14409}, + {"sort_buttons_by_angle", 14410}, + {"button_switch", 14411}, + {"draw_radial_buttons", 14412}, + {"draw_radial_button", 14413}, + {"zoom_to_radial_menu", 14414}, + {"radial_button_previous_group", 14415}, + {"getRadialAngleFromEnt", 14416}, + {"radial_angle_to_vector", 14417}, + {"getMidAngle", 14418}, + {"isInRange", 14419}, + {"action_back", 14420}, + {"action_weapons_primary", 14421}, + {"action_weapons_secondary", 14422}, + {"action_gears", 14423}, + {"action_killstreak", 14424}, + {"action_leaderboards", 14425}, + {"view_path_setup", 14426}, + {"view_paths", 14427}, + {"build_path_by_targetname", 14428}, + {"go_path_by_targetname", 14429}, + {"dummy_mover", 14430}, + {"go_path_by_targetname_reverse", 14431}, + {"travel_view_fx", 14432}, + {"blur_sine", 14433}, + {"force_player_angles", 14434}, + {"shotgunSetup", 14435}, + {"tryUseAutoShotgun", 14436}, + {"thumperSetup", 14437}, + {"tryUseThumper", 14438}, + {"saveWeaponAmmoOnDeath", 14439}, + {"removeWeaponOnOutOfAmmo", 14440}, + {"spawnArmor", 14441}, + {"standardSpeed", 14442}, + {"deleteOnZ", 14443}, + {"useTank", 14444}, + {"tryUseTank", 14445}, + {"tankInUse", 14446}, + {"tankSpawner", 14447}, + {"startTank", 14448}, + {"nodes", 14449}, + {"objID", 14450}, + {"timeLastFired", 14451}, + {"neutralTarget", 14452}, + {"waitForChangeTeams", 14453}, + {"waitForDisco", 14454}, + {"setDirection", 14455}, + {"setEngagementSpeed", 14456}, + {"changingDirection", 14457}, + {"speedType", 14458}, + {"setMiniEngagementSpeed", 14459}, + {"setStandardSpeed", 14460}, + {"setEvadeSpeed", 14461}, + {"setDangerSpeed", 14462}, + {"stopToReverse", 14463}, + {"stopToForward", 14464}, + {"checkDanger", 14465}, + {"numEnemiesClose", 14466}, + {"tankUpdate", 14467}, + {"graphNodes", 14468}, + {"endNode", 14469}, + {"tankDamageMonitor", 14470}, + {"forcedTarget", 14471}, + {"handleThreat", 14472}, + {"tankCover", 14473}, + {"handlePossibleThreat", 14474}, + {"relativeAngle", 14475}, + {"watchForThreat", 14476}, + {"checkOwner", 14477}, + {"modifyDamage", 14478}, + {"destroyTank", 14479}, + {"tankFire", 14480}, + {"onHitPitchClamp", 14481}, + {"waitForTurretReady", 14482}, + {"tankGetTargets", 14483}, + {"harrier", 14484}, + {"acquireTarget", 14485}, + {"setNoTarget", 14486}, + {"explicitAbandonTarget", 14487}, + {"badTarget", 14488}, + {"badTargetReset", 14489}, + {"removeTarget", 14490}, + {"lastLostTime", 14491}, + {"isVehicleTarget", 14492}, + {"turretSightTrace", 14493}, + {"isMiniTarget", 14494}, + {"tankGetMiniTargets", 14495}, + {"getBestMiniTarget", 14496}, + {"acquireMiniTarget", 14497}, + {"bestMiniTarget", 14498}, + {"fireMiniOnTarget", 14499}, + {"watchMiniTargetDeath", 14500}, + {"watchMiniTargetDistance", 14501}, + {"watchMiniTargetThreat", 14502}, + {"explicitAbandonMiniTarget", 14503}, + {"addToTankList", 14504}, + {"removeFromTankList", 14505}, + {"getNodeNearEnemies", 14506}, + {"dist", 14507}, + {"setupPaths", 14508}, + {"branchNodes", 14509}, + {"next", 14510}, + {"length", 14511}, + {"graphId", 14512}, + {"getRandomBranchNode", 14513}, + {"links", 14514}, + {"linkDirs", 14515}, + {"getNextNodeForEndNode", 14516}, + {"g", 14517}, + {"otherDir", 14518}, + {"handleBranchNode", 14519}, + {"linkStartNodes", 14520}, + {"handleCapNode", 14521}, + {"nodeTracker", 14522}, + {"forwardGraphId", 14523}, + {"reverseGraphId", 14524}, + {"forceTrigger", 14525}, + {"getForwardGraphNode", 14526}, + {"getReverseGraphNode", 14527}, + {"getNextNode", 14528}, + {"getPrevNode", 14529}, + {"initNodeGraph", 14530}, + {"linkInfos", 14531}, + {"linkLengths", 14532}, + {"addLinkNode", 14533}, + {"toGraphNode", 14534}, + {"toGraphId", 14535}, + {"direction", 14536}, + {"startNode", 14537}, + {"generatePath", 14538}, + {"openList", 14539}, + {"closedList", 14540}, + {"h", 14541}, + {"f", 14542}, + {"parentNode", 14543}, + {"addToOpenList", 14544}, + {"openListID", 14545}, + {"closedListID", 14546}, + {"addToClosedList", 14547}, + {"getHValue", 14548}, + {"getGValue", 14549}, + {"drawPath", 14550}, + {"drawGraph", 14551}, + {"drawLink", 14552}, + {"debugPrintLn2", 14553}, + {"debugPrint3D", 14554}, + {"drawTankGraphIds", 14555}, + {"tankExplode", 14556}, + {"tankFlash", 14557}, + {"tankDust1", 14558}, + {"tankDust2", 14559}, + {"ground_support_locs", 14560}, + {"tryUseMobileMortar", 14561}, + {"mobileMortar", 14562}, + {"selectEntranceLocation", 14563}, + {"createMobileMortar", 14564}, + {"playersAttacked", 14565}, + {"lastTarget", 14566}, + {"lowX", 14567}, + {"highX", 14568}, + {"lowY", 14569}, + {"highY", 14570}, + {"moveToPosition", 14571}, + {"fxEnt", 14572}, + {"findTarget", 14573}, + {"findRandomTarget", 14574}, + {"mortarAttack", 14575}, + {"fireMortar", 14576}, + {"watchProjectileOnMiniMap", 14577}, + {"mortarRecoil", 14578}, + {"watchProximity", 14579}, + {"watchDamage", 14580}, + {"a10_fx", 14581}, + {"a10MaxHealth", 14582}, + {"a10Speed", 14583}, + {"a10SpeedReduction", 14584}, + {"a10StartPointOffset", 14585}, + {"a10ImpactFXDelay", 14586}, + {"a10Damage", 14587}, + {"a10DamageRadius", 14588}, + {"a10DamageDelay", 14589}, + {"a10BulletRainDelay", 14590}, + {"a10BulletImpactsDelay", 14591}, + {"a10EarthquakeMagnitude", 14592}, + {"a10EarthquakeDuration", 14593}, + {"a10EarthquakeDelay", 14594}, + {"a10DirtEffectRadius", 14595}, + {"a10ShootingGroundSoundDelay", 14596}, + {"a10StartPositionScalar", 14597}, + {"a10SupportSetup", 14598}, + {"usedUavA10", 14599}, + {"tryUseA10Strike", 14600}, + {"selectA10StrikeLocation", 14601}, + {"finishA10StrikeUsage", 14602}, + {"callA10Strike", 14603}, + {"doA10Strike", 14604}, + {"a10", 14605}, + {"a10StartMove", 14606}, + {"initialDelay", 14607}, + {"startPoint", 14608}, + {"attackPoint", 14609}, + {"endPoint", 14610}, + {"a10PlayEngineFX", 14611}, + {"spawnA10", 14612}, + {"fakeA10", 14613}, + {"startA10Shooting", 14614}, + {"a10ShootingPos", 14615}, + {"playBulletRain", 14616}, + {"manageShootingLoopSound", 14617}, + {"manageShootingGroundSound", 14618}, + {"a10Earthquake", 14619}, + {"a10Destroyed", 14620}, + {"a10Explode", 14621}, + {"removeA10", 14622}, + {"tryUseTeamAmmoRefill", 14623}, + {"giveTeamAmmoRefill", 14624}, + {"showSpawnpoint", 14625}, + {"showSpawnpoints", 14626}, + {"print3DUntilNotified", 14627}, + {"lineUntilNotified", 14628}, + {"hideSpawnpoints", 14629}, + {"updateReflectionProbe", 14630}, + {"reflectionProbeButtons", 14631}, + {"gotoNextSpawn", 14632}, + {"gotoPrevSpawn", 14633}, + {"endGameOnTimeLimit", 14634}, + {"playersLookingForSafeSpawn", 14635}, + {"registerDvars", 14636}, + {"blank", 14637}, + {"testMenu", 14638}, + {"testShock", 14639}, + {"fakeLag", 14640}, + {"spawn_all", 14641}, + {"spawn_axis_start", 14642}, + {"spawn_allies_start", 14643}, + {"flagBaseFXid", 14644}, + {"bestSpawnFlag", 14645}, + {"nearbyspawns", 14646}, + {"domFlags", 14647}, + {"lastStatus", 14648}, + {"baseeffectforward", 14649}, + {"baseeffectright", 14650}, + {"baseeffectpos", 14651}, + {"useObj", 14652}, + {"adjflags", 14653}, + {"getUnownedFlagNearestStart", 14654}, + {"didStatusNotify", 14655}, + {"statusDialog", 14656}, + {"resetFlagBaseEffect", 14657}, + {"baseeffect", 14658}, + {"captureTime", 14659}, + {"giveFlagCaptureXP", 14660}, + {"delayedLeaderDialog", 14661}, + {"delayedLeaderDialogBothTeams", 14662}, + {"updateDomScores", 14663}, + {"getOwnedDomFlags", 14664}, + {"getTeamFlagCount", 14665}, + {"getFlagTeam", 14666}, + {"getBoundaryFlags", 14667}, + {"getBoundaryFlagSpawns", 14668}, + {"getSpawnsBoundingFlag", 14669}, + {"getOwnedAndBoundingFlagSpawns", 14670}, + {"getOwnedFlagSpawns", 14671}, + {"flagSetup", 14672}, + {"descriptor", 14673}, + {"updateCPM", 14674}, + {"CPM", 14675}, + {"numCaps", 14676}, + {"getCapXPScale", 14677}, + {"multiBomb", 14678}, + {"bombPlanted", 14679}, + {"sd_loadout", 14680}, + {"checkAllowSpectating", 14681}, + {"sd_endGame", 14682}, + {"bombZones", 14683}, + {"killCamEntNum", 14684}, + {"bombDefused", 14685}, + {"plantTime", 14686}, + {"defuseTime", 14687}, + {"removeBombZoneC", 14688}, + {"relatedBrushModel", 14689}, + {"bombs", 14690}, + {"sdBomb", 14691}, + {"exploderIndex", 14692}, + {"bombDefuseTrig", 14693}, + {"otherBombZones", 14694}, + {"setupKillCamEnt", 14695}, + {"sdBombModel", 14696}, + {"onUsePlantObject", 14697}, + {"bombOwner", 14698}, + {"bombPlantedTime", 14699}, + {"applyBombCarrierClass", 14700}, + {"removeBombCarrierClass", 14701}, + {"onUseDefuseObject", 14702}, + {"tickingObject", 14703}, + {"BombTimerWait", 14704}, + {"handleHostMigration", 14705}, + {"setSpecialLoadout", 14706}, + {"spawn_axis", 14707}, + {"spawn_axis_planted", 14708}, + {"spawn_allies", 14709}, + {"spawn_allies_planted", 14710}, + {"otSpawned", 14711}, + {"sab_loadouts", 14712}, + {"printOTHint", 14713}, + {"hotPotato", 14714}, + {"scoreMode", 14715}, + {"sabotage", 14716}, + {"sabBomb", 14717}, + {"getClosestSite", 14718}, + {"distanceToSite", 14719}, + {"scoreThread", 14720}, + {"bombDistance", 14721}, + {"createBombZone", 14722}, + {"abandonmentThink", 14723}, + {"overtimeThread", 14724}, + {"bombDistanceThread", 14725}, + {"dangerTeam", 14726}, + {"resetBombsite", 14727}, + {"setUpForDefusing", 14728}, + {"setSpecialLoadouts", 14729}, + {"doPrematch", 14730}, + {"hqAutoDestroyTime", 14731}, + {"hqSpawnTime", 14732}, + {"kothMode", 14733}, + {"destroyTime", 14734}, + {"delayPlayer", 14735}, + {"spawnDelay", 14736}, + {"extraDelay", 14737}, + {"proMode", 14738}, + {"iconoffset", 14739}, + {"updateObjectiveHintMessages", 14740}, + {"getRespawnDelay", 14741}, + {"radioObject", 14742}, + {"hqDestroyTime", 14743}, + {"objectiveHintPrepareHQ", 14744}, + {"objectiveHintCaptureHQ", 14745}, + {"objectiveHintDestroyHQ", 14746}, + {"objectiveHintDefendHQ", 14747}, + {"HQMainLoop", 14748}, + {"hqRevealTime", 14749}, + {"timerDisplay", 14750}, + {"gameobject", 14751}, + {"trigorigin", 14752}, + {"hqDestroyedByTimer", 14753}, + {"hideTimerDisplayOnGameEnd", 14754}, + {"forceSpawnTeam", 14755}, + {"onRadioCapture", 14756}, + {"onRadioDestroy", 14757}, + {"DestroyHQAfterTime", 14758}, + {"awardHQPoints", 14759}, + {"nearSpawns", 14760}, + {"outerSpawns", 14761}, + {"SetupRadios", 14762}, + {"trig", 14763}, + {"radios", 14764}, + {"prevradio", 14765}, + {"prevradio2", 14766}, + {"makeRadioActive", 14767}, + {"makeRadioInactive", 14768}, + {"setUpNearbySpawns", 14769}, + {"distsq", 14770}, + {"PickRadioToSpawn", 14771}, + {"flagReturnTime", 14772}, + {"usingObj", 14773}, + {"oneflag_ctf", 14774}, + {"flagModel", 14775}, + {"icon2D", 14776}, + {"iconCapture3D", 14777}, + {"iconCapture2D", 14778}, + {"iconDefend3D", 14779}, + {"iconDefend2D", 14780}, + {"iconTarget3D", 14781}, + {"iconTarget2D", 14782}, + {"teamFlags", 14783}, + {"capZones", 14784}, + {"flagCaptured", 14785}, + {"createTeamFlag", 14786}, + {"createCapZone", 14787}, + {"returnFlag", 14788}, + {"attachFlag", 14789}, + {"detachFlag", 14790}, + {"ctf_loadouts", 14791}, + {"ctf", 14792}, + {"iconEscort3D", 14793}, + {"iconEscort2D", 14794}, + {"iconKill3D", 14795}, + {"iconKill2D", 14796}, + {"iconCaptureFlag3D", 14797}, + {"iconCaptureFlag2D", 14798}, + {"iconDefendFlag3D", 14799}, + {"iconDefendFlag2D", 14800}, + {"iconReturnFlag3D", 14801}, + {"iconReturnFlag2D", 14802}, + {"iconWaitForFlag3D", 14803}, + {"iconWaitForFlag2D", 14804}, + {"friendlyFlagStatusIcon", 14805}, + {"friendlyFlagStatusText", 14806}, + {"enemyFlagStatusIcon", 14807}, + {"enemyFlagStatusText", 14808}, + {"returnAfterTime", 14809}, + {"applyFlagCarrierClass", 14810}, + {"removeFlagCarrierClass", 14811}, + {"ctfPro", 14812}, + {"iconFlagBase2D", 14813}, + {"iconFlagBase3D", 14814}, + {"createTeamFlags", 14815}, + {"atHome", 14816}, + {"createCapZones", 14817}, + {"zoneHeadIcon", 14818}, + {"zoneMapIcon", 14819}, + {"cappedFlag", 14820}, + {"giveScore", 14821}, + {"matchRules_initialAmmo", 14822}, + {"matchRules_rewardAmmo", 14823}, + {"oic_firstSpawn", 14824}, + {"oic_rewardAmmo", 14825}, + {"oic_loadouts", 14826}, + {"waitLoadoutDone", 14827}, + {"oic_gun", 14828}, + {"waitGiveAmmo", 14829}, + {"giveAmmo", 14830}, + {"watchElimination", 14831}, + {"setGun", 14832}, + {"matchRules_dropTime", 14833}, + {"matchRules_zoneSwitchTime", 14834}, + {"grnd_fx", 14835}, + {"grnd_centerLoc", 14836}, + {"initFirstZone", 14838}, + {"zonesCycling", 14839}, + {"grnd_dropZones", 14840}, + {"grnd_initialIndex", 14841}, + {"grnd_zone", 14842}, + {"initZones", 14843}, + {"grnd_zones", 14844}, + {"inGrindZone", 14845}, + {"setPlayerMessages", 14846}, + {"inGrindZonePoints", 14847}, + {"grndHeadIcon", 14849}, + {"grndObjId", 14850}, + {"getNextZone", 14851}, + {"distToZone", 14852}, + {"cycleZones", 14853}, + {"grndTracking", 14854}, + {"locationScoring", 14855}, + {"randomDrops", 14856}, + {"getBestPlayer", 14857}, + {"getDropZoneCrateType", 14858}, + {"hideHudElementOnGameEnd", 14859}, + {"createZones", 14860}, + {"matchRules_enemyFlagRadar", 14861}, + {"tdef", 14862}, + {"tdef_loadouts", 14863}, + {"tdef_flagTime", 14864}, + {"portable_radar", 14865}, + {"currentCarrier", 14866}, + {"currentTeam", 14867}, + {"watchForEndGame", 14868}, + {"createFlag", 14869}, + {"flagAttachRadar", 14870}, + {"getFlagRadarOwner", 14871}, + {"flagRadarMover", 14872}, + {"flagWatchRadarOwnerLost", 14873}, + {"conf_fx", 14874}, + {"dogtags", 14875}, + {"spawnDogTags", 14876}, + {"victimTeam", 14877}, + {"showToTeam", 14878}, + {"bounce", 14879}, + {"clearOnVictimDisconnect", 14880}, + {"matchRules_numInitialInfected", 14881}, + {"infect_timerDisplay", 14882}, + {"infect_choseFirstInfected", 14883}, + {"infect_choosingFirstInfected", 14884}, + {"infect_firstSpawn", 14885}, + {"isInitialInfected", 14886}, + {"infect_loadouts", 14887}, + {"chooseFirstInfected", 14888}, + {"infect_isBeingChosen", 14889}, + {"setInitialToNormalInfected", 14890}, + {"updateTeamScores", 14891}, + {"matchRules_respawnNewJugg", 14894}, + {"matchRules_showJuggWorldIcon", 14895}, + {"jugg_juggernaut", 14896}, + {"jugg_choosingJugg", 14897}, + {"jugg_timerDisplay", 14898}, + {"chooseInitialJugg", 14899}, + {"jugg_juggScore", 14900}, + {"jugg_firstSpawn", 14901}, + {"jugg_loadouts", 14902}, + {"jugg_headIcon", 14903}, + {"resetJugg", 14904}, + {"giveJuggLoadout", 14905}, + {"updateJuggScores", 14906}, + {"gun_firstSpawn", 14907}, + {"gunGameGunIndex", 14908}, + {"gunGamePrevGunIndex", 14909}, + {"gun_loadouts", 14910}, + {"giveNextGun", 14911}, + {"gun_guns", 14912}, + {"refillSingleCountAmmo", 14914}, + {"initGunHUD", 14915}, + {"updateGunHUD", 14917}, + {"hideOnGameEnd", 14919}, + {"setGuns", 14920}, + {"matchRules_juggSwitchTime", 14921}, + {"jugg_available", 14922}, + {"jugg_attackers", 14923}, + {"jugg_currJugg", 14924}, + {"tjugg_timerDisplay", 14925}, + {"jugg_alligience", 14926}, + {"isJuggModeJuggernaut", 14927}, + {"tjugg_loadouts", 14928}, + {"nextJuggTimeout", 14929}, + {"respawnOldJugg", 14930}, + {"rewardTeammateProximity", 14931}, + {"logAttackers", 14932}, + {"resetJuggLoadoutOnDisconnect", 14933}, + {"getBestTeammate", 14934}, + {"precacheFlag", 14935}, + {"arenaTimeFlagWaiter", 14936}, + {"arenaFlagWaiter", 14937}, + {"arenaFlag", 14938}, + {"setupDomFlag", 14939}, + {"arena_endGame", 14940}, + {"bombsPlanted", 14941}, + {"ddBombModel", 14942}, + {"spawn_defenders", 14943}, + {"spawn_defenders_a", 14944}, + {"spawn_defenders_b", 14945}, + {"spawn_attackers", 14946}, + {"spawn_attackers_a", 14947}, + {"spawn_attackers_b", 14948}, + {"spawn_defenders_start", 14949}, + {"spawn_attackers_start", 14950}, + {"aPlanted", 14951}, + {"bPlanted", 14952}, + {"waitToProcess", 14953}, + {"dd_endGame", 14954}, + {"verifyBombzones", 14955}, + {"ddBomb", 14956}, + {"onUseObject", 14957}, + {"resetBombZone", 14958}, + {"defusing", 14959}, + {"timePauseStart", 14960}, + {"destroyedObject", 14961}, + {"bombHandler", 14962}, + {"playDemolitionTickingSound", 14963}, + {"waitTime", 14964}, + {"setBombTimerDvar", 14965}, + {"dropBombModel", 14966}, + {"restartTimer", 14967}, + {"skipWait", 14968}, + {"isVip", 14969}, + {"vip_endGame", 14970}, + {"vipSelection", 14971}, + {"setupVip", 14972}, + {"extractionZone", 14973}, + {"setVIPUse", 14974}, + {"handleTimer", 14975}, + {"extractionTime", 14976}, + {"forceVIPSpawn", 14977}, + {"gtnw_endGame", 14978}, + {"useBar", 14979}, + {"useBarText", 14980}, + {"setupNukeSite", 14981}, + {"nukeSite", 14982}, + {"endGameTime", 14983}, + {"scoreCounter", 14984}, + {"activateNuke", 14985}, + {"setUseBarScore", 14986}, + {"updateHudElems", 14987}, + {"AAMissileLaunchVert", 14988}, + {"AAMissileLaunchHorz", 14989}, + {"AAMissileLaunchTargetDist", 14990}, + {"tryUseAAMissile", 14991}, + {"getTargets", 14992}, + {"aa_missile_fire", 14993}, + {"AAMmissileLaunchTargetDist", 14994}, // this is a misspelling in original script + {"teamAirDenied", 14995}, + {"tryUseAAStrike", 14996}, + {"cycleTargets", 14997}, + {"findTargets", 14998}, + {"earlyAbortWatcher", 14999}, + {"airDeniedPlayer", 15000}, + {"finishAAStrike", 15001}, + {"fireAtTarget", 15002}, + {"AASoundManager", 15003}, + {"tweakfile", 15006}, + {"damagetype", 15007}, + {"audio_settings", 15008}, + {"meleeingPlayer", 15107}, + {"attachmentMap", 17433}, + {"checkRoundWin", 17434}, + {"_unk_field_ID25827", 25827}, // was introduced in an IW patch, used in _destructible.gsc + }; + + std::unordered_map file_list = + { + {29, "maps/mp/gametypes/_tweakables"}, + {30, "common_scripts/utility"}, + {31, "common_scripts/_createfxmenu"}, + {32, "common_scripts/_fx"}, + {65, "maps/_utility"}, + {66, "maps/_mgturret"}, + {67, "maps/_bcs_location_trigs"}, + {68, "maps/_anim"}, + {69, "maps/_gameskill"}, + {70, "common_scripts/_destructible"}, + {94, "common_scripts/_destructible_types"}, + {95, "maps/_vehicle"}, + {96, "maps/_mg_penetration"}, + {97, "maps/_rank"}, + {98, "maps/_hud_util"}, + {99, "maps/_hud"}, + {100, "maps/_missions"}, + {101, "maps/_colors"}, + {102, "maps/_spawner"}, + {103, "maps/_audio"}, + {104, "maps/_audio_stream_manager"}, + {133, "maps/_audio_dynamic_ambi"}, + {134, "maps/_audio_reverb"}, + {135, "maps/_audio_mix_manager"}, + {136, "maps/_audio_presets_vehicles"}, + {137, "maps/_specialops"}, + {138, "maps/_lights"}, + {139, "maps/_audio_zone_manager"}, + {176, "maps/_audio_music"}, + {177, "maps/_audio_whizby"}, + {178, "maps/_audio_vehicles"}, + {179, "maps/_specialops_code"}, + {180, "maps/_specialops_battlechatter"}, + {181, "maps/_endmission"}, + {182, "maps/_utility_code"}, + {183, "maps/_load"}, + {184, "maps/_quotes"}, + {185, "maps/_ambient"}, + {196, "character/character_hero_europe_price_cc"}, + {224, "maps/_coop"}, + {225, "common_scripts/_artcommon"}, + {226, "maps/_arcademode"}, + {227, "maps/_damagefeedback"}, + {228, "maps/_laststand"}, + {229, "maps/_player_stats"}, + {230, "maps/_art"}, + {234, "character/character_tank_crew_a"}, + {235, "character/character_tank_crew_b"}, + {264, "maps/_noder"}, + {265, "common_scripts/_painter"}, + {266, "maps/_createfx"}, + {267, "maps/_global_fx"}, + {268, "maps/_detonategrenades"}, + {269, "maps/_names"}, + {270, "maps/_autosave"}, + {271, "maps/_debug"}, + {272, "maps/_loadout"}, + {273, "common_scripts/_elevator"}, + {314, "common_scripts/_pipes"}, + {315, "common_scripts/_dynamic_world"}, + {316, "maps/_introscreen"}, + {317, "maps/_shutter"}, + {318, "maps/_escalator"}, + {319, "maps/_friendlyfire"}, + {320, "maps/_interactive_objects"}, + {321, "maps/_intelligence"}, + {322, "maps/_animatedmodels"}, + {323, "maps/_fx"}, + {324, "codescripts/character"}, + {325, "maps/_compass"}, + {326, "maps/_hiding_door"}, + {330, "character/character_opforce_henchmen_lmg_a"}, + {331, "character/character_opforce_henchmen_lmg_b"}, + {332, "character/character_hero_europe_price_a"}, + {358, "maps/_drone"}, + {359, "maps/_patrol"}, + {360, "maps/_vehicle_aianim"}, + {361, "maps/_helicopter_ai"}, + {362, "maps/_helicopter_globals"}, + {363, "vehicle_scripts/_attack_heli"}, +// maps/vehiclenames?? + {365, "maps/_treadfx"}, + {366, "maps/mp/_utility"}, + {367, "maps/mp/gametypes/_rank"}, + {368, "maps/mp/gametypes/_persistence"}, + {375, "character/character_hero_europe_price_aa"}, + {396, "maps/_dshk_player_rescue"}, + {400, "maps/mp/gametypes/_gamelogic"}, + {401, "maps/mp/killstreaks/_killstreaks"}, + {402, "maps/mp/gametypes/_missions"}, + {403, "maps/mp/gametypes/_hud_message"}, + {404, "characters/mp_character_ally_ghillie_desert"}, + {405, "characters/mp_character_op_ghillie_desert"}, + {406, "character/mp_character_ally_ghillie_arctic"}, + {407, "character/mp_character_op_ghillie_arctic"}, + {408, "character/mp_character_ally_ghillie_urban"}, + {409, "character/mp_character_op_ghillie_urban"}, + {410, "character/mp_character_ally_ghillie_forest"}, + {411, "character/mp_character_op_ghillie_forest"}, + {412, "character/mp_character_op_ghillie_militia"}, + {413, "xmodelalias/alias_delta_elite_heads"}, + {450, "xmodelalias/alias_delta_elite_heads_longsleeves"}, + {451, "character/mp_character_delta_elite_assault_aa"}, + {452, "character/mp_character_delta_elite_assault_ab"}, + {453, "character/mp_character_delta_elite_assault_ba"}, + {454, "character/mp_character_delta_elite_assault_bb"}, + {455, "character/mp_character_delta_elite_lmg_a"}, + {456, "character/mp_character_delta_elite_lmg_b"}, + {457, "character/mp_character_delta_elite_smg_a"}, + {458, "character/mp_character_delta_elite_smg_b"}, + {488, "character/mp_character_delta_elite_shotgun_a"}, + {489, "character/mp_character_delta_elite_sniper"}, + {490, "xmodelalias/alias_sas_heads"}, + {491, "character/mp_character_sas_urban_assault"}, + {501, "character/character_hero_europe_soap_injured"}, + {512, "common_scripts/_createfx"}, +// ... + {528, "maps/so_survival_mp_paris_precache"}, +// ... + {532, "character/mp_character_sas_urban_lmg"}, + {533, "character/mp_character_sas_urban_shotgun"}, + {534, "character/mp_character_sas_urban_smg"}, + {535, "character/mp_character_sas_urban_sniper"}, + {536, "character/mp_character_gign_paris_assault"}, + {537, "character/mp_character_gign_paris_lmg"}, + {538, "character/mp_character_gign_paris_shotgun"}, + {539, "character/mp_character_gign_paris_smg"}, + {540, "character/mp_character_gign_paris_riot"}, + {541, "xmodelalias/alias_pmc_africa_heads"}, + {542, "character/mp_character_pmc_africa_assault_a"}, + {543, "character/mp_character_pmc_africa_assault_aa"}, + {544, "character/character_mp_ally_juggernaut"}, +// ... + {545, "character/mp_character_pmc_africa_lmg_a"}, + {546, "character/mp_character_pmc_africa_lmg_aa"}, + {547, "character/mp_character_pmc_africa_smg_aa"}, + {548, "character/mp_character_pmc_africa_shotgun_a"}, +// ... + {566, "maps/castle_fx"}, + {567, "maps/castle_precache"}, +// ... + {591, "character/mp_character_pmc_africa_sniper"}, + {592, "character/mp_character_opforce_air_assault"}, + {593, "character/mp_character_opforce_air_lmg"}, + {594, "character/mp_character_opforce_air_shotgun"}, + {595, "character/mp_character_opforce_air_smg"}, + {596, "character/mp_character_opforce_air_sniper"}, + {597, "character/character_mp_opforce_juggernaut"}, + {598, "xmodelalias/alias_russian_military_arctic_heads"}, + {599, "character/mp_character_opforce_snow_assault"}, + {600, "character/mp_character_opforce_snow_lmg"}, +// ... + {610, "maps/so_survival_mp_plaza2_precache"}, + {611, "maps/so_survival_mp_hardhat_precache"}, +// ... + {621, "character/mp_character_opforce_snow_shotgun"}, + {622, "character/mp_character_opforce_snow_smg"}, + {623, "character/mp_character_opforce_snow_sniper"}, + {624, "character/mp_character_opforce_urban_assault"}, + {625, "character/mp_character_opforce_urban_lmg"}, + {626, "character/mp_character_opforce_urban_shotgun"}, + {627, "character/mp_character_opforce_urban_smg"}, + {628, "character/mp_character_opforce_urban_sniper"}, + {629, "character/mp_character_opforce_woods_assault"}, +// ... + {651, "character/mp_character_opforce_woods_lmg"}, + {652, "character/mp_character_opforce_woods_shotgun"}, + {653, "character/mp_character_opforce_woods_smg"}, + {654, "character/mp_character_opforce_woods_sniper"}, + {655, "xmodelalias/alias_africa_militia_heads_mp"}, + {656, "character/mp_character_africa_militia_assault_a"}, +// { + {660, "character/mp_character_africa_militia_lmg_b"}, +// { + {662, "character/mp_character_africa_militia_shotgun_b"}, +// { + {664, "character/mp_character_africa_militia_smg_b"}, +// { + {666, "character/mp_character_africa_militia_sniper"}, + {667, "xmodelalias/alias_henchmen_heads_mp"}, + {668, "character/mp_character_opforce_hench_assault_a"}, + {669, "character/mp_character_opforce_hench_assault_b"}, + {670, "character/mp_character_opforce_hench_assault_c"}, + {671, "character/mp_character_opforce_hench_assault_d"}, + {672, "character/mp_character_opforce_hench_lmg_a"}, + {673, "character/mp_character_opforce_hench_lmg_b"}, + {674, "character/mp_character_opforce_hench_shgn_a"}, + {675, "character/mp_character_opforce_hench_shgn_b"}, +// ... + {690, "character/mp_character_pmc_africa_smg_a"}, +// ... + {709, "character/mp_character_opforce_hench_smg_a"}, + {710, "character/mp_character_opforce_hench_smg_b"}, + {711, "character/mp_character_opforce_hench_sniper"}, + {712, "maps/mp/gametypes/_hostmigration"}, + {713, "mptype/mptype_ally_ghillie_desert"}, + {714, "mptype/mptype_opforce_ghillie_desert"}, + {715, "mptype/mptype_ally_ghillie_arctic"}, + {716, "mptype/mptype_opforce_ghillie_arctic"}, + {717, "mptype/mptype_ally_ghillie_urban"}, + {718, "mptype/mptype_opforce_ghillie_urban"}, + {719, "mptype/mptype_ally_ghillie_forest"}, + {720, "mptype/mptype_opforce_ghillie_forest"}, + {721, "mptype/mptype_opforce_ghillie_militia"}, + {722, "mptype/mptype_delta_multicam_assault"}, + {723, "mptype/mptype_delta_multicam_lmg"}, + {724, "mptype/mptype_delta_multicam_smg"}, + {725, "mptype/mptype_delta_multicam_shotgun"}, + {726, "mptype/mptype_delta_multicam_riot"}, + {727, "mptype/mptype_ally_juggernaut"}, + {728, "mptype/mptype_sas_urban_assault"}, + {729, "mptype/mptype_sas_urban_lmg"}, + {730, "mptype/mptype_sas_urban_shotgun"}, + {731, "mptype/mptype_sas_urban_smg"}, + {732, "mptype/mptype_sas_urban_sniper"}, + {733, "mptype/mptype_gign_paris_assault"}, + {734, "mptype/mptype_gign_paris_lmg"}, + {735, "mptype/mptype_gign_paris_shotgun"}, + {736, "mptype/mptype_gign_paris_smg"}, + {737, "maps/so_survival_mp_alpha_precache"}, + {738, "maps/so_survival_mp_carbon_precache"}, + {739, "maps/so_survival_mp_village_precache"}, + {740, "maps/so_survival_mp_seatown_precache"}, + {741, "maps/so_survival_mp_lambeth_precache"}, + {742, "maps/so_survival_mp_bootleg_precache"}, + {743, "maps/so_survival_mp_exchange_precache"}, + {744, "maps/so_survival_mp_mogadishu_precache"}, +// ... + {750, "maps/so_survival_mp_underground_precache"}, + {751, "maps/so_survival_mp_interchange_precache"}, +// ... + {767, "mptype/mptype_gign_paris_sniper"}, + {768, "mptype/mptype_gign_paris_riot"}, + {769, "mptype/mptype_pmc_africa_assault"}, + {770, "mptype/mptype_pmc_africa_lmg"}, + {771, "mptype/mptype_pmc_africa_smg"}, + {772, "mptype/mptype_pmc_africa_shotgun"}, + {773, "mptype/mptype_pmc_africa_sniper"}, + {774, "mptype/mptype_pmc_africa_riot"}, + {775, "mptype/mptype_opforce_air_assault"}, + {776, "mptype/mptype_opforce_air_lmg"}, + {777, "mptype/mptype_opforce_air_shotgun"}, + {778, "mptype/mptype_opforce_air_smg"}, + {779, "mptype/mptype_opforce_air_sniper"}, + {780, "mptype/mptype_opforce_air_riot"}, + {781, "mptype/mptype_opforce_juggernaut"}, + {782, "mptype/mptype_opforce_snow_assault"}, + {783, "mptype/mptype_opforce_snow_lmg"}, + {784, "mptype/mptype_opforce_snow_shotgun"}, + {785, "mptype/mptype_opforce_snow_smg"}, + {786, "mptype/mptype_opforce_snow_sniper"}, + {787, "mptype/mptype_opforce_snow_riot"}, + {788, "mptype/mptype_opforce_urban_assault"}, + {789, "mptype/mptype_opforce_urban_lmg"}, + {790, "mptype/mptype_opforce_urban_shotgun"}, + {791, "mptype/mptype_opforce_urban_smg"}, + {792, "mptype/mptype_opforce_urban_sniper"}, + {793, "mptype/mptype_opforce_urban_riot"}, + {794, "mptype/mptype_opforce_woodland_assault"}, + {795, "mptype/mptype_opforce_woodland_lmg"}, + {796, "mptype/mptype_opforce_woodland_shotgun"}, +// ... + {816, "maps/so_survival_mp_dome_precache"}, + {817, "maps/so_survival_mp_radar_precache"}, + {818, "maps/so_survival_mp_bravo_precache"}, + {819, "mptype/mptype_opforce_woodland_smg"}, + {820, "mptype/mptype_opforce_woodland_sniper"}, + {821, "mptype/mptype_opforce_woodland_riot"}, + {822, "mptype/mptype_opforce_africa_assault"}, + {823, "mptype/mptype_opforce_africa_lmg"}, + {824, "mptype/mptype_opforce_africa_shotgun"}, + {825, "mptype/mptype_opforce_africa_smg"}, + {826, "mptype/mptype_opforce_africa_sniper"}, + {827, "mptype/mptype_opforce_africa_riot"}, + {828, "mptype/mptype_opforce_henchmen_assault"}, + {829, "mptype/mptype_delta_multicam_sniper"}, + {830, "mptype/mptype_opforce_henchmen_lmg"}, + {831, "mptype/mptype_opforce_henchmen_shotgun"}, + {832, "mptype/mptype_opforce_henchmen_smg"}, + {833, "mptype/mptype_opforce_henchmen_sniper"}, + {834, "mptype/mptype_opforce_henchmen_riot"}, + {835, "maps/mp/gametypes/_weapons"}, + {836, "maps/mp/_entityheadicons"}, + {837, "maps/mp/gametypes/_damagefeedback"}, + {838, "maps/mp/_stinger"}, + {839, "maps/mp/_flashgrenades"}, + {840, "maps/mp/_empgrenade"}, + {841, "maps/mp/gametypes/_class"}, + {842, "maps/mp/_equipment"}, + {843, "maps/mp/_javelin"}, + {844, "maps/mp/gametypes/_shellshock"}, + {845, "maps/mp/_matchdata"}, + {846, "maps/mp/killstreaks/_perkstreaks"}, + {847, "maps/mp/perks/_perkfunctions"}, + {848, "maps/mp/gametypes/_scrambler"}, + {849, "maps/mp/gametypes/_portable_radar"}, + {850, "maps/mp/gametypes/_objpoints"}, + {851, "maps/mp/gametypes/_hud_util"}, + {852, "maps/mp/gametypes/_gameobjects"}, +// ... + {873, "maps/mp/gametypes/_quickmessages"}, + {874, "maps/mp/gametypes/_playerlogic"}, + {875, "maps/mp/gametypes/_spectating"}, + {876, "maps/mp/gametypes/_spawnlogic"}, + {877, "maps/mp/_events"}, + {878, "maps/mp/gametypes/_gamescore"}, + {879, "maps/mp/gametypes/_menus"}, + {880, "maps/mp/_minefields"}, + {881, "maps/mp/_radiation"}, + {882, "maps/mp/_shutter"}, + {883, "maps/mp/_destructables"}, + {884, "maps/mp/_audio"}, + {885, "maps/mp/_art"}, + {886, "maps/mp/_createfx"}, + {887, "maps/mp/_global_fx"}, + {888, "maps/mp/_animatedmodels"}, + {889, "maps/mp/killstreaks/_helicopter"}, + {890, "maps/mp/_skill"}, + {891, "maps/mp/killstreaks/_remoteuav"}, + {892, "maps/mp/gametypes/_battlechatter_mp"}, + {893, "maps/mp/gametypes/_deathicons"}, + {894, "maps/mp/gametypes/_killcam"}, + {895, "maps/mp/perks/_perks"}, + {896, "maps/mp/gametypes/_damage"}, + {897, "maps/mp/_highlights"}, + {898, "maps/mp/killstreaks/_escortairdrop"}, + {899, "maps/mp/killstreaks/_juggernaut"}, + {900, "maps/mp/killstreaks/_autosentry"}, + {901, "maps/mp/killstreaks/_airdrop"}, + {902, "maps/mp/gametypes/_hud"}, + {903, "maps/mp/_load"}, + {904, "maps/mp/gametypes/_serversettings"}, +// {905, "905"}, + {906, "maps/mp/mp_plaza2_precache"}, + {907, "maps/mp/mp_plaza2_fx"}, + {908, "maps/mp/mp_carbon_precache"}, + {909, "maps/mp/mp_carbon_fx"}, +// {910, "910"}, +// {911, "911"}, + {912, "maps/mp/mp_village_precache"}, + {913, "maps/mp/mp_village_fx"}, + {914, "maps/mp/mp_seatown_precache"}, + {915, "maps/mp/mp_seatown_fx"}, + {916, "maps/mp/mp_lambeth_precache"}, + {917, "maps/mp/mp_lambeth_fx"}, + {918, "maps/mp/mp_hardhat_precache"}, + {919, "maps/mp/mp_hardhat_fx"}, + {920, "maps/mp/mp_bootleg_precache"}, + {921, "maps/mp/mp_bootleg_fx"}, + {922, "maps/mp/mp_exchange_precache"}, + {923, "maps/mp/mp_exchange_fx"}, + {924, "maps/mp/mp_mogadishu_precache"}, + {925, "maps/mp/mp_mogadishu_fx"}, + {926, "maps/mp/mp_underground_precache"}, + {927, "maps/mp/mp_underground_fx"}, + {928, "maps/mp/mp_interchange_precache"}, + {929, "maps/mp/mp_interchange_fx"}, +// {930, "930"}, +// {931, "931"}, +// {932, "932"}, +// {933, "933"}, + {934, "maps/mp/gametypes/_healthoverlay"}, + {935, "maps/mp/gametypes/_music_and_dialog"}, + {936, "maps/mp/_awards"}, + {937, "maps/mp/_areas"}, + {938, "maps/mp/_defcon"}, + {939, "maps/mp/_matchevents"}, + {940, "maps/mp/gametypes/_friendicons"}, + {941, "maps/mp/gametypes/_scoreboard"}, + {942, "maps/mp/killstreaks/_harrier"}, + {943, "maps/mp/gametypes/_callbacksetup"}, + {944, "maps/mp/killstreaks/_airstrike"}, + {945, "maps/mp/killstreaks/_emp"}, + {946, "maps/mp/killstreaks/_uav"}, + {947, "maps/mp/killstreaks/_ac130"}, + {948, "maps/mp/killstreaks/_remotemissile"}, + {949, "maps/mp/killstreaks/_helicopter_flock"}, +// ... + {967, "maps/mp/mp_dome_precache"}, + {968, "maps/mp/mp_dome_fx"}, +// {969, "969"}, +// {970, "970"}, + {971, "maps/mp/mp_radar_precache"}, + {972, "maps/mp/mp_radar_fx"}, + {973, "maps/mp/mp_paris_precache"}, + {974, "maps/mp/mp_paris_fx"}, + {975, "maps/mp/mp_bravo_precache"}, + {976, "maps/mp/mp_bravo_fx"}, + {977, "maps/mp/mp_alpha_precache"}, + {978, "maps/mp/mp_alpha_fx"}, + {979, "maps/mp/killstreaks/_helicopter_guard"}, + {980, "maps/mp/killstreaks/_nuke"}, + {981, "maps/mp/killstreaks/_remotemortar"}, + {982, "maps/mp/killstreaks/_deployablebox"}, + {983, "maps/mp/killstreaks/_ims"}, + {984, "maps/mp/killstreaks/_remoteturret"}, + {985, "maps/mp/killstreaks/_remotetank"}, + {986, "maps/mp/gametypes/_playercards"}, + {987, "maps/mp/gametypes/_globallogic"}, +// ... + {998, "maps/mp/gametypes/_teams"}, +// ... + {1216, "vehicle_scripts/_pavelow_noai"}, + {1217, "maps/mp/_fx"}, + {1218, "maps/mp/_compass"}, + {1219, "maps/mp/_menus"}, + {1220, "maps/mp/_crib"}, + {1221, "maps/mp/killstreaks/_autoshotgun"}, + {1222, "maps/mp/killstreaks/_tank"}, + {1223, "maps/mp/killstreaks/_mobilemortar"}, + {1224, "maps/mp/killstreaks/_a10"}, + {1225, "maps/mp/killstreaks/_teamammorefill"}, +// {1226, "1226"}, // maps/mp/gametypes/_clientids maybe + {1227, "maps/mp/gametypes/_dev"}, +// {1228, "1228"},// maps/mp/gametypes/_globalentities maybe +// {1229, "1229"},// maps/mp/gametypes/_hardpoints maybe + {1230, "maps/mp/killstreaks/_aamissile"}, + {1231, "maps/mp/killstreaks/_aastrike"}, +// {1232, "maps/mp/killstreaks/_ac130"}, // bad name! +// ... + {1343, "xmodelalias/alias_gign_heads"}, + {1344, "codescripts/delete"}, + {1345, "codescripts/struct"}, +// ... + {1443, "common_scripts/_destructible_types_anim_airconditioner"}, + {1444, "maps/animated_models/fence_tarp_107x56_med_01"}, + {1445, "maps/animated_models/fence_tarp_130x56_med_01"}, + {1446, "maps/animated_models/fence_tarp_134x56_med_01"}, + {1447, "maps/animated_models/fence_tarp_134x76_med_01"}, + {1448, "maps/animated_models/fence_tarp_134x76_med_02"}, + {1449, "maps/animated_models/fence_tarp_140x56_med_01"}, + {1450, "maps/animated_models/fence_tarp_151x56_med_01"}, + {1451, "maps/animated_models/fence_tarp_167x56_med_01"}, + {1452, "maps/animated_models/foliage_desertbrush_1_sway"}, + {1453, "maps/animated_models/foliage_pacific_bushtree01"}, + {1454, "maps/animated_models/foliage_pacific_flowers06_sway"}, + {1455, "maps/animated_models/oil_pump_jack01"}, + {1456, "maps/animated_models/oil_pump_jack02"}, + {1457, "maps/animated_models/windmill_spin_med"}, + {1458, "maps/animated_models/windsock_large_wind_medium"}, + {1459, "maps/createart/mp_dome_art"}, + {1460, "maps/mp/_explosive_barrels"}, + {1461, "maps/createfx/mp_dome_fx"}, + {1462, "maps/createart/mp_dome_fog"}, +// ... + {1568, "vehicle_scripts/_mi17"}, +// {1636, ""}, +// {1637, ""}, +// {1638, ""}, + {1639, "vehicle_scripts/_gaz_dshk"}, + {1640, "vehicle_scripts/_hind"}, +// {1641, ""}, + {1642, "maps/animated_models/fence_tarp_108x76_med_01"}, +// {1643, "maps/animated_models/fence_tarp_132x82_med_01"}, + {1644, "maps/_predator2"}, +// {1645, "maps/_xm25"}, + {1646, "vehicle_scripts/_blackhawk_minigun"}, +// {1647, "vehicle_scripts/_stryker50cal"}, +// ------- files chunck end --------- +// {1721, +// ... + {6358, "maps/createart/so_survival_mp_plaza2_art"}, + {6359, "maps/createart/so_survival_mp_seatown_fog"}, + {6360, "maps/createart/so_survival_mp_seatown_art"}, + {6361, "maps/createart/so_survival_mp_underground_fog"}, + {6362, "maps/createart/so_survival_mp_underground_art"}, + {6363, "maps/createart/so_survival_mp_village_fog"}, + {6364, "maps/createart/so_survival_mp_village_art"}, +// ... +// {8217, +// {8218, +// {8219, +// ... + {8224, "maps/createart/so_survival_mp_hardhat_fog"}, + {8225, "maps/createart/so_survival_mp_hardhat_art"}, + {8226, "maps/createart/so_survival_mp_alpha_fog"}, + {8227, "maps/createart/so_survival_mp_alpha_art"}, + {8228, "maps/createart/so_survival_mp_bootleg_fog"}, + {8229, "maps/createart/so_survival_mp_bootleg_art"}, + {8230, "maps/createart/so_survival_mp_bravo_fog"}, + {8231, "maps/createart/so_survival_mp_bravo_art"}, + {8232, "maps/createart/so_survival_mp_carbon_fog"}, + {8233, "maps/createart/so_survival_mp_carbon_art"}, + {8234, "maps/createart/so_survival_mp_exchange_fog"}, + {8235, "maps/createart/so_survival_mp_exchange_art"}, + {8236, "maps/createart/so_survival_mp_interchange_fog"}, + {8237, "maps/createart/so_survival_mp_interchange_art"}, + {8238, "maps/createart/so_survival_mp_lambeth_fog"}, + {8239, "maps/createart/so_survival_mp_lambeth_art"}, + {8240, "maps/createart/so_survival_mp_mogadishu_fog"}, + {8241, "maps/createart/so_survival_mp_mogadishu_art"}, + {8242, "maps/createart/so_survival_mp_paris_fog"}, + {8243, "maps/createart/so_survival_mp_paris_art"}, + {8244, "maps/createart/so_survival_mp_plaza2_fog"}, +// ... + {18378, "maps/createart/so_survival_mp_dome_fog"}, + {18379, "maps/createart/so_survival_mp_dome_art"}, + {18380, "character/character_so_juggernaut_lite"}, +// ... + {18649, "common_scripts/_destructible_types_anim_generator"}, + {18650, "common_scripts/_destructible_types_anim_lockers"}, + {18651, "maps/animated_models/fence_tarp_124x52_a_med_01"}, + {18652, "maps/animated_models/fence_tarp_124x52_b_med_01"}, + {18653, "maps/animated_models/fence_tarp_126x76_a_med_01"}, + {18654, "maps/animated_models/fence_tarp_126x76_med_01"}, + {18655, "maps/animated_models/radar_spinning"}, + {18656, "maps/createart/mp_radar_art"}, + {18657, "maps/createfx/mp_radar_fx"}, + {18658, "maps/createart/mp_radar_fog"}, + {18659, "maps/createart/so_survival_mp_radar_fog"}, + {18660, "maps/createart/so_survival_mp_radar_art"}, + {18661, "common_scripts/_destructible_types_anim_chicken"}, + {18662, "maps/animated_models/hanging_sheet_wind_medium"}, + {18663, "maps/createart/mp_village_art"}, + {18664, "maps/createfx/mp_village_fx"}, + {18665, "maps/createart/mp_village_fog"}, + {18666, "common_scripts/_destructible_types_anim_security_camera"}, + {18667, "maps/createart/mp_underground_art"}, +// {18668, ""}, +// {18669, ""}, + {18670, "maps/createfx/mp_underground_fx"}, + {18671, "maps/createart/mp_underground_fog"}, + {18672, "vehicle_scripts/_80s_hatch1"}, + {18673, "common_scripts/_destructible_types_anim_me_fanceil1_spin"}, + {18674, "maps/animated_models/hanging_apron_wind_medium"}, + {18675, "maps/animated_models/hanging_longsleeve_wind_medium"}, + {18676, "maps/animated_models/hanging_shortsleeve_wind_medium"}, + {18677, "maps/animated_models/seatown_canopy_1section_01_sway"}, + {18678, "maps/animated_models/seatown_canopy_1section_02_sway"}, + {18679, "maps/animated_models/seatown_canopy_3section_01_sway"}, + {18680, "maps/animated_models/seatown_canopy_stand_01_sway"}, + {18681, "maps/animated_models/seatown_canopy_stand_02_sway"}, + {18682, "maps/animated_models/seatown_lrg_wiregrp_sway"}, + {18683, "maps/animated_models/seatown_mid01_wiregrp_sway"}, + {18684, "maps/animated_models/seatown_wire_flags1_sway"}, + {18685, "maps/animated_models/seatown_wire_flags2_sway"}, + {18686, "maps/createart/mp_seatown_art"}, + {18687, "maps/createfx/mp_seatown_fx"}, + {18688, "maps/createart/mp_seatown_fog"}, + {18689, "common_scripts/_destructible_types_anim_wallfan"}, + {18690, "maps/animated_models/mi24p_hind_plaza_destroy_animated"}, + {18691, "maps/createart/mp_plaza2_art"}, + {18692, "maps/createfx/mp_plaza2_fx"}, + {18693, "maps/createart/mp_plaza2_fog"}, + {18694, "maps/createart/mp_paris_art"}, + {18695, "maps/createfx/mp_paris_fx"}, + {18696, "maps/createart/mp_paris_fog"}, + {18697, "common_scripts/_destructible_types_anim_motorcycle_01"}, + {18698, "maps/createart/mp_mogadishu_art"}, + {18699, "maps/createfx/mp_mogadishu_fx"}, + {18700, "maps/createart/mp_mogadishu_fog"}, + {18701, "maps/animated_models/com_roofvent2"}, + {18702, "maps/animated_models/foliage_tree_river_birch_lg_a"}, + {18703, "maps/animated_models/foliage_tree_river_birch_xl_a"}, + {18704, "maps/createart/mp_lambeth_art"}, + {18705, "maps/createfx/mp_lambeth_fx"}, + {18706, "maps/createart/mp_lambeth_fog"}, + {18707, "maps/createart/mp_interchange_art"}, + {18708, "maps/createfx/mp_interchange_fx"}, + {18709, "maps/createart/mp_interchange_fog"}, + {18710, "maps/animated_models/fence_tarp_128x84_med_01"}, + {18711, "maps/animated_models/fence_tarp_192x50_med_01"}, + {18712, "maps/animated_models/fence_tarp_192x84_a_med_01"}, + {18713, "maps/animated_models/fence_tarp_196x146_med_01"}, + {18714, "maps/animated_models/fence_tarp_196x36_med_01"}, + {18715, "maps/animated_models/fence_tarp_196x56_med_01"}, + {18716, "maps/animated_models/fence_tarp_208x42_med_01"}, + {18717, "maps/animated_models/fence_tarp_352x88_med_01"}, + {18718, "maps/animated_models/fence_tarp_draping_224x116_01"}, + {18719, "maps/animated_models/fence_tarp_draping_98x94_med_01"}, + {18720, "maps/animated_models/fence_tarp_draping_98x94_med_02"}, + {18721, "maps/animated_models/fence_tarp_rooftop_set_01_med_01"}, + {18722, "maps/animated_models/hanging_dead_paratrooper01_animated"}, + {18723, "maps/animated_models/plastic_fence_232x88_med_01"}, + {18724, "maps/animated_models/plastic_fence_234x88_med_01"}, + {18725, "maps/animated_models/plastic_fence_256x48_med_01"}, + {18726, "maps/animated_models/plastic_fence_264x40_med_01"}, + {18727, "maps/animated_models/plastic_fence_300x88_med_01"}, + {18728, "maps/animated_models/plastic_fence_400x88_med_01"}, + {18729, "maps/animated_models/plastic_fence_528x88_med_01"}, + {18730, "maps/createart/mp_hardhat_art"}, + {18731, "maps/createfx/mp_hardhat_fx"}, + {18732, "maps/createart/mp_hardhat_fog"}, + {18733, "maps/createart/mp_exchange_art"}, + {18734, "maps/createfx/mp_exchange_fx"}, + {18735, "maps/createart/mp_exchange_fog"}, + {18736, "common_scripts/_destructible_types_anim_light_fluo_single"}, + {18737, "maps/animated_models/fence_tarp_110x64_med_01"}, + {18738, "maps/animated_models/fence_tarp_124x64_med_01"}, + {18739, "maps/animated_models/fence_tarp_128x64_med_01"}, + {18740, "maps/animated_models/fence_tarp_130x76_med_01"}, + {18741, "maps/animated_models/fence_tarp_130x82_a_med_01"}, + {18742, "maps/animated_models/fence_tarp_130x82_med_01"}, + {18743, "maps/animated_models/fence_tarp_132x62_med_01"}, + {18744, "maps/animated_models/fence_tarp_132x82_a_med_01"}, + {18745, "maps/animated_models/fence_tarp_140x68_med_01"}, + {18746, "maps/animated_models/fence_tarp_160x82_med_01"}, + {18747, "maps/animated_models/fence_tarp_162x64_med_01"}, + {18748, "maps/animated_models/fence_tarp_40x58_med_01"}, + {18749, "maps/animated_models/fence_tarp_68x58_med_01"}, + {18750, "maps/animated_models/fence_tarp_70x82_med_01"}, + {18751, "maps/animated_models/fence_tarp_80x84_med_01"}, + {18752, "maps/animated_models/fence_tarp_90x64_med_01"}, + {18753, "maps/animated_models/fence_tarp_94x64_med_01"}, + {18754, "maps/createart/mp_carbon_art"}, +// {18755, ""}, +// {18756, ""}, +// {18757, ""}, + {18758, "maps/createfx/mp_carbon_fx"}, + {18759, "maps/createart/mp_carbon_fog"}, + {18760, "maps/animated_models/foliage_cod5_tree_jungle_03"}, + {18761, "maps/animated_models/foliage_pacific_bushtree01"}, + {18762, "maps/animated_models/foliage_pacific_palms08"}, + {18763, "maps/createart/mp_bravo_art"}, + {18764, "maps/createfx/mp_bravo_fx"}, + {18765, "maps/createart/mp_bravo_fog"}, + {18766, "common_scripts/_destructible_types_anim_light_fluo_on"}, + {18767, "maps/createart/mp_bootleg_art"}, + {18768, "maps/createfx/mp_bootleg_fx"}, + {18769, "maps/createart/mp_bootleg_fog"}, + {18770, "maps/animated_models/alpha_hanging_civs_animated"}, + {18771, "maps/createart/mp_alpha_art"}, + {18772, "maps/createfx/mp_alpha_fx"}, + {18773, "maps/createart/mp_alpha_fog"}, +// ... + {21505, "vehicle_scripts/_btr80"}, + {21688, "vehicle_scripts/_uaz_castle"}, +// ... + {33361, "maps/mp/mp_italy_precache"}, + {33362, "maps/createart/mp_italy_art"}, + {33363, "maps/mp/mp_italy_fx"}, + {33364, "maps/createfx/mp_italy_fx"}, + {33365, "maps/createart/mp_italy_fog"}, + {33366, "maps/mp/mp_park_precache"}, + {33367, "maps/createart/mp_park_art"}, + {33368, "maps/mp/mp_park_fx"}, + {33369, "maps/createfx/mp_park_fx"}, + {33370, "maps/createart/mp_park_fog"}, + {33371, "maps/mp/mp_overwatch_precache"}, + {33372, "maps/createart/mp_overwatch_art"}, + {33373, "maps/mp/mp_overwatch_fx"}, + {33374, "maps/createfx/mp_overwatch_fx"}, + {33375, "maps/createart/mp_overwatch_fog"}, + {33376, "maps/mp/mp_morningwood_precache"}, + {33377, "maps/createart/mp_morningwood_art"}, + {33378, "maps/mp/mp_morningwood_fx"}, + {33379, "maps/createfx/mp_morningwood_fx"}, + {33380, "maps/createart/mp_morningwood_fog"}, + {33381, "maps/createart/so_survival_mp_italy_fog"}, + {33382, "maps/createart/so_survival_mp_italy_art"}, + {33383, "maps/so_survival_mp_italy_precache"}, + {33384, "maps/createart/so_survival_mp_park_fog"}, + {33385, "maps/createart/so_survival_mp_park_art"}, + {33386, "maps/so_survival_mp_park_precache"}, + }; +} \ No newline at end of file diff --git a/src/game/scripting/functions.cpp b/src/game/scripting/functions.cpp new file mode 100644 index 0000000..18b5195 --- /dev/null +++ b/src/game/scripting/functions.cpp @@ -0,0 +1,93 @@ +#include +#include "functions.hpp" + +#include + +namespace scripting +{ + namespace + { + std::unordered_map lowercase_map( + const std::unordered_map& old_map) + { + std::unordered_map new_map{}; + for (auto& entry : old_map) + { + new_map[utils::string::to_lower(entry.first)] = entry.second; + } + + return new_map; + } + + const std::unordered_map& get_methods() + { + static auto methods = lowercase_map(method_map); + return methods; + } + + const std::unordered_map& get_functions() + { + static auto function = lowercase_map(function_map); + return function; + } + + int find_function_index(const std::string& name, const bool prefer_global) + { + const auto target = utils::string::to_lower(name); + + const auto& primary_map = prefer_global + ? get_functions() + : get_methods(); + const auto& secondary_map = !prefer_global + ? get_functions() + : get_methods(); + + auto function_entry = primary_map.find(target); + if (function_entry != primary_map.end()) + { + return function_entry->second; + } + + function_entry = secondary_map.find(target); + if (function_entry != secondary_map.end()) + { + return function_entry->second; + } + + return -1; + } + + script_function get_function_by_index(const unsigned index) + { + static const auto function_table = 0x1D6EB34; + static const auto method_table = 0x1D4F258; + + if (index < 0x1C7) + { + return reinterpret_cast(function_table)[index]; + } + + return reinterpret_cast(method_table)[index]; + } + } + + int find_token_id(const std::string& name) + { + const auto result = token_map.find(name); + + if (result != token_map.end()) + { + return result->second; + } + + return -1; + } + + script_function find_function(const std::string& name, const bool prefer_global) + { + const auto index = find_function_index(name, prefer_global); + if (index < 0) return nullptr; + + return get_function_by_index(index); + } +} diff --git a/src/game/scripting/functions.hpp b/src/game/scripting/functions.hpp new file mode 100644 index 0000000..2f0cc11 --- /dev/null +++ b/src/game/scripting/functions.hpp @@ -0,0 +1,15 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + extern std::unordered_map method_map; + extern std::unordered_map function_map; + extern std::unordered_map token_map; + extern std::unordered_map file_list; + + using script_function = void(*)(game::scr_entref_t); + + script_function find_function(const std::string& name, const bool prefer_global); + int find_token_id(const std::string& name); +} diff --git a/src/game/scripting/safe_execution.cpp b/src/game/scripting/safe_execution.cpp new file mode 100644 index 0000000..55e2421 --- /dev/null +++ b/src/game/scripting/safe_execution.cpp @@ -0,0 +1,74 @@ +#include +#include "safe_execution.hpp" + +#pragma warning(push) +#pragma warning(disable: 4611) + +namespace scripting::safe_execution +{ + namespace + { + bool execute_with_seh(const script_function function, const game::scr_entref_t& entref) + { + __try + { + function(entref); + return true; + } + __except (EXCEPTION_EXECUTE_HANDLER) + { + return false; + } + } + } + + bool call(const script_function function, const game::scr_entref_t& entref) + { + *game::g_script_error_level += 1; + if (game::_setjmp(&game::g_script_error[*game::g_script_error_level])) + { + *game::g_script_error_level -= 1; + return false; + } + + const auto result = execute_with_seh(function, entref); + *game::g_script_error_level -= 1; + return result; + } + + bool set_entity_field(const game::scr_entref_t& entref, const int offset) + { + *game::g_script_error_level += 1; + if (game::_setjmp(&game::g_script_error[*game::g_script_error_level])) + { + *game::g_script_error_level -= 1; + return false; + } + + game::Scr_SetObjectField(entref.classnum, entref.entnum, offset); + + *game::g_script_error_level -= 1; + return true; + } + + bool get_entity_field(const game::scr_entref_t& entref, const int offset, game::VariableValue* value) + { + *game::g_script_error_level += 1; + if (game::_setjmp(&game::g_script_error[*game::g_script_error_level])) + { + value->type = game::SCRIPT_NONE; + value->u.intValue = 0; + *game::g_script_error_level -= 1; + return false; + } + + const auto _value = game::GetEntityFieldValue(entref.classnum, entref.entnum, offset); + value->type = _value.type; + value->u = _value.u; + + *game::g_script_error_level -= 1; + return true; + } +} + +#pragma warning(pop) diff --git a/src/game/scripting/safe_execution.hpp b/src/game/scripting/safe_execution.hpp new file mode 100644 index 0000000..6eea59d --- /dev/null +++ b/src/game/scripting/safe_execution.hpp @@ -0,0 +1,10 @@ +#pragma once +#include "functions.hpp" + +namespace scripting::safe_execution +{ + bool call(script_function function, const game::scr_entref_t& entref); + + bool set_entity_field(const game::scr_entref_t& entref, int offset); + bool get_entity_field(const game::scr_entref_t& entref, int offset, game::VariableValue* value); +} diff --git a/src/game/scripting/script_value.cpp b/src/game/scripting/script_value.cpp new file mode 100644 index 0000000..6962c1a --- /dev/null +++ b/src/game/scripting/script_value.cpp @@ -0,0 +1,287 @@ +#include +#include "script_value.hpp" +#include "entity.hpp" + + +namespace scripting +{ + /*************************************************************** + * Constructors + **************************************************************/ + + script_value::script_value(const game::VariableValue& value) + : value_(value) + { + } + + script_value::script_value(void* value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_INTEGER; + variable.u.intValue = reinterpret_cast(value); + + this->value_ = variable; + } + + script_value::script_value(const int value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_INTEGER; + variable.u.intValue = value; + + this->value_ = variable; + } + + script_value::script_value(const unsigned int value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_INTEGER; + variable.u.uintValue = value; + + this->value_ = variable; + } + + script_value::script_value(const bool value) + : script_value(static_cast(value)) + { + } + + script_value::script_value(const float value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_FLOAT; + variable.u.floatValue = value; + + this->value_ = variable; + } + + script_value::script_value(const double value) + : script_value(static_cast(value)) + { + } + + script_value::script_value(const char* value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_STRING; + variable.u.stringValue = game::SL_GetString(value, 0); + + const auto _ = gsl::finally([&variable]() + { + game::RemoveRefToValue(variable.type, variable.u); + }); + + this->value_ = variable; + } + + script_value::script_value(const std::string& value) + : script_value(value.data()) + { + } + + script_value::script_value(const entity& value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_OBJECT; + variable.u.pointerValue = value.get_entity_id(); + + this->value_ = variable; + } + + script_value::script_value(const vector& value) + { + game::VariableValue variable{}; + variable.type = game::SCRIPT_VECTOR; + variable.u.vectorValue = game::Scr_AllocVector(value); + + const auto _ = gsl::finally([&variable]() + { + game::RemoveRefToValue(variable.type, variable.u); + }); + + this->value_ = variable; + } + + /*************************************************************** + * Integer + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_INTEGER; + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + int script_value::get() const + { + return this->get_raw().u.intValue; + } + + template <> + unsigned int script_value::get() const + { + return this->get_raw().u.uintValue; + } + + template <> + bool script_value::get() const + { + return this->get_raw().u.uintValue != 0; + } + + /*************************************************************** + * Float + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_FLOAT; + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + float script_value::get() const + { + return this->get_raw().u.floatValue; + } + + template <> + double script_value::get() const + { + return static_cast(this->get_raw().u.floatValue); + } + + /*************************************************************** + * String + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_STRING; + } + + template <> + bool script_value::is() const + { + return this->is(); + } + + template <> + const char* script_value::get() const + { + return game::SL_ConvertToString(static_cast(this->get_raw().u.stringValue)); + } + + template <> + std::string script_value::get() const + { + return this->get(); + } + + /*************************************************************** + * Entity + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_OBJECT; + } + + template <> + entity script_value::get() const + { + return entity(this->get_raw().u.pointerValue); + } + + /*************************************************************** + * Array + **************************************************************/ + + template <> + bool script_value::is>() const + { + if (this->get_raw().type != game::SCRIPT_OBJECT) + { + return false; + } + + const auto id = this->get_raw().u.uintValue; + const auto type = game::scr_VarGlob->objectVariableValue[id].w.type; + + return type == game::SCRIPT_ARRAY; + } + + /*************************************************************** + * Struct + **************************************************************/ + + template <> + bool script_value::is>() const + { + if (this->get_raw().type != game::SCRIPT_OBJECT) + { + return false; + } + + const auto id = this->get_raw().u.uintValue; + const auto type = game::scr_VarGlob->objectVariableValue[id].w.type; + + return type == game::SCRIPT_STRUCT; + } + + /*************************************************************** + * Function + **************************************************************/ + + template <> + bool script_value::is>() const + { + return this->get_raw().type == game::SCRIPT_FUNCTION; + } + + /*************************************************************** + * Vector + **************************************************************/ + + template <> + bool script_value::is() const + { + return this->get_raw().type == game::SCRIPT_VECTOR; + } + + template <> + vector script_value::get() const + { + return this->get_raw().u.vectorValue; + } + + /*************************************************************** + * + **************************************************************/ + + const game::VariableValue& script_value::get_raw() const + { + return this->value_.get(); + } +} diff --git a/src/game/scripting/script_value.hpp b/src/game/scripting/script_value.hpp new file mode 100644 index 0000000..6b86f76 --- /dev/null +++ b/src/game/scripting/script_value.hpp @@ -0,0 +1,65 @@ +#pragma once +#include "game/game.hpp" +#include "variable_value.hpp" +#include "vector.hpp" + +namespace scripting +{ + class entity; + + class script_value + { + public: + script_value() = default; + script_value(const game::VariableValue& value); + + script_value(void* value); + + script_value(int value); + script_value(unsigned int value); + script_value(bool value); + + script_value(float value); + script_value(double value); + + script_value(const char* value); + script_value(const std::string& value); + + script_value(const entity& value); + + script_value(const vector& value); + + template + bool is() const; + + template + T as() const + { + if (!this->is()) + { + throw std::runtime_error("Invalid type"); + } + + return get(); + } + + template + T* as_ptr() + { + if (!this->is()) + { + throw std::runtime_error("Invalid type"); + } + + return reinterpret_cast(this->get()); + } + + const game::VariableValue& get_raw() const; + + private: + template + T get() const; + + variable_value value_{}; + }; +} diff --git a/src/game/scripting/stack_isolation.cpp b/src/game/scripting/stack_isolation.cpp new file mode 100644 index 0000000..25fd621 --- /dev/null +++ b/src/game/scripting/stack_isolation.cpp @@ -0,0 +1,27 @@ +#include +#include "stack_isolation.hpp" + +namespace scripting +{ + stack_isolation::stack_isolation() + { + this->in_param_count_ = game::scr_VmPub->inparamcount; + this->out_param_count_ = game::scr_VmPub->outparamcount; + this->top_ = game::scr_VmPub->top; + this->max_stack_ = game::scr_VmPub->maxstack; + + game::scr_VmPub->top = this->stack_; + game::scr_VmPub->maxstack = &this->stack_[ARRAYSIZE(this->stack_) - 1]; + game::scr_VmPub->inparamcount = 0; + game::scr_VmPub->outparamcount = 0; + } + + stack_isolation::~stack_isolation() + { + game::Scr_ClearOutParams(); + game::scr_VmPub->inparamcount = this->in_param_count_; + game::scr_VmPub->outparamcount = this->out_param_count_; + game::scr_VmPub->top = this->top_; + game::scr_VmPub->maxstack = this->max_stack_; + } +} diff --git a/src/game/scripting/stack_isolation.hpp b/src/game/scripting/stack_isolation.hpp new file mode 100644 index 0000000..8dffd4b --- /dev/null +++ b/src/game/scripting/stack_isolation.hpp @@ -0,0 +1,25 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + class stack_isolation final + { + public: + stack_isolation(); + ~stack_isolation(); + + stack_isolation(stack_isolation&&) = delete; + stack_isolation(const stack_isolation&) = delete; + stack_isolation& operator=(stack_isolation&&) = delete; + stack_isolation& operator=(const stack_isolation&) = delete; + + private: + game::VariableValue stack_[512]{}; + + game::VariableValue* max_stack_; + game::VariableValue* top_; + unsigned int in_param_count_; + unsigned int out_param_count_; + }; +} diff --git a/src/game/scripting/variable_value.cpp b/src/game/scripting/variable_value.cpp new file mode 100644 index 0000000..583daab --- /dev/null +++ b/src/game/scripting/variable_value.cpp @@ -0,0 +1,68 @@ +#include +#include "variable_value.hpp" + +namespace scripting +{ + variable_value::variable_value(const game::VariableValue& value) + { + this->assign(value); + } + + variable_value::variable_value(const variable_value& other) noexcept + { + this->operator=(other); + } + + variable_value::variable_value(variable_value&& other) noexcept + { + this->operator=(std::move(other)); + } + + variable_value& variable_value::operator=(const variable_value& other) noexcept + { + if (this != &other) + { + this->release(); + this->assign(other.value_); + } + + return *this; + } + + variable_value& variable_value::operator=(variable_value&& other) noexcept + { + if (this != &other) + { + this->release(); + this->value_ = other.value_; + other.value_.type = game::SCRIPT_NONE; + } + + return *this; + } + + variable_value::~variable_value() + { + this->release(); + } + + const game::VariableValue& variable_value::get() const + { + return this->value_; + } + + void variable_value::assign(const game::VariableValue& value) + { + this->value_ = value; + game::AddRefToValue(this->value_.type, this->value_.u); + } + + void variable_value::release() + { + if (this->value_.type != game::SCRIPT_NONE) + { + game::RemoveRefToValue(this->value_.type, this->value_.u); + this->value_.type = game::SCRIPT_NONE; + } + } +} diff --git a/src/game/scripting/variable_value.hpp b/src/game/scripting/variable_value.hpp new file mode 100644 index 0000000..7a96261 --- /dev/null +++ b/src/game/scripting/variable_value.hpp @@ -0,0 +1,27 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + class variable_value + { + public: + variable_value() = default; + variable_value(const game::VariableValue& value); + variable_value(const variable_value& other) noexcept; + variable_value(variable_value&& other) noexcept; + + variable_value& operator=(const variable_value& other) noexcept; + variable_value& operator=(variable_value&& other) noexcept; + + ~variable_value(); + + const game::VariableValue& get() const; + + private: + void assign(const game::VariableValue& value); + void release(); + + game::VariableValue value_{{0}, game::SCRIPT_NONE}; + }; +} diff --git a/src/game/scripting/vector.cpp b/src/game/scripting/vector.cpp new file mode 100644 index 0000000..143e29a --- /dev/null +++ b/src/game/scripting/vector.cpp @@ -0,0 +1,85 @@ +#include +#include "vector.hpp" + +namespace scripting +{ + vector::vector(const float* value) + { + for (auto i = 0; i < 3; ++i) + { + this->value_[i] = value[i]; + } + } + + vector::vector(const game::vec3_t& value) + : vector(&value[0]) + { + } + + vector::vector(const float x, const float y, const float z) + { + this->value_[0] = x; + this->value_[1] = y; + this->value_[2] = z; + } + + vector::operator game::vec3_t& () + { + return this->value_; + } + + vector::operator const game::vec3_t& () const + { + return this->value_; + } + + game::vec_t& vector::operator[](const size_t i) + { + if (i >= 3) + { + throw std::runtime_error("Out of bounds."); + } + + return this->value_[i]; + } + + const game::vec_t& vector::operator[](const size_t i) const + { + if (i >= 3) + { + throw std::runtime_error("Out of bounds."); + } + + return this->value_[i]; + } + + float vector::get_x() const + { + return this->operator[](0); + } + + float vector::get_y() const + { + return this->operator[](1); + } + + float vector::get_z() const + { + return this->operator[](2); + } + + void vector::set_x(const float value) + { + this->operator[](0) = value; + } + + void vector::set_y(const float value) + { + this->operator[](1) = value; + } + + void vector::set_z(const float value) + { + this->operator[](2) = value; + } +} diff --git a/src/game/scripting/vector.hpp b/src/game/scripting/vector.hpp new file mode 100644 index 0000000..0bb1595 --- /dev/null +++ b/src/game/scripting/vector.hpp @@ -0,0 +1,31 @@ +#pragma once +#include "game/game.hpp" + +namespace scripting +{ + class vector final + { + public: + vector() = default; + vector(const float* value); + vector(const game::vec3_t& value); + vector(float x, float y, float z); + + operator game::vec3_t& (); + operator const game::vec3_t& () const; + + game::vec_t& operator[](size_t i); + const game::vec_t& operator[](size_t i) const; + + float get_x() const; + float get_y() const; + float get_z() const; + + void set_x(float value); + void set_y(float value); + void set_z(float value); + + private: + game::vec3_t value_{ 0 }; + }; +} \ No newline at end of file diff --git a/src/game/structs.hpp b/src/game/structs.hpp new file mode 100644 index 0000000..03c079b --- /dev/null +++ b/src/game/structs.hpp @@ -0,0 +1,301 @@ +#pragma once + +namespace game +{ + typedef float vec_t; + typedef vec_t vec2_t[2]; + typedef vec_t vec3_t[3]; + typedef vec_t vec4_t[4]; + + struct cmd_function_t + { + cmd_function_t* next; + const char* name; + const char* autoCompleteDir; + const char* autoCompleteExt; + void(__cdecl* function)(); + int flags; + }; + + struct msg_t + { + int overflowed; + int readOnly; + char* data; + char* splitData; + int maxsize; + int cursize; + int splitSize; + int readcount; + int bit; + int lastEntityRef; + }; + + struct XZoneInfo + { + const char* name; + int allocFlags; + int freeFlags; + }; + + struct scr_entref_t + { + unsigned __int16 entnum; + unsigned __int16 classnum; + }; + + typedef void(__cdecl* scr_call_t)(int entref); + + enum MeansOfDeath + { + MOD_UNKNOWN = 0, + MOD_PISTOL_BULLET = 1, + MOD_RIFLE_BULLET = 2, + MOD_EXPLOSIVE_BULLET = 3, + MOD_GRENADE = 4, + MOD_GRENADE_SPLASH = 5, + MOD_PROJECTILE = 6, + MOD_PROJECTILE_SPLASH = 7, + MOD_MELEE = 8, + MOD_HEAD_SHOT = 9, + MOD_CRUSH = 10, + MOD_FALLING = 11, + MOD_SUICIDE = 12, + MOD_TRIGGER_HURT = 13, + MOD_EXPLOSIVE = 14, + MOD_IMPACT = 15, + MOD_NUM = 16 + }; + + enum scriptType_e + { + SCRIPT_NONE = 0, + SCRIPT_OBJECT = 1, + SCRIPT_STRING = 2, + SCRIPT_ISTRING = 3, + SCRIPT_VECTOR = 4, + SCRIPT_FLOAT = 5, + SCRIPT_INTEGER = 6, + SCRIPT_END = 8, + SCRIPT_FUNCTION = 9, + SCRIPT_STRUCT = 19, + SCRIPT_ARRAY = 22, + }; + + struct VariableStackBuffer + { + const char* pos; + unsigned __int16 size; + unsigned __int16 bufLen; + unsigned __int16 localId; + char time; + char buf[1]; + }; + + union VariableUnion + { + int intValue; + float floatValue; + unsigned int stringValue; + const float* vectorValue; + const char* codePosValue; + unsigned int pointerValue; + VariableStackBuffer* stackValue; + unsigned int entityId; + unsigned int uintValue; + }; + + struct VariableValue + { + VariableUnion u; + scriptType_e type; + }; + + struct function_stack_t + { + const char* pos; + unsigned int localId; + unsigned int localVarCount; + VariableValue* top; + VariableValue* startTop; + }; + + struct function_frame_t + { + function_stack_t fs; + int topType; + }; + + struct scrVmPub_t + { + unsigned int* localVars; + VariableValue* maxstack; + int function_count; + function_frame_t* function_frame; + VariableValue* top; + /*bool debugCode; + bool abort_on_error; + bool terminal_error; + bool block_execution;*/ + unsigned int inparamcount; + unsigned int outparamcount; + unsigned int breakpointOutparamcount; + bool showError; + function_frame_t function_frame_start[32]; + VariableValue stack[2048]; + }; + + struct scr_classStruct_t + { + unsigned __int16 id; + unsigned __int16 entArrayId; + char charId; + const char* name; + }; + + struct ObjectVariableChildren + { + unsigned __int16 firstChild; + unsigned __int16 lastChild; + }; + + struct ObjectVariableValue_u_f + { + unsigned __int16 prev; + unsigned __int16 next; + }; + + union ObjectVariableValue_u_o_u + { + unsigned __int16 size; + unsigned __int16 entnum; + unsigned __int16 nextEntId; + unsigned __int16 self; + }; + + struct ObjectVariableValue_u_o + { + unsigned __int16 refCount; + ObjectVariableValue_u_o_u u; + }; + + union ObjectVariableValue_w + { + unsigned int type; + unsigned int classnum; + unsigned int notifyName; + unsigned int waitTime; + unsigned int parentLocalId; + }; + + struct ChildVariableValue_u_f + { + unsigned __int16 prev; + unsigned __int16 next; + }; + + union ChildVariableValue_u + { + ChildVariableValue_u_f f; + VariableUnion u; + }; + + struct ChildBucketMatchKeys_keys + { + unsigned __int16 name_hi; + unsigned __int16 parentId; + }; + + union ChildBucketMatchKeys + { + ChildBucketMatchKeys_keys keys; + unsigned int match; + }; + + struct ChildVariableValue + { + ChildVariableValue_u u; + unsigned __int16 next; + char type; + char name_lo; + ChildBucketMatchKeys k; + unsigned __int16 nextSibling; + unsigned __int16 prevSibling; + }; + + union ObjectVariableValue_u + { + ObjectVariableValue_u_f f; + ObjectVariableValue_u_o o; + }; + + struct ObjectVariableValue + { + ObjectVariableValue_u u; + ObjectVariableValue_w w; + }; + + struct scrVarGlob_t + { + ObjectVariableValue objectVariableValue[36864]; + ObjectVariableChildren objectVariableChildren[36864]; + unsigned __int16 childVariableBucket[65536]; + ChildVariableValue childVariableValue[102400]; + }; + + union DvarValue + { + bool enabled; + int integer; + unsigned int unsignedInt; + float value; + float vector[4]; + const char* string; + char color[4]; + }; + + struct enum_limit + { + int stringCount; + const char** strings; + }; + + struct int_limit + { + int min; + int max; + }; + + struct float_limit + { + float min; + float max; + }; + + union DvarLimits + { + enum_limit enumeration; + int_limit integer; + float_limit value; + float_limit vector; + }; + + struct dvar_t + { + const char* name; + unsigned int flags; + char type; + bool modified; + DvarValue current; + DvarValue latched; + DvarValue reset; + DvarLimits domain; + bool(__cdecl* domainFunc)(dvar_t*, DvarValue); + dvar_t* hashNext; + }; + + struct gentity_s + { + int entnum; + }; +} \ No newline at end of file diff --git a/src/game/symbols.hpp b/src/game/symbols.hpp new file mode 100644 index 0000000..82401d8 --- /dev/null +++ b/src/game/symbols.hpp @@ -0,0 +1,69 @@ +#pragma once + +#define WEAK __declspec(selectany) + +namespace game +{ + // Functions + + WEAK symbol AddRefToValue{0x5656E0}; + WEAK symbol AddReftoObject{0x5655F0}; + WEAK symbol AllocThread{0x565580}; + WEAK symbol AllocObject{0x565530}; + WEAK symbol RemoveRefToValue{0x565730}; + + WEAK symbol BG_GetWeaponNameComplete{0x42F760}; + + WEAK symbol ConcatArgs{0x502150}; + WEAK symbol Cbuf_AddText{0x545680}; + WEAK symbol Cmd_AddCommandInternal{0x0}; + WEAK symbol Cmd_Argv{0x0}; + + WEAK symbol Dvar_FindVar{0x5BDCC0}; + + WEAK symbol I_CleanStr{0x0}; + + WEAK symbol GetEntityFieldValue{0x56AF20}; + WEAK symbol FindVariable{0x5651F0}; + WEAK symbol FindObject{0x565BD0}; + WEAK symbol GetVariable{0x5663E0}; + + WEAK symbol Scr_AllocVector{0x565680}; + WEAK symbol Scr_ClearOutParams{0x569010}; + WEAK symbol Scr_GetEntityIdRef{0x565F60}; + WEAK symbol Scr_SetObjectField{0x52BCC0}; + WEAK symbol Scr_NotifyId{0x56B5E0}; + WEAK symbol Scr_GetFunctionHandle{0x5618A0}; + WEAK symbol Scr_ExecThreadInternal{0x56E1C0}; + + WEAK symbol SL_GetString{0x5649E0}; + WEAK symbol SL_ConvertToString{0x564270}; + + WEAK symbol SV_GameSendServerCommand{0x573220}; + WEAK symbol SV_Cmd_ArgvBuffer{0x5459F0}; + + WEAK symbol VM_Notify{0x569720}; + WEAK symbol VM_Execute{0x56DFE0}; + + WEAK symbol longjmp{0x7363BC}; + WEAK symbol _setjmp{0x734CF8}; + + // Variables + + WEAK symbol g_script_error_level{0x20B21FC}; + WEAK symbol g_script_error{0x20B4218}; + + WEAK symbol scr_VmPub{0x20B4A80}; + WEAK symbol scr_VarGlob{0x1E72180}; + + WEAK symbol g_classMap{0x8B4300}; + + WEAK symbol g_entities{0x0}; + WEAK symbol levelEntityId{0x208E1A4}; + + namespace plutonium + { + WEAK symbol> function_map_rev{0x205862C0}; + WEAK symbol> method_map_rev{0x205862E0}; + } +} \ No newline at end of file diff --git a/src/loader/component_interface.hpp b/src/loader/component_interface.hpp new file mode 100644 index 0000000..e1ee433 --- /dev/null +++ b/src/loader/component_interface.hpp @@ -0,0 +1,35 @@ +#pragma once + +class component_interface +{ +public: + virtual ~component_interface() + { + } + + virtual void post_start() + { + } + + virtual void post_load() + { + } + + virtual void pre_destroy() + { + } + + virtual void post_unpack() + { + } + + virtual void* load_import([[maybe_unused]] const std::string& library, [[maybe_unused]] const std::string& function) + { + return nullptr; + } + + virtual bool is_supported() + { + return true; + } +}; diff --git a/src/loader/component_loader.cpp b/src/loader/component_loader.cpp new file mode 100644 index 0000000..d6a0090 --- /dev/null +++ b/src/loader/component_loader.cpp @@ -0,0 +1,127 @@ +#include +#include "component_loader.hpp" + +void component_loader::register_component(std::unique_ptr&& component_) +{ + get_components().push_back(std::move(component_)); +} + +bool component_loader::post_start() +{ + static auto handled = false; + if (handled) return true; + handled = true; + + try + { + for (const auto& component_ : get_components()) + { + component_->post_start(); + } + } + catch (premature_shutdown_trigger&) + { + return false; + } + + return true; +} + +bool component_loader::post_load() +{ + static auto handled = false; + if (handled) return true; + handled = true; + + clean(); + + try + { + for (const auto& component_ : get_components()) + { + component_->post_load(); + } + } + catch (premature_shutdown_trigger&) + { + return false; + } + + return true; +} + +void component_loader::post_unpack() +{ + static auto handled = false; + if (handled) return; + handled = true; + + for (const auto& component_ : get_components()) + { + component_->post_unpack(); + } +} + +void component_loader::pre_destroy() +{ + static auto handled = false; + if (handled) return; + handled = true; + + for (const auto& component_ : get_components()) + { + component_->pre_destroy(); + } +} + +void component_loader::clean() +{ + auto& components = get_components(); + for (auto i = components.begin(); i != components.end();) + { + if (!(*i)->is_supported()) + { + (*i)->pre_destroy(); + i = components.erase(i); + } + else + { + ++i; + } + } +} + +void* component_loader::load_import(const std::string& library, const std::string& function) +{ + void* function_ptr = nullptr; + + for (const auto& component_ : get_components()) + { + auto* const component_function_ptr = component_->load_import(library, function); + if (component_function_ptr) + { + function_ptr = component_function_ptr; + } + } + + return function_ptr; +} + +void component_loader::trigger_premature_shutdown() +{ + throw premature_shutdown_trigger(); +} + +std::vector>& component_loader::get_components() +{ + using component_vector = std::vector>; + using component_vector_container = std::unique_ptr>; + + static component_vector_container components(new component_vector, [](component_vector* component_vector) + { + pre_destroy(); + delete component_vector; + }); + + return *components; +} diff --git a/src/loader/component_loader.hpp b/src/loader/component_loader.hpp new file mode 100644 index 0000000..1f6b4d1 --- /dev/null +++ b/src/loader/component_loader.hpp @@ -0,0 +1,61 @@ +#pragma once +#include "component_interface.hpp" + +class component_loader final +{ +public: + class premature_shutdown_trigger final : public std::exception + { + [[nodiscard]] const char* what() const noexcept override + { + return "Premature shutdown requested"; + } + }; + + template + class installer final + { + static_assert(std::is_base_of::value, "component has invalid base class"); + + public: + installer() + { + register_component(std::make_unique()); + } + }; + + template + static T* get() + { + for (const auto& component_ : get_components()) + { + if (typeid(*component_.get()) == typeid(T)) + { + return reinterpret_cast(component_.get()); + } + } + + return nullptr; + } + + static void register_component(std::unique_ptr&& component); + + static bool post_start(); + static bool post_load(); + static void post_unpack(); + static void pre_destroy(); + static void clean(); + + static void* load_import(const std::string& library, const std::string& function); + + static void trigger_premature_shutdown(); + +private: + static std::vector>& get_components(); +}; + +#define REGISTER_COMPONENT(name) \ +namespace \ +{ \ + static component_loader::installer __component; \ +} diff --git a/src/stdinc.cpp b/src/stdinc.cpp new file mode 100644 index 0000000..25163e4 --- /dev/null +++ b/src/stdinc.cpp @@ -0,0 +1 @@ +#include \ No newline at end of file diff --git a/src/stdinc.hpp b/src/stdinc.hpp new file mode 100644 index 0000000..09bc7ef --- /dev/null +++ b/src/stdinc.hpp @@ -0,0 +1,41 @@ +#pragma once + +#pragma warning(disable: 4018) +#pragma warning(disable: 4146) +#pragma warning(disable: 4244) +#pragma warning(disable: 4267) +#pragma warning(disable: 26812) + +#define DLL_EXPORT extern "C" __declspec(dllexport) +#define WIN32_LEAN_AND_MEAN +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std::literals; + +#include +#include + +#include "utils/memory.hpp" +#include "utils/string.hpp" +#include "utils/hook.hpp" +#include "utils/concurrent_list.hpp" +#include "utils/io.hpp" + +#include "game/structs.hpp" +#include "game/game.hpp" \ No newline at end of file diff --git a/src/utils/concurrent_list.hpp b/src/utils/concurrent_list.hpp new file mode 100644 index 0000000..1014e7f --- /dev/null +++ b/src/utils/concurrent_list.hpp @@ -0,0 +1,144 @@ +#pragma once + +#include +#include + +// This class is trash. Need to get rid of it. + +namespace utils +{ + template + class concurrent_list final + { + public: + class element final + { + public: + explicit element(std::recursive_mutex* mutex, std::shared_ptr entry = {}, + std::shared_ptr next = {}) : + mutex_(mutex), + entry_(std::move(entry)), + next_(std::move(next)) + { + } + + void remove(const std::shared_ptr& element) + { + std::lock_guard _(*this->mutex_); + if (!this->next_) return; + + if (this->next_->entry_.get() == element.get()) + { + this->next_ = this->next_->next_; + } + else + { + this->next_->remove(element); + } + } + + [[nodiscard]] std::shared_ptr get_next() const + { + std::lock_guard _(*this->mutex_); + return this->next_; + } + + std::shared_ptr operator*() const + { + std::lock_guard _(*this->mutex_); + return this->entry_; + } + + element& operator++() + { + std::lock_guard _(*this->mutex_); + *this = this->next_ ? *this->next_ : element(this->mutex_); + return *this; + } + + element operator++(int) + { + std::lock_guard _(*this->mutex_); + auto result = *this; + this->operator++(); + return result; + } + + bool operator==(const element& other) + { + std::lock_guard _(*this->mutex_); + return this->entry_.get() == other.entry_.get(); + } + + bool operator!=(const element& other) + { + std::lock_guard _(*this->mutex_); + return !(*this == other); + } + + private: + std::recursive_mutex* mutex_; + std::shared_ptr entry_; + std::shared_ptr next_; + }; + + element begin() + { + std::lock_guard _(this->mutex_); + return this->entry_ ? *this->entry_ : this->end(); + } + + element end() + { + std::lock_guard _(this->mutex_); + return element(&this->mutex_); + } + + void remove(const element& entry) + { + std::lock_guard _(this->mutex_); + this->remove(*entry); + } + + void remove(const std::shared_ptr& element) + { + std::lock_guard _(this->mutex_); + if (!this->entry_) return; + + if ((**this->entry_).get() == element.get()) + { + this->entry_ = this->entry_->get_next(); + } + else + { + this->entry_->remove(element); + } + } + + void add(const T& object) + { + std::lock_guard _(this->mutex_); + + const auto object_ptr = std::make_shared(object); + this->entry_ = std::make_shared(&this->mutex_, object_ptr, this->entry_); + } + + void add(T&& object) + { + std::lock_guard _(this->mutex_); + + const auto object_ptr = std::make_shared(std::move(object)); + this->entry_ = std::make_shared(&this->mutex_, object_ptr, this->entry_); + } + + void clear() + { + std::lock_guard _(this->mutex_); + this->entry_ = {}; + } + + private: + std::recursive_mutex mutex_; + std::shared_ptr entry_; + }; +} \ No newline at end of file diff --git a/src/utils/hook.cpp b/src/utils/hook.cpp new file mode 100644 index 0000000..597369a --- /dev/null +++ b/src/utils/hook.cpp @@ -0,0 +1,180 @@ +#include + +// iw6x-client + +namespace utils::hook +{ + namespace + { + [[maybe_unused]] class _ + { + public: + _() + { + if (MH_Initialize() != MH_OK) + { + throw std::runtime_error("Failed to initialize MinHook"); + } + } + + ~_() + { + MH_Uninitialize(); + } + } __; + } + + detour::detour(const size_t place, void* target) : detour(reinterpret_cast(place), target) + { + } + + detour::detour(void* place, void* target) + { + this->create(place, target); + } + + detour::~detour() + { + this->clear(); + } + + void detour::enable() const + { + MH_EnableHook(this->place_); + } + + void detour::disable() const + { + MH_DisableHook(this->place_); + } + + void detour::create(void* place, void* target) + { + this->clear(); + this->place_ = place; + + if (MH_CreateHook(this->place_, target, &this->original_) != MH_OK) + { + throw std::runtime_error(string::va("Unable to create hook at location: %p", this->place_)); + } + + this->enable(); + } + + void detour::create(const size_t place, void* target) + { + this->create(reinterpret_cast(place), target); + } + + void detour::clear() + { + if (this->place_) + { + MH_RemoveHook(this->place_); + } + + this->place_ = nullptr; + this->original_ = nullptr; + } + + void* detour::get_original() const + { + return this->original_; + } + + void nop(void* place, const size_t length) + { + DWORD old_protect{}; + VirtualProtect(place, length, PAGE_EXECUTE_READWRITE, &old_protect); + + std::memset(place, 0x90, length); + + VirtualProtect(place, length, old_protect, &old_protect); + FlushInstructionCache(GetCurrentProcess(), place, length); + } + + void nop(const size_t place, const size_t length) + { + nop(reinterpret_cast(place), length); + } + + void copy(void* place, const void* data, const size_t length) + { + DWORD old_protect{}; + VirtualProtect(place, length, PAGE_EXECUTE_READWRITE, &old_protect); + + std::memmove(place, data, length); + + VirtualProtect(place, length, old_protect, &old_protect); + FlushInstructionCache(GetCurrentProcess(), place, length); + } + + void copy(const size_t place, const void* data, const size_t length) + { + copy(reinterpret_cast(place), data, length); + } + + bool is_relatively_far(const void* pointer, const void* data, int offset) + { + const int64_t diff = size_t(data) - (size_t(pointer) + offset); + const auto small_diff = int32_t(diff); + return diff != int64_t(small_diff); + } + + void call(void* pointer, void* data) + { + if (is_relatively_far(pointer, data)) + { + throw std::runtime_error("Too far away to create 32bit relative branch"); + } + + auto* patch_pointer = PBYTE(pointer); + set(patch_pointer, 0xE8); + set(patch_pointer + 1, int32_t(size_t(data) - (size_t(pointer) + 5))); + } + + void call(const size_t pointer, void* data) + { + return call(reinterpret_cast(pointer), data); + } + + void call(const size_t pointer, const size_t data) + { + return call(pointer, reinterpret_cast(data)); + } + + void set(std::uintptr_t address, std::vector&& bytes) + { + DWORD oldProtect = 0; + + auto* place = reinterpret_cast(address); + VirtualProtect(place, bytes.size(), PAGE_EXECUTE_READWRITE, &oldProtect); + memcpy(place, bytes.data(), bytes.size()); + VirtualProtect(place, bytes.size(), oldProtect, &oldProtect); + FlushInstructionCache(GetCurrentProcess(), place, bytes.size()); + } + + void set(std::uintptr_t address, void* buffer, size_t size) + { + DWORD oldProtect = 0; + + auto* place = reinterpret_cast(address); + VirtualProtect(place, size, PAGE_EXECUTE_READWRITE, &oldProtect); + memcpy(place, buffer, size); + VirtualProtect(place, size, oldProtect, &oldProtect); + FlushInstructionCache(GetCurrentProcess(), place, size); + } + + void jump(std::uintptr_t address, void* destination) + { + if (!address) return; + + std::uint8_t* bytes = new std::uint8_t[5]; + *bytes = 0xE9; + *reinterpret_cast(bytes + 1) = CalculateRelativeJMPAddress(address, destination); + + set(address, bytes, 5); + + delete[] bytes; + } +} \ No newline at end of file diff --git a/src/utils/hook.hpp b/src/utils/hook.hpp new file mode 100644 index 0000000..7a6413d --- /dev/null +++ b/src/utils/hook.hpp @@ -0,0 +1,116 @@ +#pragma once + +#define CalculateRelativeJMPAddress(X, Y) (((std::uintptr_t)Y - (std::uintptr_t)X) - 5) + +namespace utils::hook +{ + class detour + { + public: + detour() = default; + detour(void* place, void* target); + detour(size_t place, void* target); + ~detour(); + + detour(detour&& other) noexcept + { + this->operator=(std::move(other)); + } + + detour& operator= (detour&& other) noexcept + { + if (this != &other) + { + this->~detour(); + + this->place_ = other.place_; + this->original_ = other.original_; + + other.place_ = nullptr; + other.original_ = nullptr; + } + + return *this; + } + + detour(const detour&) = delete; + detour& operator= (const detour&) = delete; + + void enable() const; + void disable() const; + + void create(void* place, void* target); + void create(size_t place, void* target); + void clear(); + + template + T* get() const + { + return static_cast(this->get_original()); + } + + template + T invoke(Args... args) + { + return static_cast(this->get_original())(args...); + } + + [[nodiscard]] void* get_original() const; + + private: + void* place_{}; + void* original_{}; + }; + + void nop(void* place, size_t length); + void nop(size_t place, size_t length); + + void copy(void* place, const void* data, size_t length); + void copy(size_t place, const void* data, size_t length); + + bool is_relatively_far(const void* pointer, const void* data, int offset = 5); + + void call(void* pointer, void* data); + void call(size_t pointer, void* data); + void call(size_t pointer, size_t data); + + void jump(std::uintptr_t address, void* destination); + + template + T extract(void* address) + { + const auto data = static_cast(address); + const auto offset = *reinterpret_cast(data); + return reinterpret_cast(data + offset + 4); + } + + template + static void set(void* place, T value) + { + DWORD old_protect; + VirtualProtect(place, sizeof(T), PAGE_EXECUTE_READWRITE, &old_protect); + + *static_cast(place) = value; + + VirtualProtect(place, sizeof(T), old_protect, &old_protect); + FlushInstructionCache(GetCurrentProcess(), place, sizeof(T)); + } + + template + static void set(const size_t place, T value) + { + return set(reinterpret_cast(place), value); + } + + template + static T invoke(size_t func, Args... args) + { + return reinterpret_cast(func)(args...); + } + + template + static T invoke(void* func, Args... args) + { + return static_cast(func)(args...); + } +} \ No newline at end of file diff --git a/src/utils/io.cpp b/src/utils/io.cpp new file mode 100644 index 0000000..99da803 --- /dev/null +++ b/src/utils/io.cpp @@ -0,0 +1,112 @@ +#include +#include + +namespace utils::io +{ + bool file_exists(const std::string& file) + { + return std::ifstream(file).good(); + } + + bool write_file(const std::string& file, const std::string& data, const bool append) + { + const auto pos = file.find_last_of("/\\"); + if (pos != std::string::npos) + { + create_directory(file.substr(0, pos)); + } + + std::ofstream stream( + file, std::ios::binary | std::ofstream::out | (append ? std::ofstream::app : 0)); + + if (stream.is_open()) + { + stream.write(data.data(), data.size()); + stream.close(); + return true; + } + + return false; + } + + std::string read_file(const std::string& file) + { + std::string data; + read_file(file, &data); + return data; + } + + bool read_file(const std::string& file, std::string* data) + { + if (!data) return false; + data->clear(); + + if (file_exists(file)) + { + std::ifstream stream(file, std::ios::binary); + if (!stream.is_open()) return false; + + stream.seekg(0, std::ios::end); + const std::streamsize size = stream.tellg(); + stream.seekg(0, std::ios::beg); + + if (size > -1) + { + data->resize(static_cast(size)); + stream.read(const_cast(data->data()), size); + stream.close(); + return true; + } + } + + return false; + } + + size_t file_size(const std::string& file) + { + if (file_exists(file)) + { + std::ifstream stream(file, std::ios::binary); + + if (stream.good()) + { + stream.seekg(0, std::ios::end); + return static_cast(stream.tellg()); + } + } + + return 0; + } + + bool create_directory(const std::string& directory) + { + return std::filesystem::create_directories(directory); + } + + bool directory_exists(const std::string& directory) + { + return std::filesystem::is_directory(directory); + } + + bool directory_is_empty(const std::string& directory) + { + return std::filesystem::is_empty(directory); + } + + std::vector list_files(const std::string& directory) + { + std::vector files; + + for (auto& file : std::filesystem::directory_iterator(directory)) + { + files.push_back(file.path().generic_string()); + } + + return files; + } + + void copy_folder(const std::filesystem::path& src, const std::filesystem::path& target) + { + std::filesystem::copy(src, target, std::filesystem::copy_options::overwrite_existing | std::filesystem::copy_options::recursive); + } +} \ No newline at end of file diff --git a/src/utils/io.hpp b/src/utils/io.hpp new file mode 100644 index 0000000..e82a416 --- /dev/null +++ b/src/utils/io.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include +#include +#include + +namespace utils::io +{ + bool file_exists(const std::string& file); + bool write_file(const std::string& file, const std::string& data, bool append = false); + bool read_file(const std::string& file, std::string* data); + std::string read_file(const std::string& file); + size_t file_size(const std::string& file); + bool create_directory(const std::string& directory); + bool directory_exists(const std::string& directory); + bool directory_is_empty(const std::string& directory); + std::vector list_files(const std::string& directory); + void copy_folder(const std::filesystem::path& src, const std::filesystem::path& target); +} diff --git a/src/utils/memory.cpp b/src/utils/memory.cpp new file mode 100644 index 0000000..0022989 --- /dev/null +++ b/src/utils/memory.cpp @@ -0,0 +1,112 @@ +// https://github.com/momo5502/open-iw5 + +#include + +namespace utils +{ + memory::allocator memory::mem_allocator_; + + memory::allocator::~allocator() + { + this->clear(); + } + + void memory::allocator::clear() + { + std::lock_guard _(this->mutex_); + + for (auto& data : this->pool_) + { + memory::free(data); + } + + this->pool_.clear(); + } + + void memory::allocator::free(void* data) + { + std::lock_guard _(this->mutex_); + + const auto j = std::find(this->pool_.begin(), this->pool_.end(), data); + if (j != this->pool_.end()) + { + memory::free(data); + this->pool_.erase(j); + } + } + + void memory::allocator::free(const void* data) + { + this->free(const_cast(data)); + } + + void* memory::allocator::allocate(const size_t length) + { + std::lock_guard _(this->mutex_); + + const auto data = memory::allocate(length); + this->pool_.push_back(data); + return data; + } + + bool memory::allocator::empty() const + { + return this->pool_.empty(); + } + + /*char* memory::allocator::duplicate_string(const std::string& string) + { + std::lock_guard _(this->mutex_); + + const auto data = memory::duplicate_string(string); + this->pool_.push_back(data); + return data; + }*/ + + void* memory::allocate(const size_t length) + { + const auto data = calloc(length, 1); + assert(data != nullptr); + return data; + } + + /*char* memory::duplicate_string(const std::string& string) + { + const auto new_string = allocate_array(string.size() + 1); + std::memcpy(new_string, string.data(), string.size()); + return new_string; + }*/ + + void memory::free(void* data) + { + if (data) + { + ::free(data); + } + } + + void memory::free(const void* data) + { + free(const_cast(data)); + } + + bool memory::is_set(const void* mem, const char chr, const size_t length) + { + const auto mem_arr = static_cast(mem); + + for (size_t i = 0; i < length; ++i) + { + if (mem_arr[i] != chr) + { + return false; + } + } + + return true; + } + + memory::allocator* memory::get_allocator() + { + return &memory::mem_allocator_; + } +} diff --git a/src/utils/memory.hpp b/src/utils/memory.hpp new file mode 100644 index 0000000..bcc9d96 --- /dev/null +++ b/src/utils/memory.hpp @@ -0,0 +1,70 @@ +// https://github.com/momo5502/open-iw5 + +#pragma once + +namespace utils +{ + class memory final + { + public: + class allocator final + { + public: + ~allocator(); + + void clear(); + + void free(void* data); + + void free(const void* data); + + void* allocate(size_t length); + + template + T* allocate() + { + return this->allocate_array(1); + } + + template + T* allocate_array(const size_t count = 1) + { + return static_cast(this->allocate(count * sizeof(T))); + } + + bool empty() const; + + //char* duplicate_string(const std::string& string); + + private: + std::mutex mutex_; + std::vector pool_; + }; + + static void* allocate(size_t length); + + template + static inline T* allocate() + { + return allocate_array(1); + } + + template + static inline T* allocate_array(const size_t count = 1) + { + return static_cast(allocate(count * sizeof(T))); + } + + //static char* duplicate_string(const std::string& string); + + static void free(void* data); + static void free(const void* data); + + static bool is_set(const void* mem, char chr, size_t length); + + static allocator* get_allocator(); + + private: + static allocator mem_allocator_; + }; +} diff --git a/src/utils/string.cpp b/src/utils/string.cpp new file mode 100644 index 0000000..23f7c9f --- /dev/null +++ b/src/utils/string.cpp @@ -0,0 +1,151 @@ +#include + +namespace utils::string +{ + const char* va(const char* fmt, ...) + { + static thread_local va_provider<8, 256> provider; + + va_list ap; + va_start(ap, fmt); + + const char* result = provider.get(fmt, ap); + + va_end(ap); + return result; + } + + std::vector split(const std::string& s, const char delim) + { + std::stringstream ss(s); + std::string item; + std::vector elems; + + while (std::getline(ss, item, delim)) + { + elems.push_back(item); // elems.push_back(std::move(item)); // if C++11 (based on comment from @mchiasson) + } + + return elems; + } + + std::string to_lower(std::string text) + { + std::transform(text.begin(), text.end(), text.begin(), [](const char input) + { + return static_cast(tolower(input)); + }); + + return text; + } + + std::string to_upper(std::string text) + { + std::transform(text.begin(), text.end(), text.begin(), [](const char input) + { + return static_cast(toupper(input)); + }); + + return text; + } + + bool starts_with(const std::string& text, const std::string& substring) + { + return text.find(substring) == 0; + } + + bool ends_with(const std::string& text, const std::string& substring) + { + if (substring.size() > text.size()) return false; + return std::equal(substring.rbegin(), substring.rend(), text.rbegin()); + } + + std::string dump_hex(const std::string& data, const std::string& separator) + { + std::string result; + + for (unsigned int i = 0; i < data.size(); ++i) + { + if (i > 0) + { + result.append(separator); + } + + result.append(va("%02X", data[i] & 0xFF)); + } + + return result; + } + + void strip(const char* in, char* out, int max) + { + if (!in || !out) return; + + max--; + auto current = 0; + while (*in != 0 && current < max) + { + const auto color_index = (*(in + 1) - 48) >= 0xC ? 7 : (*(in + 1) - 48); + + if (*in == '^' && (color_index != 7 || *(in + 1) == '7')) + { + ++in; + } + else + { + *out = *in; + ++out; + ++current; + } + + ++in; + } + *out = '\0'; + } + +#pragma warning(push) +#pragma warning(disable: 4100) + std::string convert(const std::wstring& wstr) + { + std::string result; + result.reserve(wstr.size()); + + for (const auto& chr : wstr) + { + result.push_back(static_cast(chr)); + } + + return result; + } + + std::wstring convert(const std::string& str) + { + std::wstring result; + result.reserve(str.size()); + + for (const auto& chr : str) + { + result.push_back(static_cast(chr)); + } + + return result; + } +#pragma warning(pop) + + std::string replace(std::string str, const std::string& from, const std::string& to) + { + if (from.empty()) + { + return str; + } + + size_t start_pos = 0; + while ((start_pos = str.find(from, start_pos)) != std::string::npos) + { + str.replace(start_pos, from.length(), to); + start_pos += to.length(); + } + + return str; + } +} diff --git a/src/utils/string.hpp b/src/utils/string.hpp new file mode 100644 index 0000000..45e70ce --- /dev/null +++ b/src/utils/string.hpp @@ -0,0 +1,98 @@ +#pragma once +#include "memory.hpp" +#include + +#ifndef ARRAYSIZE +template +size_t ARRAYSIZE(Type(&)[n]) { return n; } +#endif + +namespace utils::string +{ + template + class va_provider final + { + public: + static_assert(Buffers != 0 && MinBufferSize != 0, "Buffers and MinBufferSize mustn't be 0"); + + va_provider() : current_buffer_(0) + { + } + + char* get(const char* format, const va_list ap) + { + ++this->current_buffer_ %= ARRAYSIZE(this->string_pool_); + auto entry = &this->string_pool_[this->current_buffer_]; + + if (!entry->size || !entry->buffer) + { + throw std::runtime_error("String pool not initialized"); + } + + while (true) + { + const int res = vsnprintf_s(entry->buffer, entry->size, _TRUNCATE, format, ap); + if (res > 0) break; // Success + if (res == 0) return nullptr; // Error + + entry->double_size(); + } + + return entry->buffer; + } + + private: + class entry final + { + public: + explicit entry(const size_t _size = MinBufferSize) : size(_size), buffer(nullptr) + { + if (this->size < MinBufferSize) this->size = MinBufferSize; + this->allocate(); + } + + ~entry() + { + if (this->buffer) memory::get_allocator()->free(this->buffer); + this->size = 0; + this->buffer = nullptr; + } + + void allocate() + { + if (this->buffer) memory::get_allocator()->free(this->buffer); + this->buffer = memory::get_allocator()->allocate_array(this->size + 1); + } + + void double_size() + { + this->size *= 2; + this->allocate(); + } + + size_t size; + char* buffer; + }; + + size_t current_buffer_; + entry string_pool_[Buffers]; + }; + + const char* va(const char* fmt, ...); + + std::vector split(const std::string& s, char delim); + + std::string to_lower(std::string text); + std::string to_upper(std::string text); + bool starts_with(const std::string& text, const std::string& substring); + bool ends_with(const std::string& text, const std::string& substring); + + std::string dump_hex(const std::string& data, const std::string& separator = " "); + + void strip(const char* in, char* out, int max); + + std::string convert(const std::wstring& wstr); + std::wstring convert(const std::string& str); + + std::string replace(std::string str, const std::string& from, const std::string& to); +} diff --git a/tools/windows/premake5.exe b/tools/windows/premake5.exe new file mode 100644 index 0000000..9048d51 Binary files /dev/null and b/tools/windows/premake5.exe differ