Future/T4SP-Server-Plugin
1
0
Fork 0
mirror of https://github.com/JezuzLizard/T4SP-Server-Plugin.git synced 2025-07-04 18:21:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

The decomp is compiling!

Browse Source
This commit is contained in:
ineed bots
2023-08-31 18:56:00 -06:00
parent 00dcc0e424
commit 469e8f9630
41 changed files with 13313 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -20,11 +20,11 @@
#define VARIABLELIST_CHILD_BEGIN 0x6000
#define IsObject(__parentValue__) \
((__parentValue__->w.status & VAR_MASK) >= VAR_THREAD) \
((__parentValue__->w.status & VAR_MASK) >= game::VAR_THREAD) \
#define MT_NODE_BITS 16
#define MT_NODE_SIZE sizeof(MemoryNode)
#define MT_SIZE sizeof(scrMemTreeGlob_t::nodes)
#define MT_NODE_SIZE sizeof(game::MemoryNode)
#define MT_SIZE sizeof(game::scrMemTreeGlob_t::nodes)
#define MT_NODE_COUNT (1 << MT_NODE_BITS)
#define MT_NUM_BUCKETS 256
@ -36,6 +36,8 @@
#define SL_MAX_STRING_LEN 0x2000
#define SL_MAX_STRING_INDEX 0x10000
#define MAX_VM_STACK_DEPTH 30
#ifdef __cplusplus
namespace game
{
@ -51,6 +53,7 @@ namespace game
struct sentient_s;
struct gclient_s;
struct game_hudelem_s;
struct dvar_s;
#pragma region "enums"
@ -70,6 +73,13 @@ namespace game
SCRIPT_INSTANCE_MAX = 0x2,
};
enum animUserInstance_t
{
ANIM_USER_CLIENT = 0x0,
ANIM_USER_SERVER = 0x1,
ANIM_USER_COUNT = 0x2
};
enum OpcodeVM : __int32
{
OP_End = 0x0,
@ -335,6 +345,16 @@ namespace game
FIRST_OBJECT = 0x14,
};*/
enum ObjectTypes
{
FIRST_OBJECT = 0xD,
FIRST_CLEARABLE_OBJECT = 0x11,
LAST_NONENTITY_OBJECT = 0x11,
FIRST_ENTITY_OBJECT = 0x13,
FIRST_NONFIELD_OBJECT = 0x14,
FIRST_DEAD_OBJECT = 0x15,
};
enum VariableType
{
VAR_UNDEFINED = 0x0,
@ -2231,6 +2251,8 @@ namespace game
WEAK symbol<scr_classStruct_t*> gScrClassMap{ 0x0, 0x8CF568 };
WEAK symbol<scr_const_t> scr_const{ 0x0, 0x1F33B90 };
WEAK symbol<bool> loadedImpureScript{ 0x0, 0x22C1352 };
WEAK symbol<dvar_s*> sv_clientside{ 0x0, 0x3882B6C };
WEAK symbol<char> error_message_buff{ 0x0, 0x3BE1E30 };
WEAK symbol<unsigned char> g_parse_user{ 0x0, 0x234F72E };
WEAK symbol<scriptInstance_t> gInst{ 0x0, 0x3BE624C };
@ -2272,7 +2294,7 @@ namespace game
#pragma endregion
#pragma region "functions"
WEAK symbol<BOOL(LPVOID lpAddress)>Hunk_UserDestroy{ 0x0, 0x5E4940 };
WEAK symbol<void(scriptInstance_t inst, VariableValue* value)>RemoveRefToValue{ 0x0, 0x67EB70 };
inline void* ScriptParse_ADDR() { return CALL_ADDR(0x0, 0x69D710); }
void ScriptParse(scriptInstance_t inst, sval_u* parseData, void* call_addr = ScriptParse_ADDR());
@ -2280,8 +2302,15 @@ namespace game
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());
inline void* CScr_SetEntityField_ADDR() { return CALL_ADDR(0x0, 0x671470); }
int CScr_SetEntityField(int ofs, int entnum, unsigned int clientnum, void* call_addr = CScr_SetEntityField_ADDR());
inline void* Scr_SetObjectField_ADDR() { return CALL_ADDR(0x0, 0x5469C0); }
int Scr_SetObjectField(int ofs, int entnum, classNum_e classnum, scriptInstance_t inst, void* call_addr = Scr_SetObjectField_ADDR());
inline void* CScr_GetEntityField_ADDR() { return CALL_ADDR(0x0, 0x671410); }
void CScr_GetEntityField(int ofs, int entnum, unsigned int clientnum, void* call_addr = CScr_GetEntityField_ADDR());
inline void* Scr_GetObjectField_ADDR() { return CALL_ADDR(0x0, 0x546D30); }
void Scr_GetObjectField(int ofs, int inst, classNum_e classnum, int entnum, void* call_addr = Scr_GetObjectField_ADDR());
#pragma endregion
}

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

@ -46,24 +46,63 @@ namespace game
}
}
// 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)
int CScr_SetEntityField/*@<eax>*/(int ofs/*@<edx>*/, int entnum/*@<ecx>*/, unsigned int clientnum, void* call_addr)
{
HunkUser* answer;
int answer;
__asm
{
push typ;
push debugMem;
push tempMem;
push fixed;
push name;
mov edi, maxSize;
push clientnum;
mov edx, ofs;
mov ecx, entnum;
call call_addr;
add esp, 0x14;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
int Scr_SetObjectField/*@<eax>*/(int ofs/*@<eax>*/, int entnum/*@<edx>*/, classNum_e classnum, scriptInstance_t inst, void* call_addr)
{
int answer;
__asm
{
push inst;
push classnum;
mov eax, ofs;
mov edx, entnum;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
void CScr_GetEntityField(int ofs/*@<edx>*/, int entnum/*@<ecx>*/, unsigned int clientnum, void* call_addr)
{
__asm
{
push clientnum;
mov edx, ofs;
mov ecx, entnum;
call call_addr;
add esp, 0x4;
}
}
void Scr_GetObjectField(int ofs/*@<eax>*/, int inst/*@<edx>*/, classNum_e classnum, int entnum, void* call_addr)
{
__asm
{
push entnum;
push classnum;
mov eax, ofs;
mov edx, inst;
call call_addr;
add esp, 0x8;
}
}
}

1
src/game/clientscript/cscr_memorytree.hpp
View File

@ -27,5 +27,4 @@ namespace game
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);
}

10
src/game/clientscript/cscr_memorytree_w.cpp
View File

@ -1,4 +1,5 @@
#include <stdinc.hpp>
#include "codsrc/clientscript/cscr_memorytree.hpp"
namespace game
{
@ -116,13 +117,6 @@ namespace game
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;
return codsrc::GetRefVector(inst, id);
}
}

6
src/game/clientscript/cscr_parser_w.cpp
View File

@ -1,4 +1,5 @@
#include <stdinc.hpp>
#include "codsrc/clientscript/cscr_parser.hpp"
namespace game
{
@ -305,12 +306,11 @@ namespace game
unsigned int Scr_GetPrevSourcePos(scriptInstance_t inst, const char* codePos, unsigned int index)
{
//return cscr_parser::Scr_GetPrevSourcePos(inst, codePos, index);
return 0;
return codsrc::Scr_GetPrevSourcePos(inst, codePos, index);
}
void Scr_ShutdownAllocNode(scriptInstance_t inst)
{
//cscr_parser::Scr_ShutdownAllocNode(inst);
codsrc::Scr_ShutdownAllocNode(inst);
}
}

4
src/game/clientscript/cscr_parsetree_w.cpp
View File

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

4
src/game/clientscript/cscr_readwrite_w.cpp
View File

@ -1,4 +1,5 @@
#include <stdinc.hpp>
#include "codsrc/clientscript/cscr_readwrite.hpp"
namespace game
{
@ -38,7 +39,6 @@ namespace game
unsigned int FindVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
{
//return cscr_readwrite::FindVariableIndexInternal(inst, parentId, name);
return 0;
return codsrc::FindVariableIndexInternal(inst, parentId, name);
}
}

1
src/game/clientscript/cscr_stringlist.hpp
View File

@ -61,5 +61,4 @@ namespace game
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);
}

28
src/game/clientscript/cscr_stringlist_w.cpp
View File

@ -1,4 +1,5 @@
#include <stdinc.hpp>
#include "codsrc/clientscript/cscr_stringlist.hpp"
namespace game
{
@ -324,52 +325,41 @@ namespace game
RefString* GetRefString(scriptInstance_t inst, unsigned int id)
{
//return cscr_stringlist::GetRefString(inst, id);
return nullptr;
return codsrc::GetRefString(inst, id);
}
void SL_AddRefToString(scriptInstance_t inst, unsigned int stringValue)
{
//cscr_stringlist::SL_AddRefToString(inst, stringValue);
codsrc::SL_AddRefToString(inst, stringValue);
}
void SL_RemoveRefToStringOfSize(scriptInstance_t inst, unsigned int stringValue, unsigned int len)
{
//cscr_stringlist::SL_RemoveRefToStringOfSize(inst, stringValue, len);
codsrc::SL_RemoveRefToStringOfSize(inst, stringValue, len);
}
int SL_GetRefStringLen(RefString* refString)
{
//return cscr_stringlist::SL_GetRefStringLen(refString);
return 0;
return codsrc::SL_GetRefStringLen(refString);
}
void SL_AddUser(unsigned int stringValue, unsigned int user, scriptInstance_t inst)
{
//cscr_stringlist::SL_AddUser(stringValue, user, inst);
codsrc::SL_AddUser(stringValue, user, inst);
}
int SL_ConvertFromString(scriptInstance_t inst, const char* str)
{
//return cscr_stringlist::SL_ConvertFromString(inst, str);
return 0;
return codsrc::SL_ConvertFromString(inst, str);
}
int SL_ConvertFromRefString(scriptInstance_t inst, RefString* refString)
{
//return cscr_stringlist::SL_ConvertFromRefString(inst, refString);
return 0;
return codsrc::SL_ConvertFromRefString(inst, refString);
}
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;
return codsrc::GetRefString_0(inst, str);
}
}

8
src/game/clientscript/cscr_tempmemory_w.cpp
View File

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

84
src/game/clientscript/cscr_variable_w.cpp
View File

@ -1,4 +1,5 @@
#include <stdinc.hpp>
#include "codsrc/clientscript/cscr_variable.hpp"
namespace game
{
@ -1286,174 +1287,151 @@ namespace game
unsigned int FindObject(scriptInstance_t inst, unsigned int id)
{
//return cscr_variable::FindObject(inst, id);
return 0;
return codsrc::FindObject(inst, id);
}
float Scr_GetEntryUsageInternal(scriptInstance_t inst, unsigned int type, VariableUnion u)
{
//return cscr_variable::Scr_GetEntryUsageInternal(inst, type, u);
return 0;
return codsrc::Scr_GetEntryUsageInternal(inst, type, u);
}
float Scr_GetEntryUsage(scriptInstance_t inst, VariableValueInternal* entryValue)
{
//return cscr_variable::Scr_GetEntryUsage(inst, entryValue);
return 0;
return codsrc::Scr_GetEntryUsage(inst, entryValue);
}
unsigned int FindFirstSibling(scriptInstance_t inst, unsigned int id)
{
//return cscr_variable::FindFirstSibling(inst, id);
return 0;
return codsrc::FindFirstSibling(inst, id);
}
unsigned int FindNextSibling(scriptInstance_t inst, unsigned int id)
{
//return cscr_variable::FindNextSibling(inst, id);
return 0;
return codsrc::FindNextSibling(inst, id);
}
VariableValue Scr_GetArrayIndexValue(scriptInstance_t inst, unsigned int name)
{
//return cscr_variable::Scr_GetArrayIndexValue(inst, name);
VariableValue l;
l.type = VAR_UNDEFINED;
return l;
return codsrc::Scr_GetArrayIndexValue(inst, name);
}
void AddRefToObject(scriptInstance_t inst, unsigned int id)
{
//cscr_variable::AddRefToObject(inst, id);
codsrc::AddRefToObject(inst, id);
}
void RemoveRefToEmptyObject(scriptInstance_t inst, unsigned int id)
{
//cscr_variable::RemoveRefToEmptyObject(inst, id);
codsrc::RemoveRefToEmptyObject(inst, id);
}
void Scr_ClearThread(scriptInstance_t inst, unsigned int parentId)
{
//cscr_variable::Scr_ClearThread(inst, parentId);
codsrc::Scr_ClearThread(inst, parentId);
}
unsigned int FindObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id)
{
//return cscr_variable::FindObjectVariable(inst, parentId, id);
return 0;
return codsrc::FindObjectVariable(inst, parentId, id);
}
void RemoveObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id)
{
//cscr_variable::RemoveObjectVariable(inst, parentId, id);
codsrc::RemoveObjectVariable(inst, parentId, id);
}
VariableValueInternal_u* GetVariableValueAddress(scriptInstance_t inst, unsigned int id)
{
//return cscr_variable::GetVariableValueAddress(inst, id);
return nullptr;
return codsrc::GetVariableValueAddress(inst, id);
}
void Scr_KillEndonThread(scriptInstance_t inst, unsigned int threadId)
{
//cscr_variable::Scr_KillEndonThread(inst, threadId);
codsrc::Scr_KillEndonThread(inst, threadId);
}
BOOL IsValidArrayIndex(scriptInstance_t inst, unsigned int unsignedValue)
{
//return cscr_variable::IsValidArrayIndex(inst, unsignedValue);
return 0;
return codsrc::IsValidArrayIndex(inst, unsignedValue);
}
void RemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
{
//cscr_variable::RemoveArrayVariable(inst, parentId, unsignedValue);
codsrc::RemoveArrayVariable(inst, parentId, unsignedValue);
}
void SafeRemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
{
//cscr_variable::SafeRemoveArrayVariable(inst, parentId, unsignedValue);
codsrc::SafeRemoveArrayVariable(inst, parentId, unsignedValue);
}
void AddRefToVector(scriptInstance_t inst, const float* floatVal)
{
//cscr_variable::AddRefToVector(inst, floatVal);
codsrc::AddRefToVector(inst, floatVal);
}
unsigned int FindArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
{
//return cscr_variable::FindArrayVariableIndex(inst, parentId, unsignedValue);
return 0;
return codsrc::FindArrayVariableIndex(inst, parentId, unsignedValue);
}
unsigned int GetVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
{
//return cscr_variable::GetVariableIndexInternal(inst, parentId, name);
return 0;
return codsrc::GetVariableIndexInternal(inst, parentId, name);
}
unsigned int GetNewVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
{
//return cscr_variable::GetNewVariableIndexInternal(inst, parentId, name);
return 0;
return codsrc::GetNewVariableIndexInternal(inst, parentId, name);
}
unsigned int AllocObject(scriptInstance_t inst)
{
//return cscr_variable::AllocObject(inst);
return 0;
return codsrc::AllocObject(inst);
}
VariableType GetValueType(scriptInstance_t inst, unsigned int id)
{
//return cscr_variable::GetValueType(inst, id);
return (VariableType)0;
return codsrc::GetValueType(inst, id);
}
VariableType GetObjectType(scriptInstance_t inst, unsigned int id)
{
//return cscr_variable::GetObjectType(inst, id);
return (VariableType)0;
return codsrc::GetObjectType(inst, id);
}
float* Scr_AllocVector_(scriptInstance_t inst, const float* v)
{
//return cscr_variable::Scr_AllocVector_(inst, v);
return 0;
return codsrc::Scr_AllocVector_(inst, v);
}
void Scr_EvalInequality(scriptInstance_t inst, VariableValue* value1, VariableValue* value2)
{
//cscr_variable::Scr_EvalInequality(inst, value1, value2);
codsrc::Scr_EvalInequality(inst, value1, value2);
}
unsigned int Scr_EvalArrayRefInternal(scriptInstance_t inst, VariableValue* varValue, VariableValueInternal* parentValue)
{
//return cscr_variable::Scr_EvalArrayRefInternal(inst, varValue, parentValue);
return 0;
return codsrc::Scr_EvalArrayRefInternal(inst, varValue, parentValue);
}
unsigned int GetNewArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
{
//return cscr_variable::GetNewArrayVariableIndex(inst, parentId, unsignedValue);
return 0;
return codsrc::GetNewArrayVariableIndex(inst, parentId, unsignedValue);
}
unsigned int GetNewArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
{
//return cscr_variable::GetNewArrayVariable(inst, parentId, unsignedValue);
return 0;
return codsrc::GetNewArrayVariable(inst, parentId, unsignedValue);
}
unsigned int GetArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
{
//return cscr_variable::GetArrayVariable(inst, parentId, unsignedValue);
return 0;
return codsrc::GetArrayVariable(inst, parentId, unsignedValue);
}
unsigned int AllocThread(scriptInstance_t inst, unsigned int self)
{
//return cscr_variable::AllocThread(inst, self);
return 0;
return codsrc::AllocThread(inst, self);
}
}

104
src/game/clientscript/cscr_vm_w.cpp
View File

@ -1,4 +1,5 @@
#include <stdinc.hpp>
#include "codsrc/clientscript/cscr_vm.hpp"
namespace game
{
@ -783,224 +784,201 @@ namespace game
void SetVariableFieldValue(scriptInstance_t inst, unsigned int id, VariableValue* value)
{
//cscr_vm::SetVariableFieldValue(inst, id, value);
codsrc::SetVariableFieldValue(inst, id, value);
}
void SetNewVariableValue(scriptInstance_t inst, unsigned int id, VariableValue* value)
{
//cscr_vm::SetNewVariableValue(inst, id, value);
codsrc::SetNewVariableValue(inst, id, value);
}
void Scr_ClearErrorMessage(scriptInstance_t inst)
{
//cscr_vm::Scr_ClearErrorMessage(inst);
codsrc::Scr_ClearErrorMessage(inst);
}
void VM_Shutdown(scriptInstance_t inst)
{
//cscr_vm::VM_Shutdown(inst);
codsrc::VM_Shutdown(inst);
}
void Scr_ShutdownVariables(scriptInstance_t inst)
{
//cscr_vm::Scr_ShutdownVariables(inst);
codsrc::Scr_ShutdownVariables(inst);
}
void ClearVariableValue(scriptInstance_t inst, unsigned int id)
{
//cscr_vm::ClearVariableValue(inst, id);
codsrc::ClearVariableValue(inst, id);
}
unsigned int Scr_GetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId)
{
//return cscr_vm::Scr_GetThreadNotifyName(inst, startLocalId);
return 0;
return codsrc::Scr_GetThreadNotifyName(inst, startLocalId);
}
void Scr_RemoveThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId)
{
//cscr_vm::Scr_RemoveThreadNotifyName(inst, startLocalId);
codsrc::Scr_RemoveThreadNotifyName(inst, startLocalId);
}
unsigned int GetArraySize(scriptInstance_t inst, unsigned int id)
{
//return cscr_vm::GetArraySize(inst, id);
return 0;
return codsrc::GetArraySize(inst, id);
}
void IncInParam(scriptInstance_t inst)
{
//cscr_vm::IncInParam(inst);
codsrc::IncInParam(inst);
}
unsigned int GetParentLocalId(scriptInstance_t inst, unsigned int threadId)
{
//return cscr_vm::GetParentLocalId(inst, threadId);
return 0;
return codsrc::GetParentLocalId(inst, threadId);
}
void Scr_ClearWaitTime(scriptInstance_t inst, unsigned int startLocalId)
{
//cscr_vm::Scr_ClearWaitTime(inst, startLocalId);
codsrc::Scr_ClearWaitTime(inst, startLocalId);
}
void Scr_SetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId, unsigned int waitTime)
{
//cscr_vm::Scr_SetThreadWaitTime(inst, startLocalId, waitTime);
codsrc::Scr_SetThreadWaitTime(inst, startLocalId, waitTime);
}
void Scr_SetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId, unsigned int stringValue)
{
//cscr_vm::Scr_SetThreadNotifyName(inst, startLocalId, stringValue);
codsrc::Scr_SetThreadNotifyName(inst, startLocalId, stringValue);
}
void Scr_DebugTerminateThread(scriptInstance_t inst, int topThread)
{
//cscr_vm::Scr_DebugTerminateThread(inst, topThread);
codsrc::Scr_DebugTerminateThread(inst, topThread);
}
unsigned int Scr_GetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId)
{
//return cscr_vm::Scr_GetThreadWaitTime(inst, startLocalId);
return 0;
return codsrc::Scr_GetThreadWaitTime(inst, startLocalId);
}
const char* Scr_GetStackThreadPos(scriptInstance_t inst, unsigned int endLocalId, VariableStackBuffer* stackValue, bool killThread)
{
//return cscr_vm::Scr_GetStackThreadPos(inst, endLocalId, stackValue, killThread);
return 0;
return codsrc::Scr_GetStackThreadPos(inst, endLocalId, stackValue, killThread);
}
unsigned int Scr_GetSelf(scriptInstance_t inst, unsigned int threadId)
{
//return cscr_vm::Scr_GetSelf(inst, threadId);
return 0;
return codsrc::Scr_GetSelf(inst, threadId);
}
unsigned int GetVariableKeyObject(scriptInstance_t inst, unsigned int id)
{
//return cscr_vm::GetVariableKeyObject(inst, id);
return 0;
return codsrc::GetVariableKeyObject(inst, id);
}
int MT_Realloc(scriptInstance_t inst, int oldNumBytes, int newNumbytes)
{
//return cscr_vm::MT_Realloc(inst, oldNumBytes, newNumbytes);
return 0;
return codsrc::MT_Realloc(inst, oldNumBytes, newNumbytes);
}
void CScr_GetObjectField(classNum_e classnum, int entnum, int clientNum, int offset)
{
//cscr_vm::CScr_GetObjectField(classnum, entnum, clientNum, offset);
codsrc::CScr_GetObjectField(classnum, entnum, clientNum, offset);
}
int CScr_SetObjectField(classNum_e classnum, int entnum, int clientNum, int offset)
{
//return cscr_vm::CScr_SetObjectField(classnum, entnum, clientNum, offset);
return 0;
return codsrc::CScr_SetObjectField(classnum, entnum, clientNum, offset);
}
void Scr_SetErrorMessage(scriptInstance_t inst, const char* error)
{
//cscr_vm::Scr_SetErrorMessage(inst, error);
codsrc::Scr_SetErrorMessage(inst, error);
}
bool Scr_IsStackClear(scriptInstance_t inst)
{
//return cscr_vm::Scr_IsStackClear(inst);
return 0;
return codsrc::Scr_IsStackClear(inst);
}
void SL_CheckExists(scriptInstance_t inst, unsigned int stringValue)
{
//cscr_vm::SL_CheckExists(inst, stringValue);
codsrc::SL_CheckExists(inst, stringValue);
}
const char* Scr_ReadCodePos(scriptInstance_t inst, const char** pos)
{
//return cscr_vm::Scr_ReadCodePos(inst, pos);
return 0;
return codsrc::Scr_ReadCodePos(inst, pos);
}
unsigned int Scr_ReadUnsignedInt(scriptInstance_t inst, const char** pos)
{
//return cscr_vm::Scr_ReadUnsignedInt(inst, pos);
return 0;
return codsrc::Scr_ReadUnsignedInt(inst, pos);
}
unsigned short Scr_ReadUnsignedShort(scriptInstance_t inst, const char** pos)
{
//return cscr_vm::Scr_ReadUnsignedShort(inst, pos);
return 0;
return codsrc::Scr_ReadUnsignedShort(inst, pos);
}
unsigned char Scr_ReadUnsignedByte(scriptInstance_t inst, const char** pos)
{
//return cscr_vm::Scr_ReadUnsignedByte(inst, pos);
return 0;
return codsrc::Scr_ReadUnsignedByte(inst, pos);
}
float Scr_ReadFloat(scriptInstance_t inst, const char** pos)
{
//return cscr_vm::Scr_ReadFloat(inst, pos);
return 0;
return codsrc::Scr_ReadFloat(inst, pos);
}
const float* Scr_ReadVector(scriptInstance_t inst, const char** pos)
{
//return cscr_vm::Scr_ReadVector(inst, pos);
return 0;
return codsrc::Scr_ReadVector(inst, pos);
}
BOOL IsFieldObject(scriptInstance_t inst, unsigned int id)
{
//return cscr_vm::IsFieldObject(inst, id);
return 0;
return codsrc::IsFieldObject(inst, id);
}
void RemoveVariableValue(scriptInstance_t inst, unsigned int parentId, unsigned int index)
{
//cscr_vm::RemoveVariableValue(inst, parentId, index);
codsrc::RemoveVariableValue(inst, parentId, index);
}
VariableStackBuffer* GetRefVariableStackBuffer(scriptInstance_t inst, int id)
{
//return cscr_vm::GetRefVariableStackBuffer(inst, id);
return 0;
return codsrc::GetRefVariableStackBuffer(inst, id);
}
unsigned int GetNewVariableIndexReverseInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
{
//return cscr_vm::GetNewVariableIndexReverseInternal(inst, parentId, name);
return 0;
return codsrc::GetNewVariableIndexReverseInternal(inst, parentId, name);
}
unsigned int GetNewObjectVariableReverse(scriptInstance_t inst, unsigned int parentId, unsigned int id)
{
//return cscr_vm::GetNewObjectVariableReverse(inst, parentId, id);
return 0;
return codsrc::GetNewObjectVariableReverse(inst, parentId, id);
}
unsigned int Scr_GetLocalVar(scriptInstance_t inst, int pos)
{
//return cscr_vm::Scr_GetLocalVar(inst, pos);
return 0;
return codsrc::Scr_GetLocalVar(inst, pos);
}
void Scr_EvalBoolNot(scriptInstance_t inst, VariableValue* value)
{
//cscr_vm::Scr_EvalBoolNot(inst, value);
codsrc::Scr_EvalBoolNot(inst, value);
}
unsigned int GetInternalVariableIndex(scriptInstance_t inst, unsigned int unsignedValue)
{
//return cscr_vm::GetInternalVariableIndex(inst, unsignedValue);
return 0;
return codsrc::GetInternalVariableIndex(inst, unsignedValue);
}
const char* Scr_ReadData(scriptInstance_t inst, const char** pos, unsigned int count)
{
//return cscr_vm::Scr_ReadData(inst, pos, count);
return 0;
return codsrc::Scr_ReadData(inst, pos, count);
}
}

177
src/game/game.cpp
View File

@ -23,6 +23,183 @@ namespace game
}
}
// 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;
}
// unsigned int __usercall Hunk_AllocateTempMemoryHigh@<eax>(int a1@<eax>)
unsigned int Hunk_AllocateTempMemoryHigh(int size_, void* call_addr)
{
unsigned int answer;
__asm
{
mov eax, size_;
call call_addr;
mov answer, eax;
}
return answer;
}
// void __usercall FS_FCloseFile(int h@<eax>)
void FS_FCloseFile(int h, void* call_addr)
{
__asm
{
mov eax, h;
call call_addr;
}
}
// void *__usercall Z_TryVirtualAlloc@<eax>(signed int a1@<edi>)
void* Z_TryVirtualAlloc(signed int size_, void* call_addr)
{
void* answer;
__asm
{
mov edi, size_;
call call_addr;
mov answer, eax;
}
return answer;
}
// int __usercall I_stricmp@<eax>(int a1@<eax>, CHAR *a2@<edx>, const char *a3)
int I_stricmp(int len, const char* s0, const char* s1, void* call_addr)
{
int answer;
__asm
{
push s1;
mov eax, len;
mov edx, s0;
call call_addr;
mov answer, eax;
add esp, 0x4;
}
return answer;
}
//parseInfo_t* __usercall Com_Parse@<eax>(const char** a1@<esi>)
parseInfo_t* Com_Parse(const char** buffer, void* call_addr)
{
parseInfo_t* answer;
__asm
{
mov esi, buffer;
call call_addr;
mov answer, eax;
}
return answer;
}
//int __usercall I_strncmp@<eax>(char *str1@<edx>, char *str2@<ecx>, int len)
int I_strncmp(const char* str1, const char* str2, int len, void* call_addr)
{
int answer;
__asm
{
push len;
mov ecx, str2;
mov edx, str1;
call call_addr;
mov answer, eax;
}
return answer;
}
// const char **__usercall FS_ListFilteredFiles@<eax>(searchpath_s *searchPath@<eax>, const char *path@<edx>, const char *extension, const char *filter, FsListBehavior_e behavior, int *numFiles)
const char** FS_ListFilteredFiles(searchpath_s* searchPath, const char* path, const char* extension, const char* filter, FsListBehavior_e behavior, int* numFiles, void* call_addr)
{
const char** answer;
__asm
{
push numFiles;
push behavior;
push filter;
push extension;
mov eax, searchPath;
mov edx, path;
call call_addr;
mov answer, eax;
add esp, 0x10;
}
return answer;
}
dvar_s * Dvar_RegisterBool/*@<eax>*/(unsigned __int8 val/*@<al>*/, const char * name/*@<edi>*/, int flags, const char * desc, void* call_addr)
{
dvar_s * answer;
__asm
{
push desc;
push flags;
mov al, val;
mov edi, name;
call call_addr;
mov answer, eax;
add esp, 0x8;
}
return answer;
}
const char * XAnimGetAnimDebugName/*@<eax>*/(unsigned int animIndex/*@<ecx>*/, XAnim_s * anims/*@<edx>*/, void* call_addr)
{
const char * answer;
__asm
{
mov ecx, animIndex;
mov edx, anims;
call call_addr;
mov answer, eax;
}
return answer;
}
// restored
void Sys_EnterCriticalSection(CriticalSection critSect)
{
EnterCriticalSection(&s_criticalSection[critSect]);
}
// restored
void Sys_LeaveCriticalSection(CriticalSection critSect)
{
LeaveCriticalSection(&s_criticalSection[critSect]);
}
namespace plutonium
{
}

62
src/game/symbols.hpp
View File

@ -4,9 +4,69 @@ namespace game
{
// Functions
WEAK symbol<void(con_channel_e channel, const char* fmt, ...)> Com_Printf{ 0x0, 0x59A2C0 };
WEAK symbol<void(con_channel_e a1, const char* Source, int a3)>Com_PrintMessage{ 0x0, 0x59A170 };
WEAK symbol<void(con_channel_e a1, const char* Format, ...)>Com_PrintWarning{ 0x0, 0x59A440 };
WEAK symbol<void(con_channel_e a1, const char* Format, ...)>Com_PrintError{ 0x0, 0x59A380 };
WEAK symbol<void(errorParm_t a1, const char* Format, ...)>Com_Error{ 0x0, 0x59AC50 };
WEAK symbol<void(const char* Format, ...)>Sys_Error{ 0x0, 0x5FE8C0 };
WEAK symbol<void(HunkUser *user)>Hunk_UserDestroy{ 0x0, 0x5E4940 };
WEAK symbol<void *(HunkUser *user, int size, int alignment)> Hunk_UserAlloc{ 0x0, 0x5E47B0 };
WEAK symbol<void()> Hunk_ClearTempMemoryHigh{ 0x0, 0x5E4300 };
WEAK symbol<int(const char* filename, int* file)>FS_FOpenFileRead{ 0x0, 0x5DBD20 };
WEAK symbol<int(char* Buffer, size_t ElementCount, int a3)>FS_Read{ 0x0, 0x5DBDF0 };
WEAK symbol<int(const char* filename, int* file, fsMode_t mode)>FS_FOpenFileByMode{ 0x0, 0x5DB630 };
WEAK symbol<const char*(const char* Format, ...)>va{ 0x0, 0x5F6D80 };
WEAK symbol<parseInfo_t* (const char* ArgList)>Com_BeginParseSession{ 0x0, 0x5F5830 };
WEAK symbol<void()> Com_EndParseSession{ 0x0, 0x5F5910 };
WEAK symbol<int()> Sys_Milliseconds{ 0x0, 0x603D40 };
WEAK symbol<void(char* Destination, const char* Source, size_t Count)>I_strncpyz{ 0x0, 0x7AA9C0 };
inline void* I_strncmp_ADDR() { return CALL_ADDR(0x0, 0x5F6A40); }
int I_strncmp(const char* str1, const char* str2, int len, void* call_addr = I_strncmp_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());
inline void* Hunk_AllocateTempMemoryHigh_ADDR() { return CALL_ADDR(0x0, 0x5E4220); }
unsigned int Hunk_AllocateTempMemoryHigh(int size_, void* call_addr = Hunk_AllocateTempMemoryHigh_ADDR());
inline void* FS_FCloseFile_ADDR() { return CALL_ADDR(0x0, 0x5DB060); }
void FS_FCloseFile(int h, void* call_addr = FS_FCloseFile_ADDR());
inline void* FS_ListFilteredFiles_ADDR() { return CALL_ADDR(0x0, 0x5DC720); }
const char** FS_ListFilteredFiles(searchpath_s* searchPath, const char* path, const char* extension, const char* filter, FsListBehavior_e behavior, int* numFiles, void* call_addr = FS_ListFilteredFiles_ADDR());
inline void* Z_TryVirtualAlloc_ADDR() { return CALL_ADDR(0x0, 0x5E39D0); }
void* Z_TryVirtualAlloc(signed int size_, void* call_addr = Z_TryVirtualAlloc_ADDR());
inline void* I_stricmp_ADDR() { return CALL_ADDR(0x0, 0x5F69E0); }
int I_stricmp(int len, const char* s0, const char* s1, void* call_addr = I_stricmp_ADDR());
inline void* Com_Parse_ADDR() { return CALL_ADDR(0x0, 0x5F61B0); }
parseInfo_t* Com_Parse(const char** buffer, void* call_addr = Com_Parse_ADDR());
inline void* Dvar_RegisterBool_ADDR() { return CALL_ADDR(0x0, 0x5EEE20); }
dvar_s * Dvar_RegisterBool(unsigned __int8 val, const char * name, int flags, const char * desc, void* call_addr = Dvar_RegisterBool_ADDR());
inline void* XAnimGetAnimDebugName_ADDR() { return CALL_ADDR(0x0, 0x60F850); }
const char * XAnimGetAnimDebugName(unsigned int animIndex, XAnim_s * anims, void* call_addr = XAnimGetAnimDebugName_ADDR());
void Sys_EnterCriticalSection(CriticalSection critSect);
void Sys_LeaveCriticalSection(CriticalSection critSect);
// Variables
WEAK symbol<char> tempServerCommandBuf{ 0x0, 0x2FCDC00 };
WEAK symbol<CRITICAL_SECTION> s_criticalSection{ 0x0, 0x2298D08 };
WEAK symbol<HunkUser*> g_DebugHunkUser{ 0x0, 0x212B2EC };
WEAK symbol<dvar_s*> useFastFile{ 0x0, 0x1F552FC };
WEAK symbol<fileHandleData_t> fsh{ 0x0, 0x2126E20 };
WEAK symbol<dvar_s*> fs_game{ 0x0, 0x2122B00 };
WEAK symbol<dvar_s*> com_developer{ 0x0, 0x1F55288 };
WEAK symbol<int> statmon_related_bool{ 0x0, 0x2122B04 };
WEAK symbol<HunkUser*> g_allocNodeUser{ 0x0, 0x3882B20 };
WEAK symbol<struct HunkUser *> g_user{ 0x0, 0x3882B48 };
WEAK symbol<searchpath_s*> fs_searchpaths{ 0x0, 0x46E5044 };
namespace plutonium
{

1
src/game/xasset.hpp
View File

@ -5418,5 +5418,6 @@ namespace game
ASSERT_STRUCT_OFFSET(XZone, blocks, 0xC);
#ifdef __cplusplus
WEAK symbol<XAssetHeader(XAssetType type, const char* name, bool errorIfMissing, int waitTime)>DB_FindXAssetHeader{ 0x0, 0x48DA30 };
}
#endif