311 lines
11 KiB
C++
311 lines
11 KiB
C++
#include "functions.hpp"
|
|
|
|
int* s_messageDialoglInfoMode;
|
|
|
|
|
|
void Dvar_SetBoolFromSource(uintptr_t dvar, bool value, int source) {
|
|
auto func = reinterpret_cast<void(*)(uintptr_t, bool, int)>(g_Addrs.Dvar_SetBoolFromSource);
|
|
func(dvar, value, source);
|
|
}
|
|
|
|
void Dvar_SetStringFromSource(uintptr_t dvar, const char * value, int source) {
|
|
auto func = reinterpret_cast<void(*)(uintptr_t, bool, int)>(g_Addrs.Dvar_SetStringFromSource);
|
|
func(dvar, value, source);
|
|
}
|
|
|
|
void CL_Disconnect(int localClientNum, bool deactivateClient, const char* message) {
|
|
auto func = reinterpret_cast<void(*)(int, bool, const char*)>(g_Addrs.CL_Disconnect);
|
|
func(localClientNum, deactivateClient, message);
|
|
}
|
|
|
|
void set_username(uintptr_t a1, const char* username) {
|
|
auto func = reinterpret_cast<void(*)(uintptr_t, const char*)>(g_Addrs.set_username);
|
|
func(a1, username);
|
|
}
|
|
|
|
uintptr_t LiveUser_GetUserDataForController(int controllerIndex) {
|
|
auto func = reinterpret_cast<uintptr_t(*)(int)>(g_Addrs.LiveUser_GetUserDataForController);
|
|
return func(controllerIndex);
|
|
}
|
|
|
|
void SetScreen(int screen, char unk) {
|
|
auto func = reinterpret_cast<void(*)(int, char)>(g_Addrs.SetScreen);
|
|
func(screen, unk);
|
|
}
|
|
|
|
void LobbyBase_SetNetworkMode(LobbyNetworkMode networkMode) {
|
|
auto func = reinterpret_cast<void(*)(LobbyNetworkMode)>(g_Addrs.LobbyBase_SetNetworkMode);
|
|
func(networkMode);
|
|
}
|
|
|
|
void Com_SessionMode_SetMode(int mode) {
|
|
auto func = reinterpret_cast<void(*)(int)>(g_Addrs.Com_SessionMode_SetNetworkMode);
|
|
func(mode);
|
|
}
|
|
|
|
void Com_GametypeSettings_SetGametype(const char* gametype, bool loadDefaultSettings) {
|
|
auto func = reinterpret_cast<void(*)(const char*, bool)>(g_Addrs.Com_GametypeSettings_SetGametype);
|
|
func(gametype, loadDefaultSettings);
|
|
}
|
|
|
|
LRESULT KeyboardInput(int code, WPARAM wParam, LPARAM lParam) {
|
|
auto func = reinterpret_cast<LRESULT(*)(int, WPARAM, LPARAM)>(g_Addrs.KeyboardInput);
|
|
return func(code, wParam, lParam);
|
|
}
|
|
|
|
int LobbySession_GetControllingLobbySession(int lobbyModule) {
|
|
auto func = reinterpret_cast<int(*)(int)>(g_Addrs.LobbySession_GetControllingLobbySession);
|
|
return func(lobbyModule);
|
|
}
|
|
|
|
void LobbyData_SetMap(int lobbyType, const char* mapname) {
|
|
auto func = reinterpret_cast<void(*)(int, const char*)>(g_Addrs.LobbyData_SetMap);
|
|
func(lobbyType, mapname);
|
|
}
|
|
|
|
void LobbyData_SetGameType(int lobbyType, const char* gametype) {
|
|
auto func = reinterpret_cast<void(*)(int, const char*)>(g_Addrs.LobbyData_SetGameType);
|
|
func(lobbyType, gametype);
|
|
}
|
|
|
|
const char* ScrStr_ConvertToString(ScrString_t stringValue) {
|
|
auto func = reinterpret_cast<const char* (*)(ScrString_t)>(g_Addrs.ScrStr_ConvertToString);
|
|
return func(stringValue);
|
|
}
|
|
|
|
void VM_OP_Notify_Handler(int a1, __int64 a2, ScrVmContext_t* a3, __int64 a4) {
|
|
auto func = reinterpret_cast<void(*)(int, __int64, ScrVmContext_t*, __int64)>(g_Addrs.VM_OP_Notify_Handler);
|
|
func(a1, a2, a3, a4);
|
|
}
|
|
|
|
void SetMode(int mode, int menu) {
|
|
SetScreen(menu, 0);
|
|
LobbyBase_SetNetworkMode(LOBBY_NETWORKMODE_LAN);
|
|
Com_SessionMode_SetMode(mode);
|
|
if (!is_alpha()) {
|
|
*reinterpret_cast<char*>(g_Addrs.config[0]) = 1;
|
|
*reinterpret_cast<char*>(g_Addrs.config[1]) = 1;
|
|
}
|
|
}
|
|
|
|
void* RtlAddVectoredExceptionHandler(LONG First, PVECTORED_EXCEPTION_HANDLER Handler) {
|
|
utils::nt::library ntdll(("ntdll.dll"));
|
|
ntdll.invoke<void*>(("RtlAddVectoredExceptionHandler"), First, Handler);
|
|
}
|
|
|
|
NTSTATUS NtContinue(PCONTEXT threadContext, BOOLEAN raiseAlert) {
|
|
utils::nt::library ntdll(("ntdll.dll"));
|
|
return ntdll.invoke<NTSTATUS>(("NtContinue"), threadContext, raiseAlert);
|
|
}
|
|
|
|
bool is_alpha() {
|
|
if (*reinterpret_cast<int*>(base + 0x2602E18) == 0x5F1B8329) {
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void CL_DrawTextPhysical(const char* text, int maxChars, uintptr_t font, float x, float y, float rotation, float xScale, float yScale, const float* color, int style, int padding) {
|
|
auto func = reinterpret_cast<void(*)(const char* text, int maxChars, uintptr_t font, float x, float y, float rotation, float xScale, float yScale, const float* color, int style, int padding)>(g_Addrs.CL_DrawTextPhysical);
|
|
func(text, maxChars, font, x, y, rotation, xScale, yScale, color, style, padding);
|
|
}
|
|
|
|
void R_AddCmdDrawStretchPic(float x, float y, float w, float h, float s0, float t0, float s1, float t1, const float* color, uintptr_t material) {
|
|
auto func = reinterpret_cast<void(*)(float, float, float, float, float, float, float, float, const float*, uintptr_t)>(g_Addrs.R_AddCmdDrawStretchPic);
|
|
func(x, y, w, h, s0, t0, s1, t1, color, material);
|
|
}
|
|
|
|
uintptr_t Material_RegisterHandle(uintptr_t hash, bool a2, int a3) {
|
|
auto func = reinterpret_cast<uintptr_t(*)(uintptr_t, bool, int)>(g_Addrs.Material_RegisterHandle);
|
|
return func((uintptr_t)&hash, a2, a3);
|
|
}
|
|
|
|
uintptr_t ScrPlace_GetViewUIContext(int a1) {
|
|
auto func = reinterpret_cast<uintptr_t(*)(int)>(g_Addrs.ScrPlace_GetViewUIContext);
|
|
return func(a1);
|
|
}
|
|
|
|
uintptr_t UI_GetFontHandle(uintptr_t a1, int a2, float a3) {
|
|
auto func = reinterpret_cast<uintptr_t(*)(uintptr_t, int, float)>(g_Addrs.UI_GetFontHandle);
|
|
return func(a1, a2, a3);
|
|
}
|
|
|
|
float R_TextWidth(int a1, const char* a2, int a3, uintptr_t a4) {
|
|
auto func = reinterpret_cast<float(*)(int, const char*, int, uintptr_t)>(g_Addrs.R_TextWidth);
|
|
return func(a1, a2, a3, a4);
|
|
}
|
|
|
|
int ScrVm_ExecThread(int inst, uintptr_t handle, unsigned int paramcount, ScrVarValue_t* value, unsigned int self) {
|
|
auto func = reinterpret_cast<int(*)(int inst, uintptr_t handle, unsigned int paramcount, ScrVarValue_t * value, unsigned int self)>(g_Addrs.ScrVm_ExecThread);
|
|
return func(inst, handle, paramcount, value, self);
|
|
}
|
|
|
|
void ScrVm_FreeThread(int inst, ScrVarIndex_t handle) {
|
|
ScrVar_ReleaseVariable(inst, handle);
|
|
}
|
|
|
|
void ScrVar_ReleaseVariable(int inst, ScrVarIndex_t handle) {
|
|
auto func = reinterpret_cast<void(*)(int, ScrVarIndex_t)>(g_Addrs.ScrVar_ReleaseVariable);
|
|
func(inst, handle);
|
|
}
|
|
|
|
uintptr_t Scr_GetFunctionHandle(int inst, uintptr_t filename, uint32_t nspace, uint32_t nfunc, uint32_t* checksum, bool errorIfMissing) {
|
|
auto func = reinterpret_cast<uintptr_t(*)(int inst, uintptr_t filename, uint32_t nspace, uint32_t func, uint32_t * checksum, bool errorIfMissing)>(g_Addrs.Scr_GetFunctionHandle);
|
|
return func(inst, filename, nspace, nfunc, checksum, errorIfMissing);
|
|
}
|
|
|
|
void ScrVm_AddString(int inst, uintptr_t hash) {
|
|
auto func = reinterpret_cast<void(*)(int, uintptr_t)>(g_Addrs.ScrVm_AddString);
|
|
func(inst, hash);
|
|
}
|
|
|
|
void ScrVm_AddInt(int inst, int value) {
|
|
auto func = reinterpret_cast<void(*)(int, int)>(g_Addrs.ScrVm_AddInt);
|
|
func(inst, value);
|
|
}
|
|
|
|
bool Com_IsInGame() {
|
|
auto func = reinterpret_cast<bool(*)()>(g_Addrs.Com_IsInGame);
|
|
return func();
|
|
}
|
|
|
|
bool Sys_IsServerThread() {
|
|
auto func = reinterpret_cast<bool(*)()>(g_Addrs.Sys_IsServerThread);
|
|
return func();
|
|
}
|
|
|
|
float get_version() {
|
|
switch (*reinterpret_cast<int*>(0x1411017B0_g)) {
|
|
case 0xB8ECE9C1:
|
|
return 1.918634551f;
|
|
case 0xE9CC1D0E:
|
|
return 1.33215030131f;
|
|
}
|
|
return 0.00000000f;
|
|
}
|
|
|
|
void LobbyHostBots_AddBotsToLobby(unsigned int lobbyType, int numBots, bool param_3, unsigned long lobbyID, unsigned long param_5)
|
|
{
|
|
auto func = reinterpret_cast<void(*)(unsigned int lobbyType, int numBots, bool param_3, unsigned long lobbyID, unsigned long param_5)>(g_Addrs.LobbyHostBots_AddBotsToLobby);
|
|
func(lobbyType, numBots, param_3, lobbyID, param_5);
|
|
}
|
|
|
|
void Cbuf_AddText(const char* cmd)
|
|
{
|
|
auto func = reinterpret_cast<void(*)()>(g_Addrs.CbufAddtextFunc);
|
|
|
|
DWORD dwProcessId = GetCurrentProcessId();
|
|
HANDLE hProcess = OpenProcess(0x1fffff, 0, dwProcessId);
|
|
|
|
unsigned int cmdlen = strlen(cmd) + 1;
|
|
|
|
void* lVar2 = (void*)*(unsigned int*)(g_Addrs.CbufAddtextFunc + 0x1d);
|
|
unsigned int iVar1 = *(unsigned int*)(g_Addrs.CbufAddtextFunc + (long long)lVar2 + 0x21);
|
|
|
|
if (iVar1 == 0x74736F68)
|
|
{
|
|
WriteProcessMemory(hProcess, (LPVOID)g_Addrs.cusCbufBuffer1, cmd, cmdlen, NULL);
|
|
func();
|
|
WriteProcessMemory(hProcess, (LPVOID)g_Addrs.cusCbufBuffer1, "hostmigration_start\n", strlen("hostmigration_start\n"), NULL);
|
|
}
|
|
|
|
if (iVar1 == 0x63656863)
|
|
{
|
|
WriteProcessMemory(hProcess, (LPVOID)g_Addrs.cusCbufBuffer2, cmd, cmdlen, NULL);
|
|
func();
|
|
WriteProcessMemory(hProcess, (LPVOID)g_Addrs.cusCbufBuffer1, "checkpoint_restart\n", strlen("checkpoint_restart\n"), NULL);
|
|
}
|
|
|
|
if (iVar1 == 0x7373696D)
|
|
{
|
|
WriteProcessMemory(hProcess, (LPVOID)g_Addrs.cusCbufBuffer3, cmd, cmdlen, NULL);
|
|
func();
|
|
WriteProcessMemory(hProcess, (LPVOID)g_Addrs.cusCbufBuffer1, "mission_restart\n", strlen("mission_restart\n"), NULL);
|
|
}
|
|
}
|
|
|
|
const uint64_t fnvHash(const char* data)
|
|
{
|
|
uint64_t result = 0xCBF29CE484222325;
|
|
|
|
for (size_t i = 0; i < strlen(data); i++)
|
|
{
|
|
uint64_t value = tolower(data[i]);
|
|
|
|
if (value == '\\')
|
|
value = '/';
|
|
|
|
result = 0x100000001B3 * (value ^ result);
|
|
}
|
|
|
|
return result & 0x7FFFFFFFFFFFFFFF;
|
|
}
|
|
|
|
// build 1.34.0.15931218
|
|
|
|
dvar_t* Dvar_FindVar(__int64 dvar) {
|
|
auto func = reinterpret_cast<dvar_t * (*)(__int64)>(0x14C0B2090_g);
|
|
return func(dvar);
|
|
}
|
|
const dvar_t* Dvar_RegisterInt(__int64 hash, const char* dvarName, int value, int min, int max, unsigned int flags) {
|
|
printf("[%s] Registering int 0x%llX with value %d\n", __FUNCTION__, hash, value);
|
|
auto func = reinterpret_cast<const dvar_t * (*)(__int64, const char*, int, int, int, unsigned int)>(0x14C0C7360_g);
|
|
return func(hash, dvarName, value, min, max, flags);
|
|
}
|
|
void Dvar_SetInt(dvar_t* dvar, int value, int a3) {
|
|
auto func = reinterpret_cast<void(*)(dvar_t*, int, int)>(0x14C0B7B90_g);
|
|
func(dvar, value, a3);
|
|
}
|
|
|
|
void Dvar_SetIntByHash(__int64 hash, int value) {
|
|
dvar_t* dvar = Dvar_FindVar(hash);
|
|
// if not found we should try to register it
|
|
if (!dvar) {
|
|
Dvar_RegisterInt(hash, 0, 1, 1, 1, 0);
|
|
}
|
|
else {
|
|
Dvar_SetInt(dvar, value, 0);
|
|
}
|
|
}
|
|
|
|
void Dvar_SetVariantByHash(__int64 hash, DvarValue value)
|
|
{
|
|
auto Dvar_SetVariant = reinterpret_cast<void(*)(dvar_t* dvar, DvarValue value, int setSource)>(0xC0B8DB0_b);
|
|
|
|
dvar_t* dvar = Dvar_FindVar(hash);
|
|
if (dvar)
|
|
{
|
|
Dvar_SetVariant(dvar, value, 0);
|
|
}
|
|
else
|
|
{
|
|
printf("Dvar 0x%p doesn't exist.\n", hash);
|
|
}
|
|
}
|
|
|
|
gentity_t* SV_AddTestClient(const char* name, const char* unk) {
|
|
auto func = reinterpret_cast<gentity_t * (*)(const char*, const char*)>(0x147189410_g);
|
|
return func(name, unk);
|
|
}
|
|
|
|
void Scr_AddEntity(scriptInstance_t inst, gentity_t* ent, unsigned int classNum) {
|
|
auto func = reinterpret_cast<void(*)(scriptInstance_t, gentity_t*, unsigned int)>(0x14737F490_g);
|
|
func(inst, ent, classNum);
|
|
}
|
|
|
|
void AddTestClient() {
|
|
gentity_t* client = SV_AddTestClient(0, 0);
|
|
if (client)
|
|
Scr_AddEntity(SCRIPTINSTANCE_SERVER, client, 0);
|
|
}
|
|
|
|
void Cmd_AddCommandInternal(const char* cmdName, xcommand_t function, cmd_function_t* allocedCmd) {
|
|
__int64 hash = fnvHash(cmdName);
|
|
auto func = reinterpret_cast<void(*)(__int64, xcommand_t, cmd_function_t*)>(0x149ACBAD0_g);
|
|
func(hash, function, allocedCmd);
|
|
}
|
|
|
|
Addresses g_Addrs;
|