void ToggleDetour_ClientCommands(bool enable)
{
if (ClientCommandDetour)
{
(enable) ? ClientCommandDetour->EnableDetour() : ClientCommandDetour->DisableDetour();
}
if (enable)
{
// Build the item alias list.
// Used in ClientCommand to check and get fastly item id from alias name.
typedef struct
{
const char *alias;
int id;
} itemBuyAliasInfo;
itemBuyAliasInfo aliasToId[] =
{
{ "p228" , CSI_P228 }, { "228compact" , CSI_P228 },
{ "scout" , CSI_SCOUT }, { "hegren" , CSI_HEGRENADE },
{ "xm1014" , CSI_XM1014 }, { "autoshotgun", CSI_XM1014 },
{ "mac10" , CSI_MAC10 }, { "aug" , CSI_AUG },
{ "bullpup" , CSI_AUG }, { "sgren" , CSI_SMOKEGRENADE },
{ "elites" , CSI_ELITE }, { "fn57" , CSI_FIVESEVEN },
{ "fiveseven" , CSI_FIVESEVEN }, { "ump45" , CSI_UMP45 },
{ "sg550" , CSI_SG550 }, { "krieg550" , CSI_SG550 },
{ "galil" , CSI_GALIL }, { "defender" , CSI_GALIL },
{ "famas" , CSI_FAMAS }, { "clarion" , CSI_FAMAS },
{ "usp" , CSI_USP }, { "km45" , CSI_USP },
{ "glock" , CSI_GLOCK18 }, { "9x19mm" , CSI_GLOCK18 },
{ "awp" , CSI_AWP }, { "magnum" , CSI_AWP },
{ "mp5" , CSI_MP5NAVY }, { "smg" , CSI_MP5NAVY },
{ "m249" , CSI_M249 }, { "m3" , CSI_M3 },
{ "12gauge" , CSI_M3 }, { "m4a1" , CSI_M4A1 },
{ "tmp" , CSI_TMP }, { "mp" , CSI_TMP },
{ "g3sg1" , CSI_G3SG1 }, { "d3au1" , CSI_G3SG1 },
{ "flash" , CSI_FLASHBANG }, { "deagle" , CSI_DEAGLE },
{ "nighthawk" , CSI_DEAGLE }, { "sg552" , CSI_SG552 },
{ "krieg552" , CSI_SG552 }, { "ak47" , CSI_AK47 },
{ "cv47" , CSI_AK47 }, { "p90" , CSI_P90 },
{ "c90" , CSI_P90 }, { "vest" , CSI_VEST },
{ "vesthelm" , CSI_VESTHELM }, { "defuser" , CSI_DEFUSER },
{ "nvgs" , CSI_NVGS }, { "shield" , CSI_SHIELDGUN },
{ "buyammo1" , CSI_PRIAMMO }, { "primammo" , CSI_PRIAMMO },
{ "buyammo2" , CSI_SECAMMO }, { "secammo" , CSI_SECAMMO },
{ nullptr , 0 }
};
for (size_t i = 0; aliasToId[i].alias != nullptr; ++i)
{
ItemAliasList.insert(aliasToId[i].alias, aliasToId[i].id);
}
}
else
{
ItemAliasList.clear();
}
}
void CtrlDetours_BuyCommands(bool set)
{
if (set)
{
void *giveShieldAddress = UTIL_FindAddressFromEntry(CS_IDENT_GIVENSHIELD , CS_IDENT_HIDDEN_STATE);
void *giveNamedItemAddress = UTIL_FindAddressFromEntry(CS_IDENT_GIVENAMEDITEM, CS_IDENT_HIDDEN_STATE);
void *addAccountAddress = UTIL_FindAddressFromEntry(CS_IDENT_ADDACCOUNT , CS_IDENT_HIDDEN_STATE);
GiveShieldDetour = DETOUR_CREATE_MEMBER_FIXED(GiveShield, giveShieldAddress);
GiveNamedItemDetour = DETOUR_CREATE_MEMBER_FIXED(GiveNamedItem, giveNamedItemAddress);
AddAccountDetour = DETOUR_CREATE_MEMBER_FIXED(AddAccount, addAccountAddress);
if (GiveNamedItemDetour == NULL || AddAccountDetour == NULL)
{
MF_Log("No Buy Commands detours could be initialized - Disabled Buy forward.");
}
}
else
{
if (GiveShieldDetour)
GiveShieldDetour->Destroy();
if (GiveNamedItemDetour)
GiveNamedItemDetour->Destroy();
if (AddAccountDetour)
AddAccountDetour->Destroy();
ItemAliasList.clear();
}
}
void CtrlDetours_ClientCommand(bool set)
{
if (set)
{
void *target = (void *)MDLL_ClientCommand;
#if defined(WIN32)
UseBotArgs = *(int **)((unsigned char *)target + CS_CLICMD_OFFS_USEBOTARGS);
BotArgs = (const char **)*(const char **)((unsigned char *)target + CS_CLICMD_OFFS_BOTARGS);
#elif defined(__linux__) || defined(__APPLE__)
UseBotArgs = (int *)UTIL_FindAddressFromEntry(CS_IDENT_USEBOTARGS, CS_IDENT_HIDDEN_STATE);
BotArgs = (const char **)UTIL_FindAddressFromEntry(CS_IDENT_BOTARGS, CS_IDENT_HIDDEN_STATE);
#endif
ClientCommandDetour = DETOUR_CREATE_STATIC_FIXED(C_ClientCommand, target);
if (ClientCommandDetour == NULL)
{
MF_Log("No Client Commands detour could be initialized - Disabled Client Command forward.");
}
}
else
{
if (ClientCommandDetour)
ClientCommandDetour->Destroy();
ItemAliasList.clear();
}
}
void CtrlDetours_ClientCommand(bool set)
{
if (set)
{
void *base = reinterpret_cast<void *>(MDLL_ClientCommand);
#if defined(WIN32)
int offset = 0;
if (MainConfig->GetOffset("UseBotArgs", &offset))
{
UseBotArgs = get_pdata<int*>(base, offset);
}
if (MainConfig->GetOffset("BotArgs", &offset))
{
BotArgs = get_pdata<const char**>(base, offset);
}
#elif defined(__linux__) || defined(__APPLE__)
void *address = nullptr;
if (MainConfig->GetMemSig("UseBotArgs", &address))
{
UseBotArgs = reinterpret_cast<int *>(address);
}
if (MainConfig->GetMemSig("BotArgs", &address))
{
BotArgs = reinterpret_cast<const char **>(address);
}
#endif
ClientCommandDetour = DETOUR_CREATE_STATIC_FIXED(C_ClientCommand, base);
CommonConfig->GetOffsetByClass("CBasePlayer", "m_iTeam", &TeamOffset);
CommonConfig->GetOffsetByClass("CBasePlayer", "m_iMenu", &MenuOffset);
if (!ClientCommandDetour || !UseBotArgs || !BotArgs || !TeamOffset || !MenuOffset)
{
MF_Log("ClientCommand is not available - forward client_command has been disabled");
}
}
else
{
if (ClientCommandDetour)
{
ClientCommandDetour->Destroy();
}
ItemAliasList.clear();
}
}
void CtrlDetours_BuyCommands(bool set)
{
if (set)
{
void *address = nullptr;
if (MainConfig->GetMemSig("GiveShield", &address))
{
GiveShieldDetour = DETOUR_CREATE_MEMBER_FIXED(GiveShield, address);
}
if (MainConfig->GetMemSig("GiveNamedItem", &address))
{
GiveNamedItemDetour = DETOUR_CREATE_MEMBER_FIXED(GiveNamedItem, address);
}
if (MainConfig->GetMemSig("AddAccount", &address))
{
AddAccountDetour = DETOUR_CREATE_MEMBER_FIXED(AddAccount, address);
}
if (!GiveShieldDetour || !GiveNamedItemDetour || !AddAccountDetour)
{
if (!GiveShieldDetour)
{
MF_Log("GiveShield is not available");
}
if (!GiveNamedItemDetour)
{
MF_Log("GiveNamedItem is not available");
}
if (!AddAccountDetour)
{
MF_Log("AddAccount is not available");
}
MF_Log("Some functions are not available - forward CS_OnBuyAttempt and CS_OnBuy have been disabled");
}
}
else
{
if (GiveShieldDetour)
{
GiveShieldDetour->Destroy();
}
if (GiveNamedItemDetour)
{
GiveNamedItemDetour->Destroy();
}
if (AddAccountDetour)
{
AddAccountDetour->Destroy();
}
ItemAliasList.clear();
}
}
void Generate(const char* pcName, const vector<const char*>& kNameList)
{
funcName.clear();
funcName["glXCreateContext"] = 1;
funcName["glXMakeCurrent"] = 1;
funcName["glXSwapBuffers"] = 1;
funcName["glXGetProcAddressARB"] = 1;
funcName["wglGetProcAddress"] = 1;
funcName["wglCreateContext"] = 1;
funcName["wglMakeCurrent"] = 1;
funcName["wglDeleteContext"] = 1;
LoadContext = "";
UnloadContext = "";
smallPre = pcName;
bigPre = pcName;
int i(0);
while(pcName[i])
{
if(pcName[i] >= 'a' && pcName[i] <= 'z')
bigPre[i] = pcName[i] - 0x20;
else
bigPre[i] = pcName[i];
++i;
}
macro = "VE_";
macro += bigPre;
bigPre += "_";
if(bigPre == "WGL_") bigPre = "";
size_t stLen;
char acBuffer[1024];
sprintf_s(acBuffer, "%s.tm", pcName);
char* pcFile = OpenFile(acBuffer, stLen);
Load_tm(pcFile, stLen, g_kTypeMap);
CloseFile(pcFile);
string kGlHeader;
string kGlSource;
kGlHeader +=
"////////////////////////////////////////////////////////////////////////////\n" \
"//\n" \
"// Venus Engine Header File.\n" \
"// Copyright (C), Venus Interactive Entertainment.2012\n" \
"// -------------------------------------------------------------------------\n" \
"// File name: ";
kGlHeader += pcName;
kGlHeader += ".h\n";
kGlHeader +=
"// Version: v1.00\n" \
"// Created: by GlSpecLoader\n" \
"// Compilers: Visual Studio.NET\n" \
"// Description: \n" \
"// -------------------------------------------------------------------------\n" \
"// History:\n" \
"// http://www.venusie.com\n" \
"////////////////////////////////////////////////////////////////////////////\n\n";
kGlHeader += "#pragma once\n\n" \
"#ifdef ";
kGlHeader += macro;
kGlHeader += "\n\n" \
"extern \"C\"\n" \
"{\n\n";
kGlSource +=
"////////////////////////////////////////////////////////////////////////////\n" \
"//\n" \
"// Venus Engine Source File.\n" \
"// Copyright (C), Venus Interactive Entertainment.2012\n" \
"// -------------------------------------------------------------------------\n" \
"// File name: ";
kGlSource += pcName;
kGlSource += ".cpp\n";
kGlSource +=
"// Version: v1.00\n" \
"// Created: by GlSpecLoader\n" \
"// Compilers: Visual Studio.NET\n" \
"// Description: \n" \
"// -------------------------------------------------------------------------\n" \
"// History:\n" \
"// http://www.venusie.com\n" \
"////////////////////////////////////////////////////////////////////////////\n\n";
kGlSource +=
"#include \"VeMainPCH.h\"\n" \
"#include \"_VeGlLoader.h\"\n\n";
kGlSource += "#ifdef ";
kGlSource += macro;
kGlSource += "\n\n";
for(size_t i(0); i < kNameList.size(); ++i)
{
pcFile = OpenFile(kNameList[i], stLen);
Load_spec(pcFile, stLen, g_kTypeMap, kGlHeader, kGlSource);
CloseFile(pcFile);
}
kGlHeader += "\nvoid ";
kGlHeader += smallPre;
kGlHeader += "Funcload();\n";
kGlHeader += "\nvoid ";
kGlHeader += smallPre;
kGlHeader += "FuncUnload();\n\n";
kGlHeader += "}\n\n";
kGlHeader += "#endif\n";
kGlSource += "\nvoid ";
kGlSource += smallPre;
kGlSource += "Funcload()\n{\n";
kGlSource += LoadContext;
kGlSource += "}\n";
kGlSource += "\nvoid ";
kGlSource += smallPre;
kGlSource += "FuncUnload()\n{\n";
kGlSource += UnloadContext;
kGlSource += "}\n\n";
kGlSource += "#endif\n";
_chdir(g_acSave);
FILE* pfHeaderFile;
sprintf_s(acBuffer, "%s.h", pcName);
fopen_s(&pfHeaderFile, acBuffer, "w");
fwrite(kGlHeader.c_str(), 1, kGlHeader.length(), pfHeaderFile);
fclose(pfHeaderFile);
FILE* pfSourceFile;
sprintf_s(acBuffer, "%s.cpp", pcName);
fopen_s(&pfSourceFile, acBuffer, "w");
fwrite(kGlSource.c_str(), 1, kGlSource.length(), pfSourceFile);
fclose(pfSourceFile);
_chdir(g_acLoad);
}
void Load_spec(const char* pcBuffer, size_t stLen, StringHashMap<string>& kTypeMap, string& outHeader, string& outSource)
{
const char* pcStart = pcBuffer;
char acLineBuffer[2048];
SpecType eState = SPEC_TYPE_MAX;
SpecType eLastState = SPEC_TYPE_MAX;
string func_name;
string return_name;
vector<string> params;
StringHashMap<pair<string,bool>> paramsType;
int i(0);
while(GetLine(&pcStart, acLineBuffer))
{
++i;
switch(eState)
{
case SPEC_ENUM:
if(eState == SPEC_ENUM)
{
if(acLineBuffer[0] == '\t')
{
char acMacro[1024], acValue[1024];
GetDefine(acLineBuffer, acMacro, acValue);
if(strcmp(acMacro, "use") != 0)
{
outHeader += "#ifndef ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += "\n#define ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += " ";
outHeader += acValue;
outHeader += "\n#endif\n\n";
}
break;
}
else
{
eState = SPEC_TYPE_MAX;
eLastState = SPEC_ENUM;
}
}
case SPEC_DEFINE:
if(eState == SPEC_DEFINE)
{
if(acLineBuffer[0] == '\t')
{
char acMacro[1024], acValue[1024];
GetDefine(acLineBuffer, acMacro, acValue);
if(strcmp(acMacro, "use") != 0)
{
outHeader += "#ifndef ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += "\n#define ";
outHeader += bigPre;
outHeader += acMacro;
outHeader += " ";
outHeader += acValue;
outHeader += "\n#endif\n\n";
}
break;
}
else
{
eState = SPEC_TYPE_MAX;
eLastState = SPEC_DEFINE;
}
}
case SPEC_FUNC:
if(eState == SPEC_FUNC)
{
if(acLineBuffer[0] == '\t')
{
char acWord0[128], acWord1[128], acWord2[128];
char* pcSrc;
char* pcDst;
{
pcSrc = acLineBuffer;
pcDst = acWord0;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
}
StringHashMap<FuncType>::iterator it = func_Type.find(acWord0);
if(it != func_Type.end())
{
switch(it->second)
{
case FUNC_RETURN:
{
pcDst = acWord1;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
return_name = acWord1;
}
break;
case FUNC_PARAM:
{
pcDst = acWord1;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
pcDst = acWord2;
while(*pcSrc == ' ' || *pcSrc == '\t')
{
++pcSrc;
}
while(*pcSrc != ' ' && *pcSrc != '\t' && *pcSrc != '\0')
{
*pcDst = *pcSrc;
++pcDst;
++pcSrc;
}
*pcDst = 0;
if(strstr(pcSrc, "value"))
{
paramsType[acWord1] = make_pair(string(acWord2), false);
}
else
{
paramsType[acWord1] = make_pair(string(acWord2), true);
}
}
break;
}
}
break;
}
else
{
if(funcName.find(func_name.c_str()) == funcName.end())
{
string strTemp;
outHeader += "typedef ";
strTemp = kTypeMap[return_name];
if(strTemp == "") strTemp = "void";
outHeader += strTemp;
outHeader += " (APIENTRY *";
outHeader += func_name;
outHeader += "Func)(";
for(size_t i(0); i < params.size(); ++i)
{
strTemp = paramsType[params[i]].first;
strTemp = kTypeMap[strTemp];
if(strTemp == "")
{
strTemp = "void";
}
if(paramsType[params[i]].second)
{
strTemp += "*";
}
outHeader += strTemp;
outHeader += " ";
StringHashMap<string>::iterator it = trans.find(params[i]);
if(it != trans.end())
{
outHeader += it->second;
}
else
{
outHeader += params[i];
}
if(i < (params.size() - 1))
{
outHeader += ", ";
}
}
outHeader += ");\n";
outHeader += "extern ";
outHeader += func_name;
outHeader += "Func _";
outHeader += func_name;
outHeader += ";\n";
outHeader += "#define ";
outHeader += func_name;
if(return_name == "void")
{
outHeader += " VE_ASSERT(_";
outHeader += func_name;
outHeader += ");_";
}
else
{
outHeader += " _";
}
outHeader += func_name;
outHeader += "\n";
outSource += "#ifdef ";
outSource += func_name;
outSource += "\n";
outSource += func_name;
outSource += "Func _";
outSource += func_name;
outSource += " = NULL;\n";
outSource += "#endif\n";
LoadContext += "#\tifdef ";
LoadContext += func_name;
LoadContext += "\n";
LoadContext += "\t_";
LoadContext += func_name;
LoadContext += " = (";
LoadContext += func_name;
LoadContext += "Func)";
LoadContext += smallPre;
LoadContext += "GetFunction(\"";
LoadContext += func_name;
LoadContext += "\");\n";
LoadContext += "#\tendif\n";
UnloadContext += "#\tifdef ";
UnloadContext += func_name;
UnloadContext += "\n";
UnloadContext += "\t_";
UnloadContext += func_name;
UnloadContext += " = NULL;\n";
UnloadContext += "#\tendif\n";
funcName[func_name] = 1;
}
eState = SPEC_TYPE_MAX;
eLastState = SPEC_TYPE_MAX;
}
}
case SPEC_TYPE_MAX:
if(eState == SPEC_TYPE_MAX)
{
if(acLineBuffer[0] < 0x30 || acLineBuffer[0] > 0x7A)
{
continue;
}
char acTemp[1024];
const char* pcNext = GetSpecType(acLineBuffer, acTemp);
{
bool bFunc = false;
{
const char* pcTempPointer = acTemp;
while(*pcTempPointer)
{
if(*pcTempPointer == ')')
{
bFunc = true;
}
++pcTempPointer;
}
}
if(bFunc)
{
char acTempBuffer[128];
char* pcDst = acTempBuffer;
char* pcSrc = acLineBuffer;
while(*pcSrc)
{
*pcDst = *pcSrc;
if(*pcDst == '(')
{
++pcSrc;
break;
}
++pcDst;
++pcSrc;
}
*pcDst = 0;
func_name = smallPre + acTempBuffer;
return_name = "";
params.clear();
paramsType.clear();
while(*pcSrc)
{
pcDst = acTempBuffer;
while(*pcSrc)
{
*pcDst = *pcSrc;
if(*pcSrc == ')')
{
break;
}
else if(*pcSrc == ' ' || *pcSrc == '\t' || *pcSrc == ',')
{
++pcSrc;
break;
}
++pcSrc;
++pcDst;
}
*pcDst = 0;
if(strlen(acTempBuffer))
{
params.push_back(acTempBuffer);
}
while(*pcSrc == ' ' || *pcSrc == '\t' || *pcSrc == ',')
{
++pcSrc;
}
if(*pcSrc == ')')
{
break;
}
}
eState = SPEC_FUNC;
}
else
{
StringHashMap<SpecType>::iterator it = spec_Type.find(acTemp);
if(it != spec_Type.end())
{
if(it->second == SPEC_PASSTHRU)
{
while(*pcNext == ' ' || *pcNext == '\t')
{
++pcNext;
}
outHeader += pcNext;
outHeader += "\n";
eState = eLastState;
}
else
{
eState = it->second;
}
}
else
{
eState = SPEC_ENUM;
}
}
}
}
break;
}
}
}
