From c1adb9aee35e0c03c3a5a238354f64cfb4301b2c Mon Sep 17 00:00:00 2001 From: ineed bots Date: Mon, 18 Sep 2023 00:51:26 -0600 Subject: [PATCH] Revert "Massively improve bootup times" This reverts commit df2440a3baf87be342a611154d38bb8da795016a. --- .../decomp/clientscript/re_cscr_animtree.cpp | 100 ++- .../decomp/clientscript/re_cscr_compiler.cpp | 824 ++++++++++++------ .../decomp/clientscript/re_cscr_main.cpp | 76 +- .../clientscript/re_cscr_memorytree.cpp | 78 +- .../decomp/clientscript/re_cscr_parser.cpp | 138 ++- .../decomp/clientscript/re_cscr_parsetree.cpp | 58 +- .../decomp/clientscript/re_cscr_readwrite.cpp | 18 +- .../clientscript/re_cscr_stringlist.cpp | 160 ++-- .../decomp/clientscript/re_cscr_variable.cpp | 600 ++++++++----- .../decomp/clientscript/re_cscr_vm.cpp | 418 ++++++--- .../decomp/clientscript/re_cscr_yacc.cpp | 60 +- src/utils/hook.cpp | 13 +- src/utils/hook.hpp | 4 +- 13 files changed, 1708 insertions(+), 839 deletions(-) diff --git a/src/component/decomp/clientscript/re_cscr_animtree.cpp b/src/component/decomp/clientscript/re_cscr_animtree.cpp index d2e8e34..b38e05d 100644 --- a/src/component/decomp/clientscript/re_cscr_animtree.cpp +++ b/src/component/decomp/clientscript/re_cscr_animtree.cpp @@ -25,6 +25,25 @@ namespace re_cscr_animtree utils::hook::detour Scr_FindAnimTree_hook; utils::hook::detour Scr_FindAnim_hook; + void* AnimTreeCompileError_original; + void* GetAnimTreeParseProperties_original; + void* Scr_EmitAnimationInternal_original; + void* AnimTreeParseInternal_original; + void* Scr_AnimTreeParse_original; + void* Scr_GetAnimTreeSize_original; + void* ConnectScriptToAnim_original; + void* Scr_GetAnimsIndex_original; + void* Scr_CreateAnimationTree_original; + void* Scr_CheckAnimsDefined_original; + void* Scr_PrecacheAnimationTree_original; + void* Scr_UsingTreeInternal_original; + void* Scr_UsingTree_original; + void* Scr_SetAnimTreeConfigstring_original; + void* Scr_LoadAnimTreeInternal_original; + void* Scr_LoadAnimTreeAtIndex_original; + void* Scr_FindAnimTree_original; + void* Scr_FindAnim_original; + namespace { @@ -49,7 +68,7 @@ namespace re_cscr_animtree void Scr_EmitAnimationInternal_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, const char * pos, unsigned int animName, unsigned int names) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - game::Scr_EmitAnimationInternal(inst, pos, animName, names, Scr_EmitAnimationInternal_hook.get_original()); + game::Scr_EmitAnimationInternal(inst, pos, animName, names, Scr_EmitAnimationInternal_original); #else cscr_animtree::Scr_EmitAnimationInternal(inst, pos, animName, names); #endif @@ -79,7 +98,7 @@ namespace re_cscr_animtree void Scr_AnimTreeParse_call(game::scriptInstance_t inst, const char * pos, [[maybe_unused]] void* caller_addr, unsigned int parentNode, unsigned int names) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - game::Scr_AnimTreeParse(inst, pos, parentNode, names, Scr_AnimTreeParse_hook.get_original()); + game::Scr_AnimTreeParse(inst, pos, parentNode, names, Scr_AnimTreeParse_original); #else cscr_animtree::Scr_AnimTreeParse(inst, pos, parentNode, names); #endif @@ -110,7 +129,7 @@ namespace re_cscr_animtree void ConnectScriptToAnim_call(unsigned int name, unsigned int names, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, int index, unsigned int filename, int treeIndex) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - game::ConnectScriptToAnim(name, names, inst, index, filename, treeIndex, ConnectScriptToAnim_hook.get_original()); + game::ConnectScriptToAnim(name, names, inst, index, filename, treeIndex, ConnectScriptToAnim_original); #else cscr_animtree::ConnectScriptToAnim(name, names, inst, index, filename, treeIndex); #endif @@ -132,7 +151,7 @@ namespace re_cscr_animtree int Scr_GetAnimsIndex_call(game::XAnim_s * anim, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - return game::Scr_GetAnimsIndex(anim, Scr_GetAnimsIndex_hook.get_original()); + return game::Scr_GetAnimsIndex(anim, Scr_GetAnimsIndex_original); #else return cscr_animtree::Scr_GetAnimsIndex(anim); #endif @@ -162,7 +181,7 @@ namespace re_cscr_animtree void Scr_CheckAnimsDefined_call(unsigned int names, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr, unsigned int filename) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - game::Scr_CheckAnimsDefined(names, a2, filename, Scr_CheckAnimsDefined_hook.get_original()); + game::Scr_CheckAnimsDefined(names, a2, filename, Scr_CheckAnimsDefined_original); #else cscr_animtree::Scr_CheckAnimsDefined(names, a2, filename); #endif @@ -193,7 +212,7 @@ namespace re_cscr_animtree unsigned int Scr_UsingTreeInternal_call(const char * filename, int user, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int * index) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - return game::Scr_UsingTreeInternal(filename, user, inst, index, Scr_UsingTreeInternal_hook.get_original()); + return game::Scr_UsingTreeInternal(filename, user, inst, index, Scr_UsingTreeInternal_original); #else return cscr_animtree::Scr_UsingTreeInternal(filename, user, inst, index); #endif @@ -215,7 +234,7 @@ namespace re_cscr_animtree void Scr_UsingTree_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, const char * filename, unsigned int sourcePos) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - game::Scr_UsingTree(a1, filename, sourcePos, Scr_UsingTree_hook.get_original()); + game::Scr_UsingTree(a1, filename, sourcePos, Scr_UsingTree_original); #else cscr_animtree::Scr_UsingTree(a1, filename, sourcePos); #endif @@ -245,7 +264,7 @@ namespace re_cscr_animtree bool Scr_LoadAnimTreeInternal_call(const char * animtreeName, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int parentNode, unsigned int names) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - return game::Scr_LoadAnimTreeInternal(animtreeName, inst, parentNode, names, Scr_LoadAnimTreeInternal_hook.get_original()); + return game::Scr_LoadAnimTreeInternal(animtreeName, inst, parentNode, names, Scr_LoadAnimTreeInternal_original); #else return cscr_animtree::Scr_LoadAnimTreeInternal(animtreeName, inst, parentNode, names); #endif @@ -267,7 +286,7 @@ namespace re_cscr_animtree void Scr_LoadAnimTreeAtIndex_call(game::scriptInstance_t inst, int user, [[maybe_unused]] void* caller_addr, unsigned int index, void *(__cdecl * Alloc)(int), int modCheckSum) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - return game::Scr_LoadAnimTreeAtIndex(inst, user, index, Alloc, modCheckSum, Scr_LoadAnimTreeAtIndex_hook.get_original()); + return game::Scr_LoadAnimTreeAtIndex(inst, user, index, Alloc, modCheckSum, Scr_LoadAnimTreeAtIndex_original); #else return cscr_animtree::Scr_LoadAnimTreeAtIndex(inst, user, index, Alloc, modCheckSum); #endif @@ -289,7 +308,7 @@ namespace re_cscr_animtree game::scr_animtree_t Scr_FindAnimTree_call(const char * filename, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - return game::Scr_FindAnimTree(filename, Scr_FindAnimTree_hook.get_original()); + return game::Scr_FindAnimTree(filename, Scr_FindAnimTree_original); #else return cscr_animtree::Scr_FindAnimTree(filename); #endif @@ -310,7 +329,7 @@ namespace re_cscr_animtree void Scr_FindAnim_call(const char * animName, [[maybe_unused]] void* caller_addr, game::scr_anim_s a2, int user) { #ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - game::Scr_FindAnim(animName, a2, user, Scr_FindAnim_hook.get_original()); + game::Scr_FindAnim(animName, a2, user, Scr_FindAnim_original); #else cscr_animtree::Scr_FindAnim(animName, a2, user); #endif @@ -334,29 +353,44 @@ namespace re_cscr_animtree public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_ANIMTREE_USE_WRAPPERS - quick = false; -#endif + AnimTreeCompileError_hook.create(game::AnimTreeCompileError.get(), AnimTreeCompileError_stub); + GetAnimTreeParseProperties_hook.create(game::GetAnimTreeParseProperties.get(), GetAnimTreeParseProperties_stub); + Scr_EmitAnimationInternal_hook.create(game::Scr_EmitAnimationInternal_ADDR(), Scr_EmitAnimationInternal_stub); + AnimTreeParseInternal_hook.create(game::AnimTreeParseInternal.get(), AnimTreeParseInternal_stub); + Scr_AnimTreeParse_hook.create(game::Scr_AnimTreeParse_ADDR(), Scr_AnimTreeParse_stub); + Scr_GetAnimTreeSize_hook.create(game::Scr_GetAnimTreeSize.get(), Scr_GetAnimTreeSize_stub); + ConnectScriptToAnim_hook.create(game::ConnectScriptToAnim_ADDR(), ConnectScriptToAnim_stub); + Scr_GetAnimsIndex_hook.create(game::Scr_GetAnimsIndex_ADDR(), Scr_GetAnimsIndex_stub); + Scr_CreateAnimationTree_hook.create(game::Scr_CreateAnimationTree.get(), Scr_CreateAnimationTree_stub); + Scr_CheckAnimsDefined_hook.create(game::Scr_CheckAnimsDefined_ADDR(), Scr_CheckAnimsDefined_stub); + Scr_PrecacheAnimationTree_hook.create(game::Scr_PrecacheAnimationTree.get(), Scr_PrecacheAnimationTree_stub); + Scr_UsingTreeInternal_hook.create(game::Scr_UsingTreeInternal_ADDR(), Scr_UsingTreeInternal_stub); + Scr_UsingTree_hook.create(game::Scr_UsingTree_ADDR(), Scr_UsingTree_stub); + Scr_SetAnimTreeConfigstring_hook.create(game::Scr_SetAnimTreeConfigstring.get(), Scr_SetAnimTreeConfigstring_stub); + Scr_LoadAnimTreeInternal_hook.create(game::Scr_LoadAnimTreeInternal_ADDR(), Scr_LoadAnimTreeInternal_stub); + Scr_LoadAnimTreeAtIndex_hook.create(game::Scr_LoadAnimTreeAtIndex_ADDR(), Scr_LoadAnimTreeAtIndex_stub); + Scr_FindAnimTree_hook.create(game::Scr_FindAnimTree_ADDR(), Scr_FindAnimTree_stub); + Scr_FindAnim_hook.create(game::Scr_FindAnim_ADDR(), Scr_FindAnim_stub); - AnimTreeCompileError_hook.create(game::AnimTreeCompileError.get(), AnimTreeCompileError_stub, quick); - GetAnimTreeParseProperties_hook.create(game::GetAnimTreeParseProperties.get(), GetAnimTreeParseProperties_stub, quick); - Scr_EmitAnimationInternal_hook.create(game::Scr_EmitAnimationInternal_ADDR(), Scr_EmitAnimationInternal_stub, quick); - AnimTreeParseInternal_hook.create(game::AnimTreeParseInternal.get(), AnimTreeParseInternal_stub, quick); - Scr_AnimTreeParse_hook.create(game::Scr_AnimTreeParse_ADDR(), Scr_AnimTreeParse_stub, quick); - Scr_GetAnimTreeSize_hook.create(game::Scr_GetAnimTreeSize.get(), Scr_GetAnimTreeSize_stub, quick); - ConnectScriptToAnim_hook.create(game::ConnectScriptToAnim_ADDR(), ConnectScriptToAnim_stub, quick); - Scr_GetAnimsIndex_hook.create(game::Scr_GetAnimsIndex_ADDR(), Scr_GetAnimsIndex_stub, quick); - Scr_CreateAnimationTree_hook.create(game::Scr_CreateAnimationTree.get(), Scr_CreateAnimationTree_stub, quick); - Scr_CheckAnimsDefined_hook.create(game::Scr_CheckAnimsDefined_ADDR(), Scr_CheckAnimsDefined_stub, quick); - Scr_PrecacheAnimationTree_hook.create(game::Scr_PrecacheAnimationTree.get(), Scr_PrecacheAnimationTree_stub, quick); - Scr_UsingTreeInternal_hook.create(game::Scr_UsingTreeInternal_ADDR(), Scr_UsingTreeInternal_stub, quick); - Scr_UsingTree_hook.create(game::Scr_UsingTree_ADDR(), Scr_UsingTree_stub, quick); - Scr_SetAnimTreeConfigstring_hook.create(game::Scr_SetAnimTreeConfigstring.get(), Scr_SetAnimTreeConfigstring_stub, quick); - Scr_LoadAnimTreeInternal_hook.create(game::Scr_LoadAnimTreeInternal_ADDR(), Scr_LoadAnimTreeInternal_stub, quick); - Scr_LoadAnimTreeAtIndex_hook.create(game::Scr_LoadAnimTreeAtIndex_ADDR(), Scr_LoadAnimTreeAtIndex_stub, quick); - Scr_FindAnimTree_hook.create(game::Scr_FindAnimTree_ADDR(), Scr_FindAnimTree_stub, quick); - Scr_FindAnim_hook.create(game::Scr_FindAnim_ADDR(), Scr_FindAnim_stub, quick); + //Original hook function addresses + AnimTreeCompileError_original = AnimTreeCompileError_hook.get_original(); + GetAnimTreeParseProperties_original = GetAnimTreeParseProperties_hook.get_original(); + Scr_EmitAnimationInternal_original = Scr_EmitAnimationInternal_hook.get_original(); + AnimTreeParseInternal_original = AnimTreeParseInternal_hook.get_original(); + Scr_AnimTreeParse_original = Scr_AnimTreeParse_hook.get_original(); + Scr_GetAnimTreeSize_original = Scr_GetAnimTreeSize_hook.get_original(); + ConnectScriptToAnim_original = ConnectScriptToAnim_hook.get_original(); + Scr_GetAnimsIndex_original = Scr_GetAnimsIndex_hook.get_original(); + Scr_CreateAnimationTree_original = Scr_CreateAnimationTree_hook.get_original(); + Scr_CheckAnimsDefined_original = Scr_CheckAnimsDefined_hook.get_original(); + Scr_PrecacheAnimationTree_original = Scr_PrecacheAnimationTree_hook.get_original(); + Scr_UsingTreeInternal_original = Scr_UsingTreeInternal_hook.get_original(); + Scr_UsingTree_original = Scr_UsingTree_hook.get_original(); + Scr_SetAnimTreeConfigstring_original = Scr_SetAnimTreeConfigstring_hook.get_original(); + Scr_LoadAnimTreeInternal_original = Scr_LoadAnimTreeInternal_hook.get_original(); + Scr_LoadAnimTreeAtIndex_original = Scr_LoadAnimTreeAtIndex_hook.get_original(); + Scr_FindAnimTree_original = Scr_FindAnimTree_hook.get_original(); + Scr_FindAnim_original = Scr_FindAnim_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_compiler.cpp b/src/component/decomp/clientscript/re_cscr_compiler.cpp index d2c0edf..5e47a8c 100644 --- a/src/component/decomp/clientscript/re_cscr_compiler.cpp +++ b/src/component/decomp/clientscript/re_cscr_compiler.cpp @@ -157,6 +157,157 @@ namespace re_cscr_compiler utils::hook::detour EmitInclude_hook; utils::hook::detour ScriptCompile_hook; + void* RemoveRefToValue_original; + void* Scr_CompileRemoveRefToString_original; + void* EmitCanonicalString_original; + void* CompileTransferRefToString_original; + void* EmitOpcode_original; + void* EmitEnd_original; + void* EmitReturn_original; + void* EmitCodepos_original; + void* EmitShort_original; + void* EmitByte_original; + void* EmitGetInteger_original; + void* EmitGetFloat_original; + void* EmitAnimTree_original; + void* Scr_FindLocalVarIndex_original; + void* EmitCreateLocalVars_original; + void* EmitRemoveLocalVars_original; + void* EmitNOP2_original; + void* Scr_InitFromChildBlocks_original; + void* Scr_AppendChildBlocks_original; + void* Scr_MergeChildBlocks_original; + void* Scr_TransferBlock_original; + void* EmitSafeSetVariableField_original; + void* EmitSafeSetWaittillVariableField_original; + void* EmitGetString_original; + void* EmitGetIString_original; + void* EmitGetVector_original; + void* EmitValue_original; + void* Scr_PushValue_original; + void* EmitCastBool_original; + void* EmitBoolNot_original; + void* EmitBoolComplement_original; + void* EmitSize_original; + void* EmitSelf_original; + void* EmitLevel_original; + void* EmitGame_original; + void* EmitAnim_original; + void* EmitSelfObject_original; + void* EmitLevelObject_original; + void* EmitAnimObject_original; + void* EmitLocalVariable_original; + void* EmitLocalVariableRef_original; + void* Scr_RegisterLocalVar_original; + void* EmitGameRef_original; + void* EmitClearArray_original; + void* EmitEmptyArray_original; + void* EmitAnimation_original; + void* EmitFieldVariable_original; + void* EmitClearFieldVariable_original; + void* EmitObject_original; + void* EmitDecTop_original; + void* EmitCastFieldObject_original; + void* EmitArrayVariable_original; + void* EmitArrayVariableRef_original; + void* EmitClearArrayVariable_original; + void* EmitVariableExpression_original; + void* EmitExpressionList_original; + void* AddExpressionListOpcodePos_original; + void* AddFilePrecache_original; + void* EmitFunction_original; + void* EmitGetFunction_original; + void* AddFunction_original; + void* EmitPostScriptFunction_original; + void* EmitPostScriptFunctionPointer_original; + void* EmitPostScriptThread_original; + void* EmitPostScriptThreadPointer_original; + void* EmitPostScriptFunctionCall_original; + void* EmitPostScriptThreadCall_original; + void* EmitPreFunctionCall_original; + void* EmitPostFunctionCall_original; + void* Scr_BeginDevScript_original; + void* Scr_EndDevScript_original; + void* EmitCallBuiltinOpcode_original; + void* EmitCallBuiltinMethodOpcode_original; + void* EmitCall_original; + void* EmitMethod_original; + void* LinkThread_original; + void* LinkFile_original; + void* CheckThreadPosition_original; + void* EmitCallExpression_original; + void* EmitCallExpressionFieldObject_original; + void* Scr_CreateVector_original; + void* EvalPrimitiveExpressionList_original; + void* EmitOrEvalPrimitiveExpressionList_original; + void* EmitExpressionListFieldObject_original; + void* EvalPrimitiveExpression_original; + void* EmitOrEvalPrimitiveExpression_original; + void* EmitBoolOrExpression_original; + void* EmitBoolAndExpression_original; + void* EvalBinaryOperatorExpression_original; + void* EmitOrEvalBinaryOperatorExpression_original; + void* EmitBinaryEqualsOperatorExpression_original; + void* Scr_CalcLocalVarsVariableExpressionRef_original; + void* EvalExpression_original; + void* EmitOrEvalExpression_original; + void* EmitExpression_original; + void* EmitVariableExpressionRef_original; + void* EmitArrayPrimitiveExpressionRef_original; + void* Scr_CalcLocalVarsArrayVariableRef_original; + void* EmitPrimitiveExpressionFieldObject_original; + void* ConnectBreakStatements_original; + void* ConnectContinueStatements_original; + void* EmitClearVariableExpression_original; + void* EmitAssignmentStatement_original; + void* EmitCallExpressionStatement_original; + void* EmitReturnStatement_original; + void* EmitWaitStatement_original; + void* EmitWaittillFrameEnd_original; + void* EmitIfStatement_original; + void* Scr_CalcLocalVarsIfStatement_original; + void* EmitIfElseStatement_original; + void* Scr_CalcLocalVarsIfElseStatement_original; + void* Scr_AddBreakBlock_original; + void* Scr_AddContinueBlock_original; + void* EmitWhileStatement_original; + void* Scr_CalcLocalVarsWhileStatement_original; + void* EmitForStatement_original; + void* Scr_CalcLocalVarsForStatement_original; + void* EmitIncStatement_original; + void* EmitDecStatement_original; + void* Scr_CalcLocalVarsFormalParameterListInternal_original; + void* EmitWaittillStatement_original; + void* EmitWaittillmatchStatement_original; + void* EmitNotifyStatement_original; + void* EmitEndOnStatement_original; + void* CompareCaseInfo_original; + void* EmitCaseStatement_original; + void* EmitSwitchStatementList_original; + void* Scr_CalcLocalVarsSwitchStatement_original; + void* EmitSwitchStatement_original; + void* EmitCaseStatementInfo_original; + void* EmitBreakStatement_original; + void* EmitContinueStatement_original; + void* EmitProfStatement_original; + void* EmitStatement_original; + void* Scr_CalcLocalVarsStatement_original; + void* EmitStatementList_original; + void* Scr_CalcLocalVarsStatementList_original; + void* Scr_CalcLocalVarsDeveloperStatementList_original; + void* EmitDeveloperStatementList_original; + void* EmitFormalParameterList_original; + void* SpecifyThread_original; + void* EmitThreadInternal_original; + void* Scr_CalcLocalVarsThread_original; + void* InitThread_original; + void* EmitNormalThread_original; + void* EmitDeveloperThread_original; + void* EmitThread_original; + void* EmitThreadList_original; + void* EmitInclude_original; + void* ScriptCompile_original; + namespace { @@ -172,7 +323,7 @@ namespace re_cscr_compiler void Scr_CompileRemoveRefToString_call(game::scriptInstance_t inst, unsigned int stringVal, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_CompileRemoveRefToString(inst, stringVal, Scr_CompileRemoveRefToString_hook.get_original()); + game::Scr_CompileRemoveRefToString(inst, stringVal, Scr_CompileRemoveRefToString_original); #else codsrc::Scr_CompileRemoveRefToString(inst, stringVal); #endif @@ -194,7 +345,7 @@ namespace re_cscr_compiler void EmitCanonicalString_call(game::scriptInstance_t inst, unsigned int stringVal, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCanonicalString(inst, stringVal, EmitCanonicalString_hook.get_original()); + game::EmitCanonicalString(inst, stringVal, EmitCanonicalString_original); #else codsrc::EmitCanonicalString(inst, stringVal); #endif @@ -216,7 +367,7 @@ namespace re_cscr_compiler void CompileTransferRefToString_call(unsigned int stringValue, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int user) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::CompileTransferRefToString(stringValue, inst, user, CompileTransferRefToString_hook.get_original()); + game::CompileTransferRefToString(stringValue, inst, user, CompileTransferRefToString_original); #else codsrc::CompileTransferRefToString(stringValue, inst, user); #endif @@ -247,7 +398,7 @@ namespace re_cscr_compiler void EmitEnd_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitEnd(inst, EmitEnd_hook.get_original()); + game::EmitEnd(inst, EmitEnd_original); #else codsrc::EmitEnd(inst); #endif @@ -268,7 +419,7 @@ namespace re_cscr_compiler void EmitReturn_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitReturn(inst, EmitReturn_hook.get_original()); + game::EmitReturn(inst, EmitReturn_original); #else codsrc::EmitReturn(inst); #endif @@ -289,7 +440,7 @@ namespace re_cscr_compiler void EmitCodepos_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int codepos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCodepos(inst, codepos, EmitCodepos_hook.get_original()); + game::EmitCodepos(inst, codepos, EmitCodepos_original); #else codsrc::EmitCodepos(inst, codepos); #endif @@ -310,7 +461,7 @@ namespace re_cscr_compiler void EmitShort_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int value) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitShort(inst, value, EmitShort_hook.get_original()); + game::EmitShort(inst, value, EmitShort_original); #else codsrc::EmitShort(inst, value); #endif @@ -331,7 +482,7 @@ namespace re_cscr_compiler void EmitByte_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int value) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitByte(inst, value, EmitByte_hook.get_original()); + game::EmitByte(inst, value, EmitByte_original); #else codsrc::EmitByte(inst, value); #endif @@ -352,7 +503,7 @@ namespace re_cscr_compiler void EmitGetInteger_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int value, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGetInteger(inst, value, sourcePos, EmitGetInteger_hook.get_original()); + game::EmitGetInteger(inst, value, sourcePos, EmitGetInteger_original); #else codsrc::EmitGetInteger(inst, value, sourcePos); #endif @@ -373,7 +524,7 @@ namespace re_cscr_compiler void EmitGetFloat_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, float value, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGetFloat(inst, value, sourcePos, EmitGetFloat_hook.get_original()); + game::EmitGetFloat(inst, value, sourcePos, EmitGetFloat_original); #else codsrc::EmitGetFloat(inst, value, sourcePos); #endif @@ -394,7 +545,7 @@ namespace re_cscr_compiler void EmitAnimTree_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitAnimTree(inst, sourcePos, EmitAnimTree_hook.get_original()); + game::EmitAnimTree(inst, sourcePos, EmitAnimTree_original); #else codsrc::EmitAnimTree(inst, sourcePos); #endif @@ -433,7 +584,7 @@ namespace re_cscr_compiler void EmitRemoveLocalVars_call(game::scriptInstance_t inst, game::scr_block_s* outerBlock, [[maybe_unused]] void* caller_addr, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitRemoveLocalVars(inst, outerBlock, block, EmitRemoveLocalVars_hook.get_original()); + game::EmitRemoveLocalVars(inst, outerBlock, block, EmitRemoveLocalVars_original); #else codsrc::EmitRemoveLocalVars(inst, outerBlock, block); #endif @@ -455,7 +606,7 @@ namespace re_cscr_compiler void EmitNOP2_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int lastStatement, unsigned int endSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitNOP2(block, inst, lastStatement, endSourcePos, EmitNOP2_hook.get_original()); + game::EmitNOP2(block, inst, lastStatement, endSourcePos, EmitNOP2_original); #else codsrc::EmitNOP2(block, inst, lastStatement, endSourcePos); #endif @@ -486,7 +637,7 @@ namespace re_cscr_compiler void Scr_AppendChildBlocks_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scr_block_s** childBlocks, int childCount) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_AppendChildBlocks(block, childBlocks, childCount, Scr_AppendChildBlocks_hook.get_original()); + game::Scr_AppendChildBlocks(block, childBlocks, childCount, Scr_AppendChildBlocks_original); #else codsrc::Scr_AppendChildBlocks(block, childBlocks, childCount); #endif @@ -516,7 +667,7 @@ namespace re_cscr_compiler void Scr_TransferBlock_call(game::scr_block_s* to, [[maybe_unused]] void* caller_addr, game::scr_block_s* from) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_TransferBlock(to, from, Scr_TransferBlock_hook.get_original()); + game::Scr_TransferBlock(to, from, Scr_TransferBlock_original); #else codsrc::Scr_TransferBlock(to, from); #endif @@ -537,7 +688,7 @@ namespace re_cscr_compiler void EmitSafeSetVariableField_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitSafeSetVariableField(block, inst, expr, sourcePos, EmitSafeSetVariableField_hook.get_original()); + game::EmitSafeSetVariableField(block, inst, expr, sourcePos, EmitSafeSetVariableField_original); #else codsrc::EmitSafeSetVariableField(block, inst, expr, sourcePos); #endif @@ -559,7 +710,7 @@ namespace re_cscr_compiler void EmitSafeSetWaittillVariableField_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitSafeSetWaittillVariableField(block, inst, expr, sourcePos, EmitSafeSetWaittillVariableField_hook.get_original()); + game::EmitSafeSetWaittillVariableField(block, inst, expr, sourcePos, EmitSafeSetWaittillVariableField_original); #else codsrc::EmitSafeSetWaittillVariableField(block, inst, expr, sourcePos); #endif @@ -581,7 +732,7 @@ namespace re_cscr_compiler void EmitGetString_call(unsigned int value, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGetString(value, inst, sourcePos, EmitGetString_hook.get_original()); + game::EmitGetString(value, inst, sourcePos, EmitGetString_original); #else codsrc::EmitGetString(value, inst, sourcePos); #endif @@ -603,7 +754,7 @@ namespace re_cscr_compiler void EmitGetIString_call(unsigned int value, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGetIString(value, inst, sourcePos, EmitGetIString_hook.get_original()); + game::EmitGetIString(value, inst, sourcePos, EmitGetIString_original); #else codsrc::EmitGetIString(value, inst, sourcePos); #endif @@ -625,7 +776,7 @@ namespace re_cscr_compiler void EmitGetVector_call(const float* value, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGetVector(value, inst, sourcePos, EmitGetVector_hook.get_original()); + game::EmitGetVector(value, inst, sourcePos, EmitGetVector_original); #else codsrc::EmitGetVector(value, inst, sourcePos); #endif @@ -655,7 +806,7 @@ namespace re_cscr_compiler void Scr_PushValue_call(game::scriptInstance_t inst, game::VariableCompileValue* constValue, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_PushValue(inst, constValue, Scr_PushValue_hook.get_original()); + game::Scr_PushValue(inst, constValue, Scr_PushValue_original); #else codsrc::Scr_PushValue(inst, constValue); #endif @@ -677,7 +828,7 @@ namespace re_cscr_compiler void EmitCastBool_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCastBool(inst, sourcePos, EmitCastBool_hook.get_original()); + game::EmitCastBool(inst, sourcePos, EmitCastBool_original); #else codsrc::EmitCastBool(inst, sourcePos); #endif @@ -698,7 +849,7 @@ namespace re_cscr_compiler void EmitBoolNot_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitBoolNot(inst, sourcePos, EmitBoolNot_hook.get_original()); + game::EmitBoolNot(inst, sourcePos, EmitBoolNot_original); #else codsrc::EmitBoolNot(inst, sourcePos); #endif @@ -719,7 +870,7 @@ namespace re_cscr_compiler void EmitBoolComplement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitBoolComplement(inst, sourcePos, EmitBoolComplement_hook.get_original()); + game::EmitBoolComplement(inst, sourcePos, EmitBoolComplement_original); #else codsrc::EmitBoolComplement(inst, sourcePos); #endif @@ -740,7 +891,7 @@ namespace re_cscr_compiler void EmitSize_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitSize(block, inst, expr, sourcePos, EmitSize_hook.get_original()); + game::EmitSize(block, inst, expr, sourcePos, EmitSize_original); #else codsrc::EmitSize(block, inst, expr, sourcePos); #endif @@ -762,7 +913,7 @@ namespace re_cscr_compiler void EmitSelf_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitSelf(inst, sourcePos, EmitSelf_hook.get_original()); + game::EmitSelf(inst, sourcePos, EmitSelf_original); #else codsrc::EmitSelf(inst, sourcePos); #endif @@ -783,7 +934,7 @@ namespace re_cscr_compiler void EmitLevel_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitLevel(inst, sourcePos, EmitLevel_hook.get_original()); + game::EmitLevel(inst, sourcePos, EmitLevel_original); #else codsrc::EmitLevel(inst, sourcePos); #endif @@ -804,7 +955,7 @@ namespace re_cscr_compiler void EmitGame_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGame(inst, sourcePos, EmitGame_hook.get_original()); + game::EmitGame(inst, sourcePos, EmitGame_original); #else codsrc::EmitGame(inst, sourcePos); #endif @@ -825,7 +976,7 @@ namespace re_cscr_compiler void EmitAnim_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitAnim(inst, sourcePos, EmitAnim_hook.get_original()); + game::EmitAnim(inst, sourcePos, EmitAnim_original); #else codsrc::EmitAnim(inst, sourcePos); #endif @@ -846,7 +997,7 @@ namespace re_cscr_compiler void EmitSelfObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitSelfObject(inst, sourcePos, EmitSelfObject_hook.get_original()); + game::EmitSelfObject(inst, sourcePos, EmitSelfObject_original); #else codsrc::EmitSelfObject(inst, sourcePos); #endif @@ -867,7 +1018,7 @@ namespace re_cscr_compiler void EmitLevelObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitLevelObject(inst, sourcePos, EmitLevelObject_hook.get_original()); + game::EmitLevelObject(inst, sourcePos, EmitLevelObject_original); #else codsrc::EmitLevelObject(inst, sourcePos); #endif @@ -888,7 +1039,7 @@ namespace re_cscr_compiler void EmitAnimObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitAnimObject(inst, sourcePos, EmitAnimObject_hook.get_original()); + game::EmitAnimObject(inst, sourcePos, EmitAnimObject_original); #else codsrc::EmitAnimObject(inst, sourcePos); #endif @@ -909,7 +1060,7 @@ namespace re_cscr_compiler void EmitLocalVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitLocalVariable(block, inst, expr, sourcePos, EmitLocalVariable_hook.get_original()); + game::EmitLocalVariable(block, inst, expr, sourcePos, EmitLocalVariable_original); #else codsrc::EmitLocalVariable(block, inst, expr, sourcePos); #endif @@ -931,7 +1082,7 @@ namespace re_cscr_compiler void EmitLocalVariableRef_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitLocalVariableRef(block, inst, expr, sourcePos, EmitLocalVariableRef_hook.get_original()); + game::EmitLocalVariableRef(block, inst, expr, sourcePos, EmitLocalVariableRef_original); #else codsrc::EmitLocalVariableRef(block, inst, expr, sourcePos); #endif @@ -962,7 +1113,7 @@ namespace re_cscr_compiler void EmitGameRef_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGameRef(inst, sourcePos, EmitGameRef_hook.get_original()); + game::EmitGameRef(inst, sourcePos, EmitGameRef_original); #else codsrc::EmitGameRef(inst, sourcePos); #endif @@ -983,7 +1134,7 @@ namespace re_cscr_compiler void EmitClearArray_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos, game::sval_u indexSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitClearArray(inst, sourcePos, indexSourcePos, EmitClearArray_hook.get_original()); + game::EmitClearArray(inst, sourcePos, indexSourcePos, EmitClearArray_original); #else codsrc::EmitClearArray(inst, sourcePos, indexSourcePos); #endif @@ -1004,7 +1155,7 @@ namespace re_cscr_compiler void EmitEmptyArray_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitEmptyArray(inst, sourcePos, EmitEmptyArray_hook.get_original()); + game::EmitEmptyArray(inst, sourcePos, EmitEmptyArray_original); #else codsrc::EmitEmptyArray(inst, sourcePos); #endif @@ -1025,7 +1176,7 @@ namespace re_cscr_compiler void EmitAnimation_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u anim, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitAnimation(inst, anim, sourcePos, EmitAnimation_hook.get_original()); + game::EmitAnimation(inst, anim, sourcePos, EmitAnimation_original); #else codsrc::EmitAnimation(inst, anim, sourcePos); #endif @@ -1046,7 +1197,7 @@ namespace re_cscr_compiler void EmitFieldVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u field, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitFieldVariable(block, inst, expr, field, sourcePos, EmitFieldVariable_hook.get_original()); + game::EmitFieldVariable(block, inst, expr, field, sourcePos, EmitFieldVariable_original); #else codsrc::EmitFieldVariable(block, inst, expr, field, sourcePos); #endif @@ -1068,7 +1219,7 @@ namespace re_cscr_compiler void EmitClearFieldVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u field, game::sval_u sourcePos, game::sval_u rhsSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitClearFieldVariable(block, inst, expr, field, sourcePos, rhsSourcePos, EmitClearFieldVariable_hook.get_original()); + game::EmitClearFieldVariable(block, inst, expr, field, sourcePos, rhsSourcePos, EmitClearFieldVariable_original); #else codsrc::EmitClearFieldVariable(block, inst, expr, field, sourcePos, rhsSourcePos); #endif @@ -1090,7 +1241,7 @@ namespace re_cscr_compiler void EmitObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitObject(inst, expr, sourcePos, EmitObject_hook.get_original()); + game::EmitObject(inst, expr, sourcePos, EmitObject_original); #else codsrc::EmitObject(inst, expr, sourcePos); #endif @@ -1111,7 +1262,7 @@ namespace re_cscr_compiler void EmitDecTop_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitDecTop(inst, EmitDecTop_hook.get_original()); + game::EmitDecTop(inst, EmitDecTop_original); #else codsrc::EmitDecTop(inst); #endif @@ -1141,7 +1292,7 @@ namespace re_cscr_compiler void EmitArrayVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos, EmitArrayVariable_hook.get_original()); + game::EmitArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos, EmitArrayVariable_original); #else codsrc::EmitArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos); #endif @@ -1163,7 +1314,7 @@ namespace re_cscr_compiler void EmitArrayVariableRef_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitArrayVariableRef(block, inst, expr, index, sourcePos, indexSourcePos, EmitArrayVariableRef_hook.get_original()); + game::EmitArrayVariableRef(block, inst, expr, index, sourcePos, indexSourcePos, EmitArrayVariableRef_original); #else codsrc::EmitArrayVariableRef(block, inst, expr, index, sourcePos, indexSourcePos); #endif @@ -1185,7 +1336,7 @@ namespace re_cscr_compiler void EmitClearArrayVariable_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u index, game::sval_u sourcePos, game::sval_u indexSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitClearArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos, EmitClearArrayVariable_hook.get_original()); + game::EmitClearArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos, EmitClearArrayVariable_original); #else codsrc::EmitClearArrayVariable(block, inst, expr, index, sourcePos, indexSourcePos); #endif @@ -1225,7 +1376,7 @@ namespace re_cscr_compiler void AddExpressionListOpcodePos_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::AddExpressionListOpcodePos(inst, exprlist, AddExpressionListOpcodePos_hook.get_original()); + game::AddExpressionListOpcodePos(inst, exprlist, AddExpressionListOpcodePos_original); #else codsrc::AddExpressionListOpcodePos(inst, exprlist); #endif @@ -1246,7 +1397,7 @@ namespace re_cscr_compiler void AddFilePrecache_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int filename, unsigned int sourcePos, int include, unsigned int* filePosId, unsigned int* fileCountId) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::AddFilePrecache(inst, filename, sourcePos, include, filePosId, fileCountId, AddFilePrecache_hook.get_original()); + game::AddFilePrecache(inst, filename, sourcePos, include, filePosId, fileCountId, AddFilePrecache_original); #else codsrc::AddFilePrecache(inst, filename, sourcePos, include, filePosId, fileCountId); #endif @@ -1267,7 +1418,7 @@ namespace re_cscr_compiler void EmitFunction_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitFunction(inst, func, sourcePos, EmitFunction_hook.get_original()); + game::EmitFunction(inst, func, sourcePos, EmitFunction_original); #else codsrc::EmitFunction(inst, func, sourcePos); #endif @@ -1288,7 +1439,7 @@ namespace re_cscr_compiler void EmitGetFunction_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitGetFunction(inst, func, sourcePos, EmitGetFunction_hook.get_original()); + game::EmitGetFunction(inst, func, sourcePos, EmitGetFunction_original); #else codsrc::EmitGetFunction(inst, func, sourcePos); #endif @@ -1327,7 +1478,7 @@ namespace re_cscr_compiler void EmitPostScriptFunctionPointer_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, int param_count, int bMethod, game::sval_u nameSourcePos, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitPostScriptFunctionPointer(block, inst, expr, param_count, bMethod, nameSourcePos, sourcePos, EmitPostScriptFunctionPointer_hook.get_original()); + game::EmitPostScriptFunctionPointer(block, inst, expr, param_count, bMethod, nameSourcePos, sourcePos, EmitPostScriptFunctionPointer_original); #else codsrc::EmitPostScriptFunctionPointer(block, inst, expr, param_count, bMethod, nameSourcePos, sourcePos); #endif @@ -1349,7 +1500,7 @@ namespace re_cscr_compiler void EmitPostScriptThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func, int param_count, int bMethod, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitPostScriptThread(inst, func, param_count, bMethod, sourcePos, EmitPostScriptThread_hook.get_original()); + game::EmitPostScriptThread(inst, func, param_count, bMethod, sourcePos, EmitPostScriptThread_original); #else codsrc::EmitPostScriptThread(inst, func, param_count, bMethod, sourcePos); #endif @@ -1370,7 +1521,7 @@ namespace re_cscr_compiler void EmitPostScriptThreadPointer_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, int param_count, int bMethod, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitPostScriptThreadPointer(block, inst, expr, param_count, bMethod, sourcePos, EmitPostScriptThreadPointer_hook.get_original()); + game::EmitPostScriptThreadPointer(block, inst, expr, param_count, bMethod, sourcePos, EmitPostScriptThreadPointer_original); #else codsrc::EmitPostScriptThreadPointer(block, inst, expr, param_count, bMethod, sourcePos); #endif @@ -1392,7 +1543,7 @@ namespace re_cscr_compiler void EmitPostScriptFunctionCall_call(game::scriptInstance_t inst, int bMethod, int param_count, [[maybe_unused]] void* caller_addr, game::sval_u func_name, game::sval_u nameSourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitPostScriptFunctionCall(inst, bMethod, param_count, func_name, nameSourcePos, block, EmitPostScriptFunctionCall_hook.get_original()); + game::EmitPostScriptFunctionCall(inst, bMethod, param_count, func_name, nameSourcePos, block, EmitPostScriptFunctionCall_original); #else codsrc::EmitPostScriptFunctionCall(inst, bMethod, param_count, func_name, nameSourcePos, block); #endif @@ -1415,7 +1566,7 @@ namespace re_cscr_compiler void EmitPostScriptThreadCall_call(game::scriptInstance_t inst, int isMethod, int param_count, [[maybe_unused]] void* caller_addr, game::sval_u func_name, game::sval_u sourcePos, game::sval_u nameSourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitPostScriptThreadCall(inst, isMethod, param_count, func_name, sourcePos, nameSourcePos, block, EmitPostScriptThreadCall_hook.get_original()); + game::EmitPostScriptThreadCall(inst, isMethod, param_count, func_name, sourcePos, nameSourcePos, block, EmitPostScriptThreadCall_original); #else codsrc::EmitPostScriptThreadCall(inst, isMethod, param_count, func_name, sourcePos, nameSourcePos, block); #endif @@ -1438,7 +1589,7 @@ namespace re_cscr_compiler void EmitPreFunctionCall_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitPreFunctionCall(inst, EmitPreFunctionCall_hook.get_original()); + game::EmitPreFunctionCall(inst, EmitPreFunctionCall_original); #else codsrc::EmitPreFunctionCall(inst); #endif @@ -1459,7 +1610,7 @@ namespace re_cscr_compiler void EmitPostFunctionCall_call(game::scriptInstance_t inst, int bMethod, [[maybe_unused]] void* caller_addr, game::sval_u func_name, int param_count, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitPostFunctionCall(inst, bMethod, func_name, param_count, block, EmitPostFunctionCall_hook.get_original()); + game::EmitPostFunctionCall(inst, bMethod, func_name, param_count, block, EmitPostFunctionCall_original); #else codsrc::EmitPostFunctionCall(inst, bMethod, func_name, param_count, block); #endif @@ -1481,7 +1632,7 @@ namespace re_cscr_compiler void Scr_BeginDevScript_call(game::scriptInstance_t isnt, int* type_, [[maybe_unused]] void* caller_addr, char** savedPos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_BeginDevScript(isnt, type_, savedPos, Scr_BeginDevScript_hook.get_original()); + game::Scr_BeginDevScript(isnt, type_, savedPos, Scr_BeginDevScript_original); #else codsrc::Scr_BeginDevScript(isnt, type_, savedPos); #endif @@ -1503,7 +1654,7 @@ namespace re_cscr_compiler void Scr_EndDevScript_call(game::scriptInstance_t inst, char** savedPos, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_EndDevScript(inst, savedPos, Scr_EndDevScript_hook.get_original()); + game::Scr_EndDevScript(inst, savedPos, Scr_EndDevScript_original); #else codsrc::Scr_EndDevScript(inst, savedPos); #endif @@ -1525,7 +1676,7 @@ namespace re_cscr_compiler void EmitCallBuiltinOpcode_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int param_count, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCallBuiltinOpcode(inst, param_count, sourcePos, EmitCallBuiltinOpcode_hook.get_original()); + game::EmitCallBuiltinOpcode(inst, param_count, sourcePos, EmitCallBuiltinOpcode_original); #else codsrc::EmitCallBuiltinOpcode(inst, param_count, sourcePos); #endif @@ -1546,7 +1697,7 @@ namespace re_cscr_compiler void EmitCallBuiltinMethodOpcode_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int param_count, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCallBuiltinMethodOpcode(inst, param_count, sourcePos, EmitCallBuiltinMethodOpcode_hook.get_original()); + game::EmitCallBuiltinMethodOpcode(inst, param_count, sourcePos, EmitCallBuiltinMethodOpcode_original); #else codsrc::EmitCallBuiltinMethodOpcode(inst, param_count, sourcePos); #endif @@ -1567,7 +1718,7 @@ namespace re_cscr_compiler void EmitCall_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u func_name, game::sval_u params, int bStatement, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCall(inst, func_name, params, bStatement, block, EmitCall_hook.get_original()); + game::EmitCall(inst, func_name, params, bStatement, block, EmitCall_original); #else codsrc::EmitCall(inst, func_name, params, bStatement, block); #endif @@ -1597,7 +1748,7 @@ namespace re_cscr_compiler void LinkThread_call(game::scriptInstance_t inst, unsigned int threadCountId, [[maybe_unused]] void* caller_addr, game::VariableValue* pos, int allowFarCall) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::LinkThread(inst, threadCountId, pos, allowFarCall, LinkThread_hook.get_original()); + game::LinkThread(inst, threadCountId, pos, allowFarCall, LinkThread_original); #else codsrc::LinkThread(inst, threadCountId, pos, allowFarCall); #endif @@ -1619,7 +1770,7 @@ namespace re_cscr_compiler void LinkFile_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int filePosId, unsigned int fileCountId) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::LinkFile(inst, filePosId, fileCountId, LinkFile_hook.get_original()); + game::LinkFile(inst, filePosId, fileCountId, LinkFile_original); #else codsrc::LinkFile(inst, filePosId, fileCountId); #endif @@ -1649,7 +1800,7 @@ namespace re_cscr_compiler void EmitCallExpression_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::sval_u expr, int bStatement) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCallExpression(inst, block, expr, bStatement, EmitCallExpression_hook.get_original()); + game::EmitCallExpression(inst, block, expr, bStatement, EmitCallExpression_original); #else codsrc::EmitCallExpression(inst, block, expr, bStatement); #endif @@ -1671,7 +1822,7 @@ namespace re_cscr_compiler void EmitCallExpressionFieldObject_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCallExpressionFieldObject(block, inst, expr, EmitCallExpressionFieldObject_hook.get_original()); + game::EmitCallExpressionFieldObject(block, inst, expr, EmitCallExpressionFieldObject_original); #else codsrc::EmitCallExpressionFieldObject(block, inst, expr); #endif @@ -1693,7 +1844,7 @@ namespace re_cscr_compiler void Scr_CreateVector_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::VariableCompileValue* constValue, game::VariableValue* value) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_CreateVector(inst, constValue, value, Scr_CreateVector_hook.get_original()); + game::Scr_CreateVector(inst, constValue, value, Scr_CreateVector_original); #else codsrc::Scr_CreateVector(inst, constValue, value); #endif @@ -1723,7 +1874,7 @@ namespace re_cscr_compiler bool EmitOrEvalPrimitiveExpressionList_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist, game::sval_u sourcePos, game::VariableCompileValue* constValue, game::scr_block_s* a5) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - return game::EmitOrEvalPrimitiveExpressionList(inst, exprlist, sourcePos, constValue, a5, EmitOrEvalPrimitiveExpressionList_hook.get_original()); + return game::EmitOrEvalPrimitiveExpressionList(inst, exprlist, sourcePos, constValue, a5, EmitOrEvalPrimitiveExpressionList_original); #else return codsrc::EmitOrEvalPrimitiveExpressionList(inst, exprlist, sourcePos, constValue, a5); #endif @@ -1744,7 +1895,7 @@ namespace re_cscr_compiler void EmitExpressionListFieldObject_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist, game::sval_u sourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitExpressionListFieldObject(inst, exprlist, sourcePos, block, EmitExpressionListFieldObject_hook.get_original()); + game::EmitExpressionListFieldObject(inst, exprlist, sourcePos, block, EmitExpressionListFieldObject_original); #else codsrc::EmitExpressionListFieldObject(inst, exprlist, sourcePos, block); #endif @@ -1783,7 +1934,7 @@ namespace re_cscr_compiler void EmitBoolOrExpression_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr1, game::sval_u expr2, game::sval_u expr1sourcePos, game::sval_u expr2sourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitBoolOrExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, block, EmitBoolOrExpression_hook.get_original()); + game::EmitBoolOrExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, block, EmitBoolOrExpression_original); #else codsrc::EmitBoolOrExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, block); #endif @@ -1804,7 +1955,7 @@ namespace re_cscr_compiler void EmitBoolAndExpression_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr1, game::sval_u expr2, game::sval_u expr1sourcePos, game::sval_u expr2sourcePos, game::scr_block_s* a6) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitBoolAndExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, a6, EmitBoolAndExpression_hook.get_original()); + game::EmitBoolAndExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, a6, EmitBoolAndExpression_original); #else codsrc::EmitBoolAndExpression(inst, expr1, expr2, expr1sourcePos, expr2sourcePos, a6); #endif @@ -1834,7 +1985,7 @@ namespace re_cscr_compiler bool EmitOrEvalBinaryOperatorExpression_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr1, game::sval_u expr2, game::sval_u opcode, game::sval_u sourcePos, game::VariableCompileValue* constValue, game::scr_block_s* a8) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - return game::EmitOrEvalBinaryOperatorExpression(inst, expr1, expr2, opcode, sourcePos, constValue, a8, EmitOrEvalBinaryOperatorExpression_hook.get_original()); + return game::EmitOrEvalBinaryOperatorExpression(inst, expr1, expr2, opcode, sourcePos, constValue, a8, EmitOrEvalBinaryOperatorExpression_original); #else return codsrc::EmitOrEvalBinaryOperatorExpression(inst, expr1, expr2, opcode, sourcePos, constValue, a8); #endif @@ -1855,7 +2006,7 @@ namespace re_cscr_compiler void EmitBinaryEqualsOperatorExpression_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u lhs, game::sval_u rhs, game::sval_u opcode, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitBinaryEqualsOperatorExpression(block, inst, lhs, rhs, opcode, sourcePos, EmitBinaryEqualsOperatorExpression_hook.get_original()); + game::EmitBinaryEqualsOperatorExpression(block, inst, lhs, rhs, opcode, sourcePos, EmitBinaryEqualsOperatorExpression_original); #else codsrc::EmitBinaryEqualsOperatorExpression(block, inst, lhs, rhs, opcode, sourcePos); #endif @@ -1877,7 +2028,7 @@ namespace re_cscr_compiler void Scr_CalcLocalVarsVariableExpressionRef_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::sval_u expr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_CalcLocalVarsVariableExpressionRef(block, expr, Scr_CalcLocalVarsVariableExpressionRef_hook.get_original()); + game::Scr_CalcLocalVarsVariableExpressionRef(block, expr, Scr_CalcLocalVarsVariableExpressionRef_original); #else codsrc::Scr_CalcLocalVarsVariableExpressionRef(block, expr); #endif @@ -1898,7 +2049,7 @@ namespace re_cscr_compiler bool EvalExpression_call(game::VariableCompileValue* constValue, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - return game::EvalExpression(constValue, inst, expr, EvalExpression_hook.get_original()); + return game::EvalExpression(constValue, inst, expr, EvalExpression_original); #else return codsrc::EvalExpression(constValue, inst, expr); #endif @@ -1947,7 +2098,7 @@ namespace re_cscr_compiler void EmitArrayPrimitiveExpressionRef_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitArrayPrimitiveExpressionRef(inst, expr, sourcePos, block, EmitArrayPrimitiveExpressionRef_hook.get_original()); + game::EmitArrayPrimitiveExpressionRef(inst, expr, sourcePos, block, EmitArrayPrimitiveExpressionRef_original); #else codsrc::EmitArrayPrimitiveExpressionRef(inst, expr, sourcePos, block); #endif @@ -1986,7 +2137,7 @@ namespace re_cscr_compiler void ConnectBreakStatements_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::ConnectBreakStatements(inst, ConnectBreakStatements_hook.get_original()); + game::ConnectBreakStatements(inst, ConnectBreakStatements_original); #else codsrc::ConnectBreakStatements(inst); #endif @@ -2007,7 +2158,7 @@ namespace re_cscr_compiler void ConnectContinueStatements_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::ConnectContinueStatements(inst, ConnectContinueStatements_hook.get_original()); + game::ConnectContinueStatements(inst, ConnectContinueStatements_original); #else codsrc::ConnectContinueStatements(inst); #endif @@ -2028,7 +2179,7 @@ namespace re_cscr_compiler bool EmitClearVariableExpression_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u rhsSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - return game::EmitClearVariableExpression(block, inst, expr, rhsSourcePos, EmitClearVariableExpression_hook.get_original()); + return game::EmitClearVariableExpression(block, inst, expr, rhsSourcePos, EmitClearVariableExpression_original); #else return codsrc::EmitClearVariableExpression(block, inst, expr, rhsSourcePos); #endif @@ -2050,7 +2201,7 @@ namespace re_cscr_compiler void EmitAssignmentStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u lhs, game::sval_u rhs, game::sval_u sourcePos, game::sval_u rhsSourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitAssignmentStatement(inst, lhs, rhs, sourcePos, rhsSourcePos, block, EmitAssignmentStatement_hook.get_original()); + game::EmitAssignmentStatement(inst, lhs, rhs, sourcePos, rhsSourcePos, block, EmitAssignmentStatement_original); #else codsrc::EmitAssignmentStatement(inst, lhs, rhs, sourcePos, rhsSourcePos, block); #endif @@ -2071,7 +2222,7 @@ namespace re_cscr_compiler void EmitCallExpressionStatement_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::sval_u expr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCallExpressionStatement(inst, block, expr, EmitCallExpressionStatement_hook.get_original()); + game::EmitCallExpressionStatement(inst, block, expr, EmitCallExpressionStatement_original); #else codsrc::EmitCallExpressionStatement(inst, block, expr); #endif @@ -2093,7 +2244,7 @@ namespace re_cscr_compiler void EmitReturnStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitReturnStatement(block, inst, expr, sourcePos, EmitReturnStatement_hook.get_original()); + game::EmitReturnStatement(block, inst, expr, sourcePos, EmitReturnStatement_original); #else codsrc::EmitReturnStatement(block, inst, expr, sourcePos); #endif @@ -2115,7 +2266,7 @@ namespace re_cscr_compiler void EmitWaitStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos, game::sval_u waitSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitWaitStatement(block, inst, expr, sourcePos, waitSourcePos, EmitWaitStatement_hook.get_original()); + game::EmitWaitStatement(block, inst, expr, sourcePos, waitSourcePos, EmitWaitStatement_original); #else codsrc::EmitWaitStatement(block, inst, expr, sourcePos, waitSourcePos); #endif @@ -2137,7 +2288,7 @@ namespace re_cscr_compiler void EmitWaittillFrameEnd_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitWaittillFrameEnd(inst, sourcePos, EmitWaittillFrameEnd_hook.get_original()); + game::EmitWaittillFrameEnd(inst, sourcePos, EmitWaittillFrameEnd_original); #else codsrc::EmitWaittillFrameEnd(inst, sourcePos); #endif @@ -2158,7 +2309,7 @@ namespace re_cscr_compiler void EmitIfStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u stmt, game::sval_u sourcePos, int lastStatement, unsigned int endSourcePos, game::scr_block_s* block, game::sval_u* ifStatBlock) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitIfStatement(inst, expr, stmt, sourcePos, lastStatement, endSourcePos, block, ifStatBlock, EmitIfStatement_hook.get_original()); + game::EmitIfStatement(inst, expr, stmt, sourcePos, lastStatement, endSourcePos, block, ifStatBlock, EmitIfStatement_original); #else codsrc::EmitIfStatement(inst, expr, stmt, sourcePos, lastStatement, endSourcePos, block, ifStatBlock); #endif @@ -2206,7 +2357,7 @@ namespace re_cscr_compiler void Scr_AddBreakBlock_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_AddBreakBlock(inst, block, Scr_AddBreakBlock_hook.get_original()); + game::Scr_AddBreakBlock(inst, block, Scr_AddBreakBlock_original); #else codsrc::Scr_AddBreakBlock(inst, block); #endif @@ -2228,7 +2379,7 @@ namespace re_cscr_compiler void Scr_AddContinueBlock_call(game::scriptInstance_t inst, game::scr_block_s* block, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_AddContinueBlock(inst, block, Scr_AddContinueBlock_hook.get_original()); + game::Scr_AddContinueBlock(inst, block, Scr_AddContinueBlock_original); #else codsrc::Scr_AddContinueBlock(inst, block); #endif @@ -2286,7 +2437,7 @@ namespace re_cscr_compiler void EmitIncStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitIncStatement(block, inst, expr, sourcePos, EmitIncStatement_hook.get_original()); + game::EmitIncStatement(block, inst, expr, sourcePos, EmitIncStatement_original); #else codsrc::EmitIncStatement(block, inst, expr, sourcePos); #endif @@ -2308,7 +2459,7 @@ namespace re_cscr_compiler void EmitDecStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitDecStatement(block, inst, expr, sourcePos, EmitDecStatement_hook.get_original()); + game::EmitDecStatement(block, inst, expr, sourcePos, EmitDecStatement_original); #else codsrc::EmitDecStatement(block, inst, expr, sourcePos); #endif @@ -2330,7 +2481,7 @@ namespace re_cscr_compiler void Scr_CalcLocalVarsFormalParameterListInternal_call(game::sval_u* node, game::scr_block_s* block, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_CalcLocalVarsFormalParameterListInternal(node, block, Scr_CalcLocalVarsFormalParameterListInternal_hook.get_original()); + game::Scr_CalcLocalVarsFormalParameterListInternal(node, block, Scr_CalcLocalVarsFormalParameterListInternal_original); #else codsrc::Scr_CalcLocalVarsFormalParameterListInternal(node, block); #endif @@ -2352,7 +2503,7 @@ namespace re_cscr_compiler void EmitWaittillStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u waitSourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitWaittillStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block, EmitWaittillStatement_hook.get_original()); + game::EmitWaittillStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block, EmitWaittillStatement_original); #else codsrc::EmitWaittillStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block); #endif @@ -2373,7 +2524,7 @@ namespace re_cscr_compiler void EmitWaittillmatchStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u waitSourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitWaittillmatchStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block, EmitWaittillmatchStatement_hook.get_original()); + game::EmitWaittillmatchStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block, EmitWaittillmatchStatement_original); #else codsrc::EmitWaittillmatchStatement(inst, obj, exprlist, sourcePos, waitSourcePos, block); #endif @@ -2394,7 +2545,7 @@ namespace re_cscr_compiler void EmitNotifyStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u exprlist, game::sval_u sourcePos, game::sval_u notifySourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitNotifyStatement(inst, obj, exprlist, sourcePos, notifySourcePos, block, EmitNotifyStatement_hook.get_original()); + game::EmitNotifyStatement(inst, obj, exprlist, sourcePos, notifySourcePos, block, EmitNotifyStatement_original); #else codsrc::EmitNotifyStatement(inst, obj, exprlist, sourcePos, notifySourcePos, block); #endif @@ -2415,7 +2566,7 @@ namespace re_cscr_compiler void EmitEndOnStatement_call(game::scr_block_s* block, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u obj, game::sval_u expr, game::sval_u sourcePos, game::sval_u exprSourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitEndOnStatement(block, inst, obj, expr, sourcePos, exprSourcePos, EmitEndOnStatement_hook.get_original()); + game::EmitEndOnStatement(block, inst, obj, expr, sourcePos, exprSourcePos, EmitEndOnStatement_original); #else codsrc::EmitEndOnStatement(block, inst, obj, expr, sourcePos, exprSourcePos); #endif @@ -2446,7 +2597,7 @@ namespace re_cscr_compiler void EmitCaseStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u expr, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCaseStatement(inst, expr, sourcePos, EmitCaseStatement_hook.get_original()); + game::EmitCaseStatement(inst, expr, sourcePos, EmitCaseStatement_original); #else codsrc::EmitCaseStatement(inst, expr, sourcePos); #endif @@ -2494,7 +2645,7 @@ namespace re_cscr_compiler void EmitCaseStatementInfo_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int name, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitCaseStatementInfo(inst, name, sourcePos, EmitCaseStatementInfo_hook.get_original()); + game::EmitCaseStatementInfo(inst, name, sourcePos, EmitCaseStatementInfo_original); #else codsrc::EmitCaseStatementInfo(inst, name, sourcePos); #endif @@ -2515,7 +2666,7 @@ namespace re_cscr_compiler void EmitBreakStatement_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitBreakStatement(block, inst, sourcePos, EmitBreakStatement_hook.get_original()); + game::EmitBreakStatement(block, inst, sourcePos, EmitBreakStatement_original); #else codsrc::EmitBreakStatement(block, inst, sourcePos); #endif @@ -2536,7 +2687,7 @@ namespace re_cscr_compiler void EmitContinueStatement_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u sourcePos) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitContinueStatement(block, inst, sourcePos, EmitContinueStatement_hook.get_original()); + game::EmitContinueStatement(block, inst, sourcePos, EmitContinueStatement_original); #else codsrc::EmitContinueStatement(block, inst, sourcePos); #endif @@ -2557,7 +2708,7 @@ namespace re_cscr_compiler void EmitProfStatement_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u profileName, game::sval_u sourcePos, game::OpcodeVM op) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitProfStatement(inst, profileName, sourcePos, op, EmitProfStatement_hook.get_original()); + game::EmitProfStatement(inst, profileName, sourcePos, op, EmitProfStatement_original); #else codsrc::EmitProfStatement(inst, profileName, sourcePos, op); #endif @@ -2605,7 +2756,7 @@ namespace re_cscr_compiler void Scr_CalcLocalVarsStatementList_call(game::scr_block_s* block, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u val) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_CalcLocalVarsStatementList(block, inst, val, Scr_CalcLocalVarsStatementList_hook.get_original()); + game::Scr_CalcLocalVarsStatementList(block, inst, val, Scr_CalcLocalVarsStatementList_original); #else codsrc::Scr_CalcLocalVarsStatementList(block, inst, val); #endif @@ -2644,7 +2795,7 @@ namespace re_cscr_compiler void EmitFormalParameterList_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u exprlist, game::sval_u sourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitFormalParameterList(inst, exprlist, sourcePos, block, EmitFormalParameterList_hook.get_original()); + game::EmitFormalParameterList(inst, exprlist, sourcePos, block, EmitFormalParameterList_original); #else codsrc::EmitFormalParameterList(inst, exprlist, sourcePos, block); #endif @@ -2665,7 +2816,7 @@ namespace re_cscr_compiler void SpecifyThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::SpecifyThread(inst, val, SpecifyThread_hook.get_original()); + game::SpecifyThread(inst, val, SpecifyThread_original); #else codsrc::SpecifyThread(inst, val); #endif @@ -2686,7 +2837,7 @@ namespace re_cscr_compiler void EmitThreadInternal_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, game::sval_u sourcePos, game::sval_u endSourcePos, game::scr_block_s* block) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitThreadInternal(inst, val, sourcePos, endSourcePos, block, EmitThreadInternal_hook.get_original()); + game::EmitThreadInternal(inst, val, sourcePos, endSourcePos, block, EmitThreadInternal_original); #else codsrc::EmitThreadInternal(inst, val, sourcePos, endSourcePos, block); #endif @@ -2707,7 +2858,7 @@ namespace re_cscr_compiler void Scr_CalcLocalVarsThread_call(game::sval_u* stmttblock, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::sval_u exprlist, game::sval_u stmtlist) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::Scr_CalcLocalVarsThread(stmttblock, inst, exprlist, stmtlist, Scr_CalcLocalVarsThread_hook.get_original()); + game::Scr_CalcLocalVarsThread(stmttblock, inst, exprlist, stmtlist, Scr_CalcLocalVarsThread_original); #else codsrc::Scr_CalcLocalVarsThread(stmttblock, inst, exprlist, stmtlist); #endif @@ -2728,7 +2879,7 @@ namespace re_cscr_compiler void InitThread_call(int type_, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::InitThread(type_, inst, InitThread_hook.get_original()); + game::InitThread(type_, inst, InitThread_original); #else codsrc::InitThread(type_, inst); #endif @@ -2750,7 +2901,7 @@ namespace re_cscr_compiler void EmitNormalThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, game::sval_u* stmttblock) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitNormalThread(inst, val, stmttblock, EmitNormalThread_hook.get_original()); + game::EmitNormalThread(inst, val, stmttblock, EmitNormalThread_original); #else codsrc::EmitNormalThread(inst, val, stmttblock); #endif @@ -2771,7 +2922,7 @@ namespace re_cscr_compiler void EmitDeveloperThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, game::sval_u* stmttblock) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitDeveloperThread(inst, val, stmttblock, EmitDeveloperThread_hook.get_original()); + game::EmitDeveloperThread(inst, val, stmttblock, EmitDeveloperThread_original); #else codsrc::EmitDeveloperThread(inst, val, stmttblock); #endif @@ -2792,7 +2943,7 @@ namespace re_cscr_compiler void EmitThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitThread(inst, val, EmitThread_hook.get_original()); + game::EmitThread(inst, val, EmitThread_original); #else codsrc::EmitThread(inst, val); #endif @@ -2822,7 +2973,7 @@ namespace re_cscr_compiler void EmitInclude_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::EmitInclude(inst, val, EmitInclude_hook.get_original()); + game::EmitInclude(inst, val, EmitInclude_original); #else codsrc::EmitInclude(inst, val); #endif @@ -2843,7 +2994,7 @@ namespace re_cscr_compiler void ScriptCompile_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, game::PrecacheEntry* entries, int entriesCount) { #ifdef RE_CSCR_COMPILER_USE_WRAPPERS - game::ScriptCompile(inst, val, filePosId, fileCountId, scriptId, entries, entriesCount, ScriptCompile_hook.get_original()); + game::ScriptCompile(inst, val, filePosId, fileCountId, scriptId, entries, entriesCount, ScriptCompile_original); #else codsrc::ScriptCompile(inst, val, filePosId, fileCountId, scriptId, entries, entriesCount); #endif @@ -2867,161 +3018,308 @@ namespace re_cscr_compiler public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_COMPILER_USE_WRAPPERS - quick = false; -#endif + RemoveRefToValue_hook.create(game::RemoveRefToValue.get(), RemoveRefToValue_stub); + Scr_CompileRemoveRefToString_hook.create(game::Scr_CompileRemoveRefToString_ADDR(), Scr_CompileRemoveRefToString_stub); + EmitCanonicalString_hook.create(game::EmitCanonicalString_ADDR(), EmitCanonicalString_stub); + CompileTransferRefToString_hook.create(game::CompileTransferRefToString_ADDR(), CompileTransferRefToString_stub); + EmitOpcode_hook.create(game::EmitOpcode.get(), EmitOpcode_stub); + EmitEnd_hook.create(game::EmitEnd_ADDR(), EmitEnd_stub); + EmitReturn_hook.create(game::EmitReturn_ADDR(), EmitReturn_stub); + EmitCodepos_hook.create(game::EmitCodepos_ADDR(), EmitCodepos_stub); + EmitShort_hook.create(game::EmitShort_ADDR(), EmitShort_stub); + EmitByte_hook.create(game::EmitByte_ADDR(), EmitByte_stub); + EmitGetInteger_hook.create(game::EmitGetInteger_ADDR(), EmitGetInteger_stub); + EmitGetFloat_hook.create(game::EmitGetFloat_ADDR(), EmitGetFloat_stub); + EmitAnimTree_hook.create(game::EmitAnimTree_ADDR(), EmitAnimTree_stub); + Scr_FindLocalVarIndex_hook.create(game::Scr_FindLocalVarIndex.get(), Scr_FindLocalVarIndex_stub); + EmitCreateLocalVars_hook.create(game::EmitCreateLocalVars.get(), EmitCreateLocalVars_stub); + EmitRemoveLocalVars_hook.create(game::EmitRemoveLocalVars_ADDR(), EmitRemoveLocalVars_stub); + EmitNOP2_hook.create(game::EmitNOP2_ADDR(), EmitNOP2_stub); + Scr_InitFromChildBlocks_hook.create(game::Scr_InitFromChildBlocks.get(), Scr_InitFromChildBlocks_stub); + Scr_AppendChildBlocks_hook.create(game::Scr_AppendChildBlocks_ADDR(), Scr_AppendChildBlocks_stub); + Scr_MergeChildBlocks_hook.create(game::Scr_MergeChildBlocks.get(), Scr_MergeChildBlocks_stub); + Scr_TransferBlock_hook.create(game::Scr_TransferBlock_ADDR(), Scr_TransferBlock_stub); + EmitSafeSetVariableField_hook.create(game::EmitSafeSetVariableField_ADDR(), EmitSafeSetVariableField_stub); + EmitSafeSetWaittillVariableField_hook.create(game::EmitSafeSetWaittillVariableField_ADDR(), EmitSafeSetWaittillVariableField_stub); + EmitGetString_hook.create(game::EmitGetString_ADDR(), EmitGetString_stub); + EmitGetIString_hook.create(game::EmitGetIString_ADDR(), EmitGetIString_stub); + EmitGetVector_hook.create(game::EmitGetVector_ADDR(), EmitGetVector_stub); + EmitValue_hook.create(game::EmitValue.get(), EmitValue_stub); + Scr_PushValue_hook.create(game::Scr_PushValue_ADDR(), Scr_PushValue_stub); + EmitCastBool_hook.create(game::EmitCastBool_ADDR(), EmitCastBool_stub); + EmitBoolNot_hook.create(game::EmitBoolNot_ADDR(), EmitBoolNot_stub); + EmitBoolComplement_hook.create(game::EmitBoolComplement_ADDR(), EmitBoolComplement_stub); + EmitSize_hook.create(game::EmitSize_ADDR(), EmitSize_stub); + EmitSelf_hook.create(game::EmitSelf_ADDR(), EmitSelf_stub); + EmitLevel_hook.create(game::EmitLevel_ADDR(), EmitLevel_stub); + EmitGame_hook.create(game::EmitGame_ADDR(), EmitGame_stub); + EmitAnim_hook.create(game::EmitAnim_ADDR(), EmitAnim_stub); + EmitSelfObject_hook.create(game::EmitSelfObject_ADDR(), EmitSelfObject_stub); + EmitLevelObject_hook.create(game::EmitLevelObject_ADDR(), EmitLevelObject_stub); + EmitAnimObject_hook.create(game::EmitAnimObject_ADDR(), EmitAnimObject_stub); + EmitLocalVariable_hook.create(game::EmitLocalVariable_ADDR(), EmitLocalVariable_stub); + EmitLocalVariableRef_hook.create(game::EmitLocalVariableRef_ADDR(), EmitLocalVariableRef_stub); + Scr_RegisterLocalVar_hook.create(game::Scr_RegisterLocalVar.get(), Scr_RegisterLocalVar_stub); + EmitGameRef_hook.create(game::EmitGameRef_ADDR(), EmitGameRef_stub); + EmitClearArray_hook.create(game::EmitClearArray_ADDR(), EmitClearArray_stub); + EmitEmptyArray_hook.create(game::EmitEmptyArray_ADDR(), EmitEmptyArray_stub); + EmitAnimation_hook.create(game::EmitAnimation_ADDR(), EmitAnimation_stub); + EmitFieldVariable_hook.create(game::EmitFieldVariable_ADDR(), EmitFieldVariable_stub); + EmitClearFieldVariable_hook.create(game::EmitClearFieldVariable_ADDR(), EmitClearFieldVariable_stub); + EmitObject_hook.create(game::EmitObject_ADDR(), EmitObject_stub); + EmitDecTop_hook.create(game::EmitDecTop_ADDR(), EmitDecTop_stub); + EmitCastFieldObject_hook.create(game::EmitCastFieldObject.get(), EmitCastFieldObject_stub); + EmitArrayVariable_hook.create(game::EmitArrayVariable_ADDR(), EmitArrayVariable_stub); + EmitArrayVariableRef_hook.create(game::EmitArrayVariableRef_ADDR(), EmitArrayVariableRef_stub); + EmitClearArrayVariable_hook.create(game::EmitClearArrayVariable_ADDR(), EmitClearArrayVariable_stub); + EmitVariableExpression_hook.create(game::EmitVariableExpression.get(), EmitVariableExpression_stub); + EmitExpressionList_hook.create(game::EmitExpressionList.get(), EmitExpressionList_stub); + AddExpressionListOpcodePos_hook.create(game::AddExpressionListOpcodePos_ADDR(), AddExpressionListOpcodePos_stub); + AddFilePrecache_hook.create(game::AddFilePrecache_ADDR(), AddFilePrecache_stub); + EmitFunction_hook.create(game::EmitFunction_ADDR(), EmitFunction_stub); + EmitGetFunction_hook.create(game::EmitGetFunction_ADDR(), EmitGetFunction_stub); + AddFunction_hook.create(game::AddFunction.get(), AddFunction_stub); + EmitPostScriptFunction_hook.create(game::EmitPostScriptFunction.get(), EmitPostScriptFunction_stub); + EmitPostScriptFunctionPointer_hook.create(game::EmitPostScriptFunctionPointer_ADDR(), EmitPostScriptFunctionPointer_stub); + EmitPostScriptThread_hook.create(game::EmitPostScriptThread_ADDR(), EmitPostScriptThread_stub); + EmitPostScriptThreadPointer_hook.create(game::EmitPostScriptThreadPointer_ADDR(), EmitPostScriptThreadPointer_stub); + EmitPostScriptFunctionCall_hook.create(game::EmitPostScriptFunctionCall_ADDR(), EmitPostScriptFunctionCall_stub); + EmitPostScriptThreadCall_hook.create(game::EmitPostScriptThreadCall_ADDR(), EmitPostScriptThreadCall_stub); + EmitPreFunctionCall_hook.create(game::EmitPreFunctionCall_ADDR(), EmitPreFunctionCall_stub); + EmitPostFunctionCall_hook.create(game::EmitPostFunctionCall_ADDR(), EmitPostFunctionCall_stub); + Scr_BeginDevScript_hook.create(game::Scr_BeginDevScript_ADDR(), Scr_BeginDevScript_stub); + Scr_EndDevScript_hook.create(game::Scr_EndDevScript_ADDR(), Scr_EndDevScript_stub); + EmitCallBuiltinOpcode_hook.create(game::EmitCallBuiltinOpcode_ADDR(), EmitCallBuiltinOpcode_stub); + EmitCallBuiltinMethodOpcode_hook.create(game::EmitCallBuiltinMethodOpcode_ADDR(), EmitCallBuiltinMethodOpcode_stub); + EmitCall_hook.create(game::EmitCall_ADDR(), EmitCall_stub); + EmitMethod_hook.create(game::EmitMethod.get(), EmitMethod_stub); + LinkThread_hook.create(game::LinkThread_ADDR(), LinkThread_stub); + LinkFile_hook.create(game::LinkFile_ADDR(), LinkFile_stub); + CheckThreadPosition_hook.create(game::CheckThreadPosition.get(), CheckThreadPosition_stub); + EmitCallExpression_hook.create(game::EmitCallExpression_ADDR(), EmitCallExpression_stub); + EmitCallExpressionFieldObject_hook.create(game::EmitCallExpressionFieldObject_ADDR(), EmitCallExpressionFieldObject_stub); + Scr_CreateVector_hook.create(game::Scr_CreateVector_ADDR(), Scr_CreateVector_stub); + EvalPrimitiveExpressionList_hook.create(game::EvalPrimitiveExpressionList.get(), EvalPrimitiveExpressionList_stub); + EmitOrEvalPrimitiveExpressionList_hook.create(game::EmitOrEvalPrimitiveExpressionList_ADDR(), EmitOrEvalPrimitiveExpressionList_stub); + EmitExpressionListFieldObject_hook.create(game::EmitExpressionListFieldObject_ADDR(), EmitExpressionListFieldObject_stub); + EvalPrimitiveExpression_hook.create(game::EvalPrimitiveExpression.get(), EvalPrimitiveExpression_stub); + EmitOrEvalPrimitiveExpression_hook.create(game::EmitOrEvalPrimitiveExpression.get(), EmitOrEvalPrimitiveExpression_stub); + EmitBoolOrExpression_hook.create(game::EmitBoolOrExpression_ADDR(), EmitBoolOrExpression_stub); + EmitBoolAndExpression_hook.create(game::EmitBoolAndExpression_ADDR(), EmitBoolAndExpression_stub); + EvalBinaryOperatorExpression_hook.create(game::EvalBinaryOperatorExpression.get(), EvalBinaryOperatorExpression_stub); + EmitOrEvalBinaryOperatorExpression_hook.create(game::EmitOrEvalBinaryOperatorExpression_ADDR(), EmitOrEvalBinaryOperatorExpression_stub); + EmitBinaryEqualsOperatorExpression_hook.create(game::EmitBinaryEqualsOperatorExpression_ADDR(), EmitBinaryEqualsOperatorExpression_stub); + Scr_CalcLocalVarsVariableExpressionRef_hook.create(game::Scr_CalcLocalVarsVariableExpressionRef_ADDR(), Scr_CalcLocalVarsVariableExpressionRef_stub); + EvalExpression_hook.create(game::EvalExpression_ADDR(), EvalExpression_stub); + EmitOrEvalExpression_hook.create(game::EmitOrEvalExpression.get(), EmitOrEvalExpression_stub); + EmitExpression_hook.create(game::EmitExpression.get(), EmitExpression_stub); + EmitVariableExpressionRef_hook.create(game::EmitVariableExpressionRef.get(), EmitVariableExpressionRef_stub); + EmitArrayPrimitiveExpressionRef_hook.create(game::EmitArrayPrimitiveExpressionRef_ADDR(), EmitArrayPrimitiveExpressionRef_stub); + Scr_CalcLocalVarsArrayVariableRef_hook.create(game::Scr_CalcLocalVarsArrayVariableRef.get(), Scr_CalcLocalVarsArrayVariableRef_stub); + EmitPrimitiveExpressionFieldObject_hook.create(game::EmitPrimitiveExpressionFieldObject.get(), EmitPrimitiveExpressionFieldObject_stub); + ConnectBreakStatements_hook.create(game::ConnectBreakStatements_ADDR(), ConnectBreakStatements_stub); + ConnectContinueStatements_hook.create(game::ConnectContinueStatements_ADDR(), ConnectContinueStatements_stub); + EmitClearVariableExpression_hook.create(game::EmitClearVariableExpression_ADDR(), EmitClearVariableExpression_stub); + EmitAssignmentStatement_hook.create(game::EmitAssignmentStatement_ADDR(), EmitAssignmentStatement_stub); + EmitCallExpressionStatement_hook.create(game::EmitCallExpressionStatement_ADDR(), EmitCallExpressionStatement_stub); + EmitReturnStatement_hook.create(game::EmitReturnStatement_ADDR(), EmitReturnStatement_stub); + EmitWaitStatement_hook.create(game::EmitWaitStatement_ADDR(), EmitWaitStatement_stub); + EmitWaittillFrameEnd_hook.create(game::EmitWaittillFrameEnd_ADDR(), EmitWaittillFrameEnd_stub); + EmitIfStatement_hook.create(game::EmitIfStatement_ADDR(), EmitIfStatement_stub); + Scr_CalcLocalVarsIfStatement_hook.create(game::Scr_CalcLocalVarsIfStatement.get(), Scr_CalcLocalVarsIfStatement_stub); + EmitIfElseStatement_hook.create(game::EmitIfElseStatement.get(), EmitIfElseStatement_stub); + Scr_CalcLocalVarsIfElseStatement_hook.create(game::Scr_CalcLocalVarsIfElseStatement.get(), Scr_CalcLocalVarsIfElseStatement_stub); + Scr_AddBreakBlock_hook.create(game::Scr_AddBreakBlock_ADDR(), Scr_AddBreakBlock_stub); + Scr_AddContinueBlock_hook.create(game::Scr_AddContinueBlock_ADDR(), Scr_AddContinueBlock_stub); + EmitWhileStatement_hook.create(game::EmitWhileStatement.get(), EmitWhileStatement_stub); + Scr_CalcLocalVarsWhileStatement_hook.create(game::Scr_CalcLocalVarsWhileStatement.get(), Scr_CalcLocalVarsWhileStatement_stub); + EmitForStatement_hook.create(game::EmitForStatement.get(), EmitForStatement_stub); + Scr_CalcLocalVarsForStatement_hook.create(game::Scr_CalcLocalVarsForStatement.get(), Scr_CalcLocalVarsForStatement_stub); + EmitIncStatement_hook.create(game::EmitIncStatement_ADDR(), EmitIncStatement_stub); + EmitDecStatement_hook.create(game::EmitDecStatement_ADDR(), EmitDecStatement_stub); + Scr_CalcLocalVarsFormalParameterListInternal_hook.create(game::Scr_CalcLocalVarsFormalParameterListInternal_ADDR(), Scr_CalcLocalVarsFormalParameterListInternal_stub); + EmitWaittillStatement_hook.create(game::EmitWaittillStatement_ADDR(), EmitWaittillStatement_stub); + EmitWaittillmatchStatement_hook.create(game::EmitWaittillmatchStatement_ADDR(), EmitWaittillmatchStatement_stub); + EmitNotifyStatement_hook.create(game::EmitNotifyStatement_ADDR(), EmitNotifyStatement_stub); + EmitEndOnStatement_hook.create(game::EmitEndOnStatement_ADDR(), EmitEndOnStatement_stub); + CompareCaseInfo_hook.create(game::CompareCaseInfo.get(), CompareCaseInfo_stub); + EmitCaseStatement_hook.create(game::EmitCaseStatement_ADDR(), EmitCaseStatement_stub); + EmitSwitchStatementList_hook.create(game::EmitSwitchStatementList.get(), EmitSwitchStatementList_stub); + Scr_CalcLocalVarsSwitchStatement_hook.create(game::Scr_CalcLocalVarsSwitchStatement.get(), Scr_CalcLocalVarsSwitchStatement_stub); + EmitSwitchStatement_hook.create(game::EmitSwitchStatement.get(), EmitSwitchStatement_stub); + EmitCaseStatementInfo_hook.create(game::EmitCaseStatementInfo_ADDR(), EmitCaseStatementInfo_stub); + EmitBreakStatement_hook.create(game::EmitBreakStatement_ADDR(), EmitBreakStatement_stub); + EmitContinueStatement_hook.create(game::EmitContinueStatement_ADDR(), EmitContinueStatement_stub); + EmitProfStatement_hook.create(game::EmitProfStatement_ADDR(), EmitProfStatement_stub); + EmitStatement_hook.create(game::EmitStatement.get(), EmitStatement_stub); + Scr_CalcLocalVarsStatement_hook.create(game::Scr_CalcLocalVarsStatement.get(), Scr_CalcLocalVarsStatement_stub); + EmitStatementList_hook.create(game::EmitStatementList.get(), EmitStatementList_stub); + Scr_CalcLocalVarsStatementList_hook.create(game::Scr_CalcLocalVarsStatementList_ADDR(), Scr_CalcLocalVarsStatementList_stub); + Scr_CalcLocalVarsDeveloperStatementList_hook.create(game::Scr_CalcLocalVarsDeveloperStatementList.get(), Scr_CalcLocalVarsDeveloperStatementList_stub); + EmitDeveloperStatementList_hook.create(game::EmitDeveloperStatementList.get(), EmitDeveloperStatementList_stub); + EmitFormalParameterList_hook.create(game::EmitFormalParameterList_ADDR(), EmitFormalParameterList_stub); + SpecifyThread_hook.create(game::SpecifyThread_ADDR(), SpecifyThread_stub); + EmitThreadInternal_hook.create(game::EmitThreadInternal_ADDR(), EmitThreadInternal_stub); + Scr_CalcLocalVarsThread_hook.create(game::Scr_CalcLocalVarsThread_ADDR(), Scr_CalcLocalVarsThread_stub); + InitThread_hook.create(game::InitThread_ADDR(), InitThread_stub); + EmitNormalThread_hook.create(game::EmitNormalThread_ADDR(), EmitNormalThread_stub); + EmitDeveloperThread_hook.create(game::EmitDeveloperThread_ADDR(), EmitDeveloperThread_stub); + EmitThread_hook.create(game::EmitThread_ADDR(), EmitThread_stub); + EmitThreadList_hook.create(game::EmitThreadList.get(), EmitThreadList_stub); + EmitInclude_hook.create(game::EmitInclude_ADDR(), EmitInclude_stub); + ScriptCompile_hook.create(game::ScriptCompile_ADDR(), ScriptCompile_stub); - RemoveRefToValue_hook.create(game::RemoveRefToValue.get(), RemoveRefToValue_stub, quick); - Scr_CompileRemoveRefToString_hook.create(game::Scr_CompileRemoveRefToString_ADDR(), Scr_CompileRemoveRefToString_stub, quick); - EmitCanonicalString_hook.create(game::EmitCanonicalString_ADDR(), EmitCanonicalString_stub, quick); - CompileTransferRefToString_hook.create(game::CompileTransferRefToString_ADDR(), CompileTransferRefToString_stub, quick); - EmitOpcode_hook.create(game::EmitOpcode.get(), EmitOpcode_stub, quick); - EmitEnd_hook.create(game::EmitEnd_ADDR(), EmitEnd_stub, quick); - EmitReturn_hook.create(game::EmitReturn_ADDR(), EmitReturn_stub, quick); - EmitCodepos_hook.create(game::EmitCodepos_ADDR(), EmitCodepos_stub, quick); - EmitShort_hook.create(game::EmitShort_ADDR(), EmitShort_stub, quick); - EmitByte_hook.create(game::EmitByte_ADDR(), EmitByte_stub, quick); - EmitGetInteger_hook.create(game::EmitGetInteger_ADDR(), EmitGetInteger_stub, quick); - EmitGetFloat_hook.create(game::EmitGetFloat_ADDR(), EmitGetFloat_stub, quick); - EmitAnimTree_hook.create(game::EmitAnimTree_ADDR(), EmitAnimTree_stub, quick); - Scr_FindLocalVarIndex_hook.create(game::Scr_FindLocalVarIndex.get(), Scr_FindLocalVarIndex_stub, quick); - EmitCreateLocalVars_hook.create(game::EmitCreateLocalVars.get(), EmitCreateLocalVars_stub, quick); - EmitRemoveLocalVars_hook.create(game::EmitRemoveLocalVars_ADDR(), EmitRemoveLocalVars_stub, quick); - EmitNOP2_hook.create(game::EmitNOP2_ADDR(), EmitNOP2_stub, quick); - Scr_InitFromChildBlocks_hook.create(game::Scr_InitFromChildBlocks.get(), Scr_InitFromChildBlocks_stub, quick); - Scr_AppendChildBlocks_hook.create(game::Scr_AppendChildBlocks_ADDR(), Scr_AppendChildBlocks_stub, quick); - Scr_MergeChildBlocks_hook.create(game::Scr_MergeChildBlocks.get(), Scr_MergeChildBlocks_stub, quick); - Scr_TransferBlock_hook.create(game::Scr_TransferBlock_ADDR(), Scr_TransferBlock_stub, quick); - EmitSafeSetVariableField_hook.create(game::EmitSafeSetVariableField_ADDR(), EmitSafeSetVariableField_stub, quick); - EmitSafeSetWaittillVariableField_hook.create(game::EmitSafeSetWaittillVariableField_ADDR(), EmitSafeSetWaittillVariableField_stub, quick); - EmitGetString_hook.create(game::EmitGetString_ADDR(), EmitGetString_stub, quick); - EmitGetIString_hook.create(game::EmitGetIString_ADDR(), EmitGetIString_stub, quick); - EmitGetVector_hook.create(game::EmitGetVector_ADDR(), EmitGetVector_stub, quick); - EmitValue_hook.create(game::EmitValue.get(), EmitValue_stub, quick); - Scr_PushValue_hook.create(game::Scr_PushValue_ADDR(), Scr_PushValue_stub, quick); - EmitCastBool_hook.create(game::EmitCastBool_ADDR(), EmitCastBool_stub, quick); - EmitBoolNot_hook.create(game::EmitBoolNot_ADDR(), EmitBoolNot_stub, quick); - EmitBoolComplement_hook.create(game::EmitBoolComplement_ADDR(), EmitBoolComplement_stub, quick); - EmitSize_hook.create(game::EmitSize_ADDR(), EmitSize_stub, quick); - EmitSelf_hook.create(game::EmitSelf_ADDR(), EmitSelf_stub, quick); - EmitLevel_hook.create(game::EmitLevel_ADDR(), EmitLevel_stub, quick); - EmitGame_hook.create(game::EmitGame_ADDR(), EmitGame_stub, quick); - EmitAnim_hook.create(game::EmitAnim_ADDR(), EmitAnim_stub, quick); - EmitSelfObject_hook.create(game::EmitSelfObject_ADDR(), EmitSelfObject_stub, quick); - EmitLevelObject_hook.create(game::EmitLevelObject_ADDR(), EmitLevelObject_stub, quick); - EmitAnimObject_hook.create(game::EmitAnimObject_ADDR(), EmitAnimObject_stub, quick); - EmitLocalVariable_hook.create(game::EmitLocalVariable_ADDR(), EmitLocalVariable_stub, quick); - EmitLocalVariableRef_hook.create(game::EmitLocalVariableRef_ADDR(), EmitLocalVariableRef_stub, quick); - Scr_RegisterLocalVar_hook.create(game::Scr_RegisterLocalVar.get(), Scr_RegisterLocalVar_stub, quick); - EmitGameRef_hook.create(game::EmitGameRef_ADDR(), EmitGameRef_stub, quick); - EmitClearArray_hook.create(game::EmitClearArray_ADDR(), EmitClearArray_stub, quick); - EmitEmptyArray_hook.create(game::EmitEmptyArray_ADDR(), EmitEmptyArray_stub, quick); - EmitAnimation_hook.create(game::EmitAnimation_ADDR(), EmitAnimation_stub, quick); - EmitFieldVariable_hook.create(game::EmitFieldVariable_ADDR(), EmitFieldVariable_stub, quick); - EmitClearFieldVariable_hook.create(game::EmitClearFieldVariable_ADDR(), EmitClearFieldVariable_stub, quick); - EmitObject_hook.create(game::EmitObject_ADDR(), EmitObject_stub, quick); - EmitDecTop_hook.create(game::EmitDecTop_ADDR(), EmitDecTop_stub, quick); - EmitCastFieldObject_hook.create(game::EmitCastFieldObject.get(), EmitCastFieldObject_stub, quick); - EmitArrayVariable_hook.create(game::EmitArrayVariable_ADDR(), EmitArrayVariable_stub, quick); - EmitArrayVariableRef_hook.create(game::EmitArrayVariableRef_ADDR(), EmitArrayVariableRef_stub, quick); - EmitClearArrayVariable_hook.create(game::EmitClearArrayVariable_ADDR(), EmitClearArrayVariable_stub, quick); - EmitVariableExpression_hook.create(game::EmitVariableExpression.get(), EmitVariableExpression_stub, quick); - EmitExpressionList_hook.create(game::EmitExpressionList.get(), EmitExpressionList_stub, quick); - AddExpressionListOpcodePos_hook.create(game::AddExpressionListOpcodePos_ADDR(), AddExpressionListOpcodePos_stub, quick); - AddFilePrecache_hook.create(game::AddFilePrecache_ADDR(), AddFilePrecache_stub, quick); - EmitFunction_hook.create(game::EmitFunction_ADDR(), EmitFunction_stub, quick); - EmitGetFunction_hook.create(game::EmitGetFunction_ADDR(), EmitGetFunction_stub, quick); - AddFunction_hook.create(game::AddFunction.get(), AddFunction_stub, quick); - EmitPostScriptFunction_hook.create(game::EmitPostScriptFunction.get(), EmitPostScriptFunction_stub, quick); - EmitPostScriptFunctionPointer_hook.create(game::EmitPostScriptFunctionPointer_ADDR(), EmitPostScriptFunctionPointer_stub, quick); - EmitPostScriptThread_hook.create(game::EmitPostScriptThread_ADDR(), EmitPostScriptThread_stub, quick); - EmitPostScriptThreadPointer_hook.create(game::EmitPostScriptThreadPointer_ADDR(), EmitPostScriptThreadPointer_stub, quick); - EmitPostScriptFunctionCall_hook.create(game::EmitPostScriptFunctionCall_ADDR(), EmitPostScriptFunctionCall_stub, quick); - EmitPostScriptThreadCall_hook.create(game::EmitPostScriptThreadCall_ADDR(), EmitPostScriptThreadCall_stub, quick); - EmitPreFunctionCall_hook.create(game::EmitPreFunctionCall_ADDR(), EmitPreFunctionCall_stub, quick); - EmitPostFunctionCall_hook.create(game::EmitPostFunctionCall_ADDR(), EmitPostFunctionCall_stub, quick); - Scr_BeginDevScript_hook.create(game::Scr_BeginDevScript_ADDR(), Scr_BeginDevScript_stub, quick); - Scr_EndDevScript_hook.create(game::Scr_EndDevScript_ADDR(), Scr_EndDevScript_stub, quick); - EmitCallBuiltinOpcode_hook.create(game::EmitCallBuiltinOpcode_ADDR(), EmitCallBuiltinOpcode_stub, quick); - EmitCallBuiltinMethodOpcode_hook.create(game::EmitCallBuiltinMethodOpcode_ADDR(), EmitCallBuiltinMethodOpcode_stub, quick); - EmitCall_hook.create(game::EmitCall_ADDR(), EmitCall_stub, quick); - EmitMethod_hook.create(game::EmitMethod.get(), EmitMethod_stub, quick); - LinkThread_hook.create(game::LinkThread_ADDR(), LinkThread_stub, quick); - LinkFile_hook.create(game::LinkFile_ADDR(), LinkFile_stub, quick); - CheckThreadPosition_hook.create(game::CheckThreadPosition.get(), CheckThreadPosition_stub, quick); - EmitCallExpression_hook.create(game::EmitCallExpression_ADDR(), EmitCallExpression_stub, quick); - EmitCallExpressionFieldObject_hook.create(game::EmitCallExpressionFieldObject_ADDR(), EmitCallExpressionFieldObject_stub, quick); - Scr_CreateVector_hook.create(game::Scr_CreateVector_ADDR(), Scr_CreateVector_stub, quick); - EvalPrimitiveExpressionList_hook.create(game::EvalPrimitiveExpressionList.get(), EvalPrimitiveExpressionList_stub, quick); - EmitOrEvalPrimitiveExpressionList_hook.create(game::EmitOrEvalPrimitiveExpressionList_ADDR(), EmitOrEvalPrimitiveExpressionList_stub, quick); - EmitExpressionListFieldObject_hook.create(game::EmitExpressionListFieldObject_ADDR(), EmitExpressionListFieldObject_stub, quick); - EvalPrimitiveExpression_hook.create(game::EvalPrimitiveExpression.get(), EvalPrimitiveExpression_stub, quick); - EmitOrEvalPrimitiveExpression_hook.create(game::EmitOrEvalPrimitiveExpression.get(), EmitOrEvalPrimitiveExpression_stub, quick); - EmitBoolOrExpression_hook.create(game::EmitBoolOrExpression_ADDR(), EmitBoolOrExpression_stub, quick); - EmitBoolAndExpression_hook.create(game::EmitBoolAndExpression_ADDR(), EmitBoolAndExpression_stub, quick); - EvalBinaryOperatorExpression_hook.create(game::EvalBinaryOperatorExpression.get(), EvalBinaryOperatorExpression_stub, quick); - EmitOrEvalBinaryOperatorExpression_hook.create(game::EmitOrEvalBinaryOperatorExpression_ADDR(), EmitOrEvalBinaryOperatorExpression_stub, quick); - EmitBinaryEqualsOperatorExpression_hook.create(game::EmitBinaryEqualsOperatorExpression_ADDR(), EmitBinaryEqualsOperatorExpression_stub, quick); - Scr_CalcLocalVarsVariableExpressionRef_hook.create(game::Scr_CalcLocalVarsVariableExpressionRef_ADDR(), Scr_CalcLocalVarsVariableExpressionRef_stub, quick); - EvalExpression_hook.create(game::EvalExpression_ADDR(), EvalExpression_stub, quick); - EmitOrEvalExpression_hook.create(game::EmitOrEvalExpression.get(), EmitOrEvalExpression_stub, quick); - EmitExpression_hook.create(game::EmitExpression.get(), EmitExpression_stub, quick); - EmitVariableExpressionRef_hook.create(game::EmitVariableExpressionRef.get(), EmitVariableExpressionRef_stub, quick); - EmitArrayPrimitiveExpressionRef_hook.create(game::EmitArrayPrimitiveExpressionRef_ADDR(), EmitArrayPrimitiveExpressionRef_stub, quick); - Scr_CalcLocalVarsArrayVariableRef_hook.create(game::Scr_CalcLocalVarsArrayVariableRef.get(), Scr_CalcLocalVarsArrayVariableRef_stub, quick); - EmitPrimitiveExpressionFieldObject_hook.create(game::EmitPrimitiveExpressionFieldObject.get(), EmitPrimitiveExpressionFieldObject_stub, quick); - ConnectBreakStatements_hook.create(game::ConnectBreakStatements_ADDR(), ConnectBreakStatements_stub, quick); - ConnectContinueStatements_hook.create(game::ConnectContinueStatements_ADDR(), ConnectContinueStatements_stub, quick); - EmitClearVariableExpression_hook.create(game::EmitClearVariableExpression_ADDR(), EmitClearVariableExpression_stub, quick); - EmitAssignmentStatement_hook.create(game::EmitAssignmentStatement_ADDR(), EmitAssignmentStatement_stub, quick); - EmitCallExpressionStatement_hook.create(game::EmitCallExpressionStatement_ADDR(), EmitCallExpressionStatement_stub, quick); - EmitReturnStatement_hook.create(game::EmitReturnStatement_ADDR(), EmitReturnStatement_stub, quick); - EmitWaitStatement_hook.create(game::EmitWaitStatement_ADDR(), EmitWaitStatement_stub, quick); - EmitWaittillFrameEnd_hook.create(game::EmitWaittillFrameEnd_ADDR(), EmitWaittillFrameEnd_stub, quick); - EmitIfStatement_hook.create(game::EmitIfStatement_ADDR(), EmitIfStatement_stub, quick); - Scr_CalcLocalVarsIfStatement_hook.create(game::Scr_CalcLocalVarsIfStatement.get(), Scr_CalcLocalVarsIfStatement_stub, quick); - EmitIfElseStatement_hook.create(game::EmitIfElseStatement.get(), EmitIfElseStatement_stub, quick); - Scr_CalcLocalVarsIfElseStatement_hook.create(game::Scr_CalcLocalVarsIfElseStatement.get(), Scr_CalcLocalVarsIfElseStatement_stub, quick); - Scr_AddBreakBlock_hook.create(game::Scr_AddBreakBlock_ADDR(), Scr_AddBreakBlock_stub, quick); - Scr_AddContinueBlock_hook.create(game::Scr_AddContinueBlock_ADDR(), Scr_AddContinueBlock_stub, quick); - EmitWhileStatement_hook.create(game::EmitWhileStatement.get(), EmitWhileStatement_stub, quick); - Scr_CalcLocalVarsWhileStatement_hook.create(game::Scr_CalcLocalVarsWhileStatement.get(), Scr_CalcLocalVarsWhileStatement_stub, quick); - EmitForStatement_hook.create(game::EmitForStatement.get(), EmitForStatement_stub, quick); - Scr_CalcLocalVarsForStatement_hook.create(game::Scr_CalcLocalVarsForStatement.get(), Scr_CalcLocalVarsForStatement_stub, quick); - EmitIncStatement_hook.create(game::EmitIncStatement_ADDR(), EmitIncStatement_stub, quick); - EmitDecStatement_hook.create(game::EmitDecStatement_ADDR(), EmitDecStatement_stub, quick); - Scr_CalcLocalVarsFormalParameterListInternal_hook.create(game::Scr_CalcLocalVarsFormalParameterListInternal_ADDR(), Scr_CalcLocalVarsFormalParameterListInternal_stub, quick); - EmitWaittillStatement_hook.create(game::EmitWaittillStatement_ADDR(), EmitWaittillStatement_stub, quick); - EmitWaittillmatchStatement_hook.create(game::EmitWaittillmatchStatement_ADDR(), EmitWaittillmatchStatement_stub, quick); - EmitNotifyStatement_hook.create(game::EmitNotifyStatement_ADDR(), EmitNotifyStatement_stub, quick); - EmitEndOnStatement_hook.create(game::EmitEndOnStatement_ADDR(), EmitEndOnStatement_stub, quick); - CompareCaseInfo_hook.create(game::CompareCaseInfo.get(), CompareCaseInfo_stub, quick); - EmitCaseStatement_hook.create(game::EmitCaseStatement_ADDR(), EmitCaseStatement_stub, quick); - EmitSwitchStatementList_hook.create(game::EmitSwitchStatementList.get(), EmitSwitchStatementList_stub, quick); - Scr_CalcLocalVarsSwitchStatement_hook.create(game::Scr_CalcLocalVarsSwitchStatement.get(), Scr_CalcLocalVarsSwitchStatement_stub, quick); - EmitSwitchStatement_hook.create(game::EmitSwitchStatement.get(), EmitSwitchStatement_stub, quick); - EmitCaseStatementInfo_hook.create(game::EmitCaseStatementInfo_ADDR(), EmitCaseStatementInfo_stub, quick); - EmitBreakStatement_hook.create(game::EmitBreakStatement_ADDR(), EmitBreakStatement_stub, quick); - EmitContinueStatement_hook.create(game::EmitContinueStatement_ADDR(), EmitContinueStatement_stub, quick); - EmitProfStatement_hook.create(game::EmitProfStatement_ADDR(), EmitProfStatement_stub, quick); - EmitStatement_hook.create(game::EmitStatement.get(), EmitStatement_stub, quick); - Scr_CalcLocalVarsStatement_hook.create(game::Scr_CalcLocalVarsStatement.get(), Scr_CalcLocalVarsStatement_stub, quick); - EmitStatementList_hook.create(game::EmitStatementList.get(), EmitStatementList_stub, quick); - Scr_CalcLocalVarsStatementList_hook.create(game::Scr_CalcLocalVarsStatementList_ADDR(), Scr_CalcLocalVarsStatementList_stub, quick); - Scr_CalcLocalVarsDeveloperStatementList_hook.create(game::Scr_CalcLocalVarsDeveloperStatementList.get(), Scr_CalcLocalVarsDeveloperStatementList_stub, quick); - EmitDeveloperStatementList_hook.create(game::EmitDeveloperStatementList.get(), EmitDeveloperStatementList_stub, quick); - EmitFormalParameterList_hook.create(game::EmitFormalParameterList_ADDR(), EmitFormalParameterList_stub, quick); - SpecifyThread_hook.create(game::SpecifyThread_ADDR(), SpecifyThread_stub, quick); - EmitThreadInternal_hook.create(game::EmitThreadInternal_ADDR(), EmitThreadInternal_stub, quick); - Scr_CalcLocalVarsThread_hook.create(game::Scr_CalcLocalVarsThread_ADDR(), Scr_CalcLocalVarsThread_stub, quick); - InitThread_hook.create(game::InitThread_ADDR(), InitThread_stub, quick); - EmitNormalThread_hook.create(game::EmitNormalThread_ADDR(), EmitNormalThread_stub, quick); - EmitDeveloperThread_hook.create(game::EmitDeveloperThread_ADDR(), EmitDeveloperThread_stub, quick); - EmitThread_hook.create(game::EmitThread_ADDR(), EmitThread_stub, quick); - EmitThreadList_hook.create(game::EmitThreadList.get(), EmitThreadList_stub, quick); - EmitInclude_hook.create(game::EmitInclude_ADDR(), EmitInclude_stub, quick); - ScriptCompile_hook.create(game::ScriptCompile_ADDR(), ScriptCompile_stub, quick); + //Original hook function addresses + RemoveRefToValue_original = RemoveRefToValue_hook.get_original(); + Scr_CompileRemoveRefToString_original = Scr_CompileRemoveRefToString_hook.get_original(); + EmitCanonicalString_original = EmitCanonicalString_hook.get_original(); + CompileTransferRefToString_original = CompileTransferRefToString_hook.get_original(); + EmitOpcode_original = EmitOpcode_hook.get_original(); + EmitEnd_original = EmitEnd_hook.get_original(); + EmitReturn_original = EmitReturn_hook.get_original(); + EmitCodepos_original = EmitCodepos_hook.get_original(); + EmitShort_original = EmitShort_hook.get_original(); + EmitByte_original = EmitByte_hook.get_original(); + EmitGetInteger_original = EmitGetInteger_hook.get_original(); + EmitGetFloat_original = EmitGetFloat_hook.get_original(); + EmitAnimTree_original = EmitAnimTree_hook.get_original(); + Scr_FindLocalVarIndex_original = Scr_FindLocalVarIndex_hook.get_original(); + EmitCreateLocalVars_original = EmitCreateLocalVars_hook.get_original(); + EmitRemoveLocalVars_original = EmitRemoveLocalVars_hook.get_original(); + EmitNOP2_original = EmitNOP2_hook.get_original(); + Scr_InitFromChildBlocks_original = Scr_InitFromChildBlocks_hook.get_original(); + Scr_AppendChildBlocks_original = Scr_AppendChildBlocks_hook.get_original(); + Scr_MergeChildBlocks_original = Scr_MergeChildBlocks_hook.get_original(); + Scr_TransferBlock_original = Scr_TransferBlock_hook.get_original(); + EmitSafeSetVariableField_original = EmitSafeSetVariableField_hook.get_original(); + EmitSafeSetWaittillVariableField_original = EmitSafeSetWaittillVariableField_hook.get_original(); + EmitGetString_original = EmitGetString_hook.get_original(); + EmitGetIString_original = EmitGetIString_hook.get_original(); + EmitGetVector_original = EmitGetVector_hook.get_original(); + EmitValue_original = EmitValue_hook.get_original(); + Scr_PushValue_original = Scr_PushValue_hook.get_original(); + EmitCastBool_original = EmitCastBool_hook.get_original(); + EmitBoolNot_original = EmitBoolNot_hook.get_original(); + EmitBoolComplement_original = EmitBoolComplement_hook.get_original(); + EmitSize_original = EmitSize_hook.get_original(); + EmitSelf_original = EmitSelf_hook.get_original(); + EmitLevel_original = EmitLevel_hook.get_original(); + EmitGame_original = EmitGame_hook.get_original(); + EmitAnim_original = EmitAnim_hook.get_original(); + EmitSelfObject_original = EmitSelfObject_hook.get_original(); + EmitLevelObject_original = EmitLevelObject_hook.get_original(); + EmitAnimObject_original = EmitAnimObject_hook.get_original(); + EmitLocalVariable_original = EmitLocalVariable_hook.get_original(); + EmitLocalVariableRef_original = EmitLocalVariableRef_hook.get_original(); + Scr_RegisterLocalVar_original = Scr_RegisterLocalVar_hook.get_original(); + EmitGameRef_original = EmitGameRef_hook.get_original(); + EmitClearArray_original = EmitClearArray_hook.get_original(); + EmitEmptyArray_original = EmitEmptyArray_hook.get_original(); + EmitAnimation_original = EmitAnimation_hook.get_original(); + EmitFieldVariable_original = EmitFieldVariable_hook.get_original(); + EmitClearFieldVariable_original = EmitClearFieldVariable_hook.get_original(); + EmitObject_original = EmitObject_hook.get_original(); + EmitDecTop_original = EmitDecTop_hook.get_original(); + EmitCastFieldObject_original = EmitCastFieldObject_hook.get_original(); + EmitArrayVariable_original = EmitArrayVariable_hook.get_original(); + EmitArrayVariableRef_original = EmitArrayVariableRef_hook.get_original(); + EmitClearArrayVariable_original = EmitClearArrayVariable_hook.get_original(); + EmitVariableExpression_original = EmitVariableExpression_hook.get_original(); + EmitExpressionList_original = EmitExpressionList_hook.get_original(); + AddExpressionListOpcodePos_original = AddExpressionListOpcodePos_hook.get_original(); + AddFilePrecache_original = AddFilePrecache_hook.get_original(); + EmitFunction_original = EmitFunction_hook.get_original(); + EmitGetFunction_original = EmitGetFunction_hook.get_original(); + AddFunction_original = AddFunction_hook.get_original(); + EmitPostScriptFunction_original = EmitPostScriptFunction_hook.get_original(); + EmitPostScriptFunctionPointer_original = EmitPostScriptFunctionPointer_hook.get_original(); + EmitPostScriptThread_original = EmitPostScriptThread_hook.get_original(); + EmitPostScriptThreadPointer_original = EmitPostScriptThreadPointer_hook.get_original(); + EmitPostScriptFunctionCall_original = EmitPostScriptFunctionCall_hook.get_original(); + EmitPostScriptThreadCall_original = EmitPostScriptThreadCall_hook.get_original(); + EmitPreFunctionCall_original = EmitPreFunctionCall_hook.get_original(); + EmitPostFunctionCall_original = EmitPostFunctionCall_hook.get_original(); + Scr_BeginDevScript_original = Scr_BeginDevScript_hook.get_original(); + Scr_EndDevScript_original = Scr_EndDevScript_hook.get_original(); + EmitCallBuiltinOpcode_original = EmitCallBuiltinOpcode_hook.get_original(); + EmitCallBuiltinMethodOpcode_original = EmitCallBuiltinMethodOpcode_hook.get_original(); + EmitCall_original = EmitCall_hook.get_original(); + EmitMethod_original = EmitMethod_hook.get_original(); + LinkThread_original = LinkThread_hook.get_original(); + LinkFile_original = LinkFile_hook.get_original(); + CheckThreadPosition_original = CheckThreadPosition_hook.get_original(); + EmitCallExpression_original = EmitCallExpression_hook.get_original(); + EmitCallExpressionFieldObject_original = EmitCallExpressionFieldObject_hook.get_original(); + Scr_CreateVector_original = Scr_CreateVector_hook.get_original(); + EvalPrimitiveExpressionList_original = EvalPrimitiveExpressionList_hook.get_original(); + EmitOrEvalPrimitiveExpressionList_original = EmitOrEvalPrimitiveExpressionList_hook.get_original(); + EmitExpressionListFieldObject_original = EmitExpressionListFieldObject_hook.get_original(); + EvalPrimitiveExpression_original = EvalPrimitiveExpression_hook.get_original(); + EmitOrEvalPrimitiveExpression_original = EmitOrEvalPrimitiveExpression_hook.get_original(); + EmitBoolOrExpression_original = EmitBoolOrExpression_hook.get_original(); + EmitBoolAndExpression_original = EmitBoolAndExpression_hook.get_original(); + EvalBinaryOperatorExpression_original = EvalBinaryOperatorExpression_hook.get_original(); + EmitOrEvalBinaryOperatorExpression_original = EmitOrEvalBinaryOperatorExpression_hook.get_original(); + EmitBinaryEqualsOperatorExpression_original = EmitBinaryEqualsOperatorExpression_hook.get_original(); + Scr_CalcLocalVarsVariableExpressionRef_original = Scr_CalcLocalVarsVariableExpressionRef_hook.get_original(); + EvalExpression_original = EvalExpression_hook.get_original(); + EmitOrEvalExpression_original = EmitOrEvalExpression_hook.get_original(); + EmitExpression_original = EmitExpression_hook.get_original(); + EmitVariableExpressionRef_original = EmitVariableExpressionRef_hook.get_original(); + EmitArrayPrimitiveExpressionRef_original = EmitArrayPrimitiveExpressionRef_hook.get_original(); + Scr_CalcLocalVarsArrayVariableRef_original = Scr_CalcLocalVarsArrayVariableRef_hook.get_original(); + EmitPrimitiveExpressionFieldObject_original = EmitPrimitiveExpressionFieldObject_hook.get_original(); + ConnectBreakStatements_original = ConnectBreakStatements_hook.get_original(); + ConnectContinueStatements_original = ConnectContinueStatements_hook.get_original(); + EmitClearVariableExpression_original = EmitClearVariableExpression_hook.get_original(); + EmitAssignmentStatement_original = EmitAssignmentStatement_hook.get_original(); + EmitCallExpressionStatement_original = EmitCallExpressionStatement_hook.get_original(); + EmitReturnStatement_original = EmitReturnStatement_hook.get_original(); + EmitWaitStatement_original = EmitWaitStatement_hook.get_original(); + EmitWaittillFrameEnd_original = EmitWaittillFrameEnd_hook.get_original(); + EmitIfStatement_original = EmitIfStatement_hook.get_original(); + Scr_CalcLocalVarsIfStatement_original = Scr_CalcLocalVarsIfStatement_hook.get_original(); + EmitIfElseStatement_original = EmitIfElseStatement_hook.get_original(); + Scr_CalcLocalVarsIfElseStatement_original = Scr_CalcLocalVarsIfElseStatement_hook.get_original(); + Scr_AddBreakBlock_original = Scr_AddBreakBlock_hook.get_original(); + Scr_AddContinueBlock_original = Scr_AddContinueBlock_hook.get_original(); + EmitWhileStatement_original = EmitWhileStatement_hook.get_original(); + Scr_CalcLocalVarsWhileStatement_original = Scr_CalcLocalVarsWhileStatement_hook.get_original(); + EmitForStatement_original = EmitForStatement_hook.get_original(); + Scr_CalcLocalVarsForStatement_original = Scr_CalcLocalVarsForStatement_hook.get_original(); + EmitIncStatement_original = EmitIncStatement_hook.get_original(); + EmitDecStatement_original = EmitDecStatement_hook.get_original(); + Scr_CalcLocalVarsFormalParameterListInternal_original = Scr_CalcLocalVarsFormalParameterListInternal_hook.get_original(); + EmitWaittillStatement_original = EmitWaittillStatement_hook.get_original(); + EmitWaittillmatchStatement_original = EmitWaittillmatchStatement_hook.get_original(); + EmitNotifyStatement_original = EmitNotifyStatement_hook.get_original(); + EmitEndOnStatement_original = EmitEndOnStatement_hook.get_original(); + CompareCaseInfo_original = CompareCaseInfo_hook.get_original(); + EmitCaseStatement_original = EmitCaseStatement_hook.get_original(); + EmitSwitchStatementList_original = EmitSwitchStatementList_hook.get_original(); + Scr_CalcLocalVarsSwitchStatement_original = Scr_CalcLocalVarsSwitchStatement_hook.get_original(); + EmitSwitchStatement_original = EmitSwitchStatement_hook.get_original(); + EmitCaseStatementInfo_original = EmitCaseStatementInfo_hook.get_original(); + EmitBreakStatement_original = EmitBreakStatement_hook.get_original(); + EmitContinueStatement_original = EmitContinueStatement_hook.get_original(); + EmitProfStatement_original = EmitProfStatement_hook.get_original(); + EmitStatement_original = EmitStatement_hook.get_original(); + Scr_CalcLocalVarsStatement_original = Scr_CalcLocalVarsStatement_hook.get_original(); + EmitStatementList_original = EmitStatementList_hook.get_original(); + Scr_CalcLocalVarsStatementList_original = Scr_CalcLocalVarsStatementList_hook.get_original(); + Scr_CalcLocalVarsDeveloperStatementList_original = Scr_CalcLocalVarsDeveloperStatementList_hook.get_original(); + EmitDeveloperStatementList_original = EmitDeveloperStatementList_hook.get_original(); + EmitFormalParameterList_original = EmitFormalParameterList_hook.get_original(); + SpecifyThread_original = SpecifyThread_hook.get_original(); + EmitThreadInternal_original = EmitThreadInternal_hook.get_original(); + Scr_CalcLocalVarsThread_original = Scr_CalcLocalVarsThread_hook.get_original(); + InitThread_original = InitThread_hook.get_original(); + EmitNormalThread_original = EmitNormalThread_hook.get_original(); + EmitDeveloperThread_original = EmitDeveloperThread_hook.get_original(); + EmitThread_original = EmitThread_hook.get_original(); + EmitThreadList_original = EmitThreadList_hook.get_original(); + EmitInclude_original = EmitInclude_hook.get_original(); + ScriptCompile_original = ScriptCompile_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_main.cpp b/src/component/decomp/clientscript/re_cscr_main.cpp index 805c0ba..67a2766 100644 --- a/src/component/decomp/clientscript/re_cscr_main.cpp +++ b/src/component/decomp/clientscript/re_cscr_main.cpp @@ -20,12 +20,26 @@ namespace re_cscr_main utils::hook::detour Scr_EndLoadAnimTrees_hook; utils::hook::detour Scr_FreeScripts_hook; + void* Scr_IsIdentifier_original; + void* Scr_GetFunctionHandle_original; + void* SL_TransferToCanonicalString_original; + void* SL_GetCanonicalString_original; + void* Scr_BeginLoadScripts_original; + void* Scr_BeginLoadAnimTrees_original; + void* Scr_ScanFile_original; + void* Scr_LoadScriptInternal_original; + void* Scr_LoadScript_original; + void* Scr_EndLoadScripts_original; + void* Scr_PrecacheAnimTrees_original; + void* Scr_EndLoadAnimTrees_original; + void* Scr_FreeScripts_original; + namespace { bool Scr_IsIdentifier_call(char * token, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - return game::Scr_IsIdentifier(token, Scr_IsIdentifier_hook.get_original()); + return game::Scr_IsIdentifier(token, Scr_IsIdentifier_original); #else return codsrc::Scr_IsIdentifier(token); #endif @@ -46,7 +60,7 @@ namespace re_cscr_main unsigned int Scr_GetFunctionHandle_call(const char * file, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, const char * handle) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - return game::Scr_GetFunctionHandle(file, inst, handle, Scr_GetFunctionHandle_hook.get_original()); + return game::Scr_GetFunctionHandle(file, inst, handle, Scr_GetFunctionHandle_original); #else return codsrc::Scr_GetFunctionHandle(file, inst, handle); #endif @@ -68,7 +82,7 @@ namespace re_cscr_main unsigned int SL_TransferToCanonicalString_call(game::scriptInstance_t inst, unsigned int stringValue, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - return game::SL_TransferToCanonicalString(inst, stringValue, SL_TransferToCanonicalString_hook.get_original()); + return game::SL_TransferToCanonicalString(inst, stringValue, SL_TransferToCanonicalString_original); #else return codsrc::SL_TransferToCanonicalString(inst, stringValue); #endif @@ -90,7 +104,7 @@ namespace re_cscr_main unsigned int SL_GetCanonicalString_call(char * token, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - return game::SL_GetCanonicalString(token, inst, SL_GetCanonicalString_hook.get_original()); + return game::SL_GetCanonicalString(token, inst, SL_GetCanonicalString_original); #else return codsrc::SL_GetCanonicalString(token, inst); #endif @@ -112,7 +126,7 @@ namespace re_cscr_main void Scr_BeginLoadScripts_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int user) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - game::Scr_BeginLoadScripts(inst, user, Scr_BeginLoadScripts_hook.get_original()); + game::Scr_BeginLoadScripts(inst, user, Scr_BeginLoadScripts_original); #else codsrc::Scr_BeginLoadScripts(inst, user); #endif @@ -133,7 +147,7 @@ namespace re_cscr_main void Scr_BeginLoadAnimTrees_call(game::scriptInstance_t inst, int user, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - game::Scr_BeginLoadAnimTrees(inst, user, Scr_BeginLoadAnimTrees_hook.get_original()); + game::Scr_BeginLoadAnimTrees(inst, user, Scr_BeginLoadAnimTrees_original); #else codsrc::Scr_BeginLoadAnimTrees(inst, user); #endif @@ -155,7 +169,7 @@ namespace re_cscr_main int Scr_ScanFile_call(int max_size, [[maybe_unused]] void* caller_addr, char * buf) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - return game::Scr_ScanFile(max_size, buf, Scr_ScanFile_hook.get_original()); + return game::Scr_ScanFile(max_size, buf, Scr_ScanFile_original); #else return codsrc::Scr_ScanFile(max_size, buf); #endif @@ -185,7 +199,7 @@ namespace re_cscr_main unsigned int Scr_LoadScript_call(const char * file, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - return game::Scr_LoadScript(file, inst, Scr_LoadScript_hook.get_original()); + return game::Scr_LoadScript(file, inst, Scr_LoadScript_original); #else return codsrc::Scr_LoadScript(file, inst); #endif @@ -234,7 +248,7 @@ namespace re_cscr_main void Scr_FreeScripts_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MAIN_USE_WRAPPERS - game::Scr_FreeScripts(inst, Scr_FreeScripts_hook.get_original()); + game::Scr_FreeScripts(inst, Scr_FreeScripts_original); #else codsrc::Scr_FreeScripts(inst); #endif @@ -258,24 +272,34 @@ namespace re_cscr_main public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_MAIN_USE_WRAPPERS - quick = false; -#endif + Scr_IsIdentifier_hook.create(game::Scr_IsIdentifier_ADDR(), Scr_IsIdentifier_stub); + Scr_GetFunctionHandle_hook.create(game::Scr_GetFunctionHandle_ADDR(), Scr_GetFunctionHandle_stub); + SL_TransferToCanonicalString_hook.create(game::SL_TransferToCanonicalString_ADDR(), SL_TransferToCanonicalString_stub); + SL_GetCanonicalString_hook.create(game::SL_GetCanonicalString_ADDR(), SL_GetCanonicalString_stub); + Scr_BeginLoadScripts_hook.create(game::Scr_BeginLoadScripts_ADDR(), Scr_BeginLoadScripts_stub); + Scr_BeginLoadAnimTrees_hook.create(game::Scr_BeginLoadAnimTrees_ADDR(), Scr_BeginLoadAnimTrees_stub); + Scr_ScanFile_hook.create(game::Scr_ScanFile_ADDR(), Scr_ScanFile_stub); + Scr_LoadScriptInternal_hook.create(game::Scr_LoadScriptInternal.get(), Scr_LoadScriptInternal_stub); + Scr_LoadScript_hook.create(game::Scr_LoadScript_ADDR(), Scr_LoadScript_stub); + Scr_EndLoadScripts_hook.create(game::Scr_EndLoadScripts.get(), Scr_EndLoadScripts_stub); + Scr_PrecacheAnimTrees_hook.create(game::Scr_PrecacheAnimTrees.get(), Scr_PrecacheAnimTrees_stub); + Scr_EndLoadAnimTrees_hook.create(game::Scr_EndLoadAnimTrees.get(), Scr_EndLoadAnimTrees_stub); + Scr_FreeScripts_hook.create(game::Scr_FreeScripts_ADDR(), Scr_FreeScripts_stub); - Scr_IsIdentifier_hook.create(game::Scr_IsIdentifier_ADDR(), Scr_IsIdentifier_stub, quick); - Scr_GetFunctionHandle_hook.create(game::Scr_GetFunctionHandle_ADDR(), Scr_GetFunctionHandle_stub, quick); - SL_TransferToCanonicalString_hook.create(game::SL_TransferToCanonicalString_ADDR(), SL_TransferToCanonicalString_stub, quick); - SL_GetCanonicalString_hook.create(game::SL_GetCanonicalString_ADDR(), SL_GetCanonicalString_stub, quick); - Scr_BeginLoadScripts_hook.create(game::Scr_BeginLoadScripts_ADDR(), Scr_BeginLoadScripts_stub, quick); - Scr_BeginLoadAnimTrees_hook.create(game::Scr_BeginLoadAnimTrees_ADDR(), Scr_BeginLoadAnimTrees_stub, quick); - Scr_ScanFile_hook.create(game::Scr_ScanFile_ADDR(), Scr_ScanFile_stub, quick); - Scr_LoadScriptInternal_hook.create(game::Scr_LoadScriptInternal.get(), Scr_LoadScriptInternal_stub, quick); - Scr_LoadScript_hook.create(game::Scr_LoadScript_ADDR(), Scr_LoadScript_stub, quick); - Scr_EndLoadScripts_hook.create(game::Scr_EndLoadScripts.get(), Scr_EndLoadScripts_stub, quick); - Scr_PrecacheAnimTrees_hook.create(game::Scr_PrecacheAnimTrees.get(), Scr_PrecacheAnimTrees_stub, quick); - Scr_EndLoadAnimTrees_hook.create(game::Scr_EndLoadAnimTrees.get(), Scr_EndLoadAnimTrees_stub, quick); - Scr_FreeScripts_hook.create(game::Scr_FreeScripts_ADDR(), Scr_FreeScripts_stub, quick); + //Original hook function addresses + Scr_IsIdentifier_original = Scr_IsIdentifier_hook.get_original(); + Scr_GetFunctionHandle_original = Scr_GetFunctionHandle_hook.get_original(); + SL_TransferToCanonicalString_original = SL_TransferToCanonicalString_hook.get_original(); + SL_GetCanonicalString_original = SL_GetCanonicalString_hook.get_original(); + Scr_BeginLoadScripts_original = Scr_BeginLoadScripts_hook.get_original(); + Scr_BeginLoadAnimTrees_original = Scr_BeginLoadAnimTrees_hook.get_original(); + Scr_ScanFile_original = Scr_ScanFile_hook.get_original(); + Scr_LoadScriptInternal_original = Scr_LoadScriptInternal_hook.get_original(); + Scr_LoadScript_original = Scr_LoadScript_hook.get_original(); + Scr_EndLoadScripts_original = Scr_EndLoadScripts_hook.get_original(); + Scr_PrecacheAnimTrees_original = Scr_PrecacheAnimTrees_hook.get_original(); + Scr_EndLoadAnimTrees_original = Scr_EndLoadAnimTrees_hook.get_original(); + Scr_FreeScripts_original = Scr_FreeScripts_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_memorytree.cpp b/src/component/decomp/clientscript/re_cscr_memorytree.cpp index d9c82b2..1da5a77 100644 --- a/src/component/decomp/clientscript/re_cscr_memorytree.cpp +++ b/src/component/decomp/clientscript/re_cscr_memorytree.cpp @@ -21,6 +21,21 @@ namespace re_cscr_memorytree utils::hook::detour MT_Alloc_hook; utils::hook::detour MT_Free_hook; + void* MT_GetSubTreeSize_original; + void* MT_DumpTree_original; + void* MT_InitBits_original; + void* MT_GetScore_original; + void* MT_AddMemoryNode_original; + void* MT_RemoveMemoryNode_original; + void* MT_RemoveHeadMemoryNode_original; + void* MT_Init_original; + void* MT_Error_original; + void* MT_GetSize_original; + void* MT_AllocIndex_original; + void* MT_FreeIndex_original; + void* MT_Alloc_original; + void* MT_Free_original; + namespace { int MT_GetSubTreeSize_stub(game::scriptInstance_t inst, int nodeNum, [[maybe_unused]] void* caller_addr) @@ -44,7 +59,7 @@ namespace re_cscr_memorytree void MT_InitBits_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - game::MT_InitBits(a1, MT_InitBits_hook.get_original()); + game::MT_InitBits(a1, MT_InitBits_original); #else codsrc::MT_InitBits(a1); #endif @@ -65,7 +80,7 @@ namespace re_cscr_memorytree int MT_GetScore_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, int num) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - return game::MT_GetScore(a1, num, MT_GetScore_hook.get_original()); + return game::MT_GetScore(a1, num, MT_GetScore_original); #else return codsrc::MT_GetScore(a1, num); #endif @@ -114,7 +129,7 @@ namespace re_cscr_memorytree void MT_Init_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - game::MT_Init(a1, MT_Init_hook.get_original()); + game::MT_Init(a1, MT_Init_original); #else codsrc::MT_Init(a1); #endif @@ -135,7 +150,7 @@ namespace re_cscr_memorytree void MT_Error_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, const char* funcName, int numBytes) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - game::MT_Error(a1, funcName, numBytes, MT_Error_hook.get_original()); + game::MT_Error(a1, funcName, numBytes, MT_Error_original); #else codsrc::MT_Error(a1, funcName, numBytes); #endif @@ -156,7 +171,7 @@ namespace re_cscr_memorytree int MT_GetSize_call(int numBytes, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - return game::MT_GetSize(numBytes, inst, MT_GetSize_hook.get_original()); + return game::MT_GetSize(numBytes, inst, MT_GetSize_original); #else return codsrc::MT_GetSize(numBytes, inst); #endif @@ -178,7 +193,7 @@ namespace re_cscr_memorytree unsigned __int16 MT_AllocIndex_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int size_) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - return game::MT_AllocIndex(inst, size_, MT_AllocIndex_hook.get_original()); + return game::MT_AllocIndex(inst, size_, MT_AllocIndex_original); #else return codsrc::MT_AllocIndex(inst, size_); #endif @@ -199,7 +214,7 @@ namespace re_cscr_memorytree void MT_FreeIndex_call(int numBytes, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a1, int nodeNum) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - game::MT_FreeIndex(numBytes, a1, nodeNum, MT_FreeIndex_hook.get_original()); + game::MT_FreeIndex(numBytes, a1, nodeNum, MT_FreeIndex_original); #else codsrc::MT_FreeIndex(numBytes, a1, nodeNum); #endif @@ -220,7 +235,7 @@ namespace re_cscr_memorytree char* MT_Alloc_call(int numBytes, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - return game::MT_Alloc(numBytes, inst, MT_Alloc_hook.get_original()); + return game::MT_Alloc(numBytes, inst, MT_Alloc_original); #else return codsrc::MT_Alloc(numBytes, inst); #endif @@ -254,25 +269,36 @@ namespace re_cscr_memorytree public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_MEMORYTREE_USE_WRAPPERS - quick = false; -#endif + MT_GetSubTreeSize_hook.create(game::MT_GetSubTreeSize.get(), MT_GetSubTreeSize_stub); + MT_DumpTree_hook.create(game::MT_DumpTree.get(), MT_DumpTree_stub); + MT_InitBits_hook.create(game::MT_InitBits_ADDR(), MT_InitBits_stub); + MT_GetScore_hook.create(game::MT_GetScore_ADDR(), MT_GetScore_stub); + MT_AddMemoryNode_hook.create(game::MT_AddMemoryNode.get(), MT_AddMemoryNode_stub); + MT_RemoveMemoryNode_hook.create(game::MT_RemoveMemoryNode.get(), MT_RemoveMemoryNode_stub); + MT_RemoveHeadMemoryNode_hook.create(game::MT_RemoveHeadMemoryNode.get(), MT_RemoveHeadMemoryNode_stub); + MT_Init_hook.create(game::MT_Init_ADDR(), MT_Init_stub); + MT_Error_hook.create(game::MT_Error_ADDR(), MT_Error_stub); + MT_GetSize_hook.create(game::MT_GetSize_ADDR(), MT_GetSize_stub); + MT_AllocIndex_hook.create(game::MT_AllocIndex_ADDR(), MT_AllocIndex_stub); + MT_FreeIndex_hook.create(game::MT_FreeIndex_ADDR(), MT_FreeIndex_stub); + MT_Alloc_hook.create(game::MT_Alloc_ADDR(), MT_Alloc_stub); + MT_Free_hook.create(game::MT_Free.get(), MT_Free_stub); - MT_GetSubTreeSize_hook.create(game::MT_GetSubTreeSize.get(), MT_GetSubTreeSize_stub, quick); - MT_DumpTree_hook.create(game::MT_DumpTree.get(), MT_DumpTree_stub, quick); - MT_InitBits_hook.create(game::MT_InitBits_ADDR(), MT_InitBits_stub, quick); - MT_GetScore_hook.create(game::MT_GetScore_ADDR(), MT_GetScore_stub, quick); - MT_AddMemoryNode_hook.create(game::MT_AddMemoryNode.get(), MT_AddMemoryNode_stub, quick); - MT_RemoveMemoryNode_hook.create(game::MT_RemoveMemoryNode.get(), MT_RemoveMemoryNode_stub, quick); - MT_RemoveHeadMemoryNode_hook.create(game::MT_RemoveHeadMemoryNode.get(), MT_RemoveHeadMemoryNode_stub, quick); - MT_Init_hook.create(game::MT_Init_ADDR(), MT_Init_stub, quick); - MT_Error_hook.create(game::MT_Error_ADDR(), MT_Error_stub, quick); - MT_GetSize_hook.create(game::MT_GetSize_ADDR(), MT_GetSize_stub, quick); - MT_AllocIndex_hook.create(game::MT_AllocIndex_ADDR(), MT_AllocIndex_stub, quick); - MT_FreeIndex_hook.create(game::MT_FreeIndex_ADDR(), MT_FreeIndex_stub, quick); - MT_Alloc_hook.create(game::MT_Alloc_ADDR(), MT_Alloc_stub, quick); - MT_Free_hook.create(game::MT_Free.get(), MT_Free_stub, quick); + //Original hook function addresses + MT_GetSubTreeSize_original = MT_GetSubTreeSize_hook.get_original(); + MT_DumpTree_original = MT_DumpTree_hook.get_original(); + MT_InitBits_original = MT_InitBits_hook.get_original(); + MT_GetScore_original = MT_GetScore_hook.get_original(); + MT_AddMemoryNode_original = MT_AddMemoryNode_hook.get_original(); + MT_RemoveMemoryNode_original = MT_RemoveMemoryNode_hook.get_original(); + MT_RemoveHeadMemoryNode_original = MT_RemoveHeadMemoryNode_hook.get_original(); + MT_Init_original = MT_Init_hook.get_original(); + MT_Error_original = MT_Error_hook.get_original(); + MT_GetSize_original = MT_GetSize_hook.get_original(); + MT_AllocIndex_original = MT_AllocIndex_hook.get_original(); + MT_FreeIndex_original = MT_FreeIndex_hook.get_original(); + MT_Alloc_original = MT_Alloc_hook.get_original(); + MT_Free_original = MT_Free_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_parser.cpp b/src/component/decomp/clientscript/re_cscr_parser.cpp index 4dd100e..936133c 100644 --- a/src/component/decomp/clientscript/re_cscr_parser.cpp +++ b/src/component/decomp/clientscript/re_cscr_parser.cpp @@ -30,13 +30,37 @@ namespace re_cscr_parser utils::hook::detour RuntimeErrorInternal_hook; utils::hook::detour RuntimeError_hook; + void* Scr_InitOpcodeLookup_original; + void* Scr_ShutdownOpcodeLookup_original; + void* AddOpcodePos_original; + void* RemoveOpcodePos_original; + void* AddThreadStartOpcodePos_original; + void* Scr_GetSourceBuffer_original; + void* Scr_GetLineNumInternal_original; + void* Scr_GetNewSourceBuffer_original; + void* Scr_AddSourceBufferInternal_original; + void* Scr_ReadFile_FastFile_original; + void* Scr_ReadFile_LoadObj_original; + void* Scr_ReadFile_original; + void* Scr_AddSourceBuffer_original; + void* Scr_CopyFormattedLine_original; + void* Scr_GetLineInfo_original; + void* Scr_PrintSourcePos_original; + void* Scr_GetPrevSourcePosOpcodeLookup_original; + void* Scr_GetTextSourcePos_original; + void* Scr_PrintPrevCodePos_original; + void* CompileError_original; + void* CompileError2_original; + void* RuntimeErrorInternal_original; + void* RuntimeError_original; + namespace { void Scr_InitOpcodeLookup_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::Scr_InitOpcodeLookup(a1, Scr_InitOpcodeLookup_hook.get_original()); + game::Scr_InitOpcodeLookup(a1, Scr_InitOpcodeLookup_original); #else codsrc::Scr_InitOpcodeLookup(a1); #endif @@ -57,7 +81,7 @@ namespace re_cscr_parser void Scr_ShutdownOpcodeLookup_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::Scr_ShutdownOpcodeLookup(a1, Scr_ShutdownOpcodeLookup_hook.get_original()); + game::Scr_ShutdownOpcodeLookup(a1, Scr_ShutdownOpcodeLookup_original); #else codsrc::Scr_ShutdownOpcodeLookup(a1); #endif @@ -78,7 +102,7 @@ namespace re_cscr_parser void AddOpcodePos_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int sourcePos, int type_) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::AddOpcodePos(a1, sourcePos, type_, AddOpcodePos_hook.get_original()); + game::AddOpcodePos(a1, sourcePos, type_, AddOpcodePos_original); #else codsrc::AddOpcodePos(a1, sourcePos, type_); #endif @@ -99,7 +123,7 @@ namespace re_cscr_parser void RemoveOpcodePos_call(game::scriptInstance_t result, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::RemoveOpcodePos(result, RemoveOpcodePos_hook.get_original()); + game::RemoveOpcodePos(result, RemoveOpcodePos_original); #else codsrc::RemoveOpcodePos(result); #endif @@ -120,7 +144,7 @@ namespace re_cscr_parser void AddThreadStartOpcodePos_call(game::scriptInstance_t result, [[maybe_unused]] void* caller_addr, unsigned int sourcePos) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::AddThreadStartOpcodePos(result, sourcePos, AddThreadStartOpcodePos_hook.get_original()); + game::AddThreadStartOpcodePos(result, sourcePos, AddThreadStartOpcodePos_original); #else codsrc::AddThreadStartOpcodePos(result, sourcePos); #endif @@ -141,7 +165,7 @@ namespace re_cscr_parser unsigned int Scr_GetSourceBuffer_call(game::scriptInstance_t a1, const char * codePos, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - return game::Scr_GetSourceBuffer(a1, codePos, Scr_GetSourceBuffer_hook.get_original()); + return game::Scr_GetSourceBuffer(a1, codePos, Scr_GetSourceBuffer_original); #else return codsrc::Scr_GetSourceBuffer(a1, codePos); #endif @@ -163,7 +187,7 @@ namespace re_cscr_parser unsigned int Scr_GetLineNumInternal_call(const char ** startLine, const char * buf, [[maybe_unused]] void* caller_addr, const char * sourcePos, int * col) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - return game::Scr_GetLineNumInternal(startLine, buf, sourcePos, col, Scr_GetLineNumInternal_hook.get_original()); + return game::Scr_GetLineNumInternal(startLine, buf, sourcePos, col, Scr_GetLineNumInternal_original); #else return codsrc::Scr_GetLineNumInternal(startLine, buf, sourcePos, col); #endif @@ -185,7 +209,7 @@ namespace re_cscr_parser game::SourceBufferInfo * Scr_GetNewSourceBuffer_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - return game::Scr_GetNewSourceBuffer(a1, Scr_GetNewSourceBuffer_hook.get_original()); + return game::Scr_GetNewSourceBuffer(a1, Scr_GetNewSourceBuffer_original); #else return codsrc::Scr_GetNewSourceBuffer(a1); #endif @@ -206,7 +230,7 @@ namespace re_cscr_parser void Scr_AddSourceBufferInternal_call(const char * filename, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, const char * codepos, char * buffer, int len, int archive) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::Scr_AddSourceBufferInternal(filename, inst, codepos, buffer, len, archive, Scr_AddSourceBufferInternal_hook.get_original()); + game::Scr_AddSourceBufferInternal(filename, inst, codepos, buffer, len, archive, Scr_AddSourceBufferInternal_original); #else codsrc::Scr_AddSourceBufferInternal(filename, inst, codepos, buffer, len, archive); #endif @@ -245,7 +269,7 @@ namespace re_cscr_parser char * Scr_ReadFile_call(const char * codepos, char * filename, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, int unused) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - return game::Scr_ReadFile(codepos, filename, inst, unused, Scr_ReadFile_hook.get_original()); + return game::Scr_ReadFile(codepos, filename, inst, unused, Scr_ReadFile_original); #else return codsrc::Scr_ReadFile(codepos, filename, inst, unused); #endif @@ -267,7 +291,7 @@ namespace re_cscr_parser char * Scr_AddSourceBuffer_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int unused_arg1, char * filename, const char * codepos) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - return game::Scr_AddSourceBuffer(inst, unused_arg1, filename, codepos, Scr_AddSourceBuffer_hook.get_original()); + return game::Scr_AddSourceBuffer(inst, unused_arg1, filename, codepos, Scr_AddSourceBuffer_original); #else return codsrc::Scr_AddSourceBuffer(inst, unused_arg1, filename, codepos); #endif @@ -288,7 +312,7 @@ namespace re_cscr_parser void Scr_CopyFormattedLine_call(const char * rawLine, [[maybe_unused]] void* caller_addr, char * line) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::Scr_CopyFormattedLine(rawLine, line, Scr_CopyFormattedLine_hook.get_original()); + game::Scr_CopyFormattedLine(rawLine, line, Scr_CopyFormattedLine_original); #else codsrc::Scr_CopyFormattedLine(rawLine, line); #endif @@ -309,7 +333,7 @@ namespace re_cscr_parser unsigned int Scr_GetLineInfo_call(int * col, const char * buf, [[maybe_unused]] void* caller_addr, unsigned int sourcePos, char * line) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - return game::Scr_GetLineInfo(col, buf, sourcePos, line, Scr_GetLineInfo_hook.get_original()); + return game::Scr_GetLineInfo(col, buf, sourcePos, line, Scr_GetLineInfo_original); #else return codsrc::Scr_GetLineInfo(col, buf, sourcePos, line); #endif @@ -331,7 +355,7 @@ namespace re_cscr_parser void Scr_PrintSourcePos_call(unsigned int sourcePos, const char * buf, game::con_channel_e channel, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a4, const char * file) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::Scr_PrintSourcePos(sourcePos, buf, channel, a4, file, Scr_PrintSourcePos_hook.get_original()); + game::Scr_PrintSourcePos(sourcePos, buf, channel, a4, file, Scr_PrintSourcePos_original); #else codsrc::Scr_PrintSourcePos(sourcePos, buf, channel, a4, file); #endif @@ -354,7 +378,7 @@ namespace re_cscr_parser game::OpcodeLookup * Scr_GetPrevSourcePosOpcodeLookup_call(game::scriptInstance_t a1, const char * codePos, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - return game::Scr_GetPrevSourcePosOpcodeLookup(a1, codePos, Scr_GetPrevSourcePosOpcodeLookup_hook.get_original()); + return game::Scr_GetPrevSourcePosOpcodeLookup(a1, codePos, Scr_GetPrevSourcePosOpcodeLookup_original); #else return codsrc::Scr_GetPrevSourcePosOpcodeLookup(a1, codePos); #endif @@ -376,7 +400,7 @@ namespace re_cscr_parser void Scr_GetTextSourcePos_call(char * line, const char * codePos, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::Scr_GetTextSourcePos(line, codePos, a3, Scr_GetTextSourcePos_hook.get_original()); + game::Scr_GetTextSourcePos(line, codePos, a3, Scr_GetTextSourcePos_original); #else codsrc::Scr_GetTextSourcePos(line, codePos, a3); #endif @@ -398,7 +422,7 @@ namespace re_cscr_parser void Scr_PrintPrevCodePos_call(const char * codepos, [[maybe_unused]] void* caller_addr, game::scriptInstance_t scriptInstance, game::con_channel_e channel, unsigned int index) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::Scr_PrintPrevCodePos(codepos, scriptInstance, channel, index, Scr_PrintPrevCodePos_hook.get_original()); + game::Scr_PrintPrevCodePos(codepos, scriptInstance, channel, index, Scr_PrintPrevCodePos_original); #else codsrc::Scr_PrintPrevCodePos(codepos, scriptInstance, channel, index); #endif @@ -440,7 +464,7 @@ namespace re_cscr_parser _vsnprintf(Buffer, 0x400u, msg, ArgList); va_end(ArgList); #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::CompileError2(codePos, a2, CompileError2_hook.get_original(), "%s", Buffer); + game::CompileError2(codePos, a2, CompileError2_original, "%s", Buffer); #else codsrc::CompileError2(codePos, a2, "%s", Buffer); #endif @@ -463,7 +487,7 @@ namespace re_cscr_parser void RuntimeErrorInternal_call(const char * msg, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::con_channel_e channel, const char * codepos, int index) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::RuntimeErrorInternal(msg, inst, channel, codepos, index, RuntimeErrorInternal_hook.get_original()); + game::RuntimeErrorInternal(msg, inst, channel, codepos, index, RuntimeErrorInternal_original); #else codsrc::RuntimeErrorInternal(msg, inst, channel, codepos, index); #endif @@ -485,7 +509,7 @@ namespace re_cscr_parser void RuntimeError_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, const char * pos, int error_index, const char * err, const char * err2) { #ifdef RE_CSCR_PARSER_USE_WRAPPERS - game::RuntimeError(inst, pos, error_index, err, err2, RuntimeError_hook.get_original()); + game::RuntimeError(inst, pos, error_index, err, err2, RuntimeError_original); #else codsrc::RuntimeError(inst, pos, error_index, err, err2); #endif @@ -509,34 +533,54 @@ namespace re_cscr_parser public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_PARSER_USE_WRAPPERS - quick = false; -#endif + Scr_InitOpcodeLookup_hook.create(game::Scr_InitOpcodeLookup_ADDR(), Scr_InitOpcodeLookup_stub); + Scr_ShutdownOpcodeLookup_hook.create(game::Scr_ShutdownOpcodeLookup_ADDR(), Scr_ShutdownOpcodeLookup_stub); + AddOpcodePos_hook.create(game::AddOpcodePos_ADDR(), AddOpcodePos_stub); + RemoveOpcodePos_hook.create(game::RemoveOpcodePos_ADDR(), RemoveOpcodePos_stub); + AddThreadStartOpcodePos_hook.create(game::AddThreadStartOpcodePos_ADDR(), AddThreadStartOpcodePos_stub); + Scr_GetSourceBuffer_hook.create(game::Scr_GetSourceBuffer_ADDR(), Scr_GetSourceBuffer_stub); + Scr_GetLineNumInternal_hook.create(game::Scr_GetLineNumInternal_ADDR(), Scr_GetLineNumInternal_stub); + Scr_GetNewSourceBuffer_hook.create(game::Scr_GetNewSourceBuffer_ADDR(), Scr_GetNewSourceBuffer_stub); + Scr_AddSourceBufferInternal_hook.create(game::Scr_AddSourceBufferInternal_ADDR(), Scr_AddSourceBufferInternal_stub); + Scr_ReadFile_FastFile_hook.create(game::Scr_ReadFile_FastFile.get(), Scr_ReadFile_FastFile_stub); + Scr_ReadFile_LoadObj_hook.create(game::Scr_ReadFile_LoadObj.get(), Scr_ReadFile_LoadObj_stub); + Scr_ReadFile_hook.create(game::Scr_ReadFile_ADDR(), Scr_ReadFile_stub); + Scr_AddSourceBuffer_hook.create(game::Scr_AddSourceBuffer_ADDR(), Scr_AddSourceBuffer_stub); + Scr_CopyFormattedLine_hook.create(game::Scr_CopyFormattedLine_ADDR(), Scr_CopyFormattedLine_stub); + Scr_GetLineInfo_hook.create(game::Scr_GetLineInfo_ADDR(), Scr_GetLineInfo_stub); + Scr_PrintSourcePos_hook.create(game::Scr_PrintSourcePos_ADDR(), Scr_PrintSourcePos_stub); + Scr_GetPrevSourcePosOpcodeLookup_hook.create(game::Scr_GetPrevSourcePosOpcodeLookup_ADDR(), Scr_GetPrevSourcePosOpcodeLookup_stub); + Scr_GetTextSourcePos_hook.create(game::Scr_GetTextSourcePos_ADDR(), Scr_GetTextSourcePos_stub); + Scr_PrintPrevCodePos_hook.create(game::Scr_PrintPrevCodePos_ADDR(), Scr_PrintPrevCodePos_stub); + CompileError_hook.create(game::CompileError.get(), CompileError_stub); + CompileError2_hook.create(game::CompileError2_ADDR(), CompileError2_stub); + RuntimeErrorInternal_hook.create(game::RuntimeErrorInternal_ADDR(), RuntimeErrorInternal_stub); + RuntimeError_hook.create(game::RuntimeError_ADDR(), RuntimeError_stub); - Scr_InitOpcodeLookup_hook.create(game::Scr_InitOpcodeLookup_ADDR(), Scr_InitOpcodeLookup_stub, quick); - Scr_ShutdownOpcodeLookup_hook.create(game::Scr_ShutdownOpcodeLookup_ADDR(), Scr_ShutdownOpcodeLookup_stub, quick); - AddOpcodePos_hook.create(game::AddOpcodePos_ADDR(), AddOpcodePos_stub, quick); - RemoveOpcodePos_hook.create(game::RemoveOpcodePos_ADDR(), RemoveOpcodePos_stub, quick); - AddThreadStartOpcodePos_hook.create(game::AddThreadStartOpcodePos_ADDR(), AddThreadStartOpcodePos_stub, quick); - Scr_GetSourceBuffer_hook.create(game::Scr_GetSourceBuffer_ADDR(), Scr_GetSourceBuffer_stub, quick); - Scr_GetLineNumInternal_hook.create(game::Scr_GetLineNumInternal_ADDR(), Scr_GetLineNumInternal_stub, quick); - Scr_GetNewSourceBuffer_hook.create(game::Scr_GetNewSourceBuffer_ADDR(), Scr_GetNewSourceBuffer_stub, quick); - Scr_AddSourceBufferInternal_hook.create(game::Scr_AddSourceBufferInternal_ADDR(), Scr_AddSourceBufferInternal_stub, quick); - Scr_ReadFile_FastFile_hook.create(game::Scr_ReadFile_FastFile.get(), Scr_ReadFile_FastFile_stub, quick); - Scr_ReadFile_LoadObj_hook.create(game::Scr_ReadFile_LoadObj.get(), Scr_ReadFile_LoadObj_stub, quick); - Scr_ReadFile_hook.create(game::Scr_ReadFile_ADDR(), Scr_ReadFile_stub, quick); - Scr_AddSourceBuffer_hook.create(game::Scr_AddSourceBuffer_ADDR(), Scr_AddSourceBuffer_stub, quick); - Scr_CopyFormattedLine_hook.create(game::Scr_CopyFormattedLine_ADDR(), Scr_CopyFormattedLine_stub, quick); - Scr_GetLineInfo_hook.create(game::Scr_GetLineInfo_ADDR(), Scr_GetLineInfo_stub, quick); - Scr_PrintSourcePos_hook.create(game::Scr_PrintSourcePos_ADDR(), Scr_PrintSourcePos_stub, quick); - Scr_GetPrevSourcePosOpcodeLookup_hook.create(game::Scr_GetPrevSourcePosOpcodeLookup_ADDR(), Scr_GetPrevSourcePosOpcodeLookup_stub, quick); - Scr_GetTextSourcePos_hook.create(game::Scr_GetTextSourcePos_ADDR(), Scr_GetTextSourcePos_stub, quick); - Scr_PrintPrevCodePos_hook.create(game::Scr_PrintPrevCodePos_ADDR(), Scr_PrintPrevCodePos_stub, quick); - CompileError_hook.create(game::CompileError.get(), CompileError_stub, quick); - CompileError2_hook.create(game::CompileError2_ADDR(), CompileError2_stub, quick); - RuntimeErrorInternal_hook.create(game::RuntimeErrorInternal_ADDR(), RuntimeErrorInternal_stub, quick); - RuntimeError_hook.create(game::RuntimeError_ADDR(), RuntimeError_stub, quick); + //Original hook function addresses + Scr_InitOpcodeLookup_original = Scr_InitOpcodeLookup_hook.get_original(); + Scr_ShutdownOpcodeLookup_original = Scr_ShutdownOpcodeLookup_hook.get_original(); + AddOpcodePos_original = AddOpcodePos_hook.get_original(); + RemoveOpcodePos_original = RemoveOpcodePos_hook.get_original(); + AddThreadStartOpcodePos_original = AddThreadStartOpcodePos_hook.get_original(); + Scr_GetSourceBuffer_original = Scr_GetSourceBuffer_hook.get_original(); + Scr_GetLineNumInternal_original = Scr_GetLineNumInternal_hook.get_original(); + Scr_GetNewSourceBuffer_original = Scr_GetNewSourceBuffer_hook.get_original(); + Scr_AddSourceBufferInternal_original = Scr_AddSourceBufferInternal_hook.get_original(); + Scr_ReadFile_FastFile_original = Scr_ReadFile_FastFile_hook.get_original(); + Scr_ReadFile_LoadObj_original = Scr_ReadFile_LoadObj_hook.get_original(); + Scr_ReadFile_original = Scr_ReadFile_hook.get_original(); + Scr_AddSourceBuffer_original = Scr_AddSourceBuffer_hook.get_original(); + Scr_CopyFormattedLine_original = Scr_CopyFormattedLine_hook.get_original(); + Scr_GetLineInfo_original = Scr_GetLineInfo_hook.get_original(); + Scr_PrintSourcePos_original = Scr_PrintSourcePos_hook.get_original(); + Scr_GetPrevSourcePosOpcodeLookup_original = Scr_GetPrevSourcePosOpcodeLookup_hook.get_original(); + Scr_GetTextSourcePos_original = Scr_GetTextSourcePos_hook.get_original(); + Scr_PrintPrevCodePos_original = Scr_PrintPrevCodePos_hook.get_original(); + CompileError_original = CompileError_hook.get_original(); + CompileError2_original = CompileError2_hook.get_original(); + RuntimeErrorInternal_original = RuntimeErrorInternal_hook.get_original(); + RuntimeError_original = RuntimeError_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_parsetree.cpp b/src/component/decomp/clientscript/re_cscr_parsetree.cpp index 4b27926..c636b74 100644 --- a/src/component/decomp/clientscript/re_cscr_parsetree.cpp +++ b/src/component/decomp/clientscript/re_cscr_parsetree.cpp @@ -20,6 +20,20 @@ namespace re_cscr_parsetree utils::hook::detour prepend_node_hook; utils::hook::detour append_node_hook; + void* Scr_InitAllocNode_original; + void* node0_original; + void* node1_original; + void* node2_original; + void* node3_original; + void* node4_original; + void* node5_original; + void* node6_original; + void* node7_original; + void* node8_original; + void* linked_list_end_original; + void* prepend_node_original; + void* append_node_original; + namespace { @@ -146,24 +160,34 @@ namespace re_cscr_parsetree public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_PARSETREE_USE_WRAPPERS - quick = false; -#endif + Scr_InitAllocNode_hook.create(game::Scr_InitAllocNode.get(), Scr_InitAllocNode_stub); + node0_hook.create(game::node0.get(), node0_stub); + node1_hook.create(game::node1.get(), node1_stub); + node2_hook.create(game::node2.get(), node2_stub); + node3_hook.create(game::node3.get(), node3_stub); + node4_hook.create(game::node4.get(), node4_stub); + node5_hook.create(game::node5.get(), node5_stub); + node6_hook.create(game::node6.get(), node6_stub); + node7_hook.create(game::node7.get(), node7_stub); + node8_hook.create(game::node8.get(), node8_stub); + linked_list_end_hook.create(game::linked_list_end.get(), linked_list_end_stub); + prepend_node_hook.create(game::prepend_node.get(), prepend_node_stub); + append_node_hook.create(game::append_node.get(), append_node_stub); - Scr_InitAllocNode_hook.create(game::Scr_InitAllocNode.get(), Scr_InitAllocNode_stub, quick); - node0_hook.create(game::node0.get(), node0_stub, quick); - node1_hook.create(game::node1.get(), node1_stub, quick); - node2_hook.create(game::node2.get(), node2_stub, quick); - node3_hook.create(game::node3.get(), node3_stub, quick); - node4_hook.create(game::node4.get(), node4_stub, quick); - node5_hook.create(game::node5.get(), node5_stub, quick); - node6_hook.create(game::node6.get(), node6_stub, quick); - node7_hook.create(game::node7.get(), node7_stub, quick); - node8_hook.create(game::node8.get(), node8_stub, quick); - linked_list_end_hook.create(game::linked_list_end.get(), linked_list_end_stub, quick); - prepend_node_hook.create(game::prepend_node.get(), prepend_node_stub, quick); - append_node_hook.create(game::append_node.get(), append_node_stub, quick); + //Original hook function addresses + Scr_InitAllocNode_original = Scr_InitAllocNode_hook.get_original(); + node0_original = node0_hook.get_original(); + node1_original = node1_hook.get_original(); + node2_original = node2_hook.get_original(); + node3_original = node3_hook.get_original(); + node4_original = node4_hook.get_original(); + node5_original = node5_hook.get_original(); + node6_original = node6_hook.get_original(); + node7_original = node7_hook.get_original(); + node8_original = node8_hook.get_original(); + linked_list_end_original = linked_list_end_hook.get_original(); + prepend_node_original = prepend_node_hook.get_original(); + append_node_original = append_node_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_readwrite.cpp b/src/component/decomp/clientscript/re_cscr_readwrite.cpp index 7b674d7..021a83d 100644 --- a/src/component/decomp/clientscript/re_cscr_readwrite.cpp +++ b/src/component/decomp/clientscript/re_cscr_readwrite.cpp @@ -9,13 +9,16 @@ namespace re_cscr_readwrite utils::hook::detour FindVariableIndexInternal2_hook; utils::hook::detour FindLastSibling_hook; + void* FindVariableIndexInternal2_original; + void* FindLastSibling_original; + namespace { unsigned int FindVariableIndexInternal2_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int name, unsigned int index) { #ifdef RE_CSCR_READWRITE_USE_WRAPPERS - return game::FindVariableIndexInternal2(inst, name, index, FindVariableIndexInternal2_hook.get_original()); + return game::FindVariableIndexInternal2(inst, name, index, FindVariableIndexInternal2_original); #else return codsrc::FindVariableIndexInternal2(inst, name, index); #endif @@ -36,7 +39,7 @@ namespace re_cscr_readwrite unsigned int FindLastSibling_call(unsigned int parentId, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_READWRITE_USE_WRAPPERS - return game::FindLastSibling(parentId, inst, FindLastSibling_hook.get_original()); + return game::FindLastSibling(parentId, inst, FindLastSibling_original); #else return codsrc::FindLastSibling(parentId, inst); #endif @@ -61,13 +64,12 @@ namespace re_cscr_readwrite public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_READWRITE_USE_WRAPPERS - quick = false; -#endif + FindVariableIndexInternal2_hook.create(game::FindVariableIndexInternal2_ADDR(), FindVariableIndexInternal2_stub); + FindLastSibling_hook.create(game::FindLastSibling_ADDR(), FindLastSibling_stub); - FindVariableIndexInternal2_hook.create(game::FindVariableIndexInternal2_ADDR(), FindVariableIndexInternal2_stub, quick); - FindLastSibling_hook.create(game::FindLastSibling_ADDR(), FindLastSibling_stub, quick); + //Original hook function addresses + FindVariableIndexInternal2_original = FindVariableIndexInternal2_hook.get_original(); + FindLastSibling_original = FindLastSibling_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_stringlist.cpp b/src/component/decomp/clientscript/re_cscr_stringlist.cpp index 53da4a2..3d43ffb 100644 --- a/src/component/decomp/clientscript/re_cscr_stringlist.cpp +++ b/src/component/decomp/clientscript/re_cscr_stringlist.cpp @@ -35,13 +35,42 @@ namespace re_cscr_stringlist utils::hook::detour SL_CreateCanonicalFilename_hook; utils::hook::detour Scr_CreateCanonicalFilename_hook; + void* SL_ConvertToString_original; + void* SL_GetStringLen_original; + void* GetHashCode_original; + void* SL_Init_original; + void* SL_FindStringOfSize_original; + void* SL_FindString_original; + void* SL_FindLowercaseString_original; + void* SL_AddUserInternal_original; + void* Mark_ScriptStringCustom_original; + void* SL_GetStringOfSize_original; + void* SL_GetString__original; + void* SL_GetString__0_original; + void* SL_GetLowercaseStringOfLen_original; + void* SL_GetLowercaseString_original; + void* SL_ConvertToLowercase_original; + void* SL_TransferRefToUser_original; + void* SL_FreeString_original; + void* SL_RemoveRefToString_original; + void* Scr_SetString_original; + void* Scr_SetStringFromCharString_original; + void* GScr_AllocString_original; + void* SL_GetStringForFloat_original; + void* SL_GetStringForInt_original; + void* SL_GetStringForVector_original; + void* SL_ShutdownSystem_original; + void* SL_TransferSystem_original; + void* SL_CreateCanonicalFilename_original; + void* Scr_CreateCanonicalFilename_original; + namespace { char* SL_ConvertToString_call(unsigned int id, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_ConvertToString(id, inst, SL_ConvertToString_hook.get_original()); + return game::SL_ConvertToString(id, inst, SL_ConvertToString_original); #else return codsrc::SL_ConvertToString(id, inst); #endif @@ -63,7 +92,7 @@ namespace re_cscr_stringlist int SL_GetStringLen_call(unsigned int a1, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_GetStringLen(a1, a2, SL_GetStringLen_hook.get_original()); + return game::SL_GetStringLen(a1, a2, SL_GetStringLen_original); #else return codsrc::SL_GetStringLen(a1, a2); #endif @@ -85,7 +114,7 @@ namespace re_cscr_stringlist unsigned int GetHashCode_call(unsigned int a1, const char* a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::GetHashCode(a1, a2, GetHashCode_hook.get_original()); + return game::GetHashCode(a1, a2, GetHashCode_original); #else return codsrc::GetHashCode(a1, a2); #endif @@ -107,7 +136,7 @@ namespace re_cscr_stringlist void SL_Init_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::SL_Init(a1, SL_Init_hook.get_original()); + game::SL_Init(a1, SL_Init_original); #else codsrc::SL_Init(a1); #endif @@ -128,7 +157,7 @@ namespace re_cscr_stringlist unsigned int SL_FindStringOfSize_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, const char* str_, unsigned int len) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_FindStringOfSize(inst, str_, len, SL_FindStringOfSize_hook.get_original()); + return game::SL_FindStringOfSize(inst, str_, len, SL_FindStringOfSize_original); #else return codsrc::SL_FindStringOfSize(inst, str_, len); #endif @@ -149,7 +178,7 @@ namespace re_cscr_stringlist unsigned int SL_FindString_call(const char* a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_FindString(a1, a2, SL_FindString_hook.get_original()); + return game::SL_FindString(a1, a2, SL_FindString_original); #else return codsrc::SL_FindString(a1, a2); #endif @@ -179,7 +208,7 @@ namespace re_cscr_stringlist void SL_AddUserInternal_call(unsigned int user, game::RefString* refStr, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::SL_AddUserInternal(user, refStr, SL_AddUserInternal_hook.get_original()); + game::SL_AddUserInternal(user, refStr, SL_AddUserInternal_original); #else codsrc::SL_AddUserInternal(user, refStr); #endif @@ -201,7 +230,7 @@ namespace re_cscr_stringlist void Mark_ScriptStringCustom_call(unsigned int a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::Mark_ScriptStringCustom(a1, Mark_ScriptStringCustom_hook.get_original()); + game::Mark_ScriptStringCustom(a1, Mark_ScriptStringCustom_original); #else codsrc::Mark_ScriptStringCustom(a1); #endif @@ -231,7 +260,7 @@ namespace re_cscr_stringlist unsigned int SL_GetString__call(const char* a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2, unsigned int user) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_GetString_(a1, a2, user, SL_GetString__hook.get_original()); + return game::SL_GetString_(a1, a2, user, SL_GetString__original); #else return codsrc::SL_GetString_(a1, a2, user); #endif @@ -252,7 +281,7 @@ namespace re_cscr_stringlist unsigned int SL_GetString__0_call(const char* a1, [[maybe_unused]] void* caller_addr, unsigned int user, game::scriptInstance_t a3) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_GetString__0(a1, user, a3, SL_GetString__0_hook.get_original()); + return game::SL_GetString__0(a1, user, a3, SL_GetString__0_original); #else return codsrc::SL_GetString__0(a1, user, a3); #endif @@ -282,7 +311,7 @@ namespace re_cscr_stringlist unsigned int SL_GetLowercaseString_call(const char* a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_GetLowercaseString(a2, SL_GetLowercaseString_hook.get_original()); + return game::SL_GetLowercaseString(a2, SL_GetLowercaseString_original); #else return codsrc::SL_GetLowercaseString(a2); #endif @@ -312,7 +341,7 @@ namespace re_cscr_stringlist void SL_TransferRefToUser_call(unsigned int stringValue, unsigned int user, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::SL_TransferRefToUser(stringValue, user, inst, SL_TransferRefToUser_hook.get_original()); + game::SL_TransferRefToUser(stringValue, user, inst, SL_TransferRefToUser_original); #else codsrc::SL_TransferRefToUser(stringValue, user, inst); #endif @@ -343,7 +372,7 @@ namespace re_cscr_stringlist void SL_RemoveRefToString_call(unsigned int stringVal, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::SL_RemoveRefToString(stringVal, inst, SL_RemoveRefToString_hook.get_original()); + game::SL_RemoveRefToString(stringVal, inst, SL_RemoveRefToString_original); #else codsrc::SL_RemoveRefToString(stringVal, inst); #endif @@ -365,7 +394,7 @@ namespace re_cscr_stringlist void Scr_SetString_call(game::scriptInstance_t inst, unsigned int from, [[maybe_unused]] void* caller_addr, unsigned __int16* to) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::Scr_SetString(inst, from, to, Scr_SetString_hook.get_original()); + game::Scr_SetString(inst, from, to, Scr_SetString_original); #else codsrc::Scr_SetString(inst, from, to); #endif @@ -387,7 +416,7 @@ namespace re_cscr_stringlist void Scr_SetStringFromCharString_call(const char* a1, [[maybe_unused]] void* caller_addr, unsigned __int16* a2) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::Scr_SetStringFromCharString(a1, a2, Scr_SetStringFromCharString_hook.get_original()); + game::Scr_SetStringFromCharString(a1, a2, Scr_SetStringFromCharString_original); #else codsrc::Scr_SetStringFromCharString(a1, a2); #endif @@ -408,7 +437,7 @@ namespace re_cscr_stringlist unsigned int GScr_AllocString_call(const char* a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::GScr_AllocString(a1, inst, GScr_AllocString_hook.get_original()); + return game::GScr_AllocString(a1, inst, GScr_AllocString_original); #else return codsrc::GScr_AllocString(a1, inst); #endif @@ -429,7 +458,7 @@ namespace re_cscr_stringlist unsigned int SL_GetStringForFloat_call(float a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_GetStringForFloat(a1, a2, SL_GetStringForFloat_hook.get_original()); + return game::SL_GetStringForFloat(a1, a2, SL_GetStringForFloat_original); #else return codsrc::SL_GetStringForFloat(a1, a2); #endif @@ -451,7 +480,7 @@ namespace re_cscr_stringlist unsigned int SL_GetStringForInt_call(int a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_GetStringForInt(a1, a2, SL_GetStringForInt_hook.get_original()); + return game::SL_GetStringForInt(a1, a2, SL_GetStringForInt_original); #else return codsrc::SL_GetStringForInt(a1, a2); #endif @@ -472,7 +501,7 @@ namespace re_cscr_stringlist unsigned int SL_GetStringForVector_call(float* a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - return game::SL_GetStringForVector(a1, a2, SL_GetStringForVector_hook.get_original()); + return game::SL_GetStringForVector(a1, a2, SL_GetStringForVector_original); #else return codsrc::SL_GetStringForVector(a1, a2); #endif @@ -493,7 +522,7 @@ namespace re_cscr_stringlist void SL_ShutdownSystem_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::SL_ShutdownSystem(a1, a2, SL_ShutdownSystem_hook.get_original()); + game::SL_ShutdownSystem(a1, a2, SL_ShutdownSystem_original); #else codsrc::SL_ShutdownSystem(a1, a2); #endif @@ -523,7 +552,7 @@ namespace re_cscr_stringlist void SL_CreateCanonicalFilename_call(const char* filename, [[maybe_unused]] void* caller_addr, char* newFilename) { #ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - game::SL_CreateCanonicalFilename(filename, newFilename, SL_CreateCanonicalFilename_hook.get_original()); + game::SL_CreateCanonicalFilename(filename, newFilename, SL_CreateCanonicalFilename_original); #else codsrc::SL_CreateCanonicalFilename(filename, newFilename); #endif @@ -556,39 +585,64 @@ namespace re_cscr_stringlist public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_STRINGLIST_USE_WRAPPERS - quick = false; -#endif + SL_ConvertToString_hook.create(game::SL_ConvertToString_ADDR(), SL_ConvertToString_stub); + SL_GetStringLen_hook.create(game::SL_GetStringLen_ADDR(), SL_GetStringLen_stub); + GetHashCode_hook.create(game::GetHashCode_ADDR(), GetHashCode_stub); + SL_Init_hook.create(game::SL_Init_ADDR(), SL_Init_stub); + SL_FindStringOfSize_hook.create(game::SL_FindStringOfSize_ADDR(), SL_FindStringOfSize_stub); + SL_FindString_hook.create(game::SL_FindString_ADDR(), SL_FindString_stub); + SL_FindLowercaseString_hook.create(game::SL_FindLowercaseString.get(), SL_FindLowercaseString_stub); + SL_AddUserInternal_hook.create(game::SL_AddUserInternal_ADDR(), SL_AddUserInternal_stub); + Mark_ScriptStringCustom_hook.create(game::Mark_ScriptStringCustom_ADDR(), Mark_ScriptStringCustom_stub); + SL_GetStringOfSize_hook.create(game::SL_GetStringOfSize.get(), SL_GetStringOfSize_stub); + SL_GetString__hook.create(game::SL_GetString__ADDR(), SL_GetString__stub); + SL_GetString__0_hook.create(game::SL_GetString__0_ADDR(), SL_GetString__0_stub); + SL_GetLowercaseStringOfLen_hook.create(game::SL_GetLowercaseStringOfLen.get(), SL_GetLowercaseStringOfLen_stub); + SL_GetLowercaseString_hook.create(game::SL_GetLowercaseString_ADDR(), SL_GetLowercaseString_stub); + SL_ConvertToLowercase_hook.create(game::SL_ConvertToLowercase.get(), SL_ConvertToLowercase_stub); + SL_TransferRefToUser_hook.create(game::SL_TransferRefToUser_ADDR(), SL_TransferRefToUser_stub); + SL_FreeString_hook.create(game::SL_FreeString.get(), SL_FreeString_stub); + SL_RemoveRefToString_hook.create(game::SL_RemoveRefToString_ADDR(), SL_RemoveRefToString_stub); + Scr_SetString_hook.create(game::Scr_SetString_ADDR(), Scr_SetString_stub); + Scr_SetStringFromCharString_hook.create(game::Scr_SetStringFromCharString_ADDR(), Scr_SetStringFromCharString_stub); + GScr_AllocString_hook.create(game::GScr_AllocString_ADDR(), GScr_AllocString_stub); + SL_GetStringForFloat_hook.create(game::SL_GetStringForFloat_ADDR(), SL_GetStringForFloat_stub); + SL_GetStringForInt_hook.create(game::SL_GetStringForInt_ADDR(), SL_GetStringForInt_stub); + SL_GetStringForVector_hook.create(game::SL_GetStringForVector_ADDR(), SL_GetStringForVector_stub); + SL_ShutdownSystem_hook.create(game::SL_ShutdownSystem_ADDR(), SL_ShutdownSystem_stub); + SL_TransferSystem_hook.create(game::SL_TransferSystem.get(), SL_TransferSystem_stub); + SL_CreateCanonicalFilename_hook.create(game::SL_CreateCanonicalFilename_ADDR(), SL_CreateCanonicalFilename_stub); + Scr_CreateCanonicalFilename_hook.create(game::Scr_CreateCanonicalFilename.get(), Scr_CreateCanonicalFilename_stub); - SL_ConvertToString_hook.create(game::SL_ConvertToString_ADDR(), SL_ConvertToString_stub, quick); - SL_GetStringLen_hook.create(game::SL_GetStringLen_ADDR(), SL_GetStringLen_stub, quick); - GetHashCode_hook.create(game::GetHashCode_ADDR(), GetHashCode_stub, quick); - SL_Init_hook.create(game::SL_Init_ADDR(), SL_Init_stub, quick); - SL_FindStringOfSize_hook.create(game::SL_FindStringOfSize_ADDR(), SL_FindStringOfSize_stub, quick); - SL_FindString_hook.create(game::SL_FindString_ADDR(), SL_FindString_stub, quick); - SL_FindLowercaseString_hook.create(game::SL_FindLowercaseString.get(), SL_FindLowercaseString_stub, quick); - SL_AddUserInternal_hook.create(game::SL_AddUserInternal_ADDR(), SL_AddUserInternal_stub, quick); - Mark_ScriptStringCustom_hook.create(game::Mark_ScriptStringCustom_ADDR(), Mark_ScriptStringCustom_stub, quick); - SL_GetStringOfSize_hook.create(game::SL_GetStringOfSize.get(), SL_GetStringOfSize_stub, quick); - SL_GetString__hook.create(game::SL_GetString__ADDR(), SL_GetString__stub, quick); - SL_GetString__0_hook.create(game::SL_GetString__0_ADDR(), SL_GetString__0_stub, quick); - SL_GetLowercaseStringOfLen_hook.create(game::SL_GetLowercaseStringOfLen.get(), SL_GetLowercaseStringOfLen_stub, quick); - SL_GetLowercaseString_hook.create(game::SL_GetLowercaseString_ADDR(), SL_GetLowercaseString_stub, quick); - SL_ConvertToLowercase_hook.create(game::SL_ConvertToLowercase.get(), SL_ConvertToLowercase_stub, quick); - SL_TransferRefToUser_hook.create(game::SL_TransferRefToUser_ADDR(), SL_TransferRefToUser_stub, quick); - SL_FreeString_hook.create(game::SL_FreeString.get(), SL_FreeString_stub, quick); - SL_RemoveRefToString_hook.create(game::SL_RemoveRefToString_ADDR(), SL_RemoveRefToString_stub, quick); - Scr_SetString_hook.create(game::Scr_SetString_ADDR(), Scr_SetString_stub, quick); - Scr_SetStringFromCharString_hook.create(game::Scr_SetStringFromCharString_ADDR(), Scr_SetStringFromCharString_stub, quick); - GScr_AllocString_hook.create(game::GScr_AllocString_ADDR(), GScr_AllocString_stub, quick); - SL_GetStringForFloat_hook.create(game::SL_GetStringForFloat_ADDR(), SL_GetStringForFloat_stub, quick); - SL_GetStringForInt_hook.create(game::SL_GetStringForInt_ADDR(), SL_GetStringForInt_stub, quick); - SL_GetStringForVector_hook.create(game::SL_GetStringForVector_ADDR(), SL_GetStringForVector_stub, quick); - SL_ShutdownSystem_hook.create(game::SL_ShutdownSystem_ADDR(), SL_ShutdownSystem_stub, quick); - SL_TransferSystem_hook.create(game::SL_TransferSystem.get(), SL_TransferSystem_stub, quick); - SL_CreateCanonicalFilename_hook.create(game::SL_CreateCanonicalFilename_ADDR(), SL_CreateCanonicalFilename_stub, quick); - Scr_CreateCanonicalFilename_hook.create(game::Scr_CreateCanonicalFilename.get(), Scr_CreateCanonicalFilename_stub, quick); + //Original hook function addresses + SL_ConvertToString_original = SL_ConvertToString_hook.get_original(); + SL_GetStringLen_original = SL_GetStringLen_hook.get_original(); + GetHashCode_original = GetHashCode_hook.get_original(); + SL_Init_original = SL_Init_hook.get_original(); + SL_FindStringOfSize_original = SL_FindStringOfSize_hook.get_original(); + SL_FindString_original = SL_FindString_hook.get_original(); + SL_FindLowercaseString_original = SL_FindLowercaseString_hook.get_original(); + SL_AddUserInternal_original = SL_AddUserInternal_hook.get_original(); + Mark_ScriptStringCustom_original = Mark_ScriptStringCustom_hook.get_original(); + SL_GetStringOfSize_original = SL_GetStringOfSize_hook.get_original(); + SL_GetString__original = SL_GetString__hook.get_original(); + SL_GetString__0_original = SL_GetString__0_hook.get_original(); + SL_GetLowercaseStringOfLen_original = SL_GetLowercaseStringOfLen_hook.get_original(); + SL_GetLowercaseString_original = SL_GetLowercaseString_hook.get_original(); + SL_ConvertToLowercase_original = SL_ConvertToLowercase_hook.get_original(); + SL_TransferRefToUser_original = SL_TransferRefToUser_hook.get_original(); + SL_FreeString_original = SL_FreeString_hook.get_original(); + SL_RemoveRefToString_original = SL_RemoveRefToString_hook.get_original(); + Scr_SetString_original = Scr_SetString_hook.get_original(); + Scr_SetStringFromCharString_original = Scr_SetStringFromCharString_hook.get_original(); + GScr_AllocString_original = GScr_AllocString_hook.get_original(); + SL_GetStringForFloat_original = SL_GetStringForFloat_hook.get_original(); + SL_GetStringForInt_original = SL_GetStringForInt_hook.get_original(); + SL_GetStringForVector_original = SL_GetStringForVector_hook.get_original(); + SL_ShutdownSystem_original = SL_ShutdownSystem_hook.get_original(); + SL_TransferSystem_original = SL_TransferSystem_hook.get_original(); + SL_CreateCanonicalFilename_original = SL_CreateCanonicalFilename_hook.get_original(); + Scr_CreateCanonicalFilename_original = Scr_CreateCanonicalFilename_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_variable.cpp b/src/component/decomp/clientscript/re_cscr_variable.cpp index 986d803..fbd7b9e 100644 --- a/src/component/decomp/clientscript/re_cscr_variable.cpp +++ b/src/component/decomp/clientscript/re_cscr_variable.cpp @@ -112,6 +112,112 @@ namespace re_cscr_variable utils::hook::detour Scr_FreeGameVariable_hook; utils::hook::detour Scr_SLHasLowercaseString_hook; + void* ThreadInfoCompare_original; + void* Scr_DumpScriptThreads_original; + void* Scr_InitVariableRange_original; + void* Scr_InitClassMap_original; + void* GetNewVariableIndexInternal3_original; + void* GetNewVariableIndexInternal2_original; + void* GetNewVariableIndexReverseInternal2_original; + void* MakeVariableExternal_original; + void* FreeChildValue_original; + void* ClearObjectInternal_original; + void* ClearObject_original; + void* Scr_StopThread_original; + void* GetSafeParentLocalId_original; + void* GetStartLocalId_original; + void* Scr_KillThread_original; + void* AllocVariable_original; + void* FreeVariable_original; + void* AllocValue_original; + void* AllocEntity_original; + void* Scr_AllocArray_original; + void* AllocChildThread_original; + void* FreeValue_original; + void* RemoveRefToObject_original; + void* Scr_AllocVector_original; + void* RemoveRefToVector_original; + void* AddRefToValue_original; + void* RemoveRefToValueInternal_original; + void* FindArrayVariable_original; + void* FindVariable_original; + void* GetArrayVariableIndex_original; + void* Scr_GetVariableFieldIndex_original; + void* Scr_FindVariableField_original; + void* ClearVariableField_original; + void* GetVariable_original; + void* GetNewVariable_original; + void* GetObjectVariable_original; + void* GetNewObjectVariable_original; + void* RemoveVariable_original; + void* RemoveNextVariable_original; + void* SafeRemoveVariable_original; + void* CopyArray_original; + void* SetVariableValue_original; + void* SetVariableEntityFieldValue_original; + void* Scr_EvalVariable_original; + void* Scr_EvalVariableObject_original; + void* Scr_EvalVariableEntityField_original; + void* Scr_EvalVariableField_original; + void* Scr_EvalSizeValue_original; + void* GetObject_original; + void* GetArray_original; + void* Scr_EvalBoolComplement_original; + void* Scr_CastBool_original; + void* Scr_CastString_original; + void* Scr_CastDebugString_original; + void* Scr_ClearVector_original; + void* Scr_CastVector_original; + void* Scr_EvalFieldObject_original; + void* Scr_UnmatchingTypesError_original; + void* Scr_CastWeakerPair_original; + void* Scr_CastWeakerStringPair_original; + void* Scr_EvalOr_original; + void* Scr_EvalExOr_original; + void* Scr_EvalAnd_original; + void* Scr_EvalEquality_original; + void* Scr_EvalLess_original; + void* Scr_EvalGreaterEqual_original; + void* Scr_EvalGreater_original; + void* Scr_EvalLessEqual_original; + void* Scr_EvalShiftLeft_original; + void* Scr_EvalShiftRight_original; + void* Scr_EvalPlus_original; + void* Scr_EvalMinus_original; + void* Scr_EvalMultiply_original; + void* Scr_EvalDivide_original; + void* Scr_EvalMod_original; + void* Scr_EvalBinaryOperator_original; + void* Scr_FreeEntityNum_original; + void* Scr_FreeEntityList_original; + void* Scr_FreeObjects_original; + void* Scr_SetClassMap_original; + void* Scr_RemoveClassMap_original; + void* Scr_AddClassField_original; + void* Scr_GetOffset_original; + void* FindEntityId_original; + void* Scr_GetEntityId_original; + void* Scr_FindArrayIndex_original; + void* Scr_EvalArray_original; + void* Scr_EvalArrayRef_original; + void* ClearArray_original; + void* SetEmptyArray_original; + void* Scr_AddArrayKeys_original; + void* Scr_GetEntityIdRef_original; + void* CopyEntity_original; + void* Scr_GetEndonUsage_original; + void* Scr_GetObjectUsage_original; + void* Scr_GetThreadUsage_original; + void* Scr_FindField_original; + void* Scr_GetSourceFile_LoadObj_original; + void* Scr_GetSourceFile_FastFile_original; + void* Scr_AddFieldsForFile_original; + void* Scr_AddFields_LoadObj_original; + void* Scr_AddFields_FastFile_original; + void* Scr_MakeValuePrimitive_original; + void* Scr_FreeGameVariable_original; + void* Scr_SLHasLowercaseString_original; + namespace { @@ -136,7 +242,7 @@ namespace re_cscr_variable void Scr_InitVariableRange_call(unsigned int a1, unsigned int a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_InitVariableRange(a1, a2, a3, Scr_InitVariableRange_hook.get_original()); + game::Scr_InitVariableRange(a1, a2, a3, Scr_InitVariableRange_original); #else codsrc::Scr_InitVariableRange(a1, a2, a3); #endif @@ -158,7 +264,7 @@ namespace re_cscr_variable void Scr_InitClassMap_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_InitClassMap(a1, Scr_InitClassMap_hook.get_original()); + game::Scr_InitClassMap(a1, Scr_InitClassMap_original); #else codsrc::Scr_InitClassMap(a1); #endif @@ -188,7 +294,7 @@ namespace re_cscr_variable unsigned int GetNewVariableIndexInternal2_call(unsigned int name, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int parentId, unsigned int index) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetNewVariableIndexInternal2(name, inst, parentId, index, GetNewVariableIndexInternal2_hook.get_original()); + return game::GetNewVariableIndexInternal2(name, inst, parentId, index, GetNewVariableIndexInternal2_original); #else return codsrc::GetNewVariableIndexInternal2(name, inst, parentId, index); #endif @@ -209,7 +315,7 @@ namespace re_cscr_variable unsigned int GetNewVariableIndexReverseInternal2_call(unsigned int name, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int parentId, unsigned int index) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetNewVariableIndexReverseInternal2(name, inst, parentId, index, GetNewVariableIndexReverseInternal2_hook.get_original()); + return game::GetNewVariableIndexReverseInternal2(name, inst, parentId, index, GetNewVariableIndexReverseInternal2_original); #else return codsrc::GetNewVariableIndexReverseInternal2(name, inst, parentId, index); #endif @@ -230,7 +336,7 @@ namespace re_cscr_variable void MakeVariableExternal_call(game::VariableValueInternal * parentValue, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int index) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::MakeVariableExternal(parentValue, inst, index, MakeVariableExternal_hook.get_original()); + game::MakeVariableExternal(parentValue, inst, index, MakeVariableExternal_original); #else codsrc::MakeVariableExternal(parentValue, inst, index); #endif @@ -251,7 +357,7 @@ namespace re_cscr_variable void FreeChildValue_call(unsigned int id, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int parentId) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::FreeChildValue(id, inst, parentId, FreeChildValue_hook.get_original()); + game::FreeChildValue(id, inst, parentId, FreeChildValue_original); #else codsrc::FreeChildValue(id, inst, parentId); #endif @@ -281,7 +387,7 @@ namespace re_cscr_variable void ClearObject_call(unsigned int a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::ClearObject(a1, a2, ClearObject_hook.get_original()); + game::ClearObject(a1, a2, ClearObject_original); #else codsrc::ClearObject(a1, a2); #endif @@ -302,7 +408,7 @@ namespace re_cscr_variable void Scr_StopThread_call(game::scriptInstance_t inst, unsigned int a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_StopThread(inst, a2, Scr_StopThread_hook.get_original()); + game::Scr_StopThread(inst, a2, Scr_StopThread_original); #else codsrc::Scr_StopThread(inst, a2); #endif @@ -324,7 +430,7 @@ namespace re_cscr_variable unsigned int GetSafeParentLocalId_call(game::scriptInstance_t a1, [[maybe_unused]] unsigned int localId, [[maybe_unused]] void* caller_addr, unsigned int a2) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetSafeParentLocalId(a1, a2, GetSafeParentLocalId_hook.get_original()); + return game::GetSafeParentLocalId(a1, a2, GetSafeParentLocalId_original); #else return codsrc::GetSafeParentLocalId(a1, a2); #endif @@ -350,7 +456,7 @@ namespace re_cscr_variable unsigned int GetStartLocalId_call(unsigned int result, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetStartLocalId(result, a2, GetStartLocalId_hook.get_original()); + return game::GetStartLocalId(result, a2, GetStartLocalId_original); #else return codsrc::GetStartLocalId(result, a2); #endif @@ -372,7 +478,7 @@ namespace re_cscr_variable void Scr_KillThread_call(game::scriptInstance_t inst, unsigned int parentId_1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_KillThread(inst, parentId_1, Scr_KillThread_hook.get_original()); + game::Scr_KillThread(inst, parentId_1, Scr_KillThread_original); #else codsrc::Scr_KillThread(inst, parentId_1); #endif @@ -394,7 +500,7 @@ namespace re_cscr_variable unsigned __int16 AllocVariable_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::AllocVariable(inst, AllocVariable_hook.get_original()); + return game::AllocVariable(inst, AllocVariable_original); #else return codsrc::AllocVariable(inst); #endif @@ -415,7 +521,7 @@ namespace re_cscr_variable void FreeVariable_call(unsigned int a1, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::FreeVariable(a1, a2, FreeVariable_hook.get_original()); + game::FreeVariable(a1, a2, FreeVariable_original); #else codsrc::FreeVariable(a1, a2); #endif @@ -437,7 +543,7 @@ namespace re_cscr_variable unsigned int AllocValue_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::AllocValue(inst, AllocValue_hook.get_original()); + return game::AllocValue(inst, AllocValue_original); #else return codsrc::AllocValue(inst); #endif @@ -458,7 +564,7 @@ namespace re_cscr_variable unsigned int AllocEntity_call(game::classNum_e classnum, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int entnum, unsigned int clientnum) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::AllocEntity(classnum, inst, entnum, clientnum, AllocEntity_hook.get_original()); + return game::AllocEntity(classnum, inst, entnum, clientnum, AllocEntity_original); #else return codsrc::AllocEntity(classnum, inst, entnum, clientnum); #endif @@ -480,7 +586,7 @@ namespace re_cscr_variable unsigned int Scr_AllocArray_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_AllocArray(a1, Scr_AllocArray_hook.get_original()); + return game::Scr_AllocArray(a1, Scr_AllocArray_original); #else return codsrc::Scr_AllocArray(a1); #endif @@ -501,7 +607,7 @@ namespace re_cscr_variable unsigned int AllocChildThread_call(game::scriptInstance_t inst, unsigned int a2, [[maybe_unused]] void* caller_addr, unsigned int a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::AllocChildThread(inst, a2, a3, AllocChildThread_hook.get_original()); + return game::AllocChildThread(inst, a2, a3, AllocChildThread_original); #else return codsrc::AllocChildThread(inst, a2, a3); #endif @@ -523,7 +629,7 @@ namespace re_cscr_variable void FreeValue_call(unsigned int id, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::FreeValue(id, inst, FreeValue_hook.get_original()); + game::FreeValue(id, inst, FreeValue_original); #else codsrc::FreeValue(id, inst); #endif @@ -544,7 +650,7 @@ namespace re_cscr_variable void RemoveRefToObject_call(unsigned int id, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::RemoveRefToObject(id, inst, RemoveRefToObject_hook.get_original()); + game::RemoveRefToObject(id, inst, RemoveRefToObject_original); #else codsrc::RemoveRefToObject(id, inst); #endif @@ -566,7 +672,7 @@ namespace re_cscr_variable float * Scr_AllocVector_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_AllocVector(a1, Scr_AllocVector_hook.get_original()); + return game::Scr_AllocVector(a1, Scr_AllocVector_original); #else return codsrc::Scr_AllocVector(a1); #endif @@ -587,7 +693,7 @@ namespace re_cscr_variable void RemoveRefToVector_call(const float* vecVal, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::RemoveRefToVector(vecVal, inst, RemoveRefToVector_hook.get_original()); + game::RemoveRefToVector(vecVal, inst, RemoveRefToVector_original); #else codsrc::RemoveRefToVector(vecVal, inst); #endif @@ -608,7 +714,7 @@ namespace re_cscr_variable void AddRefToValue_call(game::scriptInstance_t inst, game::VariableType type_, [[maybe_unused]] void* caller_addr, game::VariableUnion u) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::AddRefToValue(inst, type_, u, AddRefToValue_hook.get_original()); + game::AddRefToValue(inst, type_, u, AddRefToValue_original); #else codsrc::AddRefToValue(inst, type_, u); #endif @@ -639,7 +745,7 @@ namespace re_cscr_variable int FindArrayVariable_call(unsigned int id, unsigned int intvalue, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::FindArrayVariable(id, intvalue, inst, FindArrayVariable_hook.get_original()); + return game::FindArrayVariable(id, intvalue, inst, FindArrayVariable_original); #else return codsrc::FindArrayVariable(id, intvalue, inst); #endif @@ -661,7 +767,7 @@ namespace re_cscr_variable int FindVariable_call(int name, int a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::FindVariable(name, a2, inst, FindVariable_hook.get_original()); + return game::FindVariable(name, a2, inst, FindVariable_original); #else return codsrc::FindVariable(name, a2, inst); #endif @@ -683,7 +789,7 @@ namespace re_cscr_variable unsigned int GetArrayVariableIndex_call(unsigned int unsignedValue, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int parentId) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetArrayVariableIndex(unsignedValue, inst, parentId, GetArrayVariableIndex_hook.get_original()); + return game::GetArrayVariableIndex(unsignedValue, inst, parentId, GetArrayVariableIndex_original); #else return codsrc::GetArrayVariableIndex(unsignedValue, inst, parentId); #endif @@ -704,7 +810,7 @@ namespace re_cscr_variable unsigned int Scr_GetVariableFieldIndex_call(game::scriptInstance_t a1, unsigned int name, [[maybe_unused]] void* caller_addr, unsigned int parentId) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_GetVariableFieldIndex(a1, name, parentId, Scr_GetVariableFieldIndex_hook.get_original()); + return game::Scr_GetVariableFieldIndex(a1, name, parentId, Scr_GetVariableFieldIndex_original); #else return codsrc::Scr_GetVariableFieldIndex(a1, name, parentId); #endif @@ -726,7 +832,7 @@ namespace re_cscr_variable game::VariableValue Scr_FindVariableField_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int parentId, unsigned int name) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_FindVariableField(inst, parentId, name, Scr_FindVariableField_hook.get_original()); + return game::Scr_FindVariableField(inst, parentId, name, Scr_FindVariableField_original); #else return codsrc::Scr_FindVariableField(inst, parentId, name); #endif @@ -747,7 +853,7 @@ namespace re_cscr_variable void ClearVariableField_call(game::scriptInstance_t inst, unsigned int id, [[maybe_unused]] void* caller_addr, unsigned int name, game::VariableValue * value) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::ClearVariableField(inst, id, name, value, ClearVariableField_hook.get_original()); + game::ClearVariableField(inst, id, name, value, ClearVariableField_original); #else codsrc::ClearVariableField(inst, id, name, value); #endif @@ -769,7 +875,7 @@ namespace re_cscr_variable unsigned int GetVariable_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int parentId, unsigned int name) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetVariable(a1, parentId, name, GetVariable_hook.get_original()); + return game::GetVariable(a1, parentId, name, GetVariable_original); #else return codsrc::GetVariable(a1, parentId, name); #endif @@ -790,7 +896,7 @@ namespace re_cscr_variable unsigned int GetNewVariable_call(game::scriptInstance_t a1, unsigned int a2, unsigned int a3, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetNewVariable(a1, a2, a3, GetNewVariable_hook.get_original()); + return game::GetNewVariable(a1, a2, a3, GetNewVariable_original); #else return codsrc::GetNewVariable(a1, a2, a3); #endif @@ -813,7 +919,7 @@ namespace re_cscr_variable unsigned int GetObjectVariable_call(unsigned int a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int parentId) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetObjectVariable(a1, inst, parentId, GetObjectVariable_hook.get_original()); + return game::GetObjectVariable(a1, inst, parentId, GetObjectVariable_original); #else return codsrc::GetObjectVariable(a1, inst, parentId); #endif @@ -834,7 +940,7 @@ namespace re_cscr_variable unsigned int GetNewObjectVariable_call(game::scriptInstance_t inst, unsigned int name, unsigned int parentId, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetNewObjectVariable(inst, name, parentId, GetNewObjectVariable_hook.get_original()); + return game::GetNewObjectVariable(inst, name, parentId, GetNewObjectVariable_original); #else return codsrc::GetNewObjectVariable(inst, name, parentId); #endif @@ -857,7 +963,7 @@ namespace re_cscr_variable void RemoveVariable_call(unsigned int name, unsigned int a2, game::scriptInstance_t a3, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::RemoveVariable(name, a2, a3, RemoveVariable_hook.get_original()); + game::RemoveVariable(name, a2, a3, RemoveVariable_original); #else codsrc::RemoveVariable(name, a2, a3); #endif @@ -880,7 +986,7 @@ namespace re_cscr_variable void RemoveNextVariable_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int parentId) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::RemoveNextVariable(a1, parentId, RemoveNextVariable_hook.get_original()); + game::RemoveNextVariable(a1, parentId, RemoveNextVariable_original); #else codsrc::RemoveNextVariable(a1, parentId); #endif @@ -901,7 +1007,7 @@ namespace re_cscr_variable void SafeRemoveVariable_call(unsigned int unsignedValue, unsigned int parentId, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::SafeRemoveVariable(unsignedValue, parentId, inst, SafeRemoveVariable_hook.get_original()); + game::SafeRemoveVariable(unsignedValue, parentId, inst, SafeRemoveVariable_original); #else codsrc::SafeRemoveVariable(unsignedValue, parentId, inst); #endif @@ -933,7 +1039,7 @@ namespace re_cscr_variable void SetVariableValue_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, unsigned int a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::SetVariableValue(a1, a2, a3, SetVariableValue_hook.get_original()); + game::SetVariableValue(a1, a2, a3, SetVariableValue_original); #else codsrc::SetVariableValue(a1, a2, a3); #endif @@ -964,7 +1070,7 @@ namespace re_cscr_variable game::VariableValue Scr_EvalVariable_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_EvalVariable(a1, a2, Scr_EvalVariable_hook.get_original()); + return game::Scr_EvalVariable(a1, a2, Scr_EvalVariable_original); #else return codsrc::Scr_EvalVariable(a1, a2); #endif @@ -985,7 +1091,7 @@ namespace re_cscr_variable unsigned int Scr_EvalVariableObject_call(game::scriptInstance_t inst, int a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_EvalVariableObject(inst, a2, Scr_EvalVariableObject_hook.get_original()); + return game::Scr_EvalVariableObject(inst, a2, Scr_EvalVariableObject_original); #else return codsrc::Scr_EvalVariableObject(inst, a2); #endif @@ -1007,7 +1113,7 @@ namespace re_cscr_variable game::VariableValue Scr_EvalVariableEntityField_call(unsigned int entId, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, unsigned int name) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_EvalVariableEntityField(entId, inst, name, Scr_EvalVariableEntityField_hook.get_original()); + return game::Scr_EvalVariableEntityField(entId, inst, name, Scr_EvalVariableEntityField_original); #else return codsrc::Scr_EvalVariableEntityField(entId, inst, name); #endif @@ -1028,7 +1134,7 @@ namespace re_cscr_variable game::VariableValue Scr_EvalVariableField_call(game::scriptInstance_t inst, unsigned int id, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_EvalVariableField(inst, id, Scr_EvalVariableField_hook.get_original()); + return game::Scr_EvalVariableField(inst, id, Scr_EvalVariableField_original); #else return codsrc::Scr_EvalVariableField(inst, id); #endif @@ -1050,7 +1156,7 @@ namespace re_cscr_variable void Scr_EvalSizeValue_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, game::VariableValue * value) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalSizeValue(a1, value, Scr_EvalSizeValue_hook.get_original()); + game::Scr_EvalSizeValue(a1, value, Scr_EvalSizeValue_original); #else codsrc::Scr_EvalSizeValue(a1, value); #endif @@ -1071,7 +1177,7 @@ namespace re_cscr_variable unsigned int GetObject_call(game::scriptInstance_t a1, unsigned int a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetObject(a1, a2, GetObject_hook.get_original()); + return game::GetObject(a1, a2, GetObject_original); #else return codsrc::GetObject(a1, a2); #endif @@ -1093,7 +1199,7 @@ namespace re_cscr_variable unsigned int GetArray_call(game::scriptInstance_t inst, unsigned int a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::GetArray(inst, a2, GetArray_hook.get_original()); + return game::GetArray(inst, a2, GetArray_original); #else return codsrc::GetArray(inst, a2); #endif @@ -1115,7 +1221,7 @@ namespace re_cscr_variable void Scr_EvalBoolComplement_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalBoolComplement(a1, a2, Scr_EvalBoolComplement_hook.get_original()); + game::Scr_EvalBoolComplement(a1, a2, Scr_EvalBoolComplement_original); #else codsrc::Scr_EvalBoolComplement(a1, a2); #endif @@ -1137,7 +1243,7 @@ namespace re_cscr_variable void Scr_CastBool_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_CastBool(a1, a2, Scr_CastBool_hook.get_original()); + game::Scr_CastBool(a1, a2, Scr_CastBool_original); #else codsrc::Scr_CastBool(a1, a2); #endif @@ -1159,7 +1265,7 @@ namespace re_cscr_variable char Scr_CastString_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_CastString(a1, a2, Scr_CastString_hook.get_original()); + return game::Scr_CastString(a1, a2, Scr_CastString_original); #else return codsrc::Scr_CastString(a1, a2); #endif @@ -1181,7 +1287,7 @@ namespace re_cscr_variable void Scr_CastDebugString_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_CastDebugString(a1, a2, Scr_CastDebugString_hook.get_original()); + game::Scr_CastDebugString(a1, a2, Scr_CastDebugString_original); #else codsrc::Scr_CastDebugString(a1, a2); #endif @@ -1212,7 +1318,7 @@ namespace re_cscr_variable void Scr_CastVector_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_CastVector(a1, a2, Scr_CastVector_hook.get_original()); + game::Scr_CastVector(a1, a2, Scr_CastVector_original); #else codsrc::Scr_CastVector(a1, a2); #endif @@ -1234,7 +1340,7 @@ namespace re_cscr_variable game::VariableUnion Scr_EvalFieldObject_call(game::VariableValue * a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, int a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_EvalFieldObject(a1, inst, a3, Scr_EvalFieldObject_hook.get_original()); + return game::Scr_EvalFieldObject(a1, inst, a3, Scr_EvalFieldObject_original); #else return codsrc::Scr_EvalFieldObject(a1, inst, a3); #endif @@ -1255,7 +1361,7 @@ namespace re_cscr_variable void Scr_UnmatchingTypesError_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::VariableValue * value) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_UnmatchingTypesError(a1, a2, value, Scr_UnmatchingTypesError_hook.get_original()); + game::Scr_UnmatchingTypesError(a1, a2, value, Scr_UnmatchingTypesError_original); #else codsrc::Scr_UnmatchingTypesError(a1, a2, value); #endif @@ -1277,7 +1383,7 @@ namespace re_cscr_variable void Scr_CastWeakerPair_call(game::VariableValue * a1, game::VariableValue * a2, game::scriptInstance_t a3, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_CastWeakerPair(a1, a2, a3, Scr_CastWeakerPair_hook.get_original()); + game::Scr_CastWeakerPair(a1, a2, a3, Scr_CastWeakerPair_original); #else codsrc::Scr_CastWeakerPair(a1, a2, a3); #endif @@ -1300,7 +1406,7 @@ namespace re_cscr_variable void Scr_CastWeakerStringPair_call(game::VariableValue * a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_CastWeakerStringPair(a1, a2, inst, Scr_CastWeakerStringPair_hook.get_original()); + game::Scr_CastWeakerStringPair(a1, a2, inst, Scr_CastWeakerStringPair_original); #else codsrc::Scr_CastWeakerStringPair(a1, a2, inst); #endif @@ -1322,7 +1428,7 @@ namespace re_cscr_variable void Scr_EvalOr_call(game::VariableValue * result, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalOr(result, a2, a3, Scr_EvalOr_hook.get_original()); + game::Scr_EvalOr(result, a2, a3, Scr_EvalOr_original); #else codsrc::Scr_EvalOr(result, a2, a3); #endif @@ -1344,7 +1450,7 @@ namespace re_cscr_variable void Scr_EvalExOr_call(game::VariableValue * result, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalExOr(result, a2, a3, Scr_EvalExOr_hook.get_original()); + game::Scr_EvalExOr(result, a2, a3, Scr_EvalExOr_original); #else codsrc::Scr_EvalExOr(result, a2, a3); #endif @@ -1366,7 +1472,7 @@ namespace re_cscr_variable void Scr_EvalAnd_call(game::VariableValue * result, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalAnd(result, a2, a3, Scr_EvalAnd_hook.get_original()); + game::Scr_EvalAnd(result, a2, a3, Scr_EvalAnd_original); #else codsrc::Scr_EvalAnd(result, a2, a3); #endif @@ -1388,7 +1494,7 @@ namespace re_cscr_variable void Scr_EvalEquality_call(game::VariableValue * a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::VariableValue * a4) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalEquality(a1, inst, a4, Scr_EvalEquality_hook.get_original()); + game::Scr_EvalEquality(a1, inst, a4, Scr_EvalEquality_original); #else codsrc::Scr_EvalEquality(a1, inst, a4); #endif @@ -1409,7 +1515,7 @@ namespace re_cscr_variable void Scr_EvalLess_call(game::VariableValue * a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalLess(a1, a2, a3, Scr_EvalLess_hook.get_original()); + game::Scr_EvalLess(a1, a2, a3, Scr_EvalLess_original); #else codsrc::Scr_EvalLess(a1, a2, a3); #endif @@ -1431,7 +1537,7 @@ namespace re_cscr_variable void Scr_EvalGreaterEqual_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::VariableValue * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalGreaterEqual(a1, a2, a3, Scr_EvalGreaterEqual_hook.get_original()); + game::Scr_EvalGreaterEqual(a1, a2, a3, Scr_EvalGreaterEqual_original); #else codsrc::Scr_EvalGreaterEqual(a1, a2, a3); #endif @@ -1453,7 +1559,7 @@ namespace re_cscr_variable void Scr_EvalGreater_call(game::VariableValue * a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalGreater(a1, a2, a3, Scr_EvalGreater_hook.get_original()); + game::Scr_EvalGreater(a1, a2, a3, Scr_EvalGreater_original); #else codsrc::Scr_EvalGreater(a1, a2, a3); #endif @@ -1475,7 +1581,7 @@ namespace re_cscr_variable void Scr_EvalLessEqual_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::VariableValue * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalLessEqual(a1, a2, a3, Scr_EvalLessEqual_hook.get_original()); + game::Scr_EvalLessEqual(a1, a2, a3, Scr_EvalLessEqual_original); #else codsrc::Scr_EvalLessEqual(a1, a2, a3); #endif @@ -1497,7 +1603,7 @@ namespace re_cscr_variable void Scr_EvalShiftLeft_call(game::VariableValue * result, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalShiftLeft(result, a2, a3, Scr_EvalShiftLeft_hook.get_original()); + game::Scr_EvalShiftLeft(result, a2, a3, Scr_EvalShiftLeft_original); #else codsrc::Scr_EvalShiftLeft(result, a2, a3); #endif @@ -1519,7 +1625,7 @@ namespace re_cscr_variable void Scr_EvalShiftRight_call(game::VariableValue * result, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalShiftRight(result, a2, a3, Scr_EvalShiftRight_hook.get_original()); + game::Scr_EvalShiftRight(result, a2, a3, Scr_EvalShiftRight_original); #else codsrc::Scr_EvalShiftRight(result, a2, a3); #endif @@ -1541,7 +1647,7 @@ namespace re_cscr_variable void Scr_EvalPlus_call(game::scriptInstance_t a, [[maybe_unused]] void* caller_addr, game::VariableValue * a1, game::VariableValue * a2) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalPlus(a, a1, a2, Scr_EvalPlus_hook.get_original()); + game::Scr_EvalPlus(a, a1, a2, Scr_EvalPlus_original); #else codsrc::Scr_EvalPlus(a, a1, a2); #endif @@ -1562,7 +1668,7 @@ namespace re_cscr_variable void Scr_EvalMinus_call(game::VariableValue * a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2, game::VariableValue * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalMinus(a1, a2, a3, Scr_EvalMinus_hook.get_original()); + game::Scr_EvalMinus(a1, a2, a3, Scr_EvalMinus_original); #else codsrc::Scr_EvalMinus(a1, a2, a3); #endif @@ -1583,7 +1689,7 @@ namespace re_cscr_variable void Scr_EvalMultiply_call(game::VariableValue * a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a2, game::VariableValue * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalMultiply(a1, a2, a3, Scr_EvalMultiply_hook.get_original()); + game::Scr_EvalMultiply(a1, a2, a3, Scr_EvalMultiply_original); #else codsrc::Scr_EvalMultiply(a1, a2, a3); #endif @@ -1604,7 +1710,7 @@ namespace re_cscr_variable void Scr_EvalDivide_call(game::VariableValue * a1, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::VariableValue * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalDivide(a1, inst, a3, Scr_EvalDivide_hook.get_original()); + game::Scr_EvalDivide(a1, inst, a3, Scr_EvalDivide_original); #else codsrc::Scr_EvalDivide(a1, inst, a3); #endif @@ -1625,7 +1731,7 @@ namespace re_cscr_variable void Scr_EvalMod_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::VariableValue * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalMod(a1, a2, a3, Scr_EvalMod_hook.get_original()); + game::Scr_EvalMod(a1, a2, a3, Scr_EvalMod_original); #else codsrc::Scr_EvalMod(a1, a2, a3); #endif @@ -1647,7 +1753,7 @@ namespace re_cscr_variable void Scr_EvalBinaryOperator_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, game::OpcodeVM a4, game::VariableValue * a5) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalBinaryOperator(a1, a2, a4, a5, Scr_EvalBinaryOperator_hook.get_original()); + game::Scr_EvalBinaryOperator(a1, a2, a4, a5, Scr_EvalBinaryOperator_original); #else codsrc::Scr_EvalBinaryOperator(a1, a2, a4, a5); #endif @@ -1669,7 +1775,7 @@ namespace re_cscr_variable void Scr_FreeEntityNum_call(game::scriptInstance_t inst, game::classNum_e classnum, [[maybe_unused]] void* caller_addr, unsigned int entnum) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_FreeEntityNum(inst, classnum, entnum, Scr_FreeEntityNum_hook.get_original()); + game::Scr_FreeEntityNum(inst, classnum, entnum, Scr_FreeEntityNum_original); #else codsrc::Scr_FreeEntityNum(inst, classnum, entnum); #endif @@ -1709,7 +1815,7 @@ namespace re_cscr_variable void Scr_SetClassMap_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, game::classNum_e a2) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_SetClassMap(a1, a2, Scr_SetClassMap_hook.get_original()); + game::Scr_SetClassMap(a1, a2, Scr_SetClassMap_original); #else codsrc::Scr_SetClassMap(a1, a2); #endif @@ -1730,7 +1836,7 @@ namespace re_cscr_variable void Scr_RemoveClassMap_call(game::classNum_e result, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_RemoveClassMap(result, a2, Scr_RemoveClassMap_hook.get_original()); + game::Scr_RemoveClassMap(result, a2, Scr_RemoveClassMap_original); #else codsrc::Scr_RemoveClassMap(result, a2); #endif @@ -1752,7 +1858,7 @@ namespace re_cscr_variable void Scr_AddClassField_call(game::scriptInstance_t inst, game::classNum_e a2, [[maybe_unused]] void* caller_addr, const char * name, unsigned int a4) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_AddClassField(inst, a2, name, a4, Scr_AddClassField_hook.get_original()); + game::Scr_AddClassField(inst, a2, name, a4, Scr_AddClassField_original); #else codsrc::Scr_AddClassField(inst, a2, name, a4); #endif @@ -1774,7 +1880,7 @@ namespace re_cscr_variable game::VariableUnion Scr_GetOffset_call(const char* name, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::classNum_e classNum) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_GetOffset(name, inst, classNum, Scr_GetOffset_hook.get_original()); + return game::Scr_GetOffset(name, inst, classNum, Scr_GetOffset_original); #else return codsrc::Scr_GetOffset(name, inst, classNum); #endif @@ -1796,7 +1902,7 @@ namespace re_cscr_variable unsigned int FindEntityId_call(unsigned int entClass, int entNum, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::FindEntityId(entClass, entNum, inst, FindEntityId_hook.get_original()); + return game::FindEntityId(entClass, entNum, inst, FindEntityId_original); #else return codsrc::FindEntityId(entClass, entNum, inst); #endif @@ -1819,7 +1925,7 @@ namespace re_cscr_variable unsigned int Scr_GetEntityId_call(int entNum, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::classNum_e classnum, int clientnum) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_GetEntityId(entNum, inst, classnum, clientnum, Scr_GetEntityId_hook.get_original()); + return game::Scr_GetEntityId(entNum, inst, classnum, clientnum, Scr_GetEntityId_original); #else return codsrc::Scr_GetEntityId(entNum, inst, classnum, clientnum); #endif @@ -1840,7 +1946,7 @@ namespace re_cscr_variable unsigned int Scr_FindArrayIndex_call(game::scriptInstance_t a1, game::VariableValue * a2, [[maybe_unused]] void* caller_addr, int a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_FindArrayIndex(a1, a2, a3, Scr_FindArrayIndex_hook.get_original()); + return game::Scr_FindArrayIndex(a1, a2, a3, Scr_FindArrayIndex_original); #else return codsrc::Scr_FindArrayIndex(a1, a2, a3); #endif @@ -1862,7 +1968,7 @@ namespace re_cscr_variable void Scr_EvalArray_call(game::scriptInstance_t a2, game::VariableValue * eax0, [[maybe_unused]] void* caller_addr, game::VariableValue * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_EvalArray(a2, eax0, a3, Scr_EvalArray_hook.get_original()); + game::Scr_EvalArray(a2, eax0, a3, Scr_EvalArray_original); #else codsrc::Scr_EvalArray(a2, eax0, a3); #endif @@ -1884,7 +1990,7 @@ namespace re_cscr_variable unsigned int Scr_EvalArrayRef_call(game::scriptInstance_t a2, unsigned int eax0, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_EvalArrayRef(a2, eax0, Scr_EvalArrayRef_hook.get_original()); + return game::Scr_EvalArrayRef(a2, eax0, Scr_EvalArrayRef_original); #else return codsrc::Scr_EvalArrayRef(a2, eax0); #endif @@ -1906,7 +2012,7 @@ namespace re_cscr_variable void ClearArray_call(unsigned int parentId, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::VariableValue * value) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::ClearArray(parentId, inst, value, ClearArray_hook.get_original()); + game::ClearArray(parentId, inst, value, ClearArray_original); #else codsrc::ClearArray(parentId, inst, value); #endif @@ -1928,7 +2034,7 @@ namespace re_cscr_variable void SetEmptyArray_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::SetEmptyArray(a1, a2, SetEmptyArray_hook.get_original()); + game::SetEmptyArray(a1, a2, SetEmptyArray_original); #else codsrc::SetEmptyArray(a1, a2); #endif @@ -1958,7 +2064,7 @@ namespace re_cscr_variable game::scr_entref_t * Scr_GetEntityIdRef_call(game::scr_entref_t * result, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr, unsigned int a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_GetEntityIdRef(result, a2, a3, Scr_GetEntityIdRef_hook.get_original()); + return game::Scr_GetEntityIdRef(result, a2, a3, Scr_GetEntityIdRef_original); #else return codsrc::Scr_GetEntityIdRef(result, a2, a3); #endif @@ -1980,7 +2086,7 @@ namespace re_cscr_variable void CopyEntity_call(unsigned int parentId, [[maybe_unused]] void* caller_addr, unsigned int newParentId) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::CopyEntity(parentId, newParentId, CopyEntity_hook.get_original()); + game::CopyEntity(parentId, newParentId, CopyEntity_original); #else codsrc::CopyEntity(parentId, newParentId); #endif @@ -2001,7 +2107,7 @@ namespace re_cscr_variable float Scr_GetEndonUsage_call(unsigned int a1, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_GetEndonUsage(a1, a2, Scr_GetEndonUsage_hook.get_original()); + return game::Scr_GetEndonUsage(a1, a2, Scr_GetEndonUsage_original); #else return codsrc::Scr_GetEndonUsage(a1, a2); #endif @@ -2032,7 +2138,7 @@ namespace re_cscr_variable float Scr_GetThreadUsage_call(game::VariableStackBuffer * a1, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr, float * a3) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_GetThreadUsage(a1, a2, a3, Scr_GetThreadUsage_hook.get_original()); + return game::Scr_GetThreadUsage(a1, a2, a3, Scr_GetThreadUsage_original); #else return codsrc::Scr_GetThreadUsage(a1, a2, a3); #endif @@ -2061,7 +2167,7 @@ namespace re_cscr_variable int Scr_FindField_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, const char * name, int * type) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_FindField(inst, name, type, Scr_FindField_hook.get_original()); + return game::Scr_FindField(inst, name, type, Scr_FindField_original); #else return codsrc::Scr_FindField(inst, name, type); #endif @@ -2136,7 +2242,7 @@ namespace re_cscr_variable void Scr_FreeGameVariable_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, int bComplete) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - game::Scr_FreeGameVariable(a1, bComplete, Scr_FreeGameVariable_hook.get_original()); + game::Scr_FreeGameVariable(a1, bComplete, Scr_FreeGameVariable_original); #else codsrc::Scr_FreeGameVariable(a1, bComplete); #endif @@ -2157,7 +2263,7 @@ namespace re_cscr_variable bool Scr_SLHasLowercaseString_call(unsigned int a1, const char * a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - return game::Scr_SLHasLowercaseString(a1, a2, Scr_SLHasLowercaseString_hook.get_original()); + return game::Scr_SLHasLowercaseString(a1, a2, Scr_SLHasLowercaseString_original); #else return codsrc::Scr_SLHasLowercaseString(a1, a2); #endif @@ -2182,116 +2288,218 @@ namespace re_cscr_variable public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_VARIABLE_USE_WRAPPERS - quick = false; -#endif + ThreadInfoCompare_hook.create(game::ThreadInfoCompare.get(), ThreadInfoCompare_stub); + Scr_DumpScriptThreads_hook.create(game::Scr_DumpScriptThreads.get(), Scr_DumpScriptThreads_stub); + Scr_InitVariableRange_hook.create(game::Scr_InitVariableRange_ADDR(), Scr_InitVariableRange_stub); + Scr_InitClassMap_hook.create(game::Scr_InitClassMap_ADDR(), Scr_InitClassMap_stub); + GetNewVariableIndexInternal3_hook.create(game::GetNewVariableIndexInternal3.get(), GetNewVariableIndexInternal3_stub); + GetNewVariableIndexInternal2_hook.create(game::GetNewVariableIndexInternal2_ADDR(), GetNewVariableIndexInternal2_stub); + GetNewVariableIndexReverseInternal2_hook.create(game::GetNewVariableIndexReverseInternal2_ADDR(), GetNewVariableIndexReverseInternal2_stub); + MakeVariableExternal_hook.create(game::MakeVariableExternal_ADDR(), MakeVariableExternal_stub); + FreeChildValue_hook.create(game::FreeChildValue_ADDR(), FreeChildValue_stub); + ClearObjectInternal_hook.create(game::ClearObjectInternal.get(), ClearObjectInternal_stub); + ClearObject_hook.create(game::ClearObject_ADDR(), ClearObject_stub); + Scr_StopThread_hook.create(game::Scr_StopThread_ADDR(), Scr_StopThread_stub); + GetSafeParentLocalId_hook.create(game::GetSafeParentLocalId_ADDR(), GetSafeParentLocalId_stub); + GetStartLocalId_hook.create(game::GetStartLocalId_ADDR(), GetStartLocalId_stub); + Scr_KillThread_hook.create(game::Scr_KillThread_ADDR(), Scr_KillThread_stub); + AllocVariable_hook.create(game::AllocVariable_ADDR(), AllocVariable_stub); + FreeVariable_hook.create(game::FreeVariable_ADDR(), FreeVariable_stub); + AllocValue_hook.create(game::AllocValue_ADDR(), AllocValue_stub); + AllocEntity_hook.create(game::AllocEntity_ADDR(), AllocEntity_stub); + Scr_AllocArray_hook.create(game::Scr_AllocArray_ADDR(), Scr_AllocArray_stub); + AllocChildThread_hook.create(game::AllocChildThread_ADDR(), AllocChildThread_stub); + FreeValue_hook.create(game::FreeValue_ADDR(), FreeValue_stub); + RemoveRefToObject_hook.create(game::RemoveRefToObject_ADDR(), RemoveRefToObject_stub); + Scr_AllocVector_hook.create(game::Scr_AllocVector_ADDR(), Scr_AllocVector_stub); + RemoveRefToVector_hook.create(game::RemoveRefToVector_ADDR(), RemoveRefToVector_stub); + AddRefToValue_hook.create(game::AddRefToValue_ADDR(), AddRefToValue_stub); + RemoveRefToValueInternal_hook.create(game::RemoveRefToValueInternal.get(), RemoveRefToValueInternal_stub); + FindArrayVariable_hook.create(game::FindArrayVariable_ADDR(), FindArrayVariable_stub); + FindVariable_hook.create(game::FindVariable_ADDR(), FindVariable_stub); + GetArrayVariableIndex_hook.create(game::GetArrayVariableIndex_ADDR(), GetArrayVariableIndex_stub); + Scr_GetVariableFieldIndex_hook.create(game::Scr_GetVariableFieldIndex_ADDR(), Scr_GetVariableFieldIndex_stub); + Scr_FindVariableField_hook.create(game::Scr_FindVariableField_ADDR(), Scr_FindVariableField_stub); + ClearVariableField_hook.create(game::ClearVariableField_ADDR(), ClearVariableField_stub); + GetVariable_hook.create(game::GetVariable_ADDR(), GetVariable_stub); + GetNewVariable_hook.create(game::GetNewVariable_ADDR(), GetNewVariable_stub); + GetObjectVariable_hook.create(game::GetObjectVariable_ADDR(), GetObjectVariable_stub); + GetNewObjectVariable_hook.create(game::GetNewObjectVariable_ADDR(), GetNewObjectVariable_stub); + RemoveVariable_hook.create(game::RemoveVariable_ADDR(), RemoveVariable_stub); + RemoveNextVariable_hook.create(game::RemoveNextVariable_ADDR(), RemoveNextVariable_stub); + SafeRemoveVariable_hook.create(game::SafeRemoveVariable_ADDR(), SafeRemoveVariable_stub); + CopyArray_hook.create(game::CopyArray.get(), CopyArray_stub); + SetVariableValue_hook.create(game::SetVariableValue_ADDR(), SetVariableValue_stub); + SetVariableEntityFieldValue_hook.create(game::SetVariableEntityFieldValue.get(), SetVariableEntityFieldValue_stub); + Scr_EvalVariable_hook.create(game::Scr_EvalVariable_ADDR(), Scr_EvalVariable_stub); + Scr_EvalVariableObject_hook.create(game::Scr_EvalVariableObject_ADDR(), Scr_EvalVariableObject_stub); + Scr_EvalVariableEntityField_hook.create(game::Scr_EvalVariableEntityField_ADDR(), Scr_EvalVariableEntityField_stub); + Scr_EvalVariableField_hook.create(game::Scr_EvalVariableField_ADDR(), Scr_EvalVariableField_stub); + Scr_EvalSizeValue_hook.create(game::Scr_EvalSizeValue_ADDR(), Scr_EvalSizeValue_stub); + GetObject_hook.create(game::GetObject_ADDR(), GetObject_stub); + GetArray_hook.create(game::GetArray_ADDR(), GetArray_stub); + Scr_EvalBoolComplement_hook.create(game::Scr_EvalBoolComplement_ADDR(), Scr_EvalBoolComplement_stub); + Scr_CastBool_hook.create(game::Scr_CastBool_ADDR(), Scr_CastBool_stub); + Scr_CastString_hook.create(game::Scr_CastString_ADDR(), Scr_CastString_stub); + Scr_CastDebugString_hook.create(game::Scr_CastDebugString_ADDR(), Scr_CastDebugString_stub); + Scr_ClearVector_hook.create(game::Scr_ClearVector.get(), Scr_ClearVector_stub); + Scr_CastVector_hook.create(game::Scr_CastVector_ADDR(), Scr_CastVector_stub); + Scr_EvalFieldObject_hook.create(game::Scr_EvalFieldObject_ADDR(), Scr_EvalFieldObject_stub); + Scr_UnmatchingTypesError_hook.create(game::Scr_UnmatchingTypesError_ADDR(), Scr_UnmatchingTypesError_stub); + Scr_CastWeakerPair_hook.create(game::Scr_CastWeakerPair_ADDR(), Scr_CastWeakerPair_stub); + Scr_CastWeakerStringPair_hook.create(game::Scr_CastWeakerStringPair_ADDR(), Scr_CastWeakerStringPair_stub); + Scr_EvalOr_hook.create(game::Scr_EvalOr_ADDR(), Scr_EvalOr_stub); + Scr_EvalExOr_hook.create(game::Scr_EvalExOr_ADDR(), Scr_EvalExOr_stub); + Scr_EvalAnd_hook.create(game::Scr_EvalAnd_ADDR(), Scr_EvalAnd_stub); + Scr_EvalEquality_hook.create(game::Scr_EvalEquality_ADDR(), Scr_EvalEquality_stub); + Scr_EvalLess_hook.create(game::Scr_EvalLess_ADDR(), Scr_EvalLess_stub); + Scr_EvalGreaterEqual_hook.create(game::Scr_EvalGreaterEqual_ADDR(), Scr_EvalGreaterEqual_stub); + Scr_EvalGreater_hook.create(game::Scr_EvalGreater_ADDR(), Scr_EvalGreater_stub); + Scr_EvalLessEqual_hook.create(game::Scr_EvalLessEqual_ADDR(), Scr_EvalLessEqual_stub); + Scr_EvalShiftLeft_hook.create(game::Scr_EvalShiftLeft_ADDR(), Scr_EvalShiftLeft_stub); + Scr_EvalShiftRight_hook.create(game::Scr_EvalShiftRight_ADDR(), Scr_EvalShiftRight_stub); + Scr_EvalPlus_hook.create(game::Scr_EvalPlus_ADDR(), Scr_EvalPlus_stub); + Scr_EvalMinus_hook.create(game::Scr_EvalMinus_ADDR(), Scr_EvalMinus_stub); + Scr_EvalMultiply_hook.create(game::Scr_EvalMultiply_ADDR(), Scr_EvalMultiply_stub); + Scr_EvalDivide_hook.create(game::Scr_EvalDivide_ADDR(), Scr_EvalDivide_stub); + Scr_EvalMod_hook.create(game::Scr_EvalMod_ADDR(), Scr_EvalMod_stub); + Scr_EvalBinaryOperator_hook.create(game::Scr_EvalBinaryOperator_ADDR(), Scr_EvalBinaryOperator_stub); + Scr_FreeEntityNum_hook.create(game::Scr_FreeEntityNum_ADDR(), Scr_FreeEntityNum_stub); + Scr_FreeEntityList_hook.create(game::Scr_FreeEntityList.get(), Scr_FreeEntityList_stub); + Scr_FreeObjects_hook.create(game::Scr_FreeObjects.get(), Scr_FreeObjects_stub); + Scr_SetClassMap_hook.create(game::Scr_SetClassMap_ADDR(), Scr_SetClassMap_stub); + Scr_RemoveClassMap_hook.create(game::Scr_RemoveClassMap_ADDR(), Scr_RemoveClassMap_stub); + Scr_AddClassField_hook.create(game::Scr_AddClassField_ADDR(), Scr_AddClassField_stub); + Scr_GetOffset_hook.create(game::Scr_GetOffset_ADDR(), Scr_GetOffset_stub); + FindEntityId_hook.create(game::FindEntityId_ADDR(), FindEntityId_stub); + Scr_GetEntityId_hook.create(game::Scr_GetEntityId_ADDR(), Scr_GetEntityId_stub); + Scr_FindArrayIndex_hook.create(game::Scr_FindArrayIndex_ADDR(), Scr_FindArrayIndex_stub); + Scr_EvalArray_hook.create(game::Scr_EvalArray_ADDR(), Scr_EvalArray_stub); + Scr_EvalArrayRef_hook.create(game::Scr_EvalArrayRef_ADDR(), Scr_EvalArrayRef_stub); + ClearArray_hook.create(game::ClearArray_ADDR(), ClearArray_stub); + SetEmptyArray_hook.create(game::SetEmptyArray_ADDR(), SetEmptyArray_stub); + Scr_AddArrayKeys_hook.create(game::Scr_AddArrayKeys.get(), Scr_AddArrayKeys_stub); + Scr_GetEntityIdRef_hook.create(game::Scr_GetEntityIdRef_ADDR(), Scr_GetEntityIdRef_stub); + CopyEntity_hook.create(game::CopyEntity_ADDR(), CopyEntity_stub); + Scr_GetEndonUsage_hook.create(game::Scr_GetEndonUsage_ADDR(), Scr_GetEndonUsage_stub); + Scr_GetObjectUsage_hook.create(game::Scr_GetObjectUsage.get(), Scr_GetObjectUsage_stub); + Scr_GetThreadUsage_hook.create(game::Scr_GetThreadUsage_ADDR(), Scr_GetThreadUsage_stub); + Scr_FindField_hook.create(game::Scr_FindField_ADDR(), Scr_FindField_stub); + Scr_GetSourceFile_LoadObj_hook.create(game::Scr_GetSourceFile_LoadObj.get(), Scr_GetSourceFile_LoadObj_stub); + Scr_GetSourceFile_FastFile_hook.create(game::Scr_GetSourceFile_FastFile.get(), Scr_GetSourceFile_FastFile_stub); + Scr_AddFieldsForFile_hook.create(game::Scr_AddFieldsForFile.get(), Scr_AddFieldsForFile_stub); + Scr_AddFields_LoadObj_hook.create(game::Scr_AddFields_LoadObj.get(), Scr_AddFields_LoadObj_stub); + Scr_AddFields_FastFile_hook.create(game::Scr_AddFields_FastFile.get(), Scr_AddFields_FastFile_stub); + Scr_MakeValuePrimitive_hook.create(game::Scr_MakeValuePrimitive.get(), Scr_MakeValuePrimitive_stub); + Scr_FreeGameVariable_hook.create(game::Scr_FreeGameVariable_ADDR(), Scr_FreeGameVariable_stub); + Scr_SLHasLowercaseString_hook.create(game::Scr_SLHasLowercaseString_ADDR(), Scr_SLHasLowercaseString_stub); - ThreadInfoCompare_hook.create(game::ThreadInfoCompare.get(), ThreadInfoCompare_stub, quick); - Scr_DumpScriptThreads_hook.create(game::Scr_DumpScriptThreads.get(), Scr_DumpScriptThreads_stub, quick); - Scr_InitVariableRange_hook.create(game::Scr_InitVariableRange_ADDR(), Scr_InitVariableRange_stub, quick); - Scr_InitClassMap_hook.create(game::Scr_InitClassMap_ADDR(), Scr_InitClassMap_stub, quick); - GetNewVariableIndexInternal3_hook.create(game::GetNewVariableIndexInternal3.get(), GetNewVariableIndexInternal3_stub, quick); - GetNewVariableIndexInternal2_hook.create(game::GetNewVariableIndexInternal2_ADDR(), GetNewVariableIndexInternal2_stub, quick); - GetNewVariableIndexReverseInternal2_hook.create(game::GetNewVariableIndexReverseInternal2_ADDR(), GetNewVariableIndexReverseInternal2_stub, quick); - MakeVariableExternal_hook.create(game::MakeVariableExternal_ADDR(), MakeVariableExternal_stub, quick); - FreeChildValue_hook.create(game::FreeChildValue_ADDR(), FreeChildValue_stub, quick); - ClearObjectInternal_hook.create(game::ClearObjectInternal.get(), ClearObjectInternal_stub, quick); - ClearObject_hook.create(game::ClearObject_ADDR(), ClearObject_stub, quick); - Scr_StopThread_hook.create(game::Scr_StopThread_ADDR(), Scr_StopThread_stub, quick); - GetSafeParentLocalId_hook.create(game::GetSafeParentLocalId_ADDR(), GetSafeParentLocalId_stub, quick); - GetStartLocalId_hook.create(game::GetStartLocalId_ADDR(), GetStartLocalId_stub, quick); - Scr_KillThread_hook.create(game::Scr_KillThread_ADDR(), Scr_KillThread_stub, quick); - AllocVariable_hook.create(game::AllocVariable_ADDR(), AllocVariable_stub, quick); - FreeVariable_hook.create(game::FreeVariable_ADDR(), FreeVariable_stub, quick); - AllocValue_hook.create(game::AllocValue_ADDR(), AllocValue_stub, quick); - AllocEntity_hook.create(game::AllocEntity_ADDR(), AllocEntity_stub, quick); - Scr_AllocArray_hook.create(game::Scr_AllocArray_ADDR(), Scr_AllocArray_stub, quick); - AllocChildThread_hook.create(game::AllocChildThread_ADDR(), AllocChildThread_stub, quick); - FreeValue_hook.create(game::FreeValue_ADDR(), FreeValue_stub, quick); - RemoveRefToObject_hook.create(game::RemoveRefToObject_ADDR(), RemoveRefToObject_stub, quick); - Scr_AllocVector_hook.create(game::Scr_AllocVector_ADDR(), Scr_AllocVector_stub, quick); - RemoveRefToVector_hook.create(game::RemoveRefToVector_ADDR(), RemoveRefToVector_stub, quick); - AddRefToValue_hook.create(game::AddRefToValue_ADDR(), AddRefToValue_stub, quick); - RemoveRefToValueInternal_hook.create(game::RemoveRefToValueInternal.get(), RemoveRefToValueInternal_stub, quick); - FindArrayVariable_hook.create(game::FindArrayVariable_ADDR(), FindArrayVariable_stub, quick); - FindVariable_hook.create(game::FindVariable_ADDR(), FindVariable_stub, quick); - GetArrayVariableIndex_hook.create(game::GetArrayVariableIndex_ADDR(), GetArrayVariableIndex_stub, quick); - Scr_GetVariableFieldIndex_hook.create(game::Scr_GetVariableFieldIndex_ADDR(), Scr_GetVariableFieldIndex_stub, quick); - Scr_FindVariableField_hook.create(game::Scr_FindVariableField_ADDR(), Scr_FindVariableField_stub, quick); - ClearVariableField_hook.create(game::ClearVariableField_ADDR(), ClearVariableField_stub, quick); - GetVariable_hook.create(game::GetVariable_ADDR(), GetVariable_stub, quick); - GetNewVariable_hook.create(game::GetNewVariable_ADDR(), GetNewVariable_stub, quick); - GetObjectVariable_hook.create(game::GetObjectVariable_ADDR(), GetObjectVariable_stub, quick); - GetNewObjectVariable_hook.create(game::GetNewObjectVariable_ADDR(), GetNewObjectVariable_stub, quick); - RemoveVariable_hook.create(game::RemoveVariable_ADDR(), RemoveVariable_stub, quick); - RemoveNextVariable_hook.create(game::RemoveNextVariable_ADDR(), RemoveNextVariable_stub, quick); - SafeRemoveVariable_hook.create(game::SafeRemoveVariable_ADDR(), SafeRemoveVariable_stub, quick); - CopyArray_hook.create(game::CopyArray.get(), CopyArray_stub, quick); - SetVariableValue_hook.create(game::SetVariableValue_ADDR(), SetVariableValue_stub, quick); - SetVariableEntityFieldValue_hook.create(game::SetVariableEntityFieldValue.get(), SetVariableEntityFieldValue_stub, quick); - Scr_EvalVariable_hook.create(game::Scr_EvalVariable_ADDR(), Scr_EvalVariable_stub, quick); - Scr_EvalVariableObject_hook.create(game::Scr_EvalVariableObject_ADDR(), Scr_EvalVariableObject_stub, quick); - Scr_EvalVariableEntityField_hook.create(game::Scr_EvalVariableEntityField_ADDR(), Scr_EvalVariableEntityField_stub, quick); - Scr_EvalVariableField_hook.create(game::Scr_EvalVariableField_ADDR(), Scr_EvalVariableField_stub, quick); - Scr_EvalSizeValue_hook.create(game::Scr_EvalSizeValue_ADDR(), Scr_EvalSizeValue_stub, quick); - GetObject_hook.create(game::GetObject_ADDR(), GetObject_stub, quick); - GetArray_hook.create(game::GetArray_ADDR(), GetArray_stub, quick); - Scr_EvalBoolComplement_hook.create(game::Scr_EvalBoolComplement_ADDR(), Scr_EvalBoolComplement_stub, quick); - Scr_CastBool_hook.create(game::Scr_CastBool_ADDR(), Scr_CastBool_stub, quick); - Scr_CastString_hook.create(game::Scr_CastString_ADDR(), Scr_CastString_stub, quick); - Scr_CastDebugString_hook.create(game::Scr_CastDebugString_ADDR(), Scr_CastDebugString_stub, quick); - Scr_ClearVector_hook.create(game::Scr_ClearVector.get(), Scr_ClearVector_stub, quick); - Scr_CastVector_hook.create(game::Scr_CastVector_ADDR(), Scr_CastVector_stub, quick); - Scr_EvalFieldObject_hook.create(game::Scr_EvalFieldObject_ADDR(), Scr_EvalFieldObject_stub, quick); - Scr_UnmatchingTypesError_hook.create(game::Scr_UnmatchingTypesError_ADDR(), Scr_UnmatchingTypesError_stub, quick); - Scr_CastWeakerPair_hook.create(game::Scr_CastWeakerPair_ADDR(), Scr_CastWeakerPair_stub, quick); - Scr_CastWeakerStringPair_hook.create(game::Scr_CastWeakerStringPair_ADDR(), Scr_CastWeakerStringPair_stub, quick); - Scr_EvalOr_hook.create(game::Scr_EvalOr_ADDR(), Scr_EvalOr_stub, quick); - Scr_EvalExOr_hook.create(game::Scr_EvalExOr_ADDR(), Scr_EvalExOr_stub, quick); - Scr_EvalAnd_hook.create(game::Scr_EvalAnd_ADDR(), Scr_EvalAnd_stub, quick); - Scr_EvalEquality_hook.create(game::Scr_EvalEquality_ADDR(), Scr_EvalEquality_stub, quick); - Scr_EvalLess_hook.create(game::Scr_EvalLess_ADDR(), Scr_EvalLess_stub, quick); - Scr_EvalGreaterEqual_hook.create(game::Scr_EvalGreaterEqual_ADDR(), Scr_EvalGreaterEqual_stub, quick); - Scr_EvalGreater_hook.create(game::Scr_EvalGreater_ADDR(), Scr_EvalGreater_stub, quick); - Scr_EvalLessEqual_hook.create(game::Scr_EvalLessEqual_ADDR(), Scr_EvalLessEqual_stub, quick); - Scr_EvalShiftLeft_hook.create(game::Scr_EvalShiftLeft_ADDR(), Scr_EvalShiftLeft_stub, quick); - Scr_EvalShiftRight_hook.create(game::Scr_EvalShiftRight_ADDR(), Scr_EvalShiftRight_stub, quick); - Scr_EvalPlus_hook.create(game::Scr_EvalPlus_ADDR(), Scr_EvalPlus_stub, quick); - Scr_EvalMinus_hook.create(game::Scr_EvalMinus_ADDR(), Scr_EvalMinus_stub, quick); - Scr_EvalMultiply_hook.create(game::Scr_EvalMultiply_ADDR(), Scr_EvalMultiply_stub, quick); - Scr_EvalDivide_hook.create(game::Scr_EvalDivide_ADDR(), Scr_EvalDivide_stub, quick); - Scr_EvalMod_hook.create(game::Scr_EvalMod_ADDR(), Scr_EvalMod_stub, quick); - Scr_EvalBinaryOperator_hook.create(game::Scr_EvalBinaryOperator_ADDR(), Scr_EvalBinaryOperator_stub, quick); - Scr_FreeEntityNum_hook.create(game::Scr_FreeEntityNum_ADDR(), Scr_FreeEntityNum_stub, quick); - Scr_FreeEntityList_hook.create(game::Scr_FreeEntityList.get(), Scr_FreeEntityList_stub, quick); - Scr_FreeObjects_hook.create(game::Scr_FreeObjects.get(), Scr_FreeObjects_stub, quick); - Scr_SetClassMap_hook.create(game::Scr_SetClassMap_ADDR(), Scr_SetClassMap_stub, quick); - Scr_RemoveClassMap_hook.create(game::Scr_RemoveClassMap_ADDR(), Scr_RemoveClassMap_stub, quick); - Scr_AddClassField_hook.create(game::Scr_AddClassField_ADDR(), Scr_AddClassField_stub, quick); - Scr_GetOffset_hook.create(game::Scr_GetOffset_ADDR(), Scr_GetOffset_stub, quick); - FindEntityId_hook.create(game::FindEntityId_ADDR(), FindEntityId_stub, quick); - Scr_GetEntityId_hook.create(game::Scr_GetEntityId_ADDR(), Scr_GetEntityId_stub, quick); - Scr_FindArrayIndex_hook.create(game::Scr_FindArrayIndex_ADDR(), Scr_FindArrayIndex_stub, quick); - Scr_EvalArray_hook.create(game::Scr_EvalArray_ADDR(), Scr_EvalArray_stub, quick); - Scr_EvalArrayRef_hook.create(game::Scr_EvalArrayRef_ADDR(), Scr_EvalArrayRef_stub, quick); - ClearArray_hook.create(game::ClearArray_ADDR(), ClearArray_stub, quick); - SetEmptyArray_hook.create(game::SetEmptyArray_ADDR(), SetEmptyArray_stub, quick); - Scr_AddArrayKeys_hook.create(game::Scr_AddArrayKeys.get(), Scr_AddArrayKeys_stub, quick); - Scr_GetEntityIdRef_hook.create(game::Scr_GetEntityIdRef_ADDR(), Scr_GetEntityIdRef_stub, quick); - CopyEntity_hook.create(game::CopyEntity_ADDR(), CopyEntity_stub, quick); - Scr_GetEndonUsage_hook.create(game::Scr_GetEndonUsage_ADDR(), Scr_GetEndonUsage_stub, quick); - Scr_GetObjectUsage_hook.create(game::Scr_GetObjectUsage.get(), Scr_GetObjectUsage_stub, quick); - Scr_GetThreadUsage_hook.create(game::Scr_GetThreadUsage_ADDR(), Scr_GetThreadUsage_stub, quick); - Scr_FindField_hook.create(game::Scr_FindField_ADDR(), Scr_FindField_stub, quick); - Scr_GetSourceFile_LoadObj_hook.create(game::Scr_GetSourceFile_LoadObj.get(), Scr_GetSourceFile_LoadObj_stub, quick); - Scr_GetSourceFile_FastFile_hook.create(game::Scr_GetSourceFile_FastFile.get(), Scr_GetSourceFile_FastFile_stub, quick); - Scr_AddFieldsForFile_hook.create(game::Scr_AddFieldsForFile.get(), Scr_AddFieldsForFile_stub, quick); - Scr_AddFields_LoadObj_hook.create(game::Scr_AddFields_LoadObj.get(), Scr_AddFields_LoadObj_stub, quick); - Scr_AddFields_FastFile_hook.create(game::Scr_AddFields_FastFile.get(), Scr_AddFields_FastFile_stub, quick); - Scr_MakeValuePrimitive_hook.create(game::Scr_MakeValuePrimitive.get(), Scr_MakeValuePrimitive_stub, quick); - Scr_FreeGameVariable_hook.create(game::Scr_FreeGameVariable_ADDR(), Scr_FreeGameVariable_stub, quick); - Scr_SLHasLowercaseString_hook.create(game::Scr_SLHasLowercaseString_ADDR(), Scr_SLHasLowercaseString_stub, quick); + //Original hook function addresses + ThreadInfoCompare_original = ThreadInfoCompare_hook.get_original(); + Scr_DumpScriptThreads_original = Scr_DumpScriptThreads_hook.get_original(); + Scr_InitVariableRange_original = Scr_InitVariableRange_hook.get_original(); + Scr_InitClassMap_original = Scr_InitClassMap_hook.get_original(); + GetNewVariableIndexInternal3_original = GetNewVariableIndexInternal3_hook.get_original(); + GetNewVariableIndexInternal2_original = GetNewVariableIndexInternal2_hook.get_original(); + GetNewVariableIndexReverseInternal2_original = GetNewVariableIndexReverseInternal2_hook.get_original(); + MakeVariableExternal_original = MakeVariableExternal_hook.get_original(); + FreeChildValue_original = FreeChildValue_hook.get_original(); + ClearObjectInternal_original = ClearObjectInternal_hook.get_original(); + ClearObject_original = ClearObject_hook.get_original(); + Scr_StopThread_original = Scr_StopThread_hook.get_original(); + GetSafeParentLocalId_original = GetSafeParentLocalId_hook.get_original(); + GetStartLocalId_original = GetStartLocalId_hook.get_original(); + Scr_KillThread_original = Scr_KillThread_hook.get_original(); + AllocVariable_original = AllocVariable_hook.get_original(); + FreeVariable_original = FreeVariable_hook.get_original(); + AllocValue_original = AllocValue_hook.get_original(); + AllocEntity_original = AllocEntity_hook.get_original(); + Scr_AllocArray_original = Scr_AllocArray_hook.get_original(); + AllocChildThread_original = AllocChildThread_hook.get_original(); + FreeValue_original = FreeValue_hook.get_original(); + RemoveRefToObject_original = RemoveRefToObject_hook.get_original(); + Scr_AllocVector_original = Scr_AllocVector_hook.get_original(); + RemoveRefToVector_original = RemoveRefToVector_hook.get_original(); + AddRefToValue_original = AddRefToValue_hook.get_original(); + RemoveRefToValueInternal_original = RemoveRefToValueInternal_hook.get_original(); + FindArrayVariable_original = FindArrayVariable_hook.get_original(); + FindVariable_original = FindVariable_hook.get_original(); + GetArrayVariableIndex_original = GetArrayVariableIndex_hook.get_original(); + Scr_GetVariableFieldIndex_original = Scr_GetVariableFieldIndex_hook.get_original(); + Scr_FindVariableField_original = Scr_FindVariableField_hook.get_original(); + ClearVariableField_original = ClearVariableField_hook.get_original(); + GetVariable_original = GetVariable_hook.get_original(); + GetNewVariable_original = GetNewVariable_hook.get_original(); + GetObjectVariable_original = GetObjectVariable_hook.get_original(); + GetNewObjectVariable_original = GetNewObjectVariable_hook.get_original(); + RemoveVariable_original = RemoveVariable_hook.get_original(); + RemoveNextVariable_original = RemoveNextVariable_hook.get_original(); + SafeRemoveVariable_original = SafeRemoveVariable_hook.get_original(); + CopyArray_original = CopyArray_hook.get_original(); + SetVariableValue_original = SetVariableValue_hook.get_original(); + SetVariableEntityFieldValue_original = SetVariableEntityFieldValue_hook.get_original(); + Scr_EvalVariable_original = Scr_EvalVariable_hook.get_original(); + Scr_EvalVariableObject_original = Scr_EvalVariableObject_hook.get_original(); + Scr_EvalVariableEntityField_original = Scr_EvalVariableEntityField_hook.get_original(); + Scr_EvalVariableField_original = Scr_EvalVariableField_hook.get_original(); + Scr_EvalSizeValue_original = Scr_EvalSizeValue_hook.get_original(); + GetObject_original = GetObject_hook.get_original(); + GetArray_original = GetArray_hook.get_original(); + Scr_EvalBoolComplement_original = Scr_EvalBoolComplement_hook.get_original(); + Scr_CastBool_original = Scr_CastBool_hook.get_original(); + Scr_CastString_original = Scr_CastString_hook.get_original(); + Scr_CastDebugString_original = Scr_CastDebugString_hook.get_original(); + Scr_ClearVector_original = Scr_ClearVector_hook.get_original(); + Scr_CastVector_original = Scr_CastVector_hook.get_original(); + Scr_EvalFieldObject_original = Scr_EvalFieldObject_hook.get_original(); + Scr_UnmatchingTypesError_original = Scr_UnmatchingTypesError_hook.get_original(); + Scr_CastWeakerPair_original = Scr_CastWeakerPair_hook.get_original(); + Scr_CastWeakerStringPair_original = Scr_CastWeakerStringPair_hook.get_original(); + Scr_EvalOr_original = Scr_EvalOr_hook.get_original(); + Scr_EvalExOr_original = Scr_EvalExOr_hook.get_original(); + Scr_EvalAnd_original = Scr_EvalAnd_hook.get_original(); + Scr_EvalEquality_original = Scr_EvalEquality_hook.get_original(); + Scr_EvalLess_original = Scr_EvalLess_hook.get_original(); + Scr_EvalGreaterEqual_original = Scr_EvalGreaterEqual_hook.get_original(); + Scr_EvalGreater_original = Scr_EvalGreater_hook.get_original(); + Scr_EvalLessEqual_original = Scr_EvalLessEqual_hook.get_original(); + Scr_EvalShiftLeft_original = Scr_EvalShiftLeft_hook.get_original(); + Scr_EvalShiftRight_original = Scr_EvalShiftRight_hook.get_original(); + Scr_EvalPlus_original = Scr_EvalPlus_hook.get_original(); + Scr_EvalMinus_original = Scr_EvalMinus_hook.get_original(); + Scr_EvalMultiply_original = Scr_EvalMultiply_hook.get_original(); + Scr_EvalDivide_original = Scr_EvalDivide_hook.get_original(); + Scr_EvalMod_original = Scr_EvalMod_hook.get_original(); + Scr_EvalBinaryOperator_original = Scr_EvalBinaryOperator_hook.get_original(); + Scr_FreeEntityNum_original = Scr_FreeEntityNum_hook.get_original(); + Scr_FreeEntityList_original = Scr_FreeEntityList_hook.get_original(); + Scr_FreeObjects_original = Scr_FreeObjects_hook.get_original(); + Scr_SetClassMap_original = Scr_SetClassMap_hook.get_original(); + Scr_RemoveClassMap_original = Scr_RemoveClassMap_hook.get_original(); + Scr_AddClassField_original = Scr_AddClassField_hook.get_original(); + Scr_GetOffset_original = Scr_GetOffset_hook.get_original(); + FindEntityId_original = FindEntityId_hook.get_original(); + Scr_GetEntityId_original = Scr_GetEntityId_hook.get_original(); + Scr_FindArrayIndex_original = Scr_FindArrayIndex_hook.get_original(); + Scr_EvalArray_original = Scr_EvalArray_hook.get_original(); + Scr_EvalArrayRef_original = Scr_EvalArrayRef_hook.get_original(); + ClearArray_original = ClearArray_hook.get_original(); + SetEmptyArray_original = SetEmptyArray_hook.get_original(); + Scr_AddArrayKeys_original = Scr_AddArrayKeys_hook.get_original(); + Scr_GetEntityIdRef_original = Scr_GetEntityIdRef_hook.get_original(); + CopyEntity_original = CopyEntity_hook.get_original(); + Scr_GetEndonUsage_original = Scr_GetEndonUsage_hook.get_original(); + Scr_GetObjectUsage_original = Scr_GetObjectUsage_hook.get_original(); + Scr_GetThreadUsage_original = Scr_GetThreadUsage_hook.get_original(); + Scr_FindField_original = Scr_FindField_hook.get_original(); + Scr_GetSourceFile_LoadObj_original = Scr_GetSourceFile_LoadObj_hook.get_original(); + Scr_GetSourceFile_FastFile_original = Scr_GetSourceFile_FastFile_hook.get_original(); + Scr_AddFieldsForFile_original = Scr_AddFieldsForFile_hook.get_original(); + Scr_AddFields_LoadObj_original = Scr_AddFields_LoadObj_hook.get_original(); + Scr_AddFields_FastFile_original = Scr_AddFields_FastFile_hook.get_original(); + Scr_MakeValuePrimitive_original = Scr_MakeValuePrimitive_hook.get_original(); + Scr_FreeGameVariable_original = Scr_FreeGameVariable_hook.get_original(); + Scr_SLHasLowercaseString_original = Scr_SLHasLowercaseString_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_vm.cpp b/src/component/decomp/clientscript/re_cscr_vm.cpp index 5c91c73..c4d770f 100644 --- a/src/component/decomp/clientscript/re_cscr_vm.cpp +++ b/src/component/decomp/clientscript/re_cscr_vm.cpp @@ -79,6 +79,79 @@ namespace re_cscr_vm utils::hook::detour Scr_RunCurrentThreads_hook; utils::hook::detour Scr_ResetTimeout_hook; + void* Scr_VM_Init_original; + void* Scr_Init_original; + void* Scr_Shutdown_original; + void* Scr_ErrorInternal_original; + void* Scr_ClearOutParams_original; + void* GetDummyObject_original; + void* GetDummyFieldValue_original; + void* VM_ExecuteInternal_original; + void* VM_CancelNotifyInternal_original; + void* VM_CancelNotify_original; + void* VM_ArchiveStack_original; + void* Scr_AddLocalVars_original; + void* VM_UnarchiveStack_original; + void* VM_TerminateStack_original; + void* VM_TrimStack_original; + void* Scr_TerminateRunningThread_original; + void* Scr_TerminateWaitThread_original; + void* Scr_CancelWaittill_original; + void* Scr_TerminateWaittillThread_original; + void* Scr_TerminateThread_original; + void* VM_Notify_original; + void* Scr_NotifyNum_Internal_original; + void* Scr_CancelNotifyList_original; + void* VM_TerminateTime_original; + void* VM_Resume_original; + void* VM_Execute_original; + void* Scr_ExecThread_original; + void* Scr_ExecEntThread_original; + void* Scr_AddExecThread_original; + void* VM_SetTime_original; + void* Scr_InitSystem_original; + void* Scr_ShutdownSystem_original; + void* Scr_IsSystemActive_original; + void* Scr_GetInt_original; + void* Scr_GetAnim_original; + void* Scr_GetAnimTree_original; + void* Scr_GetFloat_original; + void* Scr_GetConstString_original; + void* Scr_GetConstLowercaseString_original; + void* Scr_GetString_original; + void* Scr_GetConstStringIncludeNull_original; + void* Scr_GetDebugString_original; + void* Scr_GetConstIString_original; + void* Scr_GetVector_original; + void* Scr_GetFunc_original; + void* Scr_GetEntityRef_original; + void* Scr_GetObject_original; + void* Scr_GetType_original; + void* Scr_GetTypeName_original; + void* Scr_GetPointerType_original; + void* Scr_AddInt_original; + void* Scr_AddFloat_original; + void* Scr_AddAnim_original; + void* Scr_AddUndefined_original; + void* Scr_AddObject_original; + void* Scr_AddString_original; + void* Scr_AddIString_original; + void* Scr_AddConstString_original; + void* Scr_AddVector_original; + void* Scr_MakeArray_original; + void* Scr_AddArray_original; + void* Scr_AddArrayStringIndexed_original; + void* Scr_Error_original; + void* Scr_TerminalError_original; + void* Scr_ParamError_original; + void* Scr_ObjectError_original; + void* SetEntityFieldValue_original; + void* GetEntityFieldValue_original; + void* Scr_SetStructField_original; + void* Scr_IncTime_original; + void* Scr_RunCurrentThreads_original; + void* Scr_ResetTimeout_original; + namespace { @@ -94,7 +167,7 @@ namespace re_cscr_vm void Scr_Init_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_Init(a1, Scr_Init_hook.get_original()); + game::Scr_Init(a1, Scr_Init_original); #else codsrc::Scr_Init(a1); #endif @@ -114,7 +187,7 @@ namespace re_cscr_vm void Scr_Shutdown_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_Shutdown(a1, Scr_Shutdown_hook.get_original()); + game::Scr_Shutdown(a1, Scr_Shutdown_original); #else codsrc::Scr_Shutdown(a1); #endif @@ -134,7 +207,7 @@ namespace re_cscr_vm void Scr_ErrorInternal_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_ErrorInternal(a1, Scr_ErrorInternal_hook.get_original()); + game::Scr_ErrorInternal(a1, Scr_ErrorInternal_original); #else codsrc::Scr_ErrorInternal(a1); #endif @@ -154,7 +227,7 @@ namespace re_cscr_vm void Scr_ClearOutParams_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_ClearOutParams(a1, Scr_ClearOutParams_hook.get_original()); + game::Scr_ClearOutParams(a1, Scr_ClearOutParams_original); #else codsrc::Scr_ClearOutParams(a1); #endif @@ -174,7 +247,7 @@ namespace re_cscr_vm unsigned int GetDummyObject_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::GetDummyObject(a1, GetDummyObject_hook.get_original()); + return game::GetDummyObject(a1, GetDummyObject_original); #else return codsrc::GetDummyObject(a1); #endif @@ -194,7 +267,7 @@ namespace re_cscr_vm unsigned int GetDummyFieldValue_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::GetDummyFieldValue(a1, GetDummyFieldValue_hook.get_original()); + return game::GetDummyFieldValue(a1, GetDummyFieldValue_original); #else return codsrc::GetDummyFieldValue(a1); #endif @@ -223,7 +296,7 @@ namespace re_cscr_vm void VM_CancelNotifyInternal_call(game::scriptInstance_t inst, unsigned int notifyListOwnerId, [[maybe_unused]] void* caller_addr, unsigned int startLocalId, unsigned int notifyListId, unsigned int notifyNameListId, unsigned int stringValue) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_CancelNotifyInternal(inst, notifyListOwnerId, startLocalId, notifyListId, notifyNameListId, stringValue, VM_CancelNotifyInternal_hook.get_original()); + game::VM_CancelNotifyInternal(inst, notifyListOwnerId, startLocalId, notifyListId, notifyNameListId, stringValue, VM_CancelNotifyInternal_original); #else codsrc::VM_CancelNotifyInternal(inst, notifyListOwnerId, startLocalId, notifyListId, notifyNameListId, stringValue); #endif @@ -244,7 +317,7 @@ namespace re_cscr_vm void VM_CancelNotify_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2, unsigned int a3) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_CancelNotify(a1, a2, a3, VM_CancelNotify_hook.get_original()); + game::VM_CancelNotify(a1, a2, a3, VM_CancelNotify_original); #else codsrc::VM_CancelNotify(a1, a2, a3); #endif @@ -264,7 +337,7 @@ namespace re_cscr_vm game::VariableStackBuffer* VM_ArchiveStack_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::VM_ArchiveStack(inst, VM_ArchiveStack_hook.get_original()); + return game::VM_ArchiveStack(inst, VM_ArchiveStack_original); #else return codsrc::VM_ArchiveStack(inst); #endif @@ -284,7 +357,7 @@ namespace re_cscr_vm int Scr_AddLocalVars_call(game::scriptInstance_t a1, unsigned int a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_AddLocalVars(a1, a2, Scr_AddLocalVars_hook.get_original()); + return game::Scr_AddLocalVars(a1, a2, Scr_AddLocalVars_original); #else return codsrc::Scr_AddLocalVars(a1, a2); #endif @@ -314,7 +387,7 @@ namespace re_cscr_vm void VM_TerminateStack_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2, unsigned int a3, game::VariableStackBuffer* name) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_TerminateStack(a1, a2, a3, name, VM_TerminateStack_hook.get_original()); + game::VM_TerminateStack(a1, a2, a3, name, VM_TerminateStack_original); #else codsrc::VM_TerminateStack(a1, a2, a3, name); #endif @@ -334,7 +407,7 @@ namespace re_cscr_vm void VM_TrimStack_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int parentId, game::VariableStackBuffer* a3, int fromEndon) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_TrimStack(a1, parentId, a3, fromEndon, VM_TrimStack_hook.get_original()); + game::VM_TrimStack(a1, parentId, a3, fromEndon, VM_TrimStack_original); #else codsrc::VM_TrimStack(a1, parentId, a3, fromEndon); #endif @@ -354,7 +427,7 @@ namespace re_cscr_vm void Scr_TerminateRunningThread_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_TerminateRunningThread(a1, a2, Scr_TerminateRunningThread_hook.get_original()); + game::Scr_TerminateRunningThread(a1, a2, Scr_TerminateRunningThread_original); #else codsrc::Scr_TerminateRunningThread(a1, a2); #endif @@ -374,7 +447,7 @@ namespace re_cscr_vm void Scr_TerminateWaitThread_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2, unsigned int a3) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_TerminateWaitThread(a1, a2, a3, Scr_TerminateWaitThread_hook.get_original()); + game::Scr_TerminateWaitThread(a1, a2, a3, Scr_TerminateWaitThread_original); #else codsrc::Scr_TerminateWaitThread(a1, a2, a3); #endif @@ -394,7 +467,7 @@ namespace re_cscr_vm void Scr_CancelWaittill_call(game::scriptInstance_t inst, unsigned int startLocalId, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_CancelWaittill(inst, startLocalId, Scr_CancelWaittill_hook.get_original()); + game::Scr_CancelWaittill(inst, startLocalId, Scr_CancelWaittill_original); #else codsrc::Scr_CancelWaittill(inst, startLocalId); #endif @@ -415,7 +488,7 @@ namespace re_cscr_vm void Scr_TerminateWaittillThread_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int a2, unsigned int a3) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_TerminateWaittillThread(a1, a2, a3, Scr_TerminateWaittillThread_hook.get_original()); + game::Scr_TerminateWaittillThread(a1, a2, a3, Scr_TerminateWaittillThread_original); #else codsrc::Scr_TerminateWaittillThread(a1, a2, a3); #endif @@ -435,7 +508,7 @@ namespace re_cscr_vm void Scr_TerminateThread_call(unsigned int a2, game::scriptInstance_t a3, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_TerminateThread(a2, a3, Scr_TerminateThread_hook.get_original()); + game::Scr_TerminateThread(a2, a3, Scr_TerminateThread_original); #else codsrc::Scr_TerminateThread(a2, a3); #endif @@ -456,7 +529,7 @@ namespace re_cscr_vm void VM_Notify_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int notifyListOwnerId, unsigned int stringValue, game::VariableValue* top) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_Notify(inst, notifyListOwnerId, stringValue, top, VM_Notify_hook.get_original()); + game::VM_Notify(inst, notifyListOwnerId, stringValue, top, VM_Notify_original); #else codsrc::VM_Notify(inst, notifyListOwnerId, stringValue, top); #endif @@ -476,7 +549,7 @@ namespace re_cscr_vm void Scr_NotifyNum_Internal_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int entNum, int entClass, unsigned int notifStr, int numParams) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_NotifyNum_Internal(inst, entNum, entClass, notifStr, numParams, Scr_NotifyNum_Internal_hook.get_original()); + game::Scr_NotifyNum_Internal(inst, entNum, entClass, notifStr, numParams, Scr_NotifyNum_Internal_original); #else codsrc::Scr_NotifyNum_Internal(inst, entNum, entClass, notifStr, numParams); #endif @@ -496,7 +569,7 @@ namespace re_cscr_vm void Scr_CancelNotifyList_call(unsigned int notifyListOwnerId, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_CancelNotifyList(notifyListOwnerId, inst, Scr_CancelNotifyList_hook.get_original()); + game::Scr_CancelNotifyList(notifyListOwnerId, inst, Scr_CancelNotifyList_original); #else codsrc::Scr_CancelNotifyList(notifyListOwnerId, inst); #endif @@ -516,7 +589,7 @@ namespace re_cscr_vm void VM_TerminateTime_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int parentId) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_TerminateTime(a1, parentId, VM_TerminateTime_hook.get_original()); + game::VM_TerminateTime(a1, parentId, VM_TerminateTime_original); #else codsrc::VM_TerminateTime(a1, parentId); #endif @@ -536,7 +609,7 @@ namespace re_cscr_vm void VM_Resume_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int timeId) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_Resume(inst, timeId, VM_Resume_hook.get_original()); + game::VM_Resume(inst, timeId, VM_Resume_original); #else codsrc::VM_Resume(inst, timeId); #endif @@ -565,7 +638,7 @@ namespace re_cscr_vm unsigned __int16 Scr_ExecThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int handle, unsigned int paramCount) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_ExecThread(inst, handle, paramCount, Scr_ExecThread_hook.get_original()); + return game::Scr_ExecThread(inst, handle, paramCount, Scr_ExecThread_original); #else return codsrc::Scr_ExecThread(inst, handle, paramCount); #endif @@ -584,7 +657,7 @@ namespace re_cscr_vm unsigned __int16 Scr_ExecEntThread_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int entNum, unsigned int handle, int numParams, unsigned int entClass) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_ExecEntThreadNum(inst, entNum, handle, numParams, entClass, Scr_ExecEntThread_hook.get_original()); + return game::Scr_ExecEntThreadNum(inst, entNum, handle, numParams, entClass, Scr_ExecEntThread_original); #else return codsrc::Scr_ExecEntThreadNum(inst, entNum, handle, numParams, entClass); #endif @@ -604,7 +677,7 @@ namespace re_cscr_vm void Scr_AddExecThread_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, unsigned int handle) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddExecThread(a1, handle, Scr_AddExecThread_hook.get_original()); + game::Scr_AddExecThread(a1, handle, Scr_AddExecThread_original); #else codsrc::Scr_AddExecThread(a1, handle); #endif @@ -624,7 +697,7 @@ namespace re_cscr_vm void VM_SetTime_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::VM_SetTime(a1, VM_SetTime_hook.get_original()); + game::VM_SetTime(a1, VM_SetTime_original); #else codsrc::VM_SetTime(a1); #endif @@ -644,7 +717,7 @@ namespace re_cscr_vm void Scr_InitSystem_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_InitSystem(a1, Scr_InitSystem_hook.get_original()); + game::Scr_InitSystem(a1, Scr_InitSystem_original); #else codsrc::Scr_InitSystem(a1); #endif @@ -687,7 +760,7 @@ namespace re_cscr_vm int Scr_GetInt_call(game::scriptInstance_t inst, unsigned int index, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetInt(inst, index, Scr_GetInt_hook.get_original()); + return game::Scr_GetInt(inst, index, Scr_GetInt_original); #else return codsrc::Scr_GetInt(inst, index); #endif @@ -708,7 +781,7 @@ namespace re_cscr_vm game::scr_anim_s Scr_GetAnim_call(unsigned int index, game::XAnimTree_s* a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetAnim(index, a2, Scr_GetAnim_hook.get_original()); + return game::Scr_GetAnim(index, a2, Scr_GetAnim_original); #else return codsrc::Scr_GetAnim(index, a2); #endif @@ -738,7 +811,7 @@ namespace re_cscr_vm float Scr_GetFloat_call(game::scriptInstance_t inst, unsigned int index, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetFloat(inst, index, Scr_GetFloat_hook.get_original()); + return game::Scr_GetFloat(inst, index, Scr_GetFloat_original); #else return codsrc::Scr_GetFloat(inst, index); #endif @@ -766,7 +839,7 @@ namespace re_cscr_vm unsigned int Scr_GetConstString_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int index) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetConstString(inst, index, Scr_GetConstString_hook.get_original()); + return game::Scr_GetConstString(inst, index, Scr_GetConstString_original); #else return codsrc::Scr_GetConstString(inst, index); #endif @@ -786,7 +859,7 @@ namespace re_cscr_vm unsigned int Scr_GetConstLowercaseString_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, unsigned int index) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetConstLowercaseString(inst, index, Scr_GetConstLowercaseString_hook.get_original()); + return game::Scr_GetConstLowercaseString(inst, index, Scr_GetConstLowercaseString_original); #else return codsrc::Scr_GetConstLowercaseString(inst, index); #endif @@ -806,7 +879,7 @@ namespace re_cscr_vm const char* Scr_GetString_call(unsigned int index, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetString(index, inst, Scr_GetString_hook.get_original()); + return game::Scr_GetString(index, inst, Scr_GetString_original); #else return codsrc::Scr_GetString(index, inst); #endif @@ -827,7 +900,7 @@ namespace re_cscr_vm unsigned int Scr_GetConstStringIncludeNull_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetConstStringIncludeNull(a1, Scr_GetConstStringIncludeNull_hook.get_original()); + return game::Scr_GetConstStringIncludeNull(a1, Scr_GetConstStringIncludeNull_original); #else return codsrc::Scr_GetConstStringIncludeNull(a1); #endif @@ -847,7 +920,7 @@ namespace re_cscr_vm char* Scr_GetDebugString_call(game::scriptInstance_t a1, unsigned int a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetDebugString(a1, a2, Scr_GetDebugString_hook.get_original()); + return game::Scr_GetDebugString(a1, a2, Scr_GetDebugString_original); #else return codsrc::Scr_GetDebugString(a1, a2); #endif @@ -868,7 +941,7 @@ namespace re_cscr_vm unsigned int Scr_GetConstIString_call(unsigned int index, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetConstIString(index, Scr_GetConstIString_hook.get_original()); + return game::Scr_GetConstIString(index, Scr_GetConstIString_original); #else return codsrc::Scr_GetConstIString(index); #endif @@ -888,7 +961,7 @@ namespace re_cscr_vm void Scr_GetVector_call(game::scriptInstance_t inst, float* value, [[maybe_unused]] void* caller_addr, unsigned int index) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_GetVector(inst, value, index, Scr_GetVector_hook.get_original()); + game::Scr_GetVector(inst, value, index, Scr_GetVector_original); #else codsrc::Scr_GetVector(inst, value, index); #endif @@ -918,7 +991,7 @@ namespace re_cscr_vm game::scr_entref_t* Scr_GetEntityRef_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, game::scr_entref_t* retstr, unsigned int index) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetEntityRef(inst, retstr, index, Scr_GetEntityRef_hook.get_original()); + return game::Scr_GetEntityRef(inst, retstr, index, Scr_GetEntityRef_original); #else return codsrc::Scr_GetEntityRef(inst, retstr, index); #endif @@ -938,7 +1011,7 @@ namespace re_cscr_vm game::VariableUnion Scr_GetObject_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetObject(a1, Scr_GetObject_hook.get_original()); + return game::Scr_GetObject(a1, Scr_GetObject_original); #else return codsrc::Scr_GetObject(a1); #endif @@ -958,7 +1031,7 @@ namespace re_cscr_vm game::VariableType Scr_GetType_call(game::scriptInstance_t inst, unsigned int index, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetType(inst, index, Scr_GetType_hook.get_original()); + return game::Scr_GetType(inst, index, Scr_GetType_original); #else return codsrc::Scr_GetType(inst, index); #endif @@ -979,7 +1052,7 @@ namespace re_cscr_vm const char* Scr_GetTypeName_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetTypeName(a1, Scr_GetTypeName_hook.get_original()); + return game::Scr_GetTypeName(a1, Scr_GetTypeName_original); #else return codsrc::Scr_GetTypeName(a1); #endif @@ -999,7 +1072,7 @@ namespace re_cscr_vm game::VariableType Scr_GetPointerType_call(game::scriptInstance_t a1, unsigned int a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::Scr_GetPointerType(a1, a2, Scr_GetPointerType_hook.get_original()); + return game::Scr_GetPointerType(a1, a2, Scr_GetPointerType_original); #else return codsrc::Scr_GetPointerType(a1, a2); #endif @@ -1020,7 +1093,7 @@ namespace re_cscr_vm void Scr_AddInt_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int value) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddInt(inst, value, Scr_AddInt_hook.get_original()); + game::Scr_AddInt(inst, value, Scr_AddInt_original); #else codsrc::Scr_AddInt(inst, value); #endif @@ -1040,7 +1113,7 @@ namespace re_cscr_vm void Scr_AddFloat_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, float value) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddFloat(inst, value, Scr_AddFloat_hook.get_original()); + game::Scr_AddFloat(inst, value, Scr_AddFloat_original); #else codsrc::Scr_AddFloat(inst, value); #endif @@ -1069,7 +1142,7 @@ namespace re_cscr_vm void Scr_AddUndefined_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddUndefined(inst, Scr_AddUndefined_hook.get_original()); + game::Scr_AddUndefined(inst, Scr_AddUndefined_original); #else codsrc::Scr_AddUndefined(inst); #endif @@ -1089,7 +1162,7 @@ namespace re_cscr_vm void Scr_AddObject_call(game::scriptInstance_t inst, unsigned int entid, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddObject(inst, entid, Scr_AddObject_hook.get_original()); + game::Scr_AddObject(inst, entid, Scr_AddObject_original); #else codsrc::Scr_AddObject(inst, entid); #endif @@ -1110,7 +1183,7 @@ namespace re_cscr_vm void Scr_AddString_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, char* string) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddString(inst, string, Scr_AddString_hook.get_original()); + game::Scr_AddString(inst, string, Scr_AddString_original); #else codsrc::Scr_AddString(inst, string); #endif @@ -1130,7 +1203,7 @@ namespace re_cscr_vm void Scr_AddIString_call(char* string, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddIString(string, Scr_AddIString_hook.get_original()); + game::Scr_AddIString(string, Scr_AddIString_original); #else codsrc::Scr_AddIString(string); #endif @@ -1150,7 +1223,7 @@ namespace re_cscr_vm void Scr_AddConstString_call(game::scriptInstance_t inst, unsigned int id, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddConstString(inst, id, Scr_AddConstString_hook.get_original()); + game::Scr_AddConstString(inst, id, Scr_AddConstString_original); #else codsrc::Scr_AddConstString(inst, id); #endif @@ -1171,7 +1244,7 @@ namespace re_cscr_vm void Scr_AddVector_call(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, float* value) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddVector(inst, value, Scr_AddVector_hook.get_original()); + game::Scr_AddVector(inst, value, Scr_AddVector_original); #else codsrc::Scr_AddVector(inst, value); #endif @@ -1191,7 +1264,7 @@ namespace re_cscr_vm void Scr_MakeArray_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_MakeArray(a1, Scr_MakeArray_hook.get_original()); + game::Scr_MakeArray(a1, Scr_MakeArray_original); #else codsrc::Scr_MakeArray(a1); #endif @@ -1220,7 +1293,7 @@ namespace re_cscr_vm void Scr_AddArrayStringIndexed_call(unsigned int id, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_AddArrayStringIndexed(id, inst, Scr_AddArrayStringIndexed_hook.get_original()); + game::Scr_AddArrayStringIndexed(id, inst, Scr_AddArrayStringIndexed_original); #else codsrc::Scr_AddArrayStringIndexed(id, inst); #endif @@ -1241,7 +1314,7 @@ namespace re_cscr_vm void Scr_Error_call(const char* err, game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr, int is_terminal) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_Error(err, inst, is_terminal, Scr_Error_hook.get_original()); + game::Scr_Error(err, inst, is_terminal, Scr_Error_original); #else codsrc::Scr_Error(err, inst, is_terminal); #endif @@ -1262,7 +1335,7 @@ namespace re_cscr_vm void Scr_TerminalError_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, char* Source) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_TerminalError(a1, Source, Scr_TerminalError_hook.get_original()); + game::Scr_TerminalError(a1, Source, Scr_TerminalError_original); #else codsrc::Scr_TerminalError(a1, Source); #endif @@ -1282,7 +1355,7 @@ namespace re_cscr_vm void Scr_ParamError_call(int a1, game::scriptInstance_t a2, [[maybe_unused]] void* caller_addr, char* Source) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_ParamError(a1, a2, Source, Scr_ParamError_hook.get_original()); + game::Scr_ParamError(a1, a2, Source, Scr_ParamError_original); #else codsrc::Scr_ParamError(a1, a2, Source); #endif @@ -1303,7 +1376,7 @@ namespace re_cscr_vm void Scr_ObjectError_call(game::scriptInstance_t a1, const char* a2, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_ObjectError(a1, a2, Scr_ObjectError_hook.get_original()); + game::Scr_ObjectError(a1, a2, Scr_ObjectError_original); #else codsrc::Scr_ObjectError(a1, a2); #endif @@ -1324,7 +1397,7 @@ namespace re_cscr_vm bool SetEntityFieldValue_call(game::scriptInstance_t inst, int offset_, int entnum, [[maybe_unused]] void* caller_addr, game::classNum_e classnum, int clientNum, game::VariableValue* value) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::SetEntityFieldValue(inst, offset_, entnum, classnum, clientNum, value, SetEntityFieldValue_hook.get_original()); + return game::SetEntityFieldValue(inst, offset_, entnum, classnum, clientNum, value, SetEntityFieldValue_original); #else return codsrc::SetEntityFieldValue(inst, offset_, entnum, classnum, clientNum, value); #endif @@ -1346,7 +1419,7 @@ namespace re_cscr_vm game::VariableValue GetEntityFieldValue_call(int offset_, int entnum, [[maybe_unused]] void* caller_addr, game::scriptInstance_t inst, game::classNum_e classnum, int clientNum) { #ifdef RE_CSCR_VM_USE_WRAPPERS - return game::GetEntityFieldValue(offset_, entnum, inst, classnum, clientNum, GetEntityFieldValue_hook.get_original()); + return game::GetEntityFieldValue(offset_, entnum, inst, classnum, clientNum, GetEntityFieldValue_original); #else return codsrc::GetEntityFieldValue(offset_, entnum, inst, classnum, clientNum); #endif @@ -1367,7 +1440,7 @@ namespace re_cscr_vm void Scr_SetStructField_call(unsigned int a1, unsigned int a2, [[maybe_unused]] void* caller_addr, game::scriptInstance_t a3) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_SetStructField(a1, a2, a3, Scr_SetStructField_hook.get_original()); + game::Scr_SetStructField(a1, a2, a3, Scr_SetStructField_original); #else codsrc::Scr_SetStructField(a1, a2, a3); #endif @@ -1388,7 +1461,7 @@ namespace re_cscr_vm void Scr_IncTime_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_IncTime(a1, Scr_IncTime_hook.get_original()); + game::Scr_IncTime(a1, Scr_IncTime_original); #else codsrc::Scr_IncTime(a1); #endif @@ -1408,7 +1481,7 @@ namespace re_cscr_vm void Scr_RunCurrentThreads_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_RunCurrentThreads(a1, Scr_RunCurrentThreads_hook.get_original()); + game::Scr_RunCurrentThreads(a1, Scr_RunCurrentThreads_original); #else codsrc::Scr_RunCurrentThreads(a1); #endif @@ -1428,7 +1501,7 @@ namespace re_cscr_vm void Scr_ResetTimeout_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_VM_USE_WRAPPERS - game::Scr_ResetTimeout(a1, Scr_ResetTimeout_hook.get_original()); + game::Scr_ResetTimeout(a1, Scr_ResetTimeout_original); #else codsrc::Scr_ResetTimeout(a1); #endif @@ -1451,83 +1524,152 @@ namespace re_cscr_vm public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_VM_USE_WRAPPERS - quick = false; -#endif + Scr_VM_Init_hook.create(game::Scr_VM_Init.get(), Scr_VM_Init_stub); + Scr_Init_hook.create(game::Scr_Init_ADDR(), Scr_Init_stub); + Scr_Shutdown_hook.create(game::Scr_Shutdown_ADDR(), Scr_Shutdown_stub); + Scr_ErrorInternal_hook.create(game::Scr_ErrorInternal_ADDR(), Scr_ErrorInternal_stub); + Scr_ClearOutParams_hook.create(game::Scr_ClearOutParams_ADDR(), Scr_ClearOutParams_stub); + GetDummyObject_hook.create(game::GetDummyObject_ADDR(), GetDummyObject_stub); + GetDummyFieldValue_hook.create(game::GetDummyFieldValue_ADDR(), GetDummyFieldValue_stub); + VM_ExecuteInternal_hook.create(game::VM_ExecuteInternal.get(), VM_ExecuteInternal_stub); + VM_CancelNotifyInternal_hook.create(game::VM_CancelNotifyInternal_ADDR(), VM_CancelNotifyInternal_stub); + VM_CancelNotify_hook.create(game::VM_CancelNotify_ADDR(), VM_CancelNotify_stub); + VM_ArchiveStack_hook.create(game::VM_ArchiveStack_ADDR(), VM_ArchiveStack_stub); + Scr_AddLocalVars_hook.create(game::Scr_AddLocalVars_ADDR(), Scr_AddLocalVars_stub); + VM_UnarchiveStack_hook.create(game::VM_UnarchiveStack.get(), VM_UnarchiveStack_stub); + VM_TerminateStack_hook.create(game::VM_TerminateStack_ADDR(), VM_TerminateStack_stub); + VM_TrimStack_hook.create(game::VM_TrimStack_ADDR(), VM_TrimStack_stub); + Scr_TerminateRunningThread_hook.create(game::Scr_TerminateRunningThread_ADDR(), Scr_TerminateRunningThread_stub); + Scr_TerminateWaitThread_hook.create(game::Scr_TerminateWaitThread_ADDR(), Scr_TerminateWaitThread_stub); + Scr_CancelWaittill_hook.create(game::Scr_CancelWaittill_ADDR(), Scr_CancelWaittill_stub); + Scr_TerminateWaittillThread_hook.create(game::Scr_TerminateWaittillThread_ADDR(), Scr_TerminateWaittillThread_stub); + Scr_TerminateThread_hook.create(game::Scr_TerminateThread_ADDR(), Scr_TerminateThread_stub); + VM_Notify_hook.create(game::VM_Notify_ADDR(), VM_Notify_stub); + Scr_NotifyNum_Internal_hook.create(game::Scr_NotifyNum_Internal_ADDR(), Scr_NotifyNum_Internal_stub); + Scr_CancelNotifyList_hook.create(game::Scr_CancelNotifyList_ADDR(), Scr_CancelNotifyList_stub); + VM_TerminateTime_hook.create(game::VM_TerminateTime_ADDR(), VM_TerminateTime_stub); + VM_Resume_hook.create(game::VM_Resume_ADDR(), VM_Resume_stub); + VM_Execute_hook.create(game::VM_Execute.get(), VM_Execute_stub); + Scr_ExecThread_hook.create(game::Scr_ExecThread_ADDR(), Scr_ExecThread_stub); + Scr_ExecEntThread_hook.create(game::Scr_ExecEntThread_ADDR(), Scr_ExecEntThread_stub); + Scr_AddExecThread_hook.create(game::Scr_AddExecThread_ADDR(), Scr_AddExecThread_stub); + VM_SetTime_hook.create(game::VM_SetTime_ADDR(), VM_SetTime_stub); + Scr_InitSystem_hook.create(game::Scr_InitSystem_ADDR(), Scr_InitSystem_stub); + Scr_ShutdownSystem_hook.create(game::Scr_ShutdownSystem.get(), Scr_ShutdownSystem_stub); + Scr_IsSystemActive_hook.create(game::Scr_IsSystemActive.get(), Scr_IsSystemActive_stub); + Scr_GetInt_hook.create(game::Scr_GetInt_ADDR(), Scr_GetInt_stub); + Scr_GetAnim_hook.create(game::Scr_GetAnim_ADDR(), Scr_GetAnim_stub); + Scr_GetAnimTree_hook.create(game::Scr_GetAnimTree.get(), Scr_GetAnimTree_stub); + Scr_GetFloat_hook.create(game::Scr_GetFloat_ADDR(), Scr_GetFloat_stub); + Scr_GetConstString_hook.create(game::Scr_GetConstString_ADDR(), Scr_GetConstString_stub); + Scr_GetConstLowercaseString_hook.create(game::Scr_GetConstLowercaseString_ADDR(), Scr_GetConstLowercaseString_stub); + Scr_GetString_hook.create(game::Scr_GetString_ADDR(), Scr_GetString_stub); + Scr_GetConstStringIncludeNull_hook.create(game::Scr_GetConstStringIncludeNull_ADDR(), Scr_GetConstStringIncludeNull_stub); + Scr_GetDebugString_hook.create(game::Scr_GetDebugString_ADDR(), Scr_GetDebugString_stub); + Scr_GetConstIString_hook.create(game::Scr_GetConstIString_ADDR(), Scr_GetConstIString_stub); + Scr_GetVector_hook.create(game::Scr_GetVector_ADDR(), Scr_GetVector_stub); + Scr_GetFunc_hook.create(game::Scr_GetFunc.get(), Scr_GetFunc_stub); + Scr_GetEntityRef_hook.create(game::Scr_GetEntityRef_ADDR(), Scr_GetEntityRef_stub); + Scr_GetObject_hook.create(game::Scr_GetObject_ADDR(), Scr_GetObject_stub); + Scr_GetType_hook.create(game::Scr_GetType_ADDR(), Scr_GetType_stub); + Scr_GetTypeName_hook.create(game::Scr_GetTypeName_ADDR(), Scr_GetTypeName_stub); + Scr_GetPointerType_hook.create(game::Scr_GetPointerType_ADDR(), Scr_GetPointerType_stub); + Scr_AddInt_hook.create(game::Scr_AddInt_ADDR(), Scr_AddInt_stub); + Scr_AddFloat_hook.create(game::Scr_AddFloat_ADDR(), Scr_AddFloat_stub); + Scr_AddAnim_hook.create(game::Scr_AddAnim.get(), Scr_AddAnim_stub); + Scr_AddUndefined_hook.create(game::Scr_AddUndefined_ADDR(), Scr_AddUndefined_stub); + Scr_AddObject_hook.create(game::Scr_AddObject_ADDR(), Scr_AddObject_stub); + Scr_AddString_hook.create(game::Scr_AddString_ADDR(), Scr_AddString_stub); + Scr_AddIString_hook.create(game::Scr_AddIString_ADDR(), Scr_AddIString_stub); + Scr_AddConstString_hook.create(game::Scr_AddConstString_ADDR(), Scr_AddConstString_stub); + Scr_AddVector_hook.create(game::Scr_AddVector_ADDR(), Scr_AddVector_stub); + Scr_MakeArray_hook.create(game::Scr_MakeArray_ADDR(), Scr_MakeArray_stub); + Scr_AddArray_hook.create(game::Scr_AddArray.get(), Scr_AddArray_stub); + Scr_AddArrayStringIndexed_hook.create(game::Scr_AddArrayStringIndexed_ADDR(), Scr_AddArrayStringIndexed_stub); + Scr_Error_hook.create(game::Scr_Error_ADDR(), Scr_Error_stub); + Scr_TerminalError_hook.create(game::Scr_TerminalError_ADDR(), Scr_TerminalError_stub); + Scr_ParamError_hook.create(game::Scr_ParamError_ADDR(), Scr_ParamError_stub); + Scr_ObjectError_hook.create(game::Scr_ObjectError_ADDR(), Scr_ObjectError_stub); + SetEntityFieldValue_hook.create(game::SetEntityFieldValue_ADDR(), SetEntityFieldValue_stub); + GetEntityFieldValue_hook.create(game::GetEntityFieldValue_ADDR(), GetEntityFieldValue_stub); + Scr_SetStructField_hook.create(game::Scr_SetStructField_ADDR(), Scr_SetStructField_stub); + Scr_IncTime_hook.create(game::Scr_IncTime_ADDR(), Scr_IncTime_stub); + Scr_RunCurrentThreads_hook.create(game::Scr_RunCurrentThreads_ADDR(), Scr_RunCurrentThreads_stub); + Scr_ResetTimeout_hook.create(game::Scr_ResetTimeout_ADDR(), Scr_ResetTimeout_stub); - Scr_VM_Init_hook.create(game::Scr_VM_Init.get(), Scr_VM_Init_stub, quick); - Scr_Init_hook.create(game::Scr_Init_ADDR(), Scr_Init_stub, quick); - Scr_Shutdown_hook.create(game::Scr_Shutdown_ADDR(), Scr_Shutdown_stub, quick); - Scr_ErrorInternal_hook.create(game::Scr_ErrorInternal_ADDR(), Scr_ErrorInternal_stub, quick); - Scr_ClearOutParams_hook.create(game::Scr_ClearOutParams_ADDR(), Scr_ClearOutParams_stub, quick); - GetDummyObject_hook.create(game::GetDummyObject_ADDR(), GetDummyObject_stub, quick); - GetDummyFieldValue_hook.create(game::GetDummyFieldValue_ADDR(), GetDummyFieldValue_stub, quick); - VM_ExecuteInternal_hook.create(game::VM_ExecuteInternal.get(), VM_ExecuteInternal_stub, quick); - VM_CancelNotifyInternal_hook.create(game::VM_CancelNotifyInternal_ADDR(), VM_CancelNotifyInternal_stub, quick); - VM_CancelNotify_hook.create(game::VM_CancelNotify_ADDR(), VM_CancelNotify_stub, quick); - VM_ArchiveStack_hook.create(game::VM_ArchiveStack_ADDR(), VM_ArchiveStack_stub, quick); - Scr_AddLocalVars_hook.create(game::Scr_AddLocalVars_ADDR(), Scr_AddLocalVars_stub, quick); - VM_UnarchiveStack_hook.create(game::VM_UnarchiveStack.get(), VM_UnarchiveStack_stub, quick); - VM_TerminateStack_hook.create(game::VM_TerminateStack_ADDR(), VM_TerminateStack_stub, quick); - VM_TrimStack_hook.create(game::VM_TrimStack_ADDR(), VM_TrimStack_stub, quick); - Scr_TerminateRunningThread_hook.create(game::Scr_TerminateRunningThread_ADDR(), Scr_TerminateRunningThread_stub, quick); - Scr_TerminateWaitThread_hook.create(game::Scr_TerminateWaitThread_ADDR(), Scr_TerminateWaitThread_stub, quick); - Scr_CancelWaittill_hook.create(game::Scr_CancelWaittill_ADDR(), Scr_CancelWaittill_stub, quick); - Scr_TerminateWaittillThread_hook.create(game::Scr_TerminateWaittillThread_ADDR(), Scr_TerminateWaittillThread_stub, quick); - Scr_TerminateThread_hook.create(game::Scr_TerminateThread_ADDR(), Scr_TerminateThread_stub, quick); - VM_Notify_hook.create(game::VM_Notify_ADDR(), VM_Notify_stub, quick); - Scr_NotifyNum_Internal_hook.create(game::Scr_NotifyNum_Internal_ADDR(), Scr_NotifyNum_Internal_stub, quick); - Scr_CancelNotifyList_hook.create(game::Scr_CancelNotifyList_ADDR(), Scr_CancelNotifyList_stub, quick); - VM_TerminateTime_hook.create(game::VM_TerminateTime_ADDR(), VM_TerminateTime_stub, quick); - VM_Resume_hook.create(game::VM_Resume_ADDR(), VM_Resume_stub, quick); - VM_Execute_hook.create(game::VM_Execute.get(), VM_Execute_stub, quick); - Scr_ExecThread_hook.create(game::Scr_ExecThread_ADDR(), Scr_ExecThread_stub, quick); - Scr_ExecEntThread_hook.create(game::Scr_ExecEntThread_ADDR(), Scr_ExecEntThread_stub, quick); - Scr_AddExecThread_hook.create(game::Scr_AddExecThread_ADDR(), Scr_AddExecThread_stub, quick); - VM_SetTime_hook.create(game::VM_SetTime_ADDR(), VM_SetTime_stub, quick); - Scr_InitSystem_hook.create(game::Scr_InitSystem_ADDR(), Scr_InitSystem_stub, quick); - Scr_ShutdownSystem_hook.create(game::Scr_ShutdownSystem.get(), Scr_ShutdownSystem_stub, quick); - Scr_IsSystemActive_hook.create(game::Scr_IsSystemActive.get(), Scr_IsSystemActive_stub, quick); - Scr_GetInt_hook.create(game::Scr_GetInt_ADDR(), Scr_GetInt_stub, quick); - Scr_GetAnim_hook.create(game::Scr_GetAnim_ADDR(), Scr_GetAnim_stub, quick); - Scr_GetAnimTree_hook.create(game::Scr_GetAnimTree.get(), Scr_GetAnimTree_stub, quick); - Scr_GetFloat_hook.create(game::Scr_GetFloat_ADDR(), Scr_GetFloat_stub, quick); - Scr_GetConstString_hook.create(game::Scr_GetConstString_ADDR(), Scr_GetConstString_stub, quick); - Scr_GetConstLowercaseString_hook.create(game::Scr_GetConstLowercaseString_ADDR(), Scr_GetConstLowercaseString_stub, quick); - Scr_GetString_hook.create(game::Scr_GetString_ADDR(), Scr_GetString_stub, quick); - Scr_GetConstStringIncludeNull_hook.create(game::Scr_GetConstStringIncludeNull_ADDR(), Scr_GetConstStringIncludeNull_stub, quick); - Scr_GetDebugString_hook.create(game::Scr_GetDebugString_ADDR(), Scr_GetDebugString_stub, quick); - Scr_GetConstIString_hook.create(game::Scr_GetConstIString_ADDR(), Scr_GetConstIString_stub, quick); - Scr_GetVector_hook.create(game::Scr_GetVector_ADDR(), Scr_GetVector_stub, quick); - Scr_GetFunc_hook.create(game::Scr_GetFunc.get(), Scr_GetFunc_stub, quick); - Scr_GetEntityRef_hook.create(game::Scr_GetEntityRef_ADDR(), Scr_GetEntityRef_stub, quick); - Scr_GetObject_hook.create(game::Scr_GetObject_ADDR(), Scr_GetObject_stub, quick); - Scr_GetType_hook.create(game::Scr_GetType_ADDR(), Scr_GetType_stub, quick); - Scr_GetTypeName_hook.create(game::Scr_GetTypeName_ADDR(), Scr_GetTypeName_stub, quick); - Scr_GetPointerType_hook.create(game::Scr_GetPointerType_ADDR(), Scr_GetPointerType_stub, quick); - Scr_AddInt_hook.create(game::Scr_AddInt_ADDR(), Scr_AddInt_stub, quick); - Scr_AddFloat_hook.create(game::Scr_AddFloat_ADDR(), Scr_AddFloat_stub, quick); - Scr_AddAnim_hook.create(game::Scr_AddAnim.get(), Scr_AddAnim_stub, quick); - Scr_AddUndefined_hook.create(game::Scr_AddUndefined_ADDR(), Scr_AddUndefined_stub, quick); - Scr_AddObject_hook.create(game::Scr_AddObject_ADDR(), Scr_AddObject_stub, quick); - Scr_AddString_hook.create(game::Scr_AddString_ADDR(), Scr_AddString_stub, quick); - Scr_AddIString_hook.create(game::Scr_AddIString_ADDR(), Scr_AddIString_stub, quick); - Scr_AddConstString_hook.create(game::Scr_AddConstString_ADDR(), Scr_AddConstString_stub, quick); - Scr_AddVector_hook.create(game::Scr_AddVector_ADDR(), Scr_AddVector_stub, quick); - Scr_MakeArray_hook.create(game::Scr_MakeArray_ADDR(), Scr_MakeArray_stub, quick); - Scr_AddArray_hook.create(game::Scr_AddArray.get(), Scr_AddArray_stub, quick); - Scr_AddArrayStringIndexed_hook.create(game::Scr_AddArrayStringIndexed_ADDR(), Scr_AddArrayStringIndexed_stub, quick); - Scr_Error_hook.create(game::Scr_Error_ADDR(), Scr_Error_stub, quick); - Scr_TerminalError_hook.create(game::Scr_TerminalError_ADDR(), Scr_TerminalError_stub, quick); - Scr_ParamError_hook.create(game::Scr_ParamError_ADDR(), Scr_ParamError_stub, quick); - Scr_ObjectError_hook.create(game::Scr_ObjectError_ADDR(), Scr_ObjectError_stub, quick); - SetEntityFieldValue_hook.create(game::SetEntityFieldValue_ADDR(), SetEntityFieldValue_stub, quick); - GetEntityFieldValue_hook.create(game::GetEntityFieldValue_ADDR(), GetEntityFieldValue_stub, quick); - Scr_SetStructField_hook.create(game::Scr_SetStructField_ADDR(), Scr_SetStructField_stub, quick); - Scr_IncTime_hook.create(game::Scr_IncTime_ADDR(), Scr_IncTime_stub, quick); - Scr_RunCurrentThreads_hook.create(game::Scr_RunCurrentThreads_ADDR(), Scr_RunCurrentThreads_stub, quick); - Scr_ResetTimeout_hook.create(game::Scr_ResetTimeout_ADDR(), Scr_ResetTimeout_stub, quick); + //Original hook function addresses + Scr_VM_Init_original = Scr_VM_Init_hook.get_original(); + Scr_Init_original = Scr_Init_hook.get_original(); + Scr_Shutdown_original = Scr_Shutdown_hook.get_original(); + Scr_ErrorInternal_original = Scr_ErrorInternal_hook.get_original(); + Scr_ClearOutParams_original = Scr_ClearOutParams_hook.get_original(); + GetDummyObject_original = GetDummyObject_hook.get_original(); + GetDummyFieldValue_original = GetDummyFieldValue_hook.get_original(); + VM_ExecuteInternal_original = VM_ExecuteInternal_hook.get_original(); + VM_CancelNotifyInternal_original = VM_CancelNotifyInternal_hook.get_original(); + VM_CancelNotify_original = VM_CancelNotify_hook.get_original(); + VM_ArchiveStack_original = VM_ArchiveStack_hook.get_original(); + Scr_AddLocalVars_original = Scr_AddLocalVars_hook.get_original(); + VM_UnarchiveStack_original = VM_UnarchiveStack_hook.get_original(); + VM_TerminateStack_original = VM_TerminateStack_hook.get_original(); + VM_TrimStack_original = VM_TrimStack_hook.get_original(); + Scr_TerminateRunningThread_original = Scr_TerminateRunningThread_hook.get_original(); + Scr_TerminateWaitThread_original = Scr_TerminateWaitThread_hook.get_original(); + Scr_CancelWaittill_original = Scr_CancelWaittill_hook.get_original(); + Scr_TerminateWaittillThread_original = Scr_TerminateWaittillThread_hook.get_original(); + Scr_TerminateThread_original = Scr_TerminateThread_hook.get_original(); + VM_Notify_original = VM_Notify_hook.get_original(); + Scr_NotifyNum_Internal_original = Scr_NotifyNum_Internal_hook.get_original(); + Scr_CancelNotifyList_original = Scr_CancelNotifyList_hook.get_original(); + VM_TerminateTime_original = VM_TerminateTime_hook.get_original(); + VM_Resume_original = VM_Resume_hook.get_original(); + VM_Execute_original = VM_Execute_hook.get_original(); + Scr_ExecThread_original = Scr_ExecThread_hook.get_original(); + Scr_ExecEntThread_original = Scr_ExecEntThread_hook.get_original(); + Scr_AddExecThread_original = Scr_AddExecThread_hook.get_original(); + VM_SetTime_original = VM_SetTime_hook.get_original(); + Scr_InitSystem_original = Scr_InitSystem_hook.get_original(); + Scr_ShutdownSystem_original = Scr_ShutdownSystem_hook.get_original(); + Scr_IsSystemActive_original = Scr_IsSystemActive_hook.get_original(); + Scr_GetInt_original = Scr_GetInt_hook.get_original(); + Scr_GetAnim_original = Scr_GetAnim_hook.get_original(); + Scr_GetAnimTree_original = Scr_GetAnimTree_hook.get_original(); + Scr_GetFloat_original = Scr_GetFloat_hook.get_original(); + Scr_GetConstString_original = Scr_GetConstString_hook.get_original(); + Scr_GetConstLowercaseString_original = Scr_GetConstLowercaseString_hook.get_original(); + Scr_GetString_original = Scr_GetString_hook.get_original(); + Scr_GetConstStringIncludeNull_original = Scr_GetConstStringIncludeNull_hook.get_original(); + Scr_GetDebugString_original = Scr_GetDebugString_hook.get_original(); + Scr_GetConstIString_original = Scr_GetConstIString_hook.get_original(); + Scr_GetVector_original = Scr_GetVector_hook.get_original(); + Scr_GetFunc_original = Scr_GetFunc_hook.get_original(); + Scr_GetEntityRef_original = Scr_GetEntityRef_hook.get_original(); + Scr_GetObject_original = Scr_GetObject_hook.get_original(); + Scr_GetType_original = Scr_GetType_hook.get_original(); + Scr_GetTypeName_original = Scr_GetTypeName_hook.get_original(); + Scr_GetPointerType_original = Scr_GetPointerType_hook.get_original(); + Scr_AddInt_original = Scr_AddInt_hook.get_original(); + Scr_AddFloat_original = Scr_AddFloat_hook.get_original(); + Scr_AddAnim_original = Scr_AddAnim_hook.get_original(); + Scr_AddUndefined_original = Scr_AddUndefined_hook.get_original(); + Scr_AddObject_original = Scr_AddObject_hook.get_original(); + Scr_AddString_original = Scr_AddString_hook.get_original(); + Scr_AddIString_original = Scr_AddIString_hook.get_original(); + Scr_AddConstString_original = Scr_AddConstString_hook.get_original(); + Scr_AddVector_original = Scr_AddVector_hook.get_original(); + Scr_MakeArray_original = Scr_MakeArray_hook.get_original(); + Scr_AddArray_original = Scr_AddArray_hook.get_original(); + Scr_AddArrayStringIndexed_original = Scr_AddArrayStringIndexed_hook.get_original(); + Scr_Error_original = Scr_Error_hook.get_original(); + Scr_TerminalError_original = Scr_TerminalError_hook.get_original(); + Scr_ParamError_original = Scr_ParamError_hook.get_original(); + Scr_ObjectError_original = Scr_ObjectError_hook.get_original(); + SetEntityFieldValue_original = SetEntityFieldValue_hook.get_original(); + GetEntityFieldValue_original = GetEntityFieldValue_hook.get_original(); + Scr_SetStructField_original = Scr_SetStructField_hook.get_original(); + Scr_IncTime_original = Scr_IncTime_hook.get_original(); + Scr_RunCurrentThreads_original = Scr_RunCurrentThreads_hook.get_original(); + Scr_ResetTimeout_original = Scr_ResetTimeout_hook.get_original(); } private: diff --git a/src/component/decomp/clientscript/re_cscr_yacc.cpp b/src/component/decomp/clientscript/re_cscr_yacc.cpp index 31a3a1d..60bae00 100644 --- a/src/component/decomp/clientscript/re_cscr_yacc.cpp +++ b/src/component/decomp/clientscript/re_cscr_yacc.cpp @@ -18,13 +18,25 @@ namespace re_cscr_yacc utils::hook::detour yy_flush_buffer_hook; utils::hook::detour ScriptParse_hook; + void* LowerCase_original; + void* yyparse_original; + void* StringValue_original; + void* yylex_original; + void* yy_get_next_buffer_original; + void* yy_get_previous_state_original; + void* yy_try_NUL_trans_original; + void* yyrestart_original; + void* yy_create_buffer_original; + void* yy_flush_buffer_original; + void* ScriptParse_original; + namespace { unsigned int LowerCase_call(unsigned int strVal, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_YACC_USE_WRAPPERS - return game::LowerCase(strVal, LowerCase_hook.get_original()); + return game::LowerCase(strVal, LowerCase_original); #else return codsrc::LowerCase(strVal); #endif @@ -54,7 +66,7 @@ namespace re_cscr_yacc int StringValue_call(int len, const char * str_, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_YACC_USE_WRAPPERS - return game::StringValue(len, str_, StringValue_hook.get_original()); + return game::StringValue(len, str_, StringValue_original); #else return codsrc::StringValue(len, str_); #endif @@ -103,7 +115,7 @@ namespace re_cscr_yacc int yy_try_NUL_trans_call(int yy_current_state, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_YACC_USE_WRAPPERS - return game::yy_try_NUL_trans(yy_current_state, yy_try_NUL_trans_hook.get_original()); + return game::yy_try_NUL_trans(yy_current_state, yy_try_NUL_trans_original); #else return codsrc::yy_try_NUL_trans(yy_current_state); #endif @@ -142,7 +154,7 @@ namespace re_cscr_yacc void yy_flush_buffer_call(game::yy_buffer_state * result, [[maybe_unused]] void* caller_addr) { #ifdef RE_CSCR_YACC_USE_WRAPPERS - game::yy_flush_buffer(result, yy_flush_buffer_hook.get_original()); + game::yy_flush_buffer(result, yy_flush_buffer_original); #else codsrc::yy_flush_buffer(result); #endif @@ -163,7 +175,7 @@ namespace re_cscr_yacc void ScriptParse_call(game::scriptInstance_t a1, [[maybe_unused]] void* caller_addr, game::sval_u * parseData) { #ifdef RE_CSCR_YACC_USE_WRAPPERS - game::ScriptParse(a1, parseData, ScriptParse_hook.get_original()); + game::ScriptParse(a1, parseData, ScriptParse_original); #else codsrc::ScriptParse(a1, parseData); #endif @@ -187,22 +199,30 @@ namespace re_cscr_yacc public: void post_unpack() override { - bool quick = true; -#ifdef RE_CSCR_YACC_USE_WRAPPERS - quick = false; -#endif + LowerCase_hook.create(game::LowerCase(), LowerCase_stub); + yyparse_hook.create(game::yyparse.get(), yyparse_stub); + StringValue_hook.create(game::StringValue(), StringValue_stub); + yylex_hook.create(game::yylex.get(), yylex_stub); + yy_get_next_buffer_hook.create(game::yy_get_next_buffer.get(), yy_get_next_buffer_stub); + yy_get_previous_state_hook.create(game::yy_get_previous_state.get(), yy_get_previous_state_stub); + yy_try_NUL_trans_hook.create(game::yy_try_NUL_trans(), yy_try_NUL_trans_stub); + yyrestart_hook.create(game::yyrestart.get(), yyrestart_stub); + yy_create_buffer_hook.create(game::yy_create_buffer.get(), yy_create_buffer_stub); + yy_flush_buffer_hook.create(game::yy_flush_buffer(), yy_flush_buffer_stub); + ScriptParse_hook.create(game::ScriptParse(), ScriptParse_stub); - LowerCase_hook.create(game::LowerCase(), LowerCase_stub, quick); - yyparse_hook.create(game::yyparse.get(), yyparse_stub, quick); - StringValue_hook.create(game::StringValue(), StringValue_stub, quick); - yylex_hook.create(game::yylex.get(), yylex_stub, quick); - yy_get_next_buffer_hook.create(game::yy_get_next_buffer.get(), yy_get_next_buffer_stub, quick); - yy_get_previous_state_hook.create(game::yy_get_previous_state.get(), yy_get_previous_state_stub, quick); - yy_try_NUL_trans_hook.create(game::yy_try_NUL_trans(), yy_try_NUL_trans_stub, quick); - yyrestart_hook.create(game::yyrestart.get(), yyrestart_stub, quick); - yy_create_buffer_hook.create(game::yy_create_buffer.get(), yy_create_buffer_stub, quick); - yy_flush_buffer_hook.create(game::yy_flush_buffer(), yy_flush_buffer_stub, quick); - ScriptParse_hook.create(game::ScriptParse(), ScriptParse_stub, quick); + //Original hook function addresses + LowerCase_original = LowerCase_hook.get_original(); + yyparse_original = yyparse_hook.get_original(); + StringValue_original = StringValue_hook.get_original(); + yylex_original = yylex_hook.get_original(); + yy_get_next_buffer_original = yy_get_next_buffer_hook.get_original(); + yy_get_previous_state_original = yy_get_previous_state_hook.get_original(); + yy_try_NUL_trans_original = yy_try_NUL_trans_hook.get_original(); + yyrestart_original = yyrestart_hook.get_original(); + yy_create_buffer_original = yy_create_buffer_hook.get_original(); + yy_flush_buffer_original = yy_flush_buffer_hook.get_original(); + ScriptParse_original = ScriptParse_hook.get_original(); } private: diff --git a/src/utils/hook.cpp b/src/utils/hook.cpp index 17595c9..24dda0d 100644 --- a/src/utils/hook.cpp +++ b/src/utils/hook.cpp @@ -97,15 +97,8 @@ namespace utils::hook MH_DisableHook(this->place_); } - void detour::create(void* place, void* target, bool quick) + void detour::create(void* place, void* target) { - // each detour is ~30ms to install, quick is for instances where we will NEVER need to invoke the original - if (quick) - { - jump(reinterpret_cast(place), target); - return; - } - this->clear(); this->place_ = place; @@ -117,9 +110,9 @@ namespace utils::hook this->enable(); } - void detour::create(const size_t place, void* target, bool quick) + void detour::create(const size_t place, void* target) { - this->create(reinterpret_cast(place), target, quick); + this->create(reinterpret_cast(place), target); } void detour::clear() diff --git a/src/utils/hook.hpp b/src/utils/hook.hpp index bec759b..2b38de0 100644 --- a/src/utils/hook.hpp +++ b/src/utils/hook.hpp @@ -86,8 +86,8 @@ namespace utils::hook void enable() const; void disable() const; - void create(void* place, void* target, bool quick = false); - void create(size_t place, void* target, bool quick = false); + void create(void* place, void* target); + void create(size_t place, void* target); void clear(); template