Future/T4SP-Server-Plugin
1
0
Fork 0
mirror of https://github.com/JezuzLizard/T4SP-Server-Plugin.git synced 2025-05-09 21:54:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

It compiles again

Browse Source
This commit is contained in:
ineed bots 2023-08-30 22:07:05 -06:00
parent 0184ba0dcb
commit 27c3bf2d32
24 changed files with 4131 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
premake5.lua
View File

@ -50,6 +50,8 @@ workspace "t4sp-server-plugin"
warnings "Extra" warnings "Extra"
characterset "ASCII" characterset "ASCII"
defines { "_CRT_SECURE_NO_WARNINGS" }
flags flags
{ {
"NoIncrementalLink", "NoIncrementalLink",

2
src/codsrc/clientscript/clientscript_public - Copy.hpp Normal file
View File

@ -0,0 +1,2 @@
#include <stdinc.hpp>
#include "clientscript_public.hpp"

14
src/codsrc/clientscript/cscr_main.cpp
View File

@ -59,7 +59,7 @@ namespace codsrc
game::VariableValue val = game::Scr_EvalVariable(inst, filePosId); game::VariableValue val = game::Scr_EvalVariable(inst, filePosId);
assert(val.type == VAR_CODEPOS); assert(val.type == game::VAR_CODEPOS);
const char* pos = val.u.codePosValue; const char* pos = val.u.codePosValue;
if (!game::Scr_IsInOpcodeMemory(inst, pos)) if (!game::Scr_IsInOpcodeMemory(inst, pos))
@ -278,7 +278,7 @@ namespace codsrc
formatExtString = "%s.csc"; formatExtString = "%s.csc";
} }
game::Com_sprintf(extFilename, 64, game::Com_sprintf_ADDR(), formatExtString, filename); snprintf(extFilename, 64, formatExtString, filename);
oldSourceBuf = game::gScrParserPub[inst].sourceBuf; oldSourceBuf = game::gScrParserPub[inst].sourceBuf;
codepos = (const char *)game::TempMalloc(0); codepos = (const char *)game::TempMalloc(0);
sourceBuffer = game::Scr_AddSourceBuffer(inst, (int)filename, extFilename, codepos); sourceBuffer = game::Scr_AddSourceBuffer(inst, (int)filename, extFilename, codepos);
@ -324,6 +324,10 @@ namespace codsrc
// Decomp Status: Tested, Completed // Decomp Status: Tested, Completed
void Scr_EndLoadScripts(game::scriptInstance_t inst) void Scr_EndLoadScripts(game::scriptInstance_t inst)
{ {
// pluto
game::plutonium::load_custom_script_func(inst);
//
game::SL_ShutdownSystem(inst, 2u); game::SL_ShutdownSystem(inst, 2u);
game::gScrCompilePub[inst].script_loading = 0; game::gScrCompilePub[inst].script_loading = 0;
@ -376,10 +380,6 @@ namespace codsrc
assert(game::gScrAnimPub[inst].animtrees); assert(game::gScrAnimPub[inst].animtrees);
// pluto
game::plutonium::load_custom_script_func(inst);
//
game::ClearObject(game::gScrAnimPub[inst].animtrees, inst); game::ClearObject(game::gScrAnimPub[inst].animtrees, inst);
game::RemoveRefToObject(game::gScrAnimPub[inst].animtrees, inst); game::RemoveRefToObject(game::gScrAnimPub[inst].animtrees, inst);
animtreeNode = game::gScrAnimPub[inst].animtree_node; animtreeNode = game::gScrAnimPub[inst].animtree_node;
@ -403,7 +403,7 @@ namespace codsrc
// Decomp Status: Tested, Completed // Decomp Status: Tested, Completed
void Scr_FreeScripts(game::scriptInstance_t inst) void Scr_FreeScripts(game::scriptInstance_t inst)
{ {
char sys = 1; //char sys = 1;
//assert(sys == SCR_SYS_GAME); //assert(sys == SCR_SYS_GAME);

7
src/component/decomp/clientscript/re_cscr_main.cpp
View File

@ -223,7 +223,6 @@ namespace re_cscr_main
void Scr_EndLoadScripts_stub(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr) void Scr_EndLoadScripts_stub(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr)
{ {
#ifdef RE_CSCR_MAIN_USE_WRAPPERS #ifdef RE_CSCR_MAIN_USE_WRAPPERS
game::plutonium::load_custom_script_func(inst);
Scr_EndLoadScripts_hook.invoke<void>(inst); Scr_EndLoadScripts_hook.invoke<void>(inst);
#else #else
codsrc::Scr_EndLoadScripts(inst); codsrc::Scr_EndLoadScripts(inst);
@ -276,13 +275,13 @@ namespace re_cscr_main
void post_unpack() override void post_unpack() override
{ {
Scr_IsIdentifier_hook.create(game::Scr_IsIdentifier_ADDR(), Scr_IsIdentifier_stub); Scr_IsIdentifier_hook.create(game::Scr_IsIdentifier_ADDR(), Scr_IsIdentifier_stub);
Scr_GetFunctionHandle_hook.create(game::Scr_GetFunctionHandle_ADDR(), Scr_GetFunctionHandle_stub); //Scr_GetFunctionHandle_hook.create(game::Scr_GetFunctionHandle_ADDR(), Scr_GetFunctionHandle_stub);
SL_TransferToCanonicalString_hook.create(game::SL_TransferToCanonicalString_ADDR(), SL_TransferToCanonicalString_stub); SL_TransferToCanonicalString_hook.create(game::SL_TransferToCanonicalString_ADDR(), SL_TransferToCanonicalString_stub);
SL_GetCanonicalString_hook.create(game::SL_GetCanonicalString_ADDR(), SL_GetCanonicalString_stub); SL_GetCanonicalString_hook.create(game::SL_GetCanonicalString_ADDR(), SL_GetCanonicalString_stub);
Scr_BeginLoadScripts_hook.create(game::Scr_BeginLoadScripts_ADDR(), Scr_BeginLoadScripts_stub); //Scr_BeginLoadScripts_hook.create(game::Scr_BeginLoadScripts_ADDR(), Scr_BeginLoadScripts_stub);
Scr_BeginLoadAnimTrees_hook.create(game::Scr_BeginLoadAnimTrees_ADDR(), Scr_BeginLoadAnimTrees_stub); Scr_BeginLoadAnimTrees_hook.create(game::Scr_BeginLoadAnimTrees_ADDR(), Scr_BeginLoadAnimTrees_stub);
Scr_ScanFile_hook.create(game::Scr_ScanFile_ADDR(), Scr_ScanFile_stub); Scr_ScanFile_hook.create(game::Scr_ScanFile_ADDR(), Scr_ScanFile_stub);
Scr_LoadScriptInternal_hook.create(game::Scr_LoadScriptInternal.get(), Scr_LoadScriptInternal_stub); //Scr_LoadScriptInternal_hook.create(game::Scr_LoadScriptInternal.get(), Scr_LoadScriptInternal_stub);
Scr_LoadScript_hook.create(game::Scr_LoadScript_ADDR(), Scr_LoadScript_stub); Scr_LoadScript_hook.create(game::Scr_LoadScript_ADDR(), Scr_LoadScript_stub);
Scr_EndLoadScripts_hook.create(game::Scr_EndLoadScripts.get(), Scr_EndLoadScripts_stub); Scr_EndLoadScripts_hook.create(game::Scr_EndLoadScripts.get(), Scr_EndLoadScripts_stub);
Scr_PrecacheAnimTrees_hook.create(game::Scr_PrecacheAnimTrees.get(), Scr_PrecacheAnimTrees_stub); Scr_PrecacheAnimTrees_hook.create(game::Scr_PrecacheAnimTrees.get(), Scr_PrecacheAnimTrees_stub);

90
src/game/clientscript/clientscript_public.hpp
View File

@ -2170,6 +2170,40 @@ namespace game
ASSERT_STRUCT_OFFSET(node_field_t, type, 0x8); ASSERT_STRUCT_OFFSET(node_field_t, type, 0x8);
ASSERT_STRUCT_OFFSET(node_field_t, getter, 0xC); ASSERT_STRUCT_OFFSET(node_field_t, getter, 0xC);
struct yy_buffer_state
{
_iobuf * yy_input_file; //OFS: 0x0 SIZE: 0x4
char * yy_ch_buf; //OFS: 0x4 SIZE: 0x4
char * yy_buf_pos; //OFS: 0x8 SIZE: 0x4
unsigned int yy_buf_size; //OFS: 0xC SIZE: 0x4
int yy_n_chars; //OFS: 0x10 SIZE: 0x4
int yy_is_our_buffer; //OFS: 0x14 SIZE: 0x4
int yy_is_interactive; //OFS: 0x18 SIZE: 0x4
int yy_at_bol; //OFS: 0x1C SIZE: 0x4
int yy_fill_buffer; //OFS: 0x20 SIZE: 0x4
int yy_buffer_status; //OFS: 0x24 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(yy_buffer_state, 0x28);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_input_file, 0x0);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_ch_buf, 0x4);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_pos, 0x8);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_size, 0xC);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_n_chars, 0x10);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_our_buffer, 0x14);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_interactive, 0x18);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_at_bol, 0x1C);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_fill_buffer, 0x20);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buffer_status, 0x24);
struct stype_t
{
sval_u val; //OFS: 0x0 SIZE: 0x4
unsigned int pos; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(stype_t, 0x8);
ASSERT_STRUCT_OFFSET(stype_t, val, 0x0);
ASSERT_STRUCT_OFFSET(stype_t, pos, 0x4);
#pragma endregion #pragma endregion
#ifdef __cplusplus #ifdef __cplusplus
@ -2196,12 +2230,68 @@ namespace game
WEAK symbol<scrParserPub_t> gScrParserPub{ 0x0, 0x3882B00 }; WEAK symbol<scrParserPub_t> gScrParserPub{ 0x0, 0x3882B00 };
WEAK symbol<scr_classStruct_t*> gScrClassMap{ 0x0, 0x8CF568 }; WEAK symbol<scr_classStruct_t*> gScrClassMap{ 0x0, 0x8CF568 };
WEAK symbol<scr_const_t> scr_const{ 0x0, 0x1F33B90 }; WEAK symbol<scr_const_t> scr_const{ 0x0, 0x1F33B90 };
WEAK symbol<bool> loadedImpureScript{ 0x0, 0x22C1352 };
WEAK symbol<unsigned char> g_parse_user{ 0x0, 0x234F72E };
WEAK symbol<scriptInstance_t> gInst{ 0x0, 0x3BE624C };
WEAK symbol<int> yynerrs{ 0x0, 0x3BE6264 };
WEAK symbol<int> yychar{ 0x0, 0x3BE6260 };
WEAK symbol<stype_t> yylval{ 0x0, 0x3BE6240 };
WEAK symbol<unsigned int> g_sourcePos{ 0x0, 0x3BE623C };
WEAK symbol<sval_u> yaccResult{ 0x0, 0x3BE6258 };
WEAK symbol<sval_u> g_dummyVal{ 0x0, 0x3BE6254 };
WEAK symbol<int> yy_init{ 0x0, 0x8CF4A0 };
WEAK symbol<int> yy_start{ 0x0, 0x46E54D4 };
WEAK symbol<_iobuf*> yyin{ 0x0, 0x46E54D8 };
WEAK symbol<_iobuf*> yyout{ 0x0, 0x46E54DC };
WEAK symbol<yy_buffer_state*> yy_current_buffer{ 0x0, 0x46E54CC };
WEAK symbol<int> yy_n_chars{ 0x0, 0x3BE6250 };
WEAK symbol<char> yy_hold_char{ 0x0, 0x22C1353 };
WEAK symbol<int> yy_c_buf_p{ 0x0, 0x46E54D0 };
WEAK symbol<int> yy_last_accepting_state{ 0x0, 0x3BE626C };
WEAK symbol<char*> yy_last_accepting_cpos{ 0x0, 0x3BE2230 };
WEAK symbol<size_t> yyleng{ 0x0, 0x3BE6248 };
WEAK symbol<char*> yytext{ 0x0, 0x3BE2234 };
WEAK symbol<int> yy_did_buffer_switch_on_eof{ 0x0, 0x3BE6268 };
WEAK symbol<unsigned int> g_out_pos{ 0x0, 0x3BE625C };
WEAK symbol<char> ch_buf{ 0x0, 0x3BE2238 };
WEAK symbol<short> yypact{ 0x0, 0x82F2D0 };
WEAK symbol<char> yytranslate{ 0x0, 0x82ED08 };
WEAK symbol<short> yycheck{ 0x0, 0x82FFA0 };
WEAK symbol<short> yytable{ 0x0, 0x82F518 };
WEAK symbol<short> yyr1{ 0x0, 0x82EE68 };
WEAK symbol<short> yyr2{ 0x0, 0x82EF78 };
WEAK symbol<short> yydefact{ 0x0, 0x82F088 };
WEAK symbol<int> yy_ec{ 0x0, 0x830C30 };
WEAK symbol<short> yy_accept{ 0x0, 0x830A28 };
WEAK symbol<short> yy_chk{ 0x0, 0x831930 };
WEAK symbol<short> yy_base{ 0x0, 0x831120 };
WEAK symbol<short> yy_def{ 0x0, 0x831338 };
WEAK symbol<short> yy_nxt{ 0x0, 0x831550 };
WEAK symbol<unsigned char> yy_meta{ 0x0, 0x831030 };
#pragma endregion #pragma endregion
#pragma region "functions" #pragma region "functions"
WEAK symbol<BOOL(LPVOID lpAddress)>Hunk_UserDestroy{ 0x0, 0x5E4940 };
inline void* ScriptParse_ADDR() { return CALL_ADDR(0x0, 0x69D710); }
void ScriptParse(scriptInstance_t inst, sval_u* parseData, void* call_addr = ScriptParse_ADDR());
inline void* ScriptCompile_ADDR() { return CALL_ADDR(0x0, 0x688E70); }
void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry * entries, int entriesCount, void* call_addr = ScriptCompile_ADDR());
inline void* Scr_LoadAnimTreeAtIndex_ADDR() { return CALL_ADDR(0x0, 0x67E7D0); }
void Scr_LoadAnimTreeAtIndex(scriptInstance_t inst, int user, unsigned int index, void* (__cdecl* Alloc)(int), int modCheckSum, void* call_addr = Scr_LoadAnimTreeAtIndex_ADDR());
inline void* Hunk_UserCreate_ADDR() { return CALL_ADDR(0x0, 0x5E46E0); }
HunkUser* Hunk_UserCreate(signed int maxSize, const char* name, int fixed, int tempMem, int debugMem, int type, void* call_addr = Hunk_UserCreate_ADDR());
#pragma endregion #pragma endregion
} }
#include "cscr_main.hpp" #include "cscr_main.hpp"
#include "cscr_memorytree.hpp"
#include "cscr_parser.hpp"
#include "cscr_parsetree.hpp"
#include "cscr_readwrite.hpp"
#include "cscr_stringlist.hpp"
#include "cscr_tempmemory.hpp"
#include "cscr_variable.hpp"
#include "cscr_vm.hpp"
#endif #endif

68
src/game/clientscript/clientscript_public_w.cpp
View File

@ -1 +1,69 @@
#include <stdinc.hpp> #include <stdinc.hpp>
namespace game
{
// void __usercall ScriptParse(scriptInstance_t a1@<eax>, sval_u *parseData)
void ScriptParse(scriptInstance_t inst, sval_u* parseData, void* call_addr)
{
__asm
{
push parseData;
mov eax, inst;
call call_addr;
add esp, 0x4;
}
}
// void __usercall ScriptCompile(scriptInstance_t inst@<eax>, sval_u a2, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry *entries, int entriesCount)
void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry * entries, int entriesCount, void* call_addr)
{
__asm
{
push entriesCount;
push entries;
push scriptId;
push fileCountId;
push filePosId;
push val;
mov eax, inst;
call call_addr;
add esp, 0x18;
}
}
// void __usercall Scr_LoadAnimTreeAtIndex(scriptInstance_t inst@<ecx>, int a2@<eax>, int a3, int (__cdecl *a4)(int), int a5)
void Scr_LoadAnimTreeAtIndex(scriptInstance_t inst, int user, unsigned int index, void* (__cdecl* Alloc)(int), int modCheckSum, void* call_addr)
{
__asm
{
push modCheckSum;
push Alloc;
push index;
mov eax, user;
mov ecx, inst;
call call_addr;
add esp, 0xC;
}
}
// HunkUser* __usercall Hunk_UserCreate@<eax>(signed int maxSize@<edi>, char* name, char fixed, char tempMem, char debugMem, int type);
HunkUser* Hunk_UserCreate(signed int maxSize, const char* name, int fixed, int tempMem, int debugMem, int typ, void* call_addr)
{
HunkUser* answer;
__asm
{
push typ;
push debugMem;
push tempMem;
push fixed;
push name;
mov edi, maxSize;
call call_addr;
add esp, 0x14;
mov answer, eax;
}
return answer;
}
}

31
src/game/clientscript/cscr_memorytree.hpp Normal file
View File

@ -0,0 +1,31 @@
#pragma once
namespace game
{
WEAK symbol<int(scriptInstance_t inst, int nodeNum)>MT_GetSubTreeSize{ 0x0, 0x689EF0 };
WEAK symbol<void(scriptInstance_t inst)>MT_DumpTree{ 0x0, 0x689F40 };
WEAK symbol<void(scriptInstance_t inst, int newNode, int size)>MT_AddMemoryNode{ 0x0, 0x68A0E0 };
WEAK symbol<char(scriptInstance_t inst, int oldNode, int size)>MT_RemoveMemoryNode{ 0x0, 0x68A280 };
WEAK symbol<void(scriptInstance_t inst, int size)>MT_RemoveHeadMemoryNode{ 0x0, 0x68A3E0 };
WEAK symbol<void(void* p, int numBytes, scriptInstance_t inst)>MT_Free{ 0x0, 0x68A800 };
inline void* MT_InitBits_ADDR() { return CALL_ADDR(0x0, 0x68A010); }
void MT_InitBits(scriptInstance_t inst, void* call_addr = MT_InitBits_ADDR());
inline void* MT_GetScore_ADDR() { return CALL_ADDR(0x0, 0x68A080); }
int MT_GetScore(scriptInstance_t inst, int num, void* call_addr = MT_GetScore_ADDR());
inline void* MT_Init_ADDR() { return CALL_ADDR(0x0, 0x68A4F0); }
void MT_Init(scriptInstance_t inst, void* call_addr = MT_Init_ADDR());
inline void* MT_Error_ADDR() { return CALL_ADDR(0x0, 0x68A580); }
void MT_Error(scriptInstance_t inst, const char* funcName, int numBytes, void* call_addr = MT_Error_ADDR());
inline void* MT_GetSize_ADDR() { return CALL_ADDR(0x0, 0x68A5D0); }
int MT_GetSize(int numBytes, scriptInstance_t inst, void* call_addr = MT_GetSize_ADDR());
inline void* MT_AllocIndex_ADDR() { return CALL_ADDR(0x0, 0x68A630); }
unsigned __int16 MT_AllocIndex(scriptInstance_t inst, int size_, void* call_addr = MT_AllocIndex_ADDR());
inline void* MT_FreeIndex_ADDR() { return CALL_ADDR(0x0, 0x68A750); }
void MT_FreeIndex(int numBytes, scriptInstance_t inst, int nodeNum, void* call_addr = MT_FreeIndex_ADDR());
inline void* MT_Alloc_ADDR() { return CALL_ADDR(0x0, 0x68A7D0); }
char* MT_Alloc(int numBytes, scriptInstance_t inst, void* call_addr = MT_Alloc_ADDR());
RefVector* GetRefVector(scriptInstance_t inst, unsigned int id);
const char* MT_NodeInfoString(scriptInstance_t inst, unsigned int nodeNum);
}

128
src/game/clientscript/cscr_memorytree_w.cpp Normal file
View File

@ -0,0 +1,128 @@
#include <stdinc.hpp>
namespace game
{
// void __usercall MT_InitBits(scriptInstance_t a1@<ecx>)
void MT_InitBits(scriptInstance_t inst, void* call_addr)
{
__asm
{
mov ecx, inst;
call call_addr;
}
}
// int __usercall MT_GetScore@<eax>(scriptInstance_t a1@<edx>, int num)
int MT_GetScore(scriptInstance_t inst, int num, void* call_addr)
{
int answer;
__asm
{
push num;
mov edx, inst;
call call_addr;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
// void __usercall MT_Init(scriptInstance_t a1@<edi>)
void MT_Init(scriptInstance_t inst, void* call_addr)
{
__asm
{
mov edi, inst;
call call_addr;
}
}
// void __usercall MT_Error(scriptInstance_t a1@<eax>, const char *funcName, int numBytes)
void MT_Error(scriptInstance_t inst, const char* funcName, int numBytes, void* call_addr)
{
__asm
{
push numBytes;
push funcName;
mov eax, inst;
call call_addr;
add esp, 0x8;
}
}
// int __usercall MT_GetSize@<eax>(int numBytes@<eax>, scriptInstance_t inst@<ecx>)
int MT_GetSize/*@<eax>*/(int numBytes/*@<eax>*/, scriptInstance_t inst/*@<ecx>*/, void* call_addr)
{
int answer;
__asm
{
mov eax, numBytes;
mov ecx, inst;
call call_addr;
mov answer, eax;
}
return answer;
}
// unsigned __int16 __usercall MT_AllocIndex@<ax>(scriptInstance_t inst@<edi>, int size)
unsigned __int16 MT_AllocIndex/*@<ax>*/(scriptInstance_t inst/*@<edi>*/, int size_, void* call_addr)
{
unsigned __int16 answer;
__asm
{
push size_;
mov edi, inst;
call call_addr;
mov answer, ax;
add esp, 0x4;
}
return answer;
}
// void __usercall MT_FreeIndex(int numBytes@<eax>, scriptInstance_t a1, int nodeNum)
void MT_FreeIndex(int numBytes/*@<eax>*/, scriptInstance_t inst, int nodeNum, void* call_addr)
{
__asm
{
push nodeNum;
push inst;
mov eax, numBytes;
call call_addr;
add esp, 0x8;
}
}
// char *__usercall MT_Alloc@<eax>(int numBytes@<eax>, scriptInstance_t a2@<ecx>)
char* MT_Alloc(int numBytes, scriptInstance_t inst, void* call_addr)
{
char* answer;
__asm
{
mov eax, numBytes;
mov ecx, inst;
call call_addr;
mov answer, eax;
}
return answer;
}
RefVector* GetRefVector(scriptInstance_t inst, unsigned int id)
{
//return cscr_memorytree::GetRefVector(inst, id);
return nullptr;
}
const char* MT_NodeInfoString(scriptInstance_t inst, unsigned int nodeNum)
{
//return cscr_memorytree::MT_NodeInfoString(inst, nodeNum);
return nullptr;
}
}

52
src/game/clientscript/cscr_parser.hpp Normal file
View File

@ -0,0 +1,52 @@
#pragma once
namespace game
{
WEAK symbol<char* (scriptInstance_t inst, int unused, char* filename, const char* codepos, int archive)>Scr_ReadFile_FastFile{ 0x0, 0x68AE30 };
WEAK symbol<char* (scriptInstance_t inst, int unused_arg1, const char* filename, const char* codepos, int archive)>Scr_ReadFile_LoadObj{ 0x0, 0x68AED0 };
WEAK symbol<void(scriptInstance_t inst, unsigned int codePos, const char* msg, ...)>CompileError{ 0x0, 0x68B470 };
inline void* Scr_InitOpcodeLookup_ADDR() { return CALL_ADDR(0x0, 0x68A840); }
void Scr_InitOpcodeLookup(scriptInstance_t inst, void* call_addr = Scr_InitOpcodeLookup_ADDR());
inline void* Scr_ShutdownOpcodeLookup_ADDR() { return CALL_ADDR(0x0, 0x68A950); }
void Scr_ShutdownOpcodeLookup(scriptInstance_t inst, void* call_addr = Scr_ShutdownOpcodeLookup_ADDR());
inline void* AddOpcodePos_ADDR() { return CALL_ADDR(0x0, 0x68A9A0); }
void AddOpcodePos(scriptInstance_t inst, unsigned int sourcePos, int type_, void* call_addr = AddOpcodePos_ADDR());
inline void* RemoveOpcodePos_ADDR() { return CALL_ADDR(0x0, 0x68AB80); }
void RemoveOpcodePos(scriptInstance_t inst, void* call_addr = RemoveOpcodePos_ADDR());
inline void* AddThreadStartOpcodePos_ADDR() { return CALL_ADDR(0x0, 0x68ABF0); }
void AddThreadStartOpcodePos(scriptInstance_t inst, unsigned int sourcePos, void* call_addr = AddThreadStartOpcodePos_ADDR());
inline void* Scr_GetSourceBuffer_ADDR() { return CALL_ADDR(0x0, 0x68B270); }
unsigned int Scr_GetSourceBuffer(scriptInstance_t inst, const char* codePos, void* call_addr = Scr_GetSourceBuffer_ADDR());
inline void* Scr_GetLineNumInternal_ADDR() { return CALL_ADDR(0x0, 0x68AC90); }
unsigned int Scr_GetLineNumInternal(const char** startLine, const char* buf, const char* sourcePos, int* col, void* call_addr = Scr_GetLineNumInternal_ADDR());
inline void* Scr_GetNewSourceBuffer_ADDR() { return CALL_ADDR(0x0, 0x68ACC0); }
SourceBufferInfo* Scr_GetNewSourceBuffer(scriptInstance_t inst, void* call_addr = Scr_GetNewSourceBuffer_ADDR());
inline void* Scr_AddSourceBufferInternal_ADDR() { return CALL_ADDR(0x0, 0x68AD50); }
void Scr_AddSourceBufferInternal(const char* filename, scriptInstance_t inst, const char* codepos, char* buffer, int len, int archive, void* call_addr = Scr_AddSourceBufferInternal_ADDR());
inline void* Scr_ReadFile_ADDR() { return CALL_ADDR(0x0, 0x68AFA0); }
char* Scr_ReadFile(const char* codepos, char* filename, scriptInstance_t inst, int unused, void* call_addr = Scr_ReadFile_ADDR());
inline void* Scr_AddSourceBuffer_ADDR() { return CALL_ADDR(0x0, 0x68B040); }
char* Scr_AddSourceBuffer(scriptInstance_t inst, int unused_arg1, char* filename, const char* codepos, void* call_addr = Scr_AddSourceBuffer_ADDR());
inline void* Scr_CopyFormattedLine_ADDR() { return CALL_ADDR(0x0, 0x68B0E0); }
void Scr_CopyFormattedLine(const char* rawLine, char* line, void* call_addr = Scr_CopyFormattedLine_ADDR());
inline void* Scr_GetLineInfo_ADDR() { return CALL_ADDR(0x0, 0x68B140); }
unsigned int Scr_GetLineInfo(int* col, const char* buf, unsigned int sourcePos, char* line, void* call_addr = Scr_GetLineInfo_ADDR());
inline void* Scr_PrintSourcePos_ADDR() { return CALL_ADDR(0x0, 0x68B190); }
void Scr_PrintSourcePos(unsigned int sourcePos, const char* buf, con_channel_e channel, scriptInstance_t inst, const char* file, void* call_addr = Scr_PrintSourcePos_ADDR());
inline void* Scr_GetPrevSourcePosOpcodeLookup_ADDR() { return CALL_ADDR(0x0, 0x68AC40); }
OpcodeLookup* Scr_GetPrevSourcePosOpcodeLookup(scriptInstance_t inst, const char* codePos, void* call_addr = Scr_GetPrevSourcePosOpcodeLookup_ADDR());
inline void* Scr_GetTextSourcePos_ADDR() { return CALL_ADDR(0x0, 0x68B2B0); }
void Scr_GetTextSourcePos(char* line, const char* codePos, scriptInstance_t inst, void* call_addr = Scr_GetTextSourcePos_ADDR());
inline void* Scr_PrintPrevCodePos_ADDR() { return CALL_ADDR(0x0, 0x68B340); }
void Scr_PrintPrevCodePos(const char* codepos, scriptInstance_t scriptInstance, con_channel_e channel, unsigned int index, void* call_addr = Scr_PrintPrevCodePos_ADDR());
inline void* CompileError2_ADDR() { return CALL_ADDR(0x0, 0x68B600); }
void CompileError2(const char* codePos, scriptInstance_t a2, void* call_addr, const char* msg, ...);
inline void* RuntimeErrorInternal_ADDR() { return CALL_ADDR(0x0, 0x68B6D0); }
void RuntimeErrorInternal(const char* msg, scriptInstance_t inst, con_channel_e channel, const char* codepos, int index, void* call_addr = RuntimeErrorInternal_ADDR());
inline void* RuntimeError_ADDR() { return CALL_ADDR(0x0, 0x68B790); }
void RuntimeError(scriptInstance_t inst, const char* pos, int error_index, const char* err, const char* err2, void* call_addr = RuntimeError_ADDR());
unsigned int Scr_GetPrevSourcePos(scriptInstance_t inst, const char* codePos, unsigned int index);
void Scr_ShutdownAllocNode(scriptInstance_t inst);
}

316
src/game/clientscript/cscr_parser_w.cpp Normal file
View File

@ -0,0 +1,316 @@
#include <stdinc.hpp>
namespace game
{
// void __usercall Scr_InitOpcodeLookup(scriptInstance_t a1@<eax>)
void Scr_InitOpcodeLookup(scriptInstance_t a1, void* call_addr)
{
__asm
{
mov eax, a1;
call call_addr;
}
}
// void __usercall Scr_ShutdownOpcodeLookup(scriptInstance_t a1@<ecx>)
void Scr_ShutdownOpcodeLookup(scriptInstance_t a1, void* call_addr)
{
__asm
{
mov ecx, a1;
call call_addr;
}
}
// void __usercall AddOpcodePos(scriptInstance_t a1@<eax>, unsigned int sourcePos, int type)
void AddOpcodePos(scriptInstance_t a1, unsigned int sourcePos, int type_, void* call_addr)
{
__asm
{
push type_;
push sourcePos;
mov eax, a1;
call call_addr;
add esp, 0x8;
}
}
// void __usercall RemoveOpcodePos(scriptInstance_t result@<eax>)
void RemoveOpcodePos(scriptInstance_t result, void* call_addr)
{
__asm
{
mov eax, result;
call call_addr;
}
}
// void __usercall AddThreadStartOpcodePos(scriptInstance_t result@<eax>, unsigned int sourcePos)
void AddThreadStartOpcodePos(scriptInstance_t result, unsigned int sourcePos, void* call_addr)
{
__asm
{
push sourcePos;
mov eax, result;
call call_addr;
add esp, 0x4;
}
}
// unsigned int __usercall Scr_GetSourceBuffer@<eax>(scriptInstance_t inst@<eax>, const char *codePos@<esi>)
unsigned int Scr_GetSourceBuffer(scriptInstance_t a1, const char* codePos, void* call_addr)
{
unsigned int answer;
__asm
{
mov eax, a1;
mov esi, codePos;
call call_addr;
mov answer, eax;
}
return answer;
}
// unsigned int __usercall Scr_GetLineNumInternal@<eax>(const char **startLine@<edx>, const char *buf@<ecx>, const char *sourcePos, int *col)
unsigned int Scr_GetLineNumInternal(const char** startLine, const char* buf, const char* sourcePos, int* col, void* call_addr)
{
unsigned int answer;
__asm
{
push col;
push sourcePos;
mov edx, startLine;
mov ecx, buf;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
// SourceBufferInfo *__usercall Scr_GetNewSourceBuffer@<eax>(scriptInstance_t a1@<eax>)
SourceBufferInfo* Scr_GetNewSourceBuffer(scriptInstance_t a1, void* call_addr)
{
SourceBufferInfo* answer;
__asm
{
mov eax, a1;
call call_addr;
mov answer, eax;
}
return answer;
}
// void __usercall Scr_AddSourceBufferInternal(const char *filename@<eax>, scriptInstance_t inst, const char *codepos, char *buffer, int len, int archive)
void Scr_AddSourceBufferInternal(const char* filename, scriptInstance_t inst, const char* codepos, char* buffer, int len, int archive, void* call_addr)
{
__asm
{
push archive;
push len;
push buffer;
push codepos;
push inst;
mov eax, filename;
call call_addr;
add esp, 0x14;
}
}
// char *__usercall Scr_ReadFile@<eax>(const char *codepos@<edi>, char *filename@<esi>, scriptInstance_t inst, int unused)
char* Scr_ReadFile(const char* codepos, char* filename, scriptInstance_t inst, int unused, void* call_addr)
{
char* answer;
__asm
{
push unused;
push inst;
mov edi, codepos;
mov esi, filename;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
// char *__usercall Scr_AddSourceBuffer@<eax>(scriptInstance_t inst@<eax>, int unused_arg1, char *filename, const char *codepos)
char* Scr_AddSourceBuffer(scriptInstance_t inst, int unused_arg1, char* filename, const char* codepos, void* call_addr)
{
char* answer;
__asm
{
push codepos;
push filename;
push unused_arg1;
mov eax, inst;
call call_addr;
mov answer, eax;
add esp, 0xC;
}
return answer;
}
// void __usercall Scr_CopyFormattedLine(const char *rawLine@<eax>, char *line)
void Scr_CopyFormattedLine(const char* rawLine, char* line, void* call_addr)
{
__asm
{
push line;
mov eax, rawLine;
call call_addr;
add esp, 0x4;
}
}
// unsigned int __usercall Scr_GetLineInfo@<eax>(int *col@<edx>, _BYTE *buf@<ecx>, unsigned int sourcePos, char *line)
unsigned int Scr_GetLineInfo(int* col, const char* buf, unsigned int sourcePos, char* line, void* call_addr)
{
unsigned int answer;
__asm
{
push line;
push sourcePos;
mov edx, col;
mov ecx, buf;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
// void __usercall Scr_PrintSourcePos(unsigned int sourcePos@<edx>, const char *buf@<ecx>, con_channel_e channel@<esi>, scriptInstance_t a4, const char *file)
void Scr_PrintSourcePos(unsigned int sourcePos, const char* buf, con_channel_e channel, scriptInstance_t a4, const char* file, void* call_addr)
{
__asm
{
push file;
push a4;
mov edx, sourcePos;
mov ecx, buf;
mov esi, channel;
call call_addr;
add esp, 0x8;
}
}
// OpcodeLookup *__usercall Scr_GetPrevSourcePosOpcodeLookup@<eax>(scriptInstance_t a1@<eax>, const char *codePos@<edi>)
OpcodeLookup* Scr_GetPrevSourcePosOpcodeLookup(scriptInstance_t a1, const char* codePos, void* call_addr)
{
OpcodeLookup* answer;
__asm
{
mov eax, a1;
mov edi, codePos;
call call_addr;
mov answer, eax;
}
return answer;
}
// void __usercall Scr_GetTextSourcePos(char *line@<edx>, const char *codePos@<ecx>, scriptInstance_t a3)
void Scr_GetTextSourcePos(char* line, const char* codePos, scriptInstance_t a3, void* call_addr)
{
__asm
{
push a3;
mov edx, line;
mov ecx, codePos;
call call_addr;
add esp, 0x4;
}
}
// void __usercall Scr_PrintPrevCodePos(const char *codepos@<eax>, scriptInstance_t scriptInstance, con_channel_e channel, unsigned int index)
void Scr_PrintPrevCodePos(const char* codepos, scriptInstance_t scriptInstance, con_channel_e channel, unsigned int index, void* call_addr)
{
__asm
{
push index;
push channel;
push scriptInstance;
mov eax, codepos;
call call_addr;
add esp, 0xC;
}
}
//void __usercall CompileError2(const char *codePos@<edi>, scriptInstance_t a2@<esi>, char *msg, ...)
void CompileError2(const char* codePos, scriptInstance_t a2, void* call_addr, const char* msg, ...)
{
char Buffer[1024];
char* Buf = Buffer;
const char* str_ = "%s";
va_list ArgList;
va_start(ArgList, msg);
vsnprintf(Buffer, 0x400u, msg, ArgList);
va_end(ArgList);
__asm
{
push Buf;
push str_;
mov esi, a2;
mov edi, codePos;
call call_addr;
add esp, 0x8;
}
}
// void __usercall RuntimeErrorInternal(const char *msg@<eax>, scriptInstance_t inst@<edi>, con_channel_e channel, const char *codepos, int index)
void RuntimeErrorInternal(const char* msg, scriptInstance_t inst, con_channel_e channel, const char* codepos, int index, void* call_addr)
{
__asm
{
push index;
push codepos;
push channel;
mov eax, msg;
mov edi, inst;
call call_addr;
add esp, 0xC;
}
}
// void __usercall RuntimeError(scriptInstance_t inst@<eax>, const char *pos, int error_index, const char *err, const char *err2)
void RuntimeError(scriptInstance_t inst, const char* pos, int error_index, const char* err, const char* err2, void* call_addr)
{
__asm
{
push err2;
push err;
push error_index;
push pos;
mov eax, inst;
call call_addr;
add esp, 0x10;
}
}
unsigned int Scr_GetPrevSourcePos(scriptInstance_t inst, const char* codePos, unsigned int index)
{
//return cscr_parser::Scr_GetPrevSourcePos(inst, codePos, index);
return 0;
}
void Scr_ShutdownAllocNode(scriptInstance_t inst)
{
//cscr_parser::Scr_ShutdownAllocNode(inst);
}
}

20
src/game/clientscript/cscr_parsetree.hpp Normal file
View File

@ -0,0 +1,20 @@
#pragma once
namespace game
{
WEAK symbol<void(scriptInstance_t inst)>Scr_InitAllocNode{ 0x0, 0x68B870};
WEAK symbol<sval_u()>node0{ 0x0, 0x68B900};
WEAK symbol<sval_u(scr_enum_t type, sval_u val1)>node1{ 0x0, 0x68B920};
WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2)>node2{ 0x0, 0x68B950};
WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2, sval_u val3)>node3{ 0x0, 0x68B980};
WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2, sval_u val3, sval_u val4)>node4{ 0x0, 0x68B9C0};
WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5)>node5{ 0x0, 0x68BA00};
WEAK symbol<sval_u(sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5, sval_u val6)>node6{ 0x0, 0x68BA50};
WEAK symbol<sval_u(sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5, sval_u val6, sval_u val7)>node7{ 0x0, 0x68BAA0};
WEAK symbol<sval_u(sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5, sval_u val6, sval_u val7, sval_u val8)>node8{ 0x0, 0x68BB00};
WEAK symbol<sval_u(sval_u val1)>linked_list_end{ 0x0, 0x68BB60};
WEAK symbol<sval_u(sval_u val1, sval_u val2)>prepend_node{ 0x0, 0x68BBB0};
WEAK symbol<sval_u(sval_u val1, sval_u val2)>append_node{ 0x0, 0x68BBE0};
sval_u* Scr_AllocNode(scriptInstance_t inst, int size);
}

10
src/game/clientscript/cscr_parsetree_w.cpp Normal file
View File

@ -0,0 +1,10 @@
#include <stdinc.hpp>
namespace game
{
sval_u* Scr_AllocNode(scriptInstance_t inst, int size)
{
//return cscr_parsetree::Scr_AllocNode(inst, size);
return nullptr;
}
}

11
src/game/clientscript/cscr_readwrite.hpp Normal file
View File

@ -0,0 +1,11 @@
#pragma once
namespace game
{
inline void* FindVariableIndexInternal2_ADDR() { return CALL_ADDR(0x0, 0x68BC20); }
unsigned int FindVariableIndexInternal2(scriptInstance_t inst, unsigned int name, unsigned int index, void* call_addr = FindVariableIndexInternal2_ADDR());
inline void* FindLastSibling_ADDR() { return CALL_ADDR(0x0, 0x68BCA0); }
unsigned int FindLastSibling(unsigned int parentId, scriptInstance_t inst, void* call_addr = FindLastSibling_ADDR());
unsigned int FindVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
}

44
src/game/clientscript/cscr_readwrite_w.cpp Normal file
View File

@ -0,0 +1,44 @@
#include <stdinc.hpp>
namespace game
{
// unsigned int __usercall FindVariableIndexInternal2@<eax>(scriptInstance_t inst@<eax>, unsigned int name, unsigned int index)
unsigned int FindVariableIndexInternal2(scriptInstance_t inst, unsigned int name, unsigned int index, void* call_addr)
{
unsigned int answer;
__asm
{
push index;
push name;
mov eax, inst;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
// unsigned int __usercall FindLastSibling@<eax>(unsigned int parentId@<edx>, scriptInstance_t inst@<esi>)
unsigned int FindLastSibling(unsigned int parentId, scriptInstance_t inst, void* call_addr)
{
unsigned int answer;
__asm
{
mov edx, parentId;
mov esi, inst;
call call_addr;
mov answer, eax;
}
return answer;
}
unsigned int FindVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
{
//return cscr_readwrite::FindVariableIndexInternal(inst, parentId, name);
return 0;
}
}

65
src/game/clientscript/cscr_stringlist.hpp Normal file
View File

@ -0,0 +1,65 @@
#pragma once
namespace game
{
WEAK symbol<unsigned int(const char* str, scriptInstance_t inst)>SL_FindLowercaseString{ 0x0, 0x68DD50 };
WEAK symbol<unsigned int(scriptInstance_t inst, const char* string, unsigned int user, unsigned int len)>SL_GetStringOfSize{ 0x0, 0x68DE50 };
WEAK symbol<unsigned int(scriptInstance_t inst, const char* str, unsigned int user, unsigned int len)>SL_GetLowercaseStringOfLen{ 0x0, 0x68E390 };
WEAK symbol<unsigned int(scriptInstance_t inst, unsigned int stringVal, unsigned int user)>SL_ConvertToLowercase{ 0x0, 0x68E450 };
WEAK symbol<void(scriptInstance_t inst, unsigned int stringValue, RefString* refStr, unsigned int len)>SL_FreeString{ 0x0, 0x68E570 };
WEAK symbol<void()>SL_TransferSystem{ 0x0, 0x68E9D0 };
WEAK symbol<unsigned int(scriptInstance_t inst, const char* filename)>Scr_CreateCanonicalFilename{ 0x0, 0x68EB00 };
inline void* SL_ConvertToString_ADDR() { return CALL_ADDR(0x0, 0x68D950); }
char* SL_ConvertToString(unsigned int stringValue, scriptInstance_t inst, void* call_addr = SL_ConvertToString_ADDR());
inline void* SL_GetStringLen_ADDR() { return CALL_ADDR(0x0, 0x68D970); }
int SL_GetStringLen(unsigned int stringValue, scriptInstance_t inst, void* call_addr = SL_GetStringLen_ADDR());
inline void* GetHashCode_ADDR() { return CALL_ADDR(0x0, 0x68D9A0); }
unsigned int GetHashCode(unsigned int len, const char* str, void* call_addr = GetHashCode_ADDR());
inline void* SL_Init_ADDR() { return CALL_ADDR(0x0, 0x68D9F0); }
void SL_Init(scriptInstance_t inst, void* call_addr = SL_Init_ADDR());
inline void* SL_FindStringOfSize_ADDR() { return CALL_ADDR(0x0, 0x68DA90); }
unsigned int SL_FindStringOfSize(scriptInstance_t inst, const char* str, unsigned int len, void* call_addr = SL_FindStringOfSize_ADDR());
inline void* SL_FindString_ADDR() { return CALL_ADDR(0x0, 0x68DD20); }
unsigned int SL_FindString(const char* str, scriptInstance_t inst, void* call_addr = SL_FindString_ADDR());
inline void* SL_AddUserInternal_ADDR() { return CALL_ADDR(0x0, 0x68DDE0); }
signed __int32 SL_AddUserInternal(unsigned int user, RefString* refStr, void* call_addr = SL_AddUserInternal_ADDR());
inline void* Mark_ScriptStringCustom_ADDR() { return CALL_ADDR(0x0, 0x68DE10); }
int Mark_ScriptStringCustom(unsigned int stringValue, void* call_addr = Mark_ScriptStringCustom_ADDR());
inline void* SL_GetString__ADDR() { return CALL_ADDR(0x0, 0x68E330); }
unsigned int SL_GetString_(const char* str, scriptInstance_t inst, unsigned int user, void* call_addr = SL_GetString__ADDR());
inline void* SL_GetString__0_ADDR() { return CALL_ADDR(0x0, 0x68E360); }
unsigned int SL_GetString__0(const char* str, unsigned int user, scriptInstance_t inst, void* call_addr = SL_GetString__0_ADDR());
inline void* SL_GetLowercaseString_ADDR() { return CALL_ADDR(0x0, 0x68E420); }
unsigned int SL_GetLowercaseString(const char* str, void* call_addr = SL_GetLowercaseString_ADDR());
inline void* SL_TransferRefToUser_ADDR() { return CALL_ADDR(0x0, 0x68E530); }
void SL_TransferRefToUser(unsigned int stringValue, int user, scriptInstance_t inst, void* call_addr = SL_TransferRefToUser_ADDR());
inline void* SL_RemoveRefToString_ADDR() { return CALL_ADDR(0x0, 0x68E680); }
void SL_RemoveRefToString(unsigned int stringVal, scriptInstance_t inst, void* call_addr = SL_RemoveRefToString_ADDR());
inline void* Scr_SetString_ADDR() { return CALL_ADDR(0x0, 0x68E6E0); }
void Scr_SetString(scriptInstance_t inst, unsigned int from, unsigned __int16* to, void* call_addr = Scr_SetString_ADDR());
inline void* Scr_SetStringFromCharString_ADDR() { return CALL_ADDR(0x0, 0x68E720); }
void Scr_SetStringFromCharString(const char* from, unsigned short* to, void* call_addr = Scr_SetStringFromCharString_ADDR());
inline void* GScr_AllocString_ADDR() { return CALL_ADDR(0x0, 0x68E770); }
unsigned int GScr_AllocString(const char* str, scriptInstance_t inst, void* call_addr = GScr_AllocString_ADDR());
inline void* SL_GetStringForFloat_ADDR() { return CALL_ADDR(0x0, 0x68E7A0); }
unsigned int SL_GetStringForFloat(float value, scriptInstance_t inst, void* call_addr = SL_GetStringForFloat_ADDR());
inline void* SL_GetStringForInt_ADDR() { return CALL_ADDR(0x0, 0x68E800); }
unsigned int SL_GetStringForInt(int value, scriptInstance_t inst, void* call_addr = SL_GetStringForInt_ADDR());
inline void* SL_GetStringForVector_ADDR() { return CALL_ADDR(0x0, 0x68E850); }
unsigned int SL_GetStringForVector(float* value, scriptInstance_t inst, void* call_addr = SL_GetStringForVector_ADDR());
inline void* SL_ShutdownSystem_ADDR() { return CALL_ADDR(0x0, 0x68E8D0); }
void SL_ShutdownSystem(scriptInstance_t inst, unsigned int user, void* call_addr = SL_ShutdownSystem_ADDR());
inline void* SL_CreateCanonicalFilename_ADDR() { return CALL_ADDR(0x0, 0x68EA80); }
void SL_CreateCanonicalFilename(const char* filename, char* newFilename, void* call_addr = SL_CreateCanonicalFilename_ADDR());
RefString* GetRefString(scriptInstance_t inst, unsigned int id);
void SL_AddRefToString(scriptInstance_t inst, unsigned int stringValue);
void SL_RemoveRefToStringOfSize(scriptInstance_t inst, unsigned int stringValue, unsigned int len);
int SL_GetRefStringLen(RefString* refString);
void SL_AddUser(unsigned int stringValue, unsigned int user, scriptInstance_t inst);
int SL_ConvertFromString(scriptInstance_t inst, const char* str);
int SL_ConvertFromRefString(scriptInstance_t inst, RefString* refString);
RefString* GetRefString_0(scriptInstance_t inst, const char* str);
const char* SL_DebugConvertToString(unsigned int stringValue, scriptInstance_t inst);
}

375
src/game/clientscript/cscr_stringlist_w.cpp Normal file
View File

@ -0,0 +1,375 @@
#include <stdinc.hpp>
namespace game
{
// char *__usercall SL_ConvertToString@<eax>(unsigned int id@<eax>, scriptInstance_t inst@<ecx>)
char* SL_ConvertToString(unsigned int id, scriptInstance_t inst, void* call_addr)
{
char* answer;
__asm
{
mov eax, id;
mov ecx, inst;
call call_addr;
mov answer, eax;
}
return answer;
}
// int __usercall SL_GetStringLen@<eax>(unsigned int a1@<eax>, scriptInstance_t a2@<ecx>)
int SL_GetStringLen(unsigned int a1, scriptInstance_t a2, void* call_addr)
{
int answer;
__asm
{
mov eax, a1;
mov ecx, a2;
call call_addr;
mov answer, eax;
}
return answer;
}
// unsigned int __usercall GetHashCode@<eax>(unsigned int a1@<eax>, char *a2@<edx>)
unsigned int GetHashCode(unsigned int a1, const char* a2, void* call_addr)
{
unsigned int answer;
__asm
{
mov eax, a1;
mov edx, a2;
call call_addr;
mov answer, eax;
}
return answer;
}
// void __usercall SL_Init(scriptInstance_t a1@<eax>)
void SL_Init(scriptInstance_t a1, void* call_addr)
{
__asm
{
mov eax, a1;
call call_addr;
}
}
// unsigned int __usercall SL_FindStringOfSize@<eax>(scriptInstance_t inst@<eax>, const char *str, unsigned int len)
unsigned int SL_FindStringOfSize(scriptInstance_t inst, const char* str_, unsigned int len, void* call_addr)
{
unsigned int answer;
__asm
{
push len;
push str_;
mov eax, inst;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
// unsigned int __usercall SL_FindString@<eax>(char *a1@<edx>, scriptInstance_t a2)
unsigned int SL_FindString(const char* a1, scriptInstance_t a2, void* call_addr)
{
#if 0
cscr_stringlist::SL_FindString
#endif
unsigned int answer;
__asm
{
push a2;
mov edx, a1;
call call_addr;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
// signed __int32 __usercall SL_AddUserInternal@<eax>(int user@<eax>, volatile signed __int32 *a2@<edx>)
signed __int32 SL_AddUserInternal(unsigned int user, RefString* a2, void* call_addr)
{
signed __int32 answer;
__asm
{
mov eax, user;
mov edx, a2;
call call_addr;
mov answer, eax;
}
return answer;
}
// int __usercall Mark_ScriptStringCustom@<eax>(int a1@<eax>)
int Mark_ScriptStringCustom(unsigned int a1, void* call_addr)
{
int answer;
__asm
{
mov eax, a1;
call call_addr;
mov answer, eax;
}
return answer;
}
// unsigned int __usercall SL_GetString_@<eax>(char *a1@<edx>, scriptInstance_t a2, int user)
unsigned int SL_GetString_(const char* a1, scriptInstance_t a2, unsigned int user, void* call_addr)
{
unsigned int answer;
__asm
{
push user;
push a2;
mov edx, a1;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
// unsigned int __usercall SL_GetString__0@<eax>(char *a1@<edx>, int user, scriptInstance_t a3)
unsigned int SL_GetString__0(const char* a1, unsigned int user, scriptInstance_t a3, void* call_addr)
{
unsigned int answer;
__asm
{
push a3;
push user;
mov edx, a1;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
// unsigned int __usercall SL_GetLowercaseString@<eax>(const char *a2@<edx>)
unsigned int SL_GetLowercaseString(const char* a2, void* call_addr)
{
unsigned int answer;
__asm
{
mov edx, a2;
call call_addr;
mov answer, eax;
}
return answer;
}
// void __usercall SL_TransferRefToUser(unsigned int stringValue@<eax>, int user@<ecx>, scriptInstance_t inst)
void SL_TransferRefToUser(unsigned int stringValue, int user, scriptInstance_t inst, void* call_addr)
{
__asm
{
push inst;
mov eax, stringValue;
mov ecx, user;
call call_addr;
add esp, 0x4;
}
}
// void __usercall SL_RemoveRefToString(unsigned int stringVal@<edx>, scriptInstance_t inst@<esi>)
void SL_RemoveRefToString(unsigned int stringVal/*@<edx>*/, scriptInstance_t inst/*@<esi>*/, void* call_addr)
{
__asm
{
mov edx, stringVal;
mov esi, inst;
call call_addr;
}
}
// void __usercall Scr_SetString(scriptInstance_t inst@<eax>, unsigned int from@<edi>, unsigned __int16 *to)
void Scr_SetString(scriptInstance_t inst, unsigned int from, unsigned __int16* to, void* call_addr)
{
__asm
{
push to;
mov eax, inst;
mov edi, from;
call call_addr;
add esp, 0x4;
}
}
// unsigned int __usercall Scr_SetStringFromCharString@<eax>(char *a1@<edi>, _WORD *a2)
void Scr_SetStringFromCharString(const char* a1, unsigned short* a2, void* call_addr)
{
__asm
{
push a2;
mov edi, a1;
call call_addr;
add esp, 0x4;
}
}
// unsigned int __usercall GScr_AllocString@<eax>(char *a1@<edx>, scriptInstance_t inst)
unsigned int GScr_AllocString(const char* a1, scriptInstance_t inst, void* call_addr)
{
unsigned int answer;
__asm
{
push inst;
mov edx, a1;
call call_addr;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
// unsigned int __usercall SL_GetStringForFloat@<eax>(float a1@<xmm0>, scriptInstance_t a2)
unsigned int SL_GetStringForFloat(float a1, scriptInstance_t a2, void* call_addr)
{
unsigned int answer;
__asm
{
push a2;
movsd xmm0, a1;
call call_addr;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
// unsigned int __usercall SL_GetStringForInt@<eax>(int a1@<eax>, scriptInstance_t a2)
unsigned int SL_GetStringForInt(int a1, scriptInstance_t a2, void* call_addr)
{
unsigned int answer;
__asm
{
push a2;
mov eax, a1;
call call_addr;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
// unsigned int __usercall SL_GetStringForVector@<eax>(float *a1@<eax>, scriptInstance_t a2)
unsigned int SL_GetStringForVector(float* a1, scriptInstance_t a2, void* call_addr)
{
unsigned int answer;
__asm
{
push a2;
mov eax, a1;
call call_addr;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
// void __usercall SL_ShutdownSystem(scriptInstance_t a1@<edi>, unsigned int a2)
void SL_ShutdownSystem(scriptInstance_t a1, unsigned int a2, void* call_addr)
{
__asm
{
push a2;
mov edi, a1;
call call_addr;
add esp, 0x4;
}
}
// void __usercall CreateCanonicalFilename(const char *a1@<eax>, char *a2)
void SL_CreateCanonicalFilename(const char* a1, char* a2, void* call_addr)
{
__asm
{
push a2;
mov eax, a1;
call call_addr;
add esp, 0x4;
}
}
RefString* GetRefString(scriptInstance_t inst, unsigned int id)
{
//return cscr_stringlist::GetRefString(inst, id);
return nullptr;
}
void SL_AddRefToString(scriptInstance_t inst, unsigned int stringValue)
{
//cscr_stringlist::SL_AddRefToString(inst, stringValue);
}
void SL_RemoveRefToStringOfSize(scriptInstance_t inst, unsigned int stringValue, unsigned int len)
{
//cscr_stringlist::SL_RemoveRefToStringOfSize(inst, stringValue, len);
}
int SL_GetRefStringLen(RefString* refString)
{
//return cscr_stringlist::SL_GetRefStringLen(refString);
return 0;
}
void SL_AddUser(unsigned int stringValue, unsigned int user, scriptInstance_t inst)
{
//cscr_stringlist::SL_AddUser(stringValue, user, inst);
}
int SL_ConvertFromString(scriptInstance_t inst, const char* str)
{
//return cscr_stringlist::SL_ConvertFromString(inst, str);
return 0;
}
int SL_ConvertFromRefString(scriptInstance_t inst, RefString* refString)
{
//return cscr_stringlist::SL_ConvertFromRefString(inst, refString);
return 0;
}
RefString* GetRefString_0(scriptInstance_t inst, const char* str)
{
//return cscr_stringlist::GetRefString_0(inst, str);
return nullptr;
}
const char* SL_DebugConvertToString(unsigned int stringValue, scriptInstance_t inst)
{
//return cscr_stringlist::SL_DebugConvertToString(stringValue, inst);
return nullptr;
}
}

8
src/game/clientscript/cscr_tempmemory.hpp Normal file
View File

@ -0,0 +1,8 @@
#pragma once
namespace game
{
void TempMemorySetPos(char* pos);
void TempMemoryReset(HunkUser* user);
char* TempMalloc(int len);
}

20
src/game/clientscript/cscr_tempmemory_w.cpp Normal file
View File

@ -0,0 +1,20 @@
#include <stdinc.hpp>
namespace game
{
void TempMemorySetPos(char* pos)
{
//cscr_tempmemory::TempMemorySetPos(pos);
}
void TempMemoryReset(HunkUser* user)
{
//cscr_tempmemory::TempMemoryReset(user);
}
char* TempMalloc(int len)
{
//return cscr_tempmemory::TempMalloc(len);
return nullptr;
}
}

229
src/game/clientscript/cscr_variable.hpp Normal file
View File

@ -0,0 +1,229 @@
#pragma once
namespace game
{
WEAK symbol<int(const void * info1, const void * info2)>ThreadInfoCompare{ 0x0, 0x68EB50};
WEAK symbol<void(scriptInstance_t scriptInstance)>Scr_DumpScriptThreads{ 0x0, 0x68EBA0};
WEAK symbol<unsigned int(scriptInstance_t inst, unsigned int parentId, unsigned int name, unsigned int index)>GetNewVariableIndexInternal3{ 0x0, 0x68F090};
WEAK symbol<void(scriptInstance_t inst, unsigned int parentId)>ClearObjectInternal{ 0x0, 0x68F910};
WEAK symbol<void(scriptInstance_t inst, VariableType type, VariableUnion a3)>RemoveRefToValueInternal{ 0x0, 0x6901C0};
WEAK symbol<void(scriptInstance_t inst, unsigned int parentId, unsigned int newParentId)>CopyArray{ 0x0, 0x690770};
WEAK symbol<void(scriptInstance_t inst, unsigned int parentId, unsigned int name, VariableValue * value)>SetVariableEntityFieldValue{ 0x0, 0x690910};
WEAK symbol<void(scriptInstance_t inst, VariableValue * a2)>Scr_ClearVector{ 0x0, 0x691000};
WEAK symbol<void(scriptInstance_t inst)>Scr_FreeEntityList{ 0x0, 0x692160};
WEAK symbol<void(scriptInstance_t inst)>Scr_FreeObjects{ 0x0, 0x6921E0};
WEAK symbol<void(unsigned int arrayId, scriptInstance_t inst)>Scr_AddArrayKeys{ 0x0, 0x692DE0};
WEAK symbol<float(scriptInstance_t inst, unsigned int parentId)>Scr_GetObjectUsage{ 0x0, 0x693030};
WEAK symbol<char *(const char * filename)>Scr_GetSourceFile_LoadObj{ 0x0, 0x6932C0};
WEAK symbol<char *(const char * filename)>Scr_GetSourceFile_FastFile{ 0x0, 0x693350};
WEAK symbol<void(scriptInstance_t inst, char * Format)>Scr_AddFieldsForFile{ 0x0, 0x693390};
WEAK symbol<void(scriptInstance_t inst, const char * path, const char * extension)>Scr_AddFields_LoadObj{ 0x0, 0x6936B0};
WEAK symbol<void(scriptInstance_t inst, const char * path, const char * extension)>Scr_AddFields_FastFile{ 0x0, 0x693830};
WEAK symbol<int(scriptInstance_t inst, unsigned int parentId)>Scr_MakeValuePrimitive{ 0x0, 0x6938B0};
inline void* Scr_InitVariableRange_ADDR() { return CALL_ADDR(0x0, 0x68EF90); }
void Scr_InitVariableRange(unsigned int begin, unsigned int end, scriptInstance_t inst, void* call_addr = Scr_InitVariableRange_ADDR());
inline void* Scr_InitClassMap_ADDR() { return CALL_ADDR(0x0, 0x68F030); }
void Scr_InitClassMap(scriptInstance_t inst, void* call_addr = Scr_InitClassMap_ADDR());
inline void* GetNewVariableIndexInternal2_ADDR() { return CALL_ADDR(0x0, 0x68F4A0); }
unsigned int GetNewVariableIndexInternal2(unsigned int name, scriptInstance_t inst, unsigned int parentId, unsigned int index, void* call_addr = GetNewVariableIndexInternal2_ADDR());
inline void* GetNewVariableIndexReverseInternal2_ADDR() { return CALL_ADDR(0x0, 0x68F560); }
unsigned int GetNewVariableIndexReverseInternal2(unsigned int name, scriptInstance_t inst, unsigned int parentId, unsigned int index, void* call_addr = GetNewVariableIndexReverseInternal2_ADDR());
inline void* MakeVariableExternal_ADDR() { return CALL_ADDR(0x0, 0x68F620); }
void MakeVariableExternal(VariableValueInternal * parentValue, scriptInstance_t inst, unsigned int index, void* call_addr = MakeVariableExternal_ADDR());
inline void* FreeChildValue_ADDR() { return CALL_ADDR(0x0, 0x68F800); }
void FreeChildValue(unsigned int id, scriptInstance_t inst, unsigned int parentId, void* call_addr = FreeChildValue_ADDR());
inline void* ClearObject_ADDR() { return CALL_ADDR(0x0, 0x68F9E0); }
void ClearObject(unsigned int parentId, scriptInstance_t inst, void* call_addr = ClearObject_ADDR());
inline void* Scr_StopThread_ADDR() { return CALL_ADDR(0x0, 0x68FA30); }
void Scr_StopThread(scriptInstance_t inst, unsigned int threadId, void* call_addr = Scr_StopThread_ADDR());
inline void* GetSafeParentLocalId_ADDR() { return CALL_ADDR(0x0, 0x68FAA0); }
unsigned int GetSafeParentLocalId(scriptInstance_t inst, unsigned int threadId, void* call_addr = GetSafeParentLocalId_ADDR());
inline void* GetStartLocalId_ADDR() { return CALL_ADDR(0x0, 0x68FAD0); }
unsigned int GetStartLocalId(unsigned int threadId, scriptInstance_t inst, void* call_addr = GetStartLocalId_ADDR());
inline void* Scr_KillThread_ADDR() { return CALL_ADDR(0x0, 0x68FB10); }
void Scr_KillThread(scriptInstance_t inst, unsigned int parentId, void* call_addr = Scr_KillThread_ADDR());
inline void* AllocVariable_ADDR() { return CALL_ADDR(0x0, 0x68FCE0); }
unsigned __int16 AllocVariable(scriptInstance_t inst, void* call_addr = AllocVariable_ADDR());
inline void* FreeVariable_ADDR() { return CALL_ADDR(0x0, 0x68FDC0); }
void FreeVariable(unsigned int id, scriptInstance_t inst, void* call_addr = FreeVariable_ADDR());
inline void* AllocValue_ADDR() { return CALL_ADDR(0x0, 0x68FE20); }
unsigned int AllocValue(scriptInstance_t inst, void* call_addr = AllocValue_ADDR());
inline void* AllocEntity_ADDR() { return CALL_ADDR(0x0, 0x68FF10); }
unsigned int AllocEntity(unsigned int classnum, scriptInstance_t inst, int entnum, int clientnum, void* call_addr = AllocEntity_ADDR());
inline void* Scr_AllocArray_ADDR() { return CALL_ADDR(0x0, 0x68FF60); }
unsigned int Scr_AllocArray(scriptInstance_t inst, void* call_addr = Scr_AllocArray_ADDR());
inline void* AllocChildThread_ADDR() { return CALL_ADDR(0x0, 0x68FF90); }
unsigned int AllocChildThread(scriptInstance_t inst, unsigned int parentLocalId, unsigned int self, void* call_addr = AllocChildThread_ADDR());
inline void* FreeValue_ADDR() { return CALL_ADDR(0x0, 0x68FFD0); }
void FreeValue(unsigned int id, scriptInstance_t inst, void* call_addr = FreeValue_ADDR());
inline void* RemoveRefToObject_ADDR() { return CALL_ADDR(0x0, 0x690040); }
void RemoveRefToObject(unsigned int id, scriptInstance_t inst, void* call_addr = RemoveRefToObject_ADDR());
inline void* Scr_AllocVector_ADDR() { return CALL_ADDR(0x0, 0x690100); }
float * Scr_AllocVector(scriptInstance_t inst, void* call_addr = Scr_AllocVector_ADDR());
inline void* RemoveRefToVector_ADDR() { return CALL_ADDR(0x0, 0x690130); }
void RemoveRefToVector(const float* vectorValue, scriptInstance_t inst, void* call_addr = RemoveRefToVector_ADDR());
inline void* AddRefToValue_ADDR() { return CALL_ADDR(0x0, 0x690160); }
void AddRefToValue(scriptInstance_t inst, VariableType type_, VariableUnion u, void* call_addr = AddRefToValue_ADDR());
inline void* FindArrayVariable_ADDR() { return CALL_ADDR(0x0, 0x690210); }
int FindArrayVariable(unsigned int id, unsigned int intvalue, scriptInstance_t inst, void* call_addr = FindArrayVariable_ADDR());
inline void* FindVariable_ADDR() { return CALL_ADDR(0x0, 0x690260); }
unsigned int FindVariable(unsigned int unsignedValue, unsigned int parentId, scriptInstance_t inst, void* call_addr = FindVariable_ADDR());
inline void* GetArrayVariableIndex_ADDR() { return CALL_ADDR(0x0, 0x6902A0); }
unsigned int GetArrayVariableIndex(unsigned int unsignedValue, scriptInstance_t inst, unsigned int parentId, void* call_addr = GetArrayVariableIndex_ADDR());
inline void* Scr_GetVariableFieldIndex_ADDR() { return CALL_ADDR(0x0, 0x6902F0); }
unsigned int Scr_GetVariableFieldIndex(scriptInstance_t inst, unsigned int name, unsigned int parentId, void* call_addr = Scr_GetVariableFieldIndex_ADDR());
inline void* Scr_FindVariableField_ADDR() { return CALL_ADDR(0x0, 0x6903B0); }
VariableValue Scr_FindVariableField(scriptInstance_t inst, unsigned int parentId, unsigned int name, void* call_addr = Scr_FindVariableField_ADDR());
inline void* ClearVariableField_ADDR() { return CALL_ADDR(0x0, 0x690450); }
void ClearVariableField(scriptInstance_t inst, unsigned int id, unsigned int name, VariableValue * value, void* call_addr = ClearVariableField_ADDR());
inline void* GetVariable_ADDR() { return CALL_ADDR(0x0, 0x690510); }
unsigned int GetVariable(scriptInstance_t inst, unsigned int parentId, unsigned int name, void* call_addr = GetVariable_ADDR());
inline void* GetNewVariable_ADDR() { return CALL_ADDR(0x0, 0x690570); }
unsigned int GetNewVariable(scriptInstance_t inst, unsigned int unsignedValue, unsigned int parentId, void* call_addr = GetNewVariable_ADDR());
inline void* GetObjectVariable_ADDR() { return CALL_ADDR(0x0, 0x6905B0); }
unsigned int GetObjectVariable(unsigned int id, scriptInstance_t inst, unsigned int parentId, void* call_addr = GetObjectVariable_ADDR());
inline void* GetNewObjectVariable_ADDR() { return CALL_ADDR(0x0, 0x690610); }
unsigned int GetNewObjectVariable(scriptInstance_t inst, unsigned int name, unsigned int parentId, void* call_addr = GetNewObjectVariable_ADDR());
inline void* RemoveVariable_ADDR() { return CALL_ADDR(0x0, 0x690650); }
void RemoveVariable(unsigned int name, unsigned int parentId, scriptInstance_t inst, void* call_addr = RemoveVariable_ADDR());
inline void* RemoveNextVariable_ADDR() { return CALL_ADDR(0x0, 0x6906A0); }
void RemoveNextVariable(scriptInstance_t inst, unsigned int parentId, void* call_addr = RemoveNextVariable_ADDR());
inline void* SafeRemoveVariable_ADDR() { return CALL_ADDR(0x0, 0x690710); }
void SafeRemoveVariable(unsigned int unsignedValue, unsigned int parentId, scriptInstance_t inst, void* call_addr = SafeRemoveVariable_ADDR());
inline void* SetVariableValue_ADDR() { return CALL_ADDR(0x0, 0x6908D0); }
void SetVariableValue(scriptInstance_t inst, VariableValue * value, unsigned int id, void* call_addr = SetVariableValue_ADDR());
inline void* Scr_EvalVariable_ADDR() { return CALL_ADDR(0x0, 0x690A10); }
VariableValue Scr_EvalVariable(scriptInstance_t inst, unsigned int id, void* call_addr = Scr_EvalVariable_ADDR());
inline void* Scr_EvalVariableObject_ADDR() { return CALL_ADDR(0x0, 0x690A50); }
unsigned int Scr_EvalVariableObject(scriptInstance_t inst, int id, void* call_addr = Scr_EvalVariableObject_ADDR());
inline void* Scr_EvalVariableEntityField_ADDR() { return CALL_ADDR(0x0, 0x690AB0); }
VariableValue Scr_EvalVariableEntityField(unsigned int entId, scriptInstance_t inst, unsigned int name, void* call_addr = Scr_EvalVariableEntityField_ADDR());
inline void* Scr_EvalVariableField_ADDR() { return CALL_ADDR(0x0, 0x690BB0); }
VariableValue Scr_EvalVariableField(scriptInstance_t inst, unsigned int id, void* call_addr = Scr_EvalVariableField_ADDR());
inline void* Scr_EvalSizeValue_ADDR() { return CALL_ADDR(0x0, 0x690C10); }
void Scr_EvalSizeValue(scriptInstance_t inst, VariableValue * value, void* call_addr = Scr_EvalSizeValue_ADDR());
inline void* GetObject_ADDR() { return CALL_ADDR(0x0, 0x690CF0); }
unsigned int GetObject(scriptInstance_t inst, unsigned int id, void* call_addr = GetObject_ADDR());
inline void* GetArray_ADDR() { return CALL_ADDR(0x0, 0x690D50); }
unsigned int GetArray(scriptInstance_t inst, unsigned int id, void* call_addr = GetArray_ADDR());
inline void* Scr_EvalBoolComplement_ADDR() { return CALL_ADDR(0x0, 0x690DB0); }
void Scr_EvalBoolComplement(scriptInstance_t inst, VariableValue * value, void* call_addr = Scr_EvalBoolComplement_ADDR());
inline void* Scr_CastBool_ADDR() { return CALL_ADDR(0x0, 0x690E00); }
void Scr_CastBool(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastBool_ADDR());
inline void* Scr_CastString_ADDR() { return CALL_ADDR(0x0, 0x690E80); }
char Scr_CastString(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastString_ADDR());
inline void* Scr_CastDebugString_ADDR() { return CALL_ADDR(0x0, 0x690F30); }
void Scr_CastDebugString(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastDebugString_ADDR());
inline void* Scr_CastVector_ADDR() { return CALL_ADDR(0x0, 0x691040); }
void Scr_CastVector(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastVector_ADDR());
inline void* Scr_EvalFieldObject_ADDR() { return CALL_ADDR(0x0, 0x691110); }
VariableUnion Scr_EvalFieldObject(VariableValue * value, scriptInstance_t inst, int a3, void* call_addr = Scr_EvalFieldObject_ADDR());
inline void* Scr_UnmatchingTypesError_ADDR() { return CALL_ADDR(0x0, 0x6911B0); }
void Scr_UnmatchingTypesError(scriptInstance_t inst, VariableValue * value2, VariableValue * value1, void* call_addr = Scr_UnmatchingTypesError_ADDR());
inline void* Scr_CastWeakerPair_ADDR() { return CALL_ADDR(0x0, 0x691270); }
void Scr_CastWeakerPair(VariableValue * value2, VariableValue * value1, scriptInstance_t inst, void* call_addr = Scr_CastWeakerPair_ADDR());
inline void* Scr_CastWeakerStringPair_ADDR() { return CALL_ADDR(0x0, 0x691370); }
void Scr_CastWeakerStringPair(VariableValue * value2, VariableValue * value1, scriptInstance_t inst, void* call_addr = Scr_CastWeakerStringPair_ADDR());
inline void* Scr_EvalOr_ADDR() { return CALL_ADDR(0x0, 0x6914E0); }
void Scr_EvalOr(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalOr_ADDR());
inline void* Scr_EvalExOr_ADDR() { return CALL_ADDR(0x0, 0x691510); }
void Scr_EvalExOr(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalExOr_ADDR());
inline void* Scr_EvalAnd_ADDR() { return CALL_ADDR(0x0, 0x691540); }
void Scr_EvalAnd(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalAnd_ADDR());
inline void* Scr_EvalEquality_ADDR() { return CALL_ADDR(0x0, 0x691570); }
void Scr_EvalEquality(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalEquality_ADDR());
inline void* Scr_EvalLess_ADDR() { return CALL_ADDR(0x0, 0x691760); }
void Scr_EvalLess(VariableValue * value1, VariableValue * value2, scriptInstance_t a3, void* call_addr = Scr_EvalLess_ADDR());
inline void* Scr_EvalGreaterEqual_ADDR() { return CALL_ADDR(0x0, 0x6917D0); }
void Scr_EvalGreaterEqual(scriptInstance_t inst, VariableValue * value1, VariableValue * value2, void* call_addr = Scr_EvalGreaterEqual_ADDR());
inline void* Scr_EvalGreater_ADDR() { return CALL_ADDR(0x0, 0x6917F0); }
void Scr_EvalGreater(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalGreater_ADDR());
inline void* Scr_EvalLessEqual_ADDR() { return CALL_ADDR(0x0, 0x691860); }
void Scr_EvalLessEqual(scriptInstance_t inst, VariableValue * value1, VariableValue * value2, void* call_addr = Scr_EvalLessEqual_ADDR());
inline void* Scr_EvalShiftLeft_ADDR() { return CALL_ADDR(0x0, 0x691880); }
void Scr_EvalShiftLeft(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalShiftLeft_ADDR());
inline void* Scr_EvalShiftRight_ADDR() { return CALL_ADDR(0x0, 0x6918B0); }
void Scr_EvalShiftRight(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalShiftRight_ADDR());
inline void* Scr_EvalPlus_ADDR() { return CALL_ADDR(0x0, 0x6918E0); }
void Scr_EvalPlus(scriptInstance_t inst, VariableValue* value1, VariableValue* value2, void* call_addr = Scr_EvalPlus_ADDR());
inline void* Scr_EvalMinus_ADDR() { return CALL_ADDR(0x0, 0x691B00); }
void Scr_EvalMinus(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalMinus_ADDR());
inline void* Scr_EvalMultiply_ADDR() { return CALL_ADDR(0x0, 0x691C20); }
void Scr_EvalMultiply(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalMultiply_ADDR());
inline void* Scr_EvalDivide_ADDR() { return CALL_ADDR(0x0, 0x691D40); }
void Scr_EvalDivide(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalDivide_ADDR());
inline void* Scr_EvalMod_ADDR() { return CALL_ADDR(0x0, 0x691F00); }
void Scr_EvalMod(scriptInstance_t inst, VariableValue * value1, VariableValue * value2, void* call_addr = Scr_EvalMod_ADDR());
inline void* Scr_EvalBinaryOperator_ADDR() { return CALL_ADDR(0x0, 0x691F50); }
void Scr_EvalBinaryOperator(scriptInstance_t inst, VariableValue * value1, OpcodeVM op, VariableValue * value2, void* call_addr = Scr_EvalBinaryOperator_ADDR());
inline void* Scr_FreeEntityNum_ADDR() { return CALL_ADDR(0x0, 0x692090); }
void Scr_FreeEntityNum(scriptInstance_t inst, unsigned int result, unsigned int entnum, void* call_addr = Scr_FreeEntityNum_ADDR());
inline void* Scr_SetClassMap_ADDR() { return CALL_ADDR(0x0, 0x692260); }
void Scr_SetClassMap(scriptInstance_t inst, unsigned int classnum, void* call_addr = Scr_SetClassMap_ADDR());
inline void* Scr_RemoveClassMap_ADDR() { return CALL_ADDR(0x0, 0x6922E0); }
void Scr_RemoveClassMap(unsigned int classnum, scriptInstance_t inst, void* call_addr = Scr_RemoveClassMap_ADDR());
inline void* Scr_AddClassField_ADDR() { return CALL_ADDR(0x0, 0x692350); }
void Scr_AddClassField(scriptInstance_t inst, unsigned int classnum, const char * name, unsigned int offset, void* call_addr = Scr_AddClassField_ADDR());
inline void* Scr_GetOffset_ADDR() { return CALL_ADDR(0x0, 0x692440); }
VariableUnion Scr_GetOffset(const char * name, scriptInstance_t inst, classNum_e classNum, void* call_addr = Scr_GetOffset_ADDR());
inline void* FindEntityId_ADDR() { return CALL_ADDR(0x0, 0x6924C0); }
unsigned int FindEntityId(unsigned int entClass, int entNum, scriptInstance_t inst, void* call_addr = FindEntityId_ADDR());
inline void* Scr_GetEntityId_ADDR() { return CALL_ADDR(0x0, 0x692520); }
unsigned int Scr_GetEntityId(int entNum, scriptInstance_t inst, classNum_e classnum, int clientnum, void* call_addr = Scr_GetEntityId_ADDR());
inline void* Scr_FindArrayIndex_ADDR() { return CALL_ADDR(0x0, 0x6925B0); }
unsigned int Scr_FindArrayIndex(scriptInstance_t inst, VariableValue* index, unsigned int parentId, void* call_addr = Scr_FindArrayIndex_ADDR());
inline void* Scr_EvalArray_ADDR() { return CALL_ADDR(0x0, 0x692680); }
void Scr_EvalArray(scriptInstance_t inst, VariableValue * index, VariableValue * value, void* call_addr = Scr_EvalArray_ADDR());
inline void* Scr_EvalArrayRef_ADDR() { return CALL_ADDR(0x0, 0x692850); }
unsigned int Scr_EvalArrayRef(scriptInstance_t inst, unsigned int parentId, void* call_addr = Scr_EvalArrayRef_ADDR());
inline void* ClearArray_ADDR() { return CALL_ADDR(0x0, 0x692AF0); }
void ClearArray(unsigned int parentId, scriptInstance_t inst, VariableValue * value, void* call_addr = ClearArray_ADDR());
inline void* SetEmptyArray_ADDR() { return CALL_ADDR(0x0, 0x692D70); }
void SetEmptyArray(scriptInstance_t inst, unsigned int parentId, void* call_addr = SetEmptyArray_ADDR());
inline void* Scr_GetEntityIdRef_ADDR() { return CALL_ADDR(0x0, 0x692EC0); }
scr_entref_t * Scr_GetEntityIdRef(scr_entref_t * retstr, scriptInstance_t inst, unsigned int entId, void* call_addr = Scr_GetEntityIdRef_ADDR());
inline void* CopyEntity_ADDR() { return CALL_ADDR(0x0, 0x692F00); }
void CopyEntity(unsigned int parentId, unsigned int newParentId, void* call_addr = CopyEntity_ADDR());
inline void* Scr_GetEndonUsage_ADDR() { return CALL_ADDR(0x0, 0x692FC0); }
float Scr_GetEndonUsage(unsigned int parentId, scriptInstance_t inst, void* call_addr = Scr_GetEndonUsage_ADDR());
inline void* Scr_GetThreadUsage_ADDR() { return CALL_ADDR(0x0, 0x693130); }
float Scr_GetThreadUsage(VariableStackBuffer * stackBuf, scriptInstance_t inst, float * endonUsage, void* call_addr = Scr_GetThreadUsage_ADDR());
inline void* Scr_FindField_ADDR() { return CALL_ADDR(0x0, 0x693250); }
unsigned int Scr_FindField(scriptInstance_t inst, const char * name, int * type, void* call_addr = Scr_FindField_ADDR());
inline void* Scr_FreeGameVariable_ADDR() { return CALL_ADDR(0x0, 0x693A10); }
void Scr_FreeGameVariable(scriptInstance_t inst, int bComplete, void* call_addr = Scr_FreeGameVariable_ADDR());
inline void* Scr_SLHasLowercaseString_ADDR() { return CALL_ADDR(0x0, 0x693A70); }
bool Scr_SLHasLowercaseString(unsigned int parentId, const char * str, void* call_addr = Scr_SLHasLowercaseString_ADDR());
unsigned int FindObject(scriptInstance_t inst, unsigned int id);
unsigned int FindFirstSibling(scriptInstance_t inst, unsigned int id);
unsigned int FindNextSibling(scriptInstance_t inst, unsigned int id);
VariableValue Scr_GetArrayIndexValue(scriptInstance_t inst, unsigned int name);
float Scr_GetEntryUsageInternal(scriptInstance_t inst, unsigned int type, VariableUnion u);
float Scr_GetEntryUsage(scriptInstance_t inst, VariableValueInternal* entryValue);
void AddRefToObject(scriptInstance_t inst, unsigned int id);
void RemoveRefToEmptyObject(scriptInstance_t inst, unsigned int id);
void Scr_ClearThread(scriptInstance_t inst, unsigned int parentId);
unsigned int FindObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id);
void RemoveObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id);
VariableValueInternal_u* GetVariableValueAddress(scriptInstance_t inst, unsigned int id);
void Scr_KillEndonThread(scriptInstance_t inst, unsigned int threadId);
BOOL IsValidArrayIndex(scriptInstance_t inst, unsigned int unsignedValue);
void RemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
void SafeRemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
void AddRefToVector(scriptInstance_t inst, const float* floatVal);
unsigned int FindArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
unsigned int GetVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
unsigned int GetNewVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
unsigned int AllocObject(scriptInstance_t inst);
VariableType GetValueType(scriptInstance_t inst, unsigned int id);
VariableType GetObjectType(scriptInstance_t inst, unsigned int id);
float* Scr_AllocVector_(scriptInstance_t inst, const float* v);
void Scr_EvalInequality(scriptInstance_t inst, VariableValue* value1, VariableValue* value2);
unsigned int Scr_EvalArrayRefInternal(scriptInstance_t inst, VariableValue* varValue, VariableValueInternal* parentValue);
unsigned int GetNewArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
unsigned int GetNewArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
unsigned int GetArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
unsigned int AllocThread(scriptInstance_t inst, unsigned int self);
}

1459
src/game/clientscript/cscr_variable_w.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

182
src/game/clientscript/cscr_vm.hpp Normal file
View File

@ -0,0 +1,182 @@
#pragma once
namespace game
{
WEAK symbol<void(scriptInstance_t inst)>Scr_VM_Init{ 0x0, 0x693B20 };
WEAK symbol<void(scriptInstance_t inst, unsigned int startLocalId, VariableStackBuffer* stackValue)>VM_UnarchiveStack{ 0x0, 0x697BB0 };
WEAK symbol<unsigned int(scriptInstance_t inst)>VM_ExecuteInternal{ 0x0, 0x693E80 };
WEAK symbol<unsigned int(scriptInstance_t inst, unsigned int localId, const char* pos, unsigned int paramcount)>VM_Execute{ 0x0, 0x6992E0 };
WEAK symbol<void(scriptInstance_t inst, int bComplete)>Scr_ShutdownSystem{ 0x0, 0x699930 };
WEAK symbol<BOOL()>Scr_IsSystemActive{ 0x0, 0x699C30 };
WEAK symbol<scr_animtree_t()>Scr_GetAnimTree{ 0x0, 0x699DD0 };
WEAK symbol<unsigned int()>Scr_GetFunc{ 0x0, 0x69A2C0 };
WEAK symbol<void(VariableUnion value)>Scr_AddAnim{ 0x0, 0x69A6D0 };
WEAK symbol<void(scriptInstance_t inst)>Scr_AddArray{ 0x0, 0x69AA50 };
inline void* Scr_Init_ADDR() { return CALL_ADDR(0x0, 0x693C20); }
void Scr_Init(scriptInstance_t inst, void* call_addr = Scr_Init_ADDR());
inline void* Scr_Shutdown_ADDR() { return CALL_ADDR(0x0, 0x693C90); }
void Scr_Shutdown(scriptInstance_t inst, void* call_addr = Scr_Shutdown_ADDR());
inline void* Scr_ErrorInternal_ADDR() { return CALL_ADDR(0x0, 0x693CF0); }
void Scr_ErrorInternal(scriptInstance_t inst, void* call_addr = Scr_ErrorInternal_ADDR());
inline void* Scr_ClearOutParams_ADDR() { return CALL_ADDR(0x0, 0x693DA0); }
void Scr_ClearOutParams(scriptInstance_t inst, void* call_addr = Scr_ClearOutParams_ADDR());
inline void* GetDummyObject_ADDR() { return CALL_ADDR(0x0, 0x693DE0); }
unsigned int GetDummyObject(scriptInstance_t inst, void* call_addr = GetDummyObject_ADDR());
inline void* GetDummyFieldValue_ADDR() { return CALL_ADDR(0x0, 0x693E30); }
unsigned int GetDummyFieldValue(scriptInstance_t inst, void* call_addr = GetDummyFieldValue_ADDR());
inline void* VM_CancelNotifyInternal_ADDR() { return CALL_ADDR(0x0, 0x6978C0); }
void VM_CancelNotifyInternal(scriptInstance_t inst, unsigned int notifyListOwnerId, unsigned int startLocalId, unsigned int notifyListId, unsigned int notifyNameListId, unsigned int stringValue, void* call_addr = VM_CancelNotifyInternal_ADDR());
inline void* VM_CancelNotify_ADDR() { return CALL_ADDR(0x0, 0x697950); }
void VM_CancelNotify(scriptInstance_t inst, unsigned int a2, unsigned int a3, void* call_addr = VM_CancelNotify_ADDR());
inline void* VM_ArchiveStack_ADDR() { return CALL_ADDR(0x0, 0x697A00); }
VariableStackBuffer * VM_ArchiveStack(scriptInstance_t inst, void* call_addr = VM_ArchiveStack_ADDR());
inline void* Scr_AddLocalVars_ADDR() { return CALL_ADDR(0x0, 0x697B60); }
int Scr_AddLocalVars(scriptInstance_t inst, unsigned int a2, void* call_addr = Scr_AddLocalVars_ADDR());
inline void* VM_TerminateStack_ADDR() { return CALL_ADDR(0x0, 0x697D80); }
void VM_TerminateStack(scriptInstance_t inst, unsigned int endLocalId, unsigned int startLocalId, VariableStackBuffer* name, void* call_addr = VM_TerminateStack_ADDR());
inline void* VM_TrimStack_ADDR() { return CALL_ADDR(0x0, 0x697F20); }
void VM_TrimStack(scriptInstance_t inst, unsigned int parentId, VariableStackBuffer * a3, int fromEndon, void* call_addr = VM_TrimStack_ADDR());
inline void* Scr_TerminateRunningThread_ADDR() { return CALL_ADDR(0x0, 0x698150); }
void Scr_TerminateRunningThread(scriptInstance_t inst, unsigned int a2, void* call_addr = Scr_TerminateRunningThread_ADDR());
inline void* Scr_TerminateWaitThread_ADDR() { return CALL_ADDR(0x0, 0x698200); }
void Scr_TerminateWaitThread(scriptInstance_t inst, unsigned int a2, unsigned int a3, void* call_addr = Scr_TerminateWaitThread_ADDR());
inline void* Scr_CancelWaittill_ADDR() { return CALL_ADDR(0x0, 0x698310); }
void Scr_CancelWaittill(scriptInstance_t inst, unsigned int startLocalId, void* call_addr = Scr_CancelWaittill_ADDR());
inline void* Scr_TerminateWaittillThread_ADDR() { return CALL_ADDR(0x0, 0x698400); }
void Scr_TerminateWaittillThread(scriptInstance_t inst, unsigned int a2, unsigned int a3, void* call_addr = Scr_TerminateWaittillThread_ADDR());
inline void* Scr_TerminateThread_ADDR() { return CALL_ADDR(0x0, 0x698610); }
void Scr_TerminateThread(unsigned int a2, scriptInstance_t inst, void* call_addr = Scr_TerminateThread_ADDR());
inline void* VM_Notify_ADDR() { return CALL_ADDR(0x0, 0x698670); }
void VM_Notify(scriptInstance_t inst, int notifyListOwnerId, unsigned int stringValue, VariableValue * top, void* call_addr = VM_Notify_ADDR());
inline void* Scr_NotifyNum_Internal_ADDR() { return CALL_ADDR(0x0, 0x698CC0); }
void Scr_NotifyNum_Internal(scriptInstance_t inst, int entNum, int entClass, unsigned int notifStr, int numParams, void* call_addr = Scr_NotifyNum_Internal_ADDR());
inline void* Scr_CancelNotifyList_ADDR() { return CALL_ADDR(0x0, 0x698DE0); }
void Scr_CancelNotifyList(unsigned int notifyListOwnerId, scriptInstance_t inst, void* call_addr = Scr_CancelNotifyList_ADDR());
inline void* VM_TerminateTime_ADDR() { return CALL_ADDR(0x0, 0x698FE0); }
void VM_TerminateTime(scriptInstance_t inst, unsigned int parentId, void* call_addr = VM_TerminateTime_ADDR());
inline void* VM_Resume_ADDR() { return CALL_ADDR(0x0, 0x6990E0); }
void VM_Resume(scriptInstance_t inst, unsigned int timeId, void* call_addr = VM_Resume_ADDR());
inline void* Scr_ExecThread_ADDR() { return CALL_ADDR(0x0, 0x699560); }
unsigned short Scr_ExecThread(scriptInstance_t inst, unsigned int handle, unsigned int paramCount, void* call_addr = Scr_ExecThread_ADDR());
inline void* Scr_ExecEntThread_ADDR() { return CALL_ADDR(0x0, 0x699640); }
unsigned short Scr_ExecEntThreadNum(scriptInstance_t inst, int entNum, unsigned int handle, int numParams, unsigned int clientNum, void* call_addr = Scr_ExecEntThread_ADDR());
inline void* Scr_AddExecThread_ADDR() { return CALL_ADDR(0x0, 0x699730); }
void Scr_AddExecThread(scriptInstance_t inst, unsigned int handle, void* call_addr = Scr_AddExecThread_ADDR());
inline void* VM_SetTime_ADDR() { return CALL_ADDR(0x0, 0x6997E0); }
void VM_SetTime(scriptInstance_t inst, void* call_addr = VM_SetTime_ADDR());
inline void* Scr_InitSystem_ADDR() { return CALL_ADDR(0x0, 0x699860); }
void Scr_InitSystem(scriptInstance_t inst, void* call_addr = Scr_InitSystem_ADDR());
inline void* Scr_GetInt_ADDR() { return CALL_ADDR(0x0, 0x699C50); }
int Scr_GetInt(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetInt_ADDR());
inline void* Scr_GetAnim_ADDR() { return CALL_ADDR(0x0, 0x699CE0); }
scr_anim_s Scr_GetAnim(unsigned int index, XAnimTree_s * anims, void* call_addr = Scr_GetAnim_ADDR());
inline void* Scr_GetFloat_ADDR() { return CALL_ADDR(0x0, 0x699E90); }
float Scr_GetFloat(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetFloat_ADDR());
inline void* Scr_GetConstString_ADDR() { return CALL_ADDR(0x0, 0x699F30); }
unsigned int Scr_GetConstString(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetConstString_ADDR());
inline void* Scr_GetConstLowercaseString_ADDR() { return CALL_ADDR(0x0, 0x699FB0); }
unsigned int Scr_GetConstLowercaseString(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetConstLowercaseString_ADDR());
inline void* Scr_GetString_ADDR() { return CALL_ADDR(0x0, 0x69A0D0); }
const char * Scr_GetString(unsigned int index, scriptInstance_t inst, void* call_addr = Scr_GetString_ADDR());
inline void* Scr_GetConstStringIncludeNull_ADDR() { return CALL_ADDR(0x0, 0x69A100); }
unsigned int Scr_GetConstStringIncludeNull(scriptInstance_t inst, void* call_addr = Scr_GetConstStringIncludeNull_ADDR());
inline void* Scr_GetDebugString_ADDR() { return CALL_ADDR(0x0, 0x69A130); }
char * Scr_GetDebugString(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetDebugString_ADDR());
inline void* Scr_GetConstIString_ADDR() { return CALL_ADDR(0x0, 0x69A1A0); }
unsigned int Scr_GetConstIString(unsigned int index, void* call_addr = Scr_GetConstIString_ADDR());
inline void* Scr_GetVector_ADDR() { return CALL_ADDR(0x0, 0x69A220); }
void Scr_GetVector(scriptInstance_t inst, float * value, unsigned int index, void* call_addr = Scr_GetVector_ADDR());
inline void* Scr_GetEntityRef_ADDR() { return CALL_ADDR(0x0, 0x69A330); }
scr_entref_t * Scr_GetEntityRef(scriptInstance_t inst, scr_entref_t * retstr, unsigned int index, void* call_addr = Scr_GetEntityRef_ADDR());
inline void* Scr_GetObject_ADDR() { return CALL_ADDR(0x0, 0x69A460); }
VariableUnion Scr_GetObject(scriptInstance_t inst, void* call_addr = Scr_GetObject_ADDR());
inline void* Scr_GetType_ADDR() { return CALL_ADDR(0x0, 0x69A4E0); }
VariableType Scr_GetType(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetType_ADDR());
inline void* Scr_GetTypeName_ADDR() { return CALL_ADDR(0x0, 0x69A530); }
char * Scr_GetTypeName(scriptInstance_t inst, void* call_addr = Scr_GetTypeName_ADDR());
inline void* Scr_GetPointerType_ADDR() { return CALL_ADDR(0x0, 0x69A580); }
VariableType Scr_GetPointerType(scriptInstance_t inst, unsigned int a2, void* call_addr = Scr_GetPointerType_ADDR());
inline void* Scr_AddInt_ADDR() { return CALL_ADDR(0x0, 0x69A610); }
void Scr_AddInt(scriptInstance_t inst, int value, void* call_addr = Scr_AddInt_ADDR());
inline void* Scr_AddFloat_ADDR() { return CALL_ADDR(0x0, 0x69A670); }
void Scr_AddFloat(scriptInstance_t inst, float value, void* call_addr = Scr_AddFloat_ADDR());
inline void* Scr_AddUndefined_ADDR() { return CALL_ADDR(0x0, 0x69A720); }
void Scr_AddUndefined(scriptInstance_t inst, void* call_addr = Scr_AddUndefined_ADDR());
inline void* Scr_AddObject_ADDR() { return CALL_ADDR(0x0, 0x69A770); }
void Scr_AddObject(scriptInstance_t inst, unsigned int entid, void* call_addr = Scr_AddObject_ADDR());
inline void* Scr_AddString_ADDR() { return CALL_ADDR(0x0, 0x69A7E0); }
void Scr_AddString(scriptInstance_t inst, const char * string, void* call_addr = Scr_AddString_ADDR());
inline void* Scr_AddIString_ADDR() { return CALL_ADDR(0x0, 0x69A860); }
void Scr_AddIString(char * string, void* call_addr = Scr_AddIString_ADDR());
inline void* Scr_AddConstString_ADDR() { return CALL_ADDR(0x0, 0x69A8D0); }
void Scr_AddConstString(scriptInstance_t inst, unsigned int id, void* call_addr = Scr_AddConstString_ADDR());
inline void* Scr_AddVector_ADDR() { return CALL_ADDR(0x0, 0x69A940); }
void Scr_AddVector(scriptInstance_t inst, float * value, void* call_addr = Scr_AddVector_ADDR());
inline void* Scr_MakeArray_ADDR() { return CALL_ADDR(0x0, 0x69A9D0); }
void Scr_MakeArray(scriptInstance_t inst, void* call_addr = Scr_MakeArray_ADDR());
inline void* Scr_AddArrayStringIndexed_ADDR() { return CALL_ADDR(0x0, 0x69AAF0); }
void Scr_AddArrayStringIndexed(unsigned int id, scriptInstance_t inst, void* call_addr = Scr_AddArrayStringIndexed_ADDR());
inline void* Scr_Error_ADDR() { return CALL_ADDR(0x0, 0x69AB70); }
void Scr_Error(const char * err, scriptInstance_t inst, int is_terminal, void* call_addr = Scr_Error_ADDR());
inline void* Scr_TerminalError_ADDR() { return CALL_ADDR(0x0, 0x69ABD0); }
void Scr_TerminalError(scriptInstance_t inst, const char * Source, void* call_addr = Scr_TerminalError_ADDR());
inline void* Scr_ParamError_ADDR() { return CALL_ADDR(0x0, 0x69AC00); }
void Scr_ParamError(int a1, scriptInstance_t a2, const char * Source, void* call_addr = Scr_ParamError_ADDR());
inline void* Scr_ObjectError_ADDR() { return CALL_ADDR(0x0, 0x69AC30); }
void Scr_ObjectError(scriptInstance_t inst, const char * a2, void* call_addr = Scr_ObjectError_ADDR());
inline void* SetEntityFieldValue_ADDR() { return CALL_ADDR(0x0, 0x69AC50); }
bool SetEntityFieldValue(scriptInstance_t inst, int offset, int entnum, classNum_e classnum, int clientNum, VariableValue * value, void* call_addr = SetEntityFieldValue_ADDR());
inline void* GetEntityFieldValue_ADDR() { return CALL_ADDR(0x0, 0x69ACE0); }
VariableValue GetEntityFieldValue(int offset, int entnum, scriptInstance_t inst, int classnum, int clientNum, void* call_addr = GetEntityFieldValue_ADDR());
inline void* Scr_SetStructField_ADDR() { return CALL_ADDR(0x0, 0x69AD50); }
void Scr_SetStructField(unsigned int a1, unsigned int a2, scriptInstance_t inst, void* call_addr = Scr_SetStructField_ADDR());
inline void* Scr_IncTime_ADDR() { return CALL_ADDR(0x0, 0x69ADE0); }
void Scr_IncTime(scriptInstance_t inst, void* call_addr = Scr_IncTime_ADDR());
inline void* Scr_RunCurrentThreads_ADDR() { return CALL_ADDR(0x0, 0x69AE30); }
void Scr_RunCurrentThreads(scriptInstance_t inst, void* call_addr = Scr_RunCurrentThreads_ADDR());
inline void* Scr_ResetTimeout_ADDR() { return CALL_ADDR(0x0, 0x69AE60); }
void Scr_ResetTimeout(scriptInstance_t inst, void* call_addr = Scr_ResetTimeout_ADDR());
void SetVariableFieldValue(scriptInstance_t inst, unsigned int id, VariableValue* value);
void SetNewVariableValue(scriptInstance_t inst, unsigned int id, VariableValue* value);
void Scr_ClearErrorMessage(scriptInstance_t inst);
void VM_Shutdown(scriptInstance_t inst);
void Scr_ShutdownVariables(scriptInstance_t inst);
void ClearVariableValue(scriptInstance_t inst, unsigned int id);
unsigned int Scr_GetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId);
void Scr_RemoveThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId);
unsigned int GetArraySize(scriptInstance_t inst, unsigned int id);
void IncInParam(scriptInstance_t inst);
unsigned int GetParentLocalId(scriptInstance_t inst, unsigned int threadId);
void Scr_ClearWaitTime(scriptInstance_t inst, unsigned int startLocalId);
void Scr_SetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId, unsigned int waitTime);
void Scr_SetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId, unsigned int stringValue);
void Scr_DebugTerminateThread(scriptInstance_t inst, int topThread);
unsigned int Scr_GetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId);
const char* Scr_GetStackThreadPos(scriptInstance_t inst, unsigned int endLocalId, VariableStackBuffer* stackValue, bool killThread);
unsigned int Scr_GetSelf(scriptInstance_t inst, unsigned int threadId);
unsigned int GetVariableKeyObject(scriptInstance_t inst, unsigned int id);
int MT_Realloc(scriptInstance_t inst, int oldNumBytes, int newNumbytes);
void CScr_GetObjectField(classNum_e classnum, int entnum, int clientNum, int offset);
int CScr_SetObjectField(classNum_e classnum, int entnum, int clientNum, int offset);
void Scr_SetErrorMessage(scriptInstance_t inst, const char* error);
bool Scr_IsStackClear(scriptInstance_t inst);
void SL_CheckExists(scriptInstance_t inst, unsigned int stringValue);
const char* Scr_ReadCodePos(scriptInstance_t inst, const char** pos);
unsigned int Scr_ReadUnsignedInt(scriptInstance_t inst, const char** pos);
unsigned short Scr_ReadUnsignedShort(scriptInstance_t inst, const char** pos);
unsigned char Scr_ReadUnsignedByte(scriptInstance_t inst, const char** pos);
float Scr_ReadFloat(scriptInstance_t inst, const char** pos);
const float* Scr_ReadVector(scriptInstance_t inst, const char** pos);
BOOL IsFieldObject(scriptInstance_t inst, unsigned int id);
void RemoveVariableValue(scriptInstance_t inst, unsigned int parentId, unsigned int index);
VariableStackBuffer* GetRefVariableStackBuffer(scriptInstance_t inst, int id);
unsigned int GetNewObjectVariableReverse(scriptInstance_t inst, unsigned int parentId, unsigned int id);
unsigned int GetNewVariableIndexReverseInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
unsigned int Scr_GetLocalVar(scriptInstance_t inst, int pos);
void Scr_EvalBoolNot(scriptInstance_t inst, VariableValue* value);
unsigned int GetInternalVariableIndex(scriptInstance_t inst, unsigned int unsignedValue);
const char* Scr_ReadData(scriptInstance_t inst, const char** pos, unsigned int count);
}

1006
src/game/clientscript/cscr_vm_w.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

34
src/game/structs.hpp
View File

@ -7008,31 +7008,6 @@ namespace game
ASSERT_STRUCT_OFFSET(entityHandler_t, methodOfDeath, 0x24); ASSERT_STRUCT_OFFSET(entityHandler_t, methodOfDeath, 0x24);
ASSERT_STRUCT_OFFSET(entityHandler_t, splashMethodOfDeath, 0x28); ASSERT_STRUCT_OFFSET(entityHandler_t, splashMethodOfDeath, 0x28);
struct yy_buffer_state
{
_iobuf * yy_input_file; //OFS: 0x0 SIZE: 0x4
char * yy_ch_buf; //OFS: 0x4 SIZE: 0x4
char * yy_buf_pos; //OFS: 0x8 SIZE: 0x4
unsigned int yy_buf_size; //OFS: 0xC SIZE: 0x4
int yy_n_chars; //OFS: 0x10 SIZE: 0x4
int yy_is_our_buffer; //OFS: 0x14 SIZE: 0x4
int yy_is_interactive; //OFS: 0x18 SIZE: 0x4
int yy_at_bol; //OFS: 0x1C SIZE: 0x4
int yy_fill_buffer; //OFS: 0x20 SIZE: 0x4
int yy_buffer_status; //OFS: 0x24 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(yy_buffer_state, 0x28);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_input_file, 0x0);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_ch_buf, 0x4);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_pos, 0x8);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_size, 0xC);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_n_chars, 0x10);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_our_buffer, 0x14);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_interactive, 0x18);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_at_bol, 0x1C);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_fill_buffer, 0x20);
ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buffer_status, 0x24);
struct CmdArgsPrivate struct CmdArgsPrivate
{ {
char textPool[8192]; //OFS: 0x0 SIZE: 0x2000 char textPool[8192]; //OFS: 0x0 SIZE: 0x2000
@ -11255,15 +11230,6 @@ namespace game
ASSERT_STRUCT_OFFSET(struct_0, var_34, 0x14); ASSERT_STRUCT_OFFSET(struct_0, var_34, 0x14);
ASSERT_STRUCT_OFFSET(struct_0, var_30, 0x18); ASSERT_STRUCT_OFFSET(struct_0, var_30, 0x18);
struct stype_t
{
sval_u val; //OFS: 0x0 SIZE: 0x4
unsigned int pos; //OFS: 0x4 SIZE: 0x4
};
ASSERT_STRUCT_SIZE(stype_t, 0x8);
ASSERT_STRUCT_OFFSET(stype_t, val, 0x0);
ASSERT_STRUCT_OFFSET(stype_t, pos, 0x4);
struct DObjModel_s struct DObjModel_s
{ {
XModel * model; //OFS: 0x0 SIZE: 0x4 XModel * model; //OFS: 0x0 SIZE: 0x4

4
src/stdinc.hpp
View File

@ -9,7 +9,9 @@
#pragma warning(disable: 4324) #pragma warning(disable: 4324)
#pragma warning(disable: 4459) #pragma warning(disable: 4459)
#pragma warning(once: 26493) #pragma warning(error: 4409)
#pragma warning(disable: 4100) // remove when decomp is imported
#define DLL_EXPORT extern "C" __declspec(dllexport) #define DLL_EXPORT extern "C" __declspec(dllexport)
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN