1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
#include "pch.h"
#include "squirrel.h"
#include "hooks.h"
#include "hookutils.h"
#include "sigscanning.h"
#include "concommand.h"
#include <iostream>
// hook forward declarations
typedef SQInteger(*SQPrintType)(void* sqvm, char* fmt, ...);
SQPrintType ClientSQPrint;
SQPrintType UISQPrint;
SQPrintType ServerSQPrint;
template<Context context> SQInteger SQPrintHook(void* sqvm, char* fmt, ...);
typedef void*(*CreateNewVMType)(void* a1, Context contextArg);
CreateNewVMType ClientCreateNewVM; // only need a client one since ui doesn't have its own func for this
CreateNewVMType ServerCreateNewVM;
template<Context context> void* CreateNewVMHook(void* a1, Context contextArg);
typedef void(*DestroyVMType)(void* a1, void* sqvm);
DestroyVMType ClientDestroyVM; // only need a client one since ui doesn't have its own func for this
DestroyVMType ServerDestroyVM;
template<Context context> void DestroyVMHook(void* a1, void* sqvm);
typedef void (*SQCompileErrorType)(void* sqvm, const char* error, const char* file, int line, int column);
SQCompileErrorType ClientSQCompileError; // only need a client one since ui doesn't have its own func for this
SQCompileErrorType ServerSQCompileError;
template<Context context> void SQCompileErrorHook(void* sqvm, const char* error, const char* file, int line, int column);
sq_compilebufferType ClientSq_compilebuffer;
sq_compilebufferType ServerSq_compilebuffer;
sq_pushroottableType ClientSq_pushroottable;
sq_pushroottableType ServerSq_pushroottable;
sq_callType ClientSq_call;
sq_callType ServerSq_call;
template<Context context> void ExecuteCodeCommand(const CCommand& args);
// inits
SquirrelManager<CLIENT>* g_ClientSquirrelManager;
SquirrelManager<SERVER>* g_ServerSquirrelManager;
SquirrelManager<UI>* g_UISquirrelManager;
void InitialiseClientSquirrel(HMODULE baseAddress)
{
HookEnabler hook;
// client inits
g_ClientSquirrelManager = new SquirrelManager<CLIENT>();
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x12B00, &SQPrintHook<CLIENT>, reinterpret_cast<LPVOID*>(&ClientSQPrint)); // client print function
RegisterConCommand("script_client", ExecuteCodeCommand<CLIENT>, "Executes script code in the client vm", FCVAR_CLIENTDLL);
// ui inits
g_UISquirrelManager = new SquirrelManager<UI>();
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x12BA0, &SQPrintHook<UI>, reinterpret_cast<LPVOID*>(&UISQPrint)); // ui print function
RegisterConCommand("script_ui", ExecuteCodeCommand<UI>, "Executes script code in the client vm", FCVAR_CLIENTDLL);
// inits for both client and ui, since they share some functions
ClientSq_compilebuffer = (sq_compilebufferType)((char*)baseAddress + 0x3110);
ClientSq_pushroottable = (sq_pushroottableType)((char*)baseAddress + 0x5860);
ClientSq_call = (sq_callType)((char*)baseAddress + 0x8650);
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x26130, &CreateNewVMHook<CLIENT>, reinterpret_cast<LPVOID*>(&ClientCreateNewVM)); // client createnewvm function
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x26E70, &DestroyVMHook<CLIENT>, reinterpret_cast<LPVOID*>(&ClientDestroyVM)); // client destroyvm function
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x79A50, &SQCompileErrorHook<CLIENT>, reinterpret_cast<LPVOID*>(&ClientSQCompileError)); // client compileerror function
}
void InitialiseServerSquirrel(HMODULE baseAddress)
{
g_ServerSquirrelManager = new SquirrelManager<SERVER>();
HookEnabler hook;
ServerSq_compilebuffer = (sq_compilebufferType)((char*)baseAddress + 0x3110);
ServerSq_pushroottable = (sq_pushroottableType)((char*)baseAddress + 0x5840);
ServerSq_call = (sq_callType)((char*)baseAddress + 0x8620);
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x1FE90, &SQPrintHook<SERVER>, reinterpret_cast<LPVOID*>(&ServerSQPrint)); // server print function
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x260E0, &CreateNewVMHook<SERVER>, reinterpret_cast<LPVOID*>(&ServerCreateNewVM)); // server createnewvm function
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x26E20, &DestroyVMHook<SERVER>, reinterpret_cast<LPVOID*>(&ServerDestroyVM)); // server destroyvm function
ENABLER_CREATEHOOK(hook, (char*)baseAddress + 0x799E0, &SQCompileErrorHook<SERVER>, reinterpret_cast<LPVOID*>(&ServerSQCompileError)); // server compileerror function
RegisterConCommand("script", ExecuteCodeCommand<SERVER>, "Executes script code in the server vm", FCVAR_GAMEDLL);
}
// hooks
template<Context context> SQInteger SQPrintHook(void* sqvm, char* fmt, ...)
{
va_list va;
va_start(va, fmt);
SQChar buf[1024];
int charsWritten = vsnprintf_s(buf, _TRUNCATE, fmt, va);
if (charsWritten > 0)
{
if (buf[charsWritten - 1] == '\n')
buf[charsWritten - 1] = '\0';
spdlog::info("[{} SCRIPT] {}", GetContextName(context), buf);
}
va_end(va);
return 0;
}
template<Context context> void* CreateNewVMHook(void* a1, Context realContext)
{
void* sqvm;
if (context == CLIENT)
{
sqvm = ClientCreateNewVM(a1, realContext);
if (realContext == UI)
g_UISquirrelManager->sqvm = sqvm;
else
g_ClientSquirrelManager->sqvm = sqvm;
}
else if (context == SERVER)
{
sqvm = ServerCreateNewVM(a1, context);
g_ServerSquirrelManager->sqvm = sqvm;
}
spdlog::info("CreateNewVM {} {}", GetContextName(context), sqvm);
return sqvm;
}
template<Context context> void DestroyVMHook(void* a1, void* sqvm)
{
Context realContext = context; // ui and client use the same function so we use this for prints
if (context == CLIENT)
{
if (g_ClientSquirrelManager->sqvm == sqvm)
g_ClientSquirrelManager->sqvm = nullptr;
else if (g_UISquirrelManager->sqvm == sqvm)
{
g_UISquirrelManager->sqvm = nullptr;
realContext == UI;
}
ClientDestroyVM(a1, sqvm);
}
else if (context == SERVER)
{
g_ServerSquirrelManager->sqvm = nullptr;
ServerDestroyVM(a1, sqvm);
}
spdlog::info("DestroyVM {} {}", GetContextName(realContext), sqvm);
}
template<Context context> void SQCompileErrorHook(void* sqvm, const char* error, const char* file, int line, int column)
{
// note: i think vanilla might actually show the script line that errored, might be nice to implement that if it's a thing
// look into client.dll+79540 for way better errors too
Context realContext = context;
if (context == CLIENT && sqvm == g_UISquirrelManager->sqvm)
realContext = UI;
spdlog::error("{} SCRIPT COMPILE ERROR {}", GetContextName(realContext), error);
spdlog::error("{} line [{}] column [{}]", file, line, column);
// dont call the original since it kills game
// in the future it'd be nice to do an actual error with UICodeCallback_ErrorDialog here, but only if we're compiling level scripts
// compilestring and stuff shouldn't tho
// though, that also has potential to be REALLY bad if we're compiling ui scripts lol
}
template<Context context> void ExecuteCodeCommand(const CCommand& args)
{
if (context == CLIENT)
g_ClientSquirrelManager->ExecuteCode(args.ArgS());
else if (context == UI)
g_UISquirrelManager->ExecuteCode(args.ArgS());
else if (context == SERVER)
g_ServerSquirrelManager->ExecuteCode(args.ArgS());
}
|
