1529 lines
47 KiB
C++
1529 lines
47 KiB
C++
/**
|
|
* vim: set ts=4 :
|
|
* =============================================================================
|
|
* Source SDK Hooks Extension
|
|
* Copyright (C) 2010-2012 Nicholas Hastings
|
|
* Copyright (C) 2009-2010 Erik Minekus
|
|
* =============================================================================
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License, version 3.0, as published by the
|
|
* Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* As a special exception, AlliedModders LLC gives you permission to link the
|
|
* code of this program (as well as its derivative works) to "Half-Life 2," the
|
|
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
|
|
* by the Valve Corporation. You must obey the GNU General Public License in
|
|
* all respects for all other code used. Additionally, AlliedModders LLC grants
|
|
* this exception to all derivative works. AlliedModders LLC defines further
|
|
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
|
|
* or <http://www.sourcemod.net/license.php>.
|
|
*
|
|
* Version: $Id$
|
|
*/
|
|
|
|
#include <sourcemod_version.h>
|
|
#include "extension.h"
|
|
#include "compat_wrappers.h"
|
|
#include "macros.h"
|
|
#include "natives.h"
|
|
#include <sm_platform.h>
|
|
#include <const.h>
|
|
|
|
|
|
//#define SDKHOOKSDEBUG
|
|
|
|
/**
|
|
* Globals
|
|
*/
|
|
|
|
// Order MUST match SDKHookType enum
|
|
HookTypeData g_HookTypes[SDKHook_MAXHOOKS] =
|
|
{
|
|
// Hook name DT required Supported (always false til later)
|
|
{"EndTouch", "", false},
|
|
{"FireBulletsPost", "", false},
|
|
{"OnTakeDamage", "", false},
|
|
{"OnTakeDamagePost", "", false},
|
|
{"PreThink", "DT_BasePlayer", false},
|
|
{"PostThink", "DT_BasePlayer", false},
|
|
{"SetTransmit", "", false},
|
|
{"Spawn", "", false},
|
|
{"StartTouch", "", false},
|
|
{"Think", "", false},
|
|
{"Touch", "", false},
|
|
{"TraceAttack", "", false},
|
|
{"TraceAttackPost", "", false},
|
|
{"WeaponCanSwitchTo", "DT_BaseCombatCharacter", false},
|
|
{"WeaponCanUse", "DT_BaseCombatCharacter", false},
|
|
{"WeaponDrop", "DT_BaseCombatCharacter", false},
|
|
{"WeaponEquip", "DT_BaseCombatCharacter", false},
|
|
{"WeaponSwitch", "DT_BaseCombatCharacter", false},
|
|
{"ShouldCollide", "", false},
|
|
{"PreThinkPost", "DT_BasePlayer", false},
|
|
{"PostThinkPost", "DT_BasePlayer", false},
|
|
{"ThinkPost", "", false},
|
|
{"EndTouchPost", "", false},
|
|
{"GroundEntChangedPost", "", false},
|
|
{"SpawnPost", "", false},
|
|
{"StartTouchPost", "", false},
|
|
{"TouchPost", "", false},
|
|
{"VPhysicsUpdate", "", false},
|
|
{"VPhysicsUpdatePost", "", false},
|
|
{"WeaponCanSwitchToPost", "DT_BaseCombatCharacter", false},
|
|
{"WeaponCanUsePost", "DT_BaseCombatCharacter", false},
|
|
{"WeaponDropPost", "DT_BaseCombatCharacter", false},
|
|
{"WeaponEquipPost", "DT_BaseCombatCharacter", false},
|
|
{"WeaponSwitchPost", "DT_BaseCombatCharacter", false},
|
|
{"Use", "", false},
|
|
{"UsePost", "", false},
|
|
{"Reload", "DT_BaseCombatWeapon", false},
|
|
{"ReloadPost", "DT_BaseCombatWeapon", false},
|
|
{"GetMaxHealth", "", false},
|
|
};
|
|
|
|
SDKHooks g_Interface;
|
|
SMEXT_LINK(&g_Interface);
|
|
|
|
CGlobalVars *gpGlobals;
|
|
CUtlVector<HookList> g_HookList;
|
|
|
|
CBitVec<NUM_ENT_ENTRIES> m_EntityExists;
|
|
|
|
IBinTools *g_pBinTools = NULL;
|
|
ICvar *icvar = NULL;
|
|
|
|
// global hooks and forwards
|
|
IForward *g_pOnEntityCreated = NULL;
|
|
IForward *g_pOnEntityDestroyed = NULL;
|
|
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
int g_hookOnGetGameDescription = 0;
|
|
IForward *g_pOnGetGameNameDescription = NULL;
|
|
#endif
|
|
|
|
int g_hookOnGetMapEntitiesString = 0;
|
|
int g_hookOnLevelInit = 0;
|
|
IForward *g_pOnLevelInit = NULL;
|
|
|
|
IGameConfig *g_pGameConf = NULL;
|
|
|
|
char g_szMapEntities[2097152];
|
|
|
|
|
|
/**
|
|
* IServerGameDLL & IVEngineServer Hooks
|
|
*/
|
|
SH_DECL_HOOK6(IServerGameDLL, LevelInit, SH_NOATTRIB, 0, bool, const char *, const char *, const char *, const char *, bool, bool);
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
SH_DECL_HOOK0(IServerGameDLL, GetGameDescription, SH_NOATTRIB, 0, const char *);
|
|
#endif
|
|
SH_DECL_HOOK0(IVEngineServer, GetMapEntitiesString, SH_NOATTRIB, 0, const char *);
|
|
|
|
|
|
/**
|
|
* CBaseEntity Hooks
|
|
*/
|
|
SH_DECL_MANUALHOOK1_void(EndTouch, 0, 0, 0, CBaseEntity *);
|
|
SH_DECL_MANUALHOOK1_void(FireBullets, 0, 0, 0, FireBulletsInfo_t const&);
|
|
#ifdef GETMAXHEALTH_IS_VIRTUAL
|
|
SH_DECL_MANUALHOOK0(GetMaxHealth, 0, 0, 0, int);
|
|
#endif
|
|
SH_DECL_MANUALHOOK0_void(GroundEntChanged, 0, 0, 0);
|
|
SH_DECL_MANUALHOOK1(OnTakeDamage, 0, 0, 0, int, CTakeDamageInfoHack &);
|
|
SH_DECL_MANUALHOOK0_void(PreThink, 0, 0, 0);
|
|
SH_DECL_MANUALHOOK0_void(PostThink, 0, 0, 0);
|
|
SH_DECL_MANUALHOOK0(Reload, 0, 0, 0, bool);
|
|
SH_DECL_MANUALHOOK2_void(SetTransmit, 0, 0, 0, CCheckTransmitInfo *, bool);
|
|
SH_DECL_MANUALHOOK2(ShouldCollide, 0, 0, 0, bool, int, int);
|
|
SH_DECL_MANUALHOOK0_void(Spawn, 0, 0, 0);
|
|
SH_DECL_MANUALHOOK1_void(StartTouch, 0, 0, 0, CBaseEntity *);
|
|
SH_DECL_MANUALHOOK0_void(Think, 0, 0, 0);
|
|
SH_DECL_MANUALHOOK1_void(Touch, 0, 0, 0, CBaseEntity *);
|
|
#if SOURCE_ENGINE == SE_ORANGEBOXVALVE || SOURCE_ENGINE == SE_CSS
|
|
SH_DECL_MANUALHOOK4_void(TraceAttack, 0, 0, 0, CTakeDamageInfoHack &, const Vector &, CGameTrace *, void *);
|
|
#else
|
|
SH_DECL_MANUALHOOK3_void(TraceAttack, 0, 0, 0, CTakeDamageInfoHack &, const Vector &, CGameTrace *);
|
|
#endif
|
|
SH_DECL_MANUALHOOK4_void(Use, 0, 0, 0, CBaseEntity *, CBaseEntity *, USE_TYPE, float);
|
|
SH_DECL_MANUALHOOK1_void(VPhysicsUpdate, 0, 0, 0, IPhysicsObject *);
|
|
SH_DECL_MANUALHOOK1(Weapon_CanSwitchTo, 0, 0, 0, bool, CBaseCombatWeapon *);
|
|
SH_DECL_MANUALHOOK1(Weapon_CanUse, 0, 0, 0, bool, CBaseCombatWeapon *);
|
|
SH_DECL_MANUALHOOK3_void(Weapon_Drop, 0, 0, 0, CBaseCombatWeapon *, const Vector *, const Vector *);
|
|
SH_DECL_MANUALHOOK1_void(Weapon_Equip, 0, 0, 0, CBaseCombatWeapon *);
|
|
SH_DECL_MANUALHOOK2(Weapon_Switch, 0, 0, 0, bool, CBaseCombatWeapon *, int);
|
|
|
|
|
|
/**
|
|
* Forwards
|
|
*/
|
|
bool SDKHooks::SDK_OnLoad(char *error, size_t maxlength, bool late)
|
|
{
|
|
char buffer[256];
|
|
g_pSM->BuildPath(Path_SM, buffer, sizeof(buffer)-1, "/extensions/sdkhooks.ext." PLATFORM_LIB_EXT);
|
|
if (libsys->PathExists(buffer) && libsys->IsPathFile(buffer))
|
|
{
|
|
g_pSM->Format(error, maxlength-1, "SDKHooks 2.x cannot load while old version (sdkhooks.ext." PLATFORM_LIB_EXT ") is still in extensions dir");
|
|
return false;
|
|
}
|
|
|
|
g_pSM->BuildPath(Path_SM, buffer, sizeof(buffer)-1, "/gamedata/sdkhooks.games.txt");
|
|
if (libsys->PathExists(buffer) && libsys->IsPathFile(buffer))
|
|
{
|
|
g_pSM->Format(error, maxlength-1, "SDKHooks 2.x cannot load while old gamedata file (sdkhooks.games.txt) is still in gamedata dir");
|
|
return false;
|
|
}
|
|
|
|
sharesys->AddDependency(myself, "bintools.ext", true, true);
|
|
sharesys->AddNatives(myself, g_Natives);
|
|
sharesys->RegisterLibrary(myself, "sdkhooks");
|
|
sharesys->AddCapabilityProvider(myself, this, "SDKHook_DmgCustomInOTD");
|
|
sharesys->AddCapabilityProvider(myself, this, "SDKHook_LogicalEntSupport");
|
|
|
|
playerhelpers->AddClientListener(&g_Interface);
|
|
|
|
plsys->AddPluginsListener(&g_Interface);
|
|
|
|
g_pOnEntityCreated = forwards->CreateForward("OnEntityCreated", ET_Ignore, 2, NULL, Param_Cell, Param_String);
|
|
g_pOnEntityDestroyed = forwards->CreateForward("OnEntityDestroyed", ET_Ignore, 1, NULL, Param_Cell);
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
g_pOnGetGameNameDescription = forwards->CreateForward("OnGetGameDescription", ET_Hook, 2, NULL, Param_String);
|
|
#endif
|
|
g_pOnLevelInit = forwards->CreateForward("OnLevelInit", ET_Hook, 2, NULL, Param_String, Param_String);
|
|
|
|
buffer[0] = '\0';
|
|
if (!gameconfs->LoadGameConfigFile("sdkhooks.games", &g_pGameConf, buffer, sizeof(buffer)))
|
|
{
|
|
if (buffer[0])
|
|
{
|
|
g_pSM->Format(error, maxlength, "Could not read sdkhooks.games gamedata: %s", buffer);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void *gEntList = gamehelpers->GetGlobalEntityList();
|
|
if (!gEntList)
|
|
{
|
|
g_pSM->Format(error, maxlength, "Cannot find gEntList pointer");
|
|
return false;
|
|
}
|
|
|
|
int offset = -1; /* 65572 */
|
|
if (!g_pGameConf->GetOffset("EntityListeners", &offset))
|
|
{
|
|
g_pSM->Format(error, maxlength, "Cannot find EntityListeners offset");
|
|
return false;
|
|
}
|
|
|
|
CUtlVector<IEntityListener *> *pListeners = (CUtlVector<IEntityListener *> *)((intptr_t)gEntList + offset);
|
|
pListeners->AddToTail(this);
|
|
|
|
SetupHooks();
|
|
|
|
#if SOURCE_ENGINE >= SE_ORANGEBOX
|
|
int index;
|
|
CBaseHandle hndl;
|
|
for (IHandleEntity *pEnt = (IHandleEntity *)servertools->FirstEntity(); pEnt; pEnt = (IHandleEntity *)servertools->NextEntity((CBaseEntity *)pEnt))
|
|
{
|
|
hndl = pEnt->GetRefEHandle();
|
|
if (hndl == INVALID_EHANDLE_INDEX || !hndl.IsValid())
|
|
continue;
|
|
|
|
index = hndl.GetEntryIndex();
|
|
m_EntityExists.Set(index);
|
|
}
|
|
#else
|
|
for (int i = 0; i < NUM_ENT_ENTRIES; i++)
|
|
{
|
|
if (gamehelpers->ReferenceToEntity(i) != NULL)
|
|
m_EntityExists.Set(i);
|
|
}
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
inline void HookLevelInit()
|
|
{
|
|
assert(g_hookOnLevelInit == 0);
|
|
g_hookOnLevelInit = SH_ADD_HOOK_MEMFUNC(IServerGameDLL, LevelInit, gamedll, &g_Interface, &SDKHooks::Hook_LevelInit, false);
|
|
assert(g_hookOnGetMapEntitiesString == 0);
|
|
g_hookOnGetMapEntitiesString = SH_ADD_HOOK_MEMFUNC(IVEngineServer, GetMapEntitiesString, engine, &g_Interface, &SDKHooks::Hook_GetMapEntitiesString, false);
|
|
}
|
|
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
inline void HookGetGameDescription()
|
|
{
|
|
assert(g_hookOnGetGameDescription == 0);
|
|
g_hookOnGetGameDescription = SH_ADD_HOOK_MEMFUNC(IServerGameDLL, GetGameDescription, gamedll, &g_Interface, &SDKHooks::Hook_GetGameDescription, false);
|
|
}
|
|
#endif
|
|
|
|
void SDKHooks::SDK_OnAllLoaded()
|
|
{
|
|
SM_GET_LATE_IFACE(BINTOOLS, g_pBinTools);
|
|
|
|
if (!g_pBinTools)
|
|
{
|
|
g_pSM->LogError(myself, "Could not find interface: " SMINTERFACE_BINTOOLS_NAME);
|
|
return;
|
|
}
|
|
|
|
if (g_pOnLevelInit->GetFunctionCount() > 0)
|
|
HookLevelInit();
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
if (g_pOnGetGameNameDescription->GetFunctionCount() > 0)
|
|
HookGetGameDescription();
|
|
#endif
|
|
}
|
|
|
|
#define KILL_HOOK_IF_ACTIVE(hook) \
|
|
if (hook != 0) \
|
|
{ \
|
|
SH_REMOVE_HOOK_ID(hook); \
|
|
}
|
|
|
|
void SDKHooks::SDK_OnUnload()
|
|
{
|
|
// Remove left over hooks
|
|
HOOKLOOP
|
|
Unhook(i);
|
|
|
|
KILL_HOOK_IF_ACTIVE(g_hookOnLevelInit);
|
|
KILL_HOOK_IF_ACTIVE(g_hookOnGetMapEntitiesString);
|
|
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
KILL_HOOK_IF_ACTIVE(g_hookOnGetGameDescription);
|
|
#endif
|
|
|
|
forwards->ReleaseForward(g_pOnEntityCreated);
|
|
forwards->ReleaseForward(g_pOnEntityDestroyed);
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
forwards->ReleaseForward(g_pOnGetGameNameDescription);
|
|
#endif
|
|
forwards->ReleaseForward(g_pOnLevelInit);
|
|
|
|
plsys->RemovePluginsListener(&g_Interface);
|
|
|
|
playerhelpers->RemoveClientListener(&g_Interface);
|
|
|
|
sharesys->DropCapabilityProvider(myself, this, "SDKHook_DmgCustomInOTD");
|
|
sharesys->DropCapabilityProvider(myself, this, "SDKHook_LogicalEntSupport");
|
|
|
|
void *gEntList = gamehelpers->GetGlobalEntityList();
|
|
if (gEntList)
|
|
{
|
|
int offset = -1; /* 65572 */
|
|
if (g_pGameConf->GetOffset("EntityListeners", &offset))
|
|
{
|
|
CUtlVector<IEntityListener *> *pListeners = (CUtlVector<IEntityListener *> *)((intptr_t)gEntList + offset);
|
|
pListeners->FindAndRemove(this);
|
|
}
|
|
}
|
|
|
|
gameconfs->CloseGameConfigFile(g_pGameConf);
|
|
}
|
|
|
|
bool SDKHooks::SDK_OnMetamodLoad(ISmmAPI *ismm, char *error, size_t maxlen, bool late)
|
|
{
|
|
GET_V_IFACE_CURRENT(GetEngineFactory, icvar, ICvar, CVAR_INTERFACE_VERSION);
|
|
|
|
#if SOURCE_ENGINE >= SE_ORANGEBOX
|
|
g_pCVar = icvar;
|
|
#endif
|
|
CONVAR_REGISTER(this);
|
|
|
|
gpGlobals = ismm->GetCGlobals();
|
|
|
|
return true;
|
|
}
|
|
|
|
const char *SDKHooks::GetExtensionVerString()
|
|
{
|
|
return SM_VERSION_STRING;
|
|
}
|
|
|
|
const char *SDKHooks::GetExtensionDateString()
|
|
{
|
|
return SM_BUILD_TIMESTAMP;
|
|
}
|
|
|
|
void SDKHooks::OnPluginLoaded(IPlugin *plugin)
|
|
{
|
|
if (g_pOnLevelInit->GetFunctionCount() > 0 && g_hookOnLevelInit == 0)
|
|
HookLevelInit();
|
|
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
if (g_pOnGetGameNameDescription->GetFunctionCount() > 0 && g_hookOnGetGameDescription == 0)
|
|
HookGetGameDescription();
|
|
#endif
|
|
}
|
|
|
|
void SDKHooks::OnPluginUnloaded(IPlugin *plugin)
|
|
{
|
|
IPluginContext *plugincontext = plugin->GetBaseContext();
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].callback->GetParentContext() == plugincontext)
|
|
Unhook(i);
|
|
}
|
|
|
|
if (g_pOnLevelInit->GetFunctionCount() == 0)
|
|
{
|
|
KILL_HOOK_IF_ACTIVE(g_hookOnLevelInit);
|
|
KILL_HOOK_IF_ACTIVE(g_hookOnGetMapEntitiesString);
|
|
}
|
|
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
if (g_pOnGetGameNameDescription->GetFunctionCount() == 0)
|
|
KILL_HOOK_IF_ACTIVE(g_hookOnGetGameDescription);
|
|
#endif
|
|
}
|
|
|
|
void SDKHooks::OnClientPutInServer(int client)
|
|
{
|
|
g_pOnEntityCreated->PushCell(client);
|
|
|
|
CBaseEntity *pPlayer = gamehelpers->ReferenceToEntity(client);
|
|
|
|
const char * pName = gamehelpers->GetEntityClassname(pPlayer);
|
|
|
|
g_pOnEntityCreated->PushString(pName ? pName : "");
|
|
g_pOnEntityCreated->Execute(NULL);
|
|
|
|
m_EntityExists.Set(client);
|
|
}
|
|
|
|
bool SDKHooks::RegisterConCommandBase(ConCommandBase *pVar)
|
|
{
|
|
/* Always call META_REGCVAR instead of going through the engine. */
|
|
return META_REGCVAR(pVar);
|
|
}
|
|
|
|
FeatureStatus SDKHooks::GetFeatureStatus(FeatureType type, const char *name)
|
|
{
|
|
return FeatureStatus_Available;
|
|
}
|
|
|
|
/**
|
|
* Functions
|
|
*/
|
|
cell_t SDKHooks::Call(int entity, SDKHookType type, int other)
|
|
{
|
|
IPluginFunction *callback = NULL;
|
|
cell_t res, ret = Pl_Continue;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity != entity || g_HookList[i].type != type)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
if(other > -2)
|
|
callback->PushCell(other);
|
|
|
|
callback->Execute(&res);
|
|
if(res > ret)
|
|
ret = res;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
cell_t SDKHooks::Call(CBaseEntity *pEnt, SDKHookType type, int other)
|
|
{
|
|
return Call(gamehelpers->EntityToBCompatRef(pEnt), type, other);
|
|
}
|
|
|
|
cell_t SDKHooks::Call(CBaseEntity *pEnt, SDKHookType type, CBaseEntity *other)
|
|
{
|
|
return Call(gamehelpers->EntityToBCompatRef(pEnt), type, gamehelpers->EntityToBCompatRef(other));
|
|
}
|
|
|
|
void SDKHooks::SetupHooks()
|
|
{
|
|
int offset;
|
|
|
|
// gamedata pre post
|
|
// (pre is not necessarily a prehook, just named without "Post" appeneded)
|
|
|
|
CHECKOFFSET(EndTouch, true, true);
|
|
CHECKOFFSET(FireBullets, false, true);
|
|
CHECKOFFSET(GroundEntChanged, false, true);
|
|
CHECKOFFSET(OnTakeDamage, true, true);
|
|
CHECKOFFSET(PreThink, true, true);
|
|
CHECKOFFSET(PostThink, true, true);
|
|
CHECKOFFSET(Reload, true, true);
|
|
CHECKOFFSET(SetTransmit, true, false);
|
|
CHECKOFFSET(ShouldCollide, true, false);
|
|
CHECKOFFSET(Spawn, true, true);
|
|
CHECKOFFSET(StartTouch, true, true);
|
|
CHECKOFFSET(Think, true, true);
|
|
CHECKOFFSET(Touch, true, true);
|
|
CHECKOFFSET(TraceAttack, true, true);
|
|
CHECKOFFSET(Use, true, true);
|
|
CHECKOFFSET_W(CanSwitchTo, true, true);
|
|
CHECKOFFSET_W(CanUse, true, true);
|
|
CHECKOFFSET_W(Drop, true, true);
|
|
CHECKOFFSET_W(Equip, true, true);
|
|
CHECKOFFSET_W(Switch, true, true);
|
|
CHECKOFFSET(VPhysicsUpdate, true, true);
|
|
|
|
// this one is in a class all its own -_-
|
|
offset = 0;
|
|
g_pGameConf->GetOffset("GroundEntChanged", &offset);
|
|
if (offset > 0)
|
|
{
|
|
SH_MANUALHOOK_RECONFIGURE(GroundEntChanged, offset, 0, 0);
|
|
g_HookTypes[SDKHook_GroundEntChangedPost].supported = true;
|
|
}
|
|
|
|
#ifdef GETMAXHEALTH_IS_VIRTUAL
|
|
CHECKOFFSET(GetMaxHealth, true, false);
|
|
#endif
|
|
}
|
|
|
|
HookReturn SDKHooks::Hook(int entity, SDKHookType type, IPluginFunction *callback)
|
|
{
|
|
if(!g_HookTypes[type].supported)
|
|
return HookRet_NotSupported;
|
|
|
|
CBaseEntity *pEnt = UTIL_GetCBaseEntity(entity);
|
|
if(!pEnt)
|
|
return HookRet_InvalidEntity;
|
|
if(type < 0 || type >= SDKHook_MAXHOOKS)
|
|
return HookRet_InvalidHookType;
|
|
|
|
if (!!strcmp(g_HookTypes[type].dtReq, ""))
|
|
{
|
|
sm_sendprop_info_t spi;
|
|
IServerUnknown *pUnk = (IServerUnknown *)pEnt;
|
|
|
|
IServerNetworkable *pNet = pUnk->GetNetworkable();
|
|
if (pNet && !UTIL_FindDataTable(pNet->GetServerClass()->m_pTable, g_HookTypes[type].dtReq, &spi, 0))
|
|
return HookRet_BadEntForHookType;
|
|
}
|
|
|
|
bool bHooked = false;
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity == entity && g_HookList[i].type == type)
|
|
{
|
|
bHooked = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!bHooked)
|
|
{
|
|
switch(type)
|
|
{
|
|
case SDKHook_EndTouch:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(EndTouch, pEnt, &g_Interface, &SDKHooks::Hook_EndTouch, false);
|
|
break;
|
|
case SDKHook_EndTouchPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(EndTouch, pEnt, &g_Interface, &SDKHooks::Hook_EndTouchPost, true);
|
|
break;
|
|
case SDKHook_FireBulletsPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(FireBullets, pEnt, &g_Interface, &SDKHooks::Hook_FireBulletsPost, true);
|
|
break;
|
|
#ifdef GETMAXHEALTH_IS_VIRTUAL
|
|
case SDKHook_GetMaxHealth:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(GetMaxHealth, pEnt, &g_Interface, &SDKHooks::Hook_GetMaxHealth, false);
|
|
break;
|
|
#endif
|
|
case SDKHook_GroundEntChangedPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(GroundEntChanged, pEnt, &g_Interface, &SDKHooks::Hook_GroundEntChangedPost, true);
|
|
break;
|
|
case SDKHook_OnTakeDamage:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(OnTakeDamage, pEnt, &g_Interface, &SDKHooks::Hook_OnTakeDamage, false);
|
|
break;
|
|
case SDKHook_OnTakeDamagePost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(OnTakeDamage, pEnt, &g_Interface, &SDKHooks::Hook_OnTakeDamagePost, true);
|
|
break;
|
|
case SDKHook_PreThink:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(PreThink, pEnt, &g_Interface, &SDKHooks::Hook_PreThink, false);
|
|
break;
|
|
case SDKHook_PreThinkPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(PreThink, pEnt, &g_Interface, &SDKHooks::Hook_PreThinkPost, true);
|
|
break;
|
|
case SDKHook_PostThink:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(PostThink, pEnt, &g_Interface, &SDKHooks::Hook_PostThink, false);
|
|
break;
|
|
case SDKHook_PostThinkPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(PostThink, pEnt, &g_Interface, &SDKHooks::Hook_PostThinkPost, true);
|
|
break;
|
|
case SDKHook_Reload:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Reload, pEnt, &g_Interface, &SDKHooks::Hook_Reload, false);
|
|
break;
|
|
case SDKHook_ReloadPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Reload, pEnt, &g_Interface, &SDKHooks::Hook_ReloadPost, true);
|
|
break;
|
|
case SDKHook_SetTransmit:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(SetTransmit, pEnt, &g_Interface, &SDKHooks::Hook_SetTransmit, false);
|
|
break;
|
|
case SDKHook_Spawn:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Spawn, pEnt, &g_Interface, &SDKHooks::Hook_Spawn, false);
|
|
break;
|
|
case SDKHook_SpawnPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Spawn, pEnt, &g_Interface, &SDKHooks::Hook_SpawnPost, true);
|
|
break;
|
|
case SDKHook_StartTouch:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(StartTouch, pEnt, &g_Interface, &SDKHooks::Hook_StartTouch, false);
|
|
break;
|
|
case SDKHook_StartTouchPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(StartTouch, pEnt, &g_Interface, &SDKHooks::Hook_StartTouchPost, true);
|
|
break;
|
|
case SDKHook_Think:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Think, pEnt, &g_Interface, &SDKHooks::Hook_Think, false);
|
|
break;
|
|
case SDKHook_ThinkPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Think, pEnt, &g_Interface, &SDKHooks::Hook_ThinkPost, true);
|
|
break;
|
|
case SDKHook_Touch:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Touch, pEnt, &g_Interface, &SDKHooks::Hook_Touch, false);
|
|
break;
|
|
case SDKHook_TouchPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Touch, pEnt, &g_Interface, &SDKHooks::Hook_TouchPost, true);
|
|
break;
|
|
case SDKHook_TraceAttack:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(TraceAttack, pEnt, &g_Interface, &SDKHooks::Hook_TraceAttack, false);
|
|
break;
|
|
case SDKHook_TraceAttackPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(TraceAttack, pEnt, &g_Interface, &SDKHooks::Hook_TraceAttackPost, true);
|
|
break;
|
|
case SDKHook_Use:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Use, pEnt, &g_Interface, &SDKHooks::Hook_Use, false);
|
|
break;
|
|
case SDKHook_UsePost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Use, pEnt, &g_Interface, &SDKHooks::Hook_UsePost, true);
|
|
break;
|
|
case SDKHook_VPhysicsUpdate:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(VPhysicsUpdate, pEnt, &g_Interface, &SDKHooks::Hook_VPhysicsUpdate, false);
|
|
break;
|
|
case SDKHook_VPhysicsUpdatePost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(VPhysicsUpdate, pEnt, &g_Interface, &SDKHooks::Hook_VPhysicsUpdatePost, true);
|
|
break;
|
|
case SDKHook_WeaponCanSwitchTo:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_CanSwitchTo, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanSwitchTo, false);
|
|
break;
|
|
case SDKHook_WeaponCanSwitchToPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_CanSwitchTo, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanSwitchToPost, true);
|
|
break;
|
|
case SDKHook_WeaponCanUse:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_CanUse, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanUse, false);
|
|
break;
|
|
case SDKHook_WeaponCanUsePost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_CanUse, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanUsePost, true);
|
|
break;
|
|
case SDKHook_WeaponDrop:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_Drop, pEnt, &g_Interface, &SDKHooks::Hook_WeaponDrop, false);
|
|
break;
|
|
case SDKHook_WeaponDropPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_Drop, pEnt, &g_Interface, &SDKHooks::Hook_WeaponDropPost, true);
|
|
break;
|
|
case SDKHook_WeaponEquip:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_Equip, pEnt, &g_Interface, &SDKHooks::Hook_WeaponEquip, false);
|
|
break;
|
|
case SDKHook_WeaponEquipPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_Equip, pEnt, &g_Interface, &SDKHooks::Hook_WeaponEquipPost, true);
|
|
break;
|
|
case SDKHook_WeaponSwitch:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_Switch, pEnt, &g_Interface, &SDKHooks::Hook_WeaponSwitch, false);
|
|
break;
|
|
case SDKHook_WeaponSwitchPost:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(Weapon_Switch, pEnt, &g_Interface, &SDKHooks::Hook_WeaponSwitchPost, true);
|
|
break;
|
|
case SDKHook_ShouldCollide:
|
|
SH_ADD_MANUALHOOK_MEMFUNC(ShouldCollide, pEnt, &g_Interface, &SDKHooks::Hook_ShouldCollide, false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Add hook to hook list
|
|
HookList hook;
|
|
hook.entity = entity;
|
|
hook.type = type;
|
|
hook.callback = callback;
|
|
g_HookList.AddToTail(hook);
|
|
#ifdef SDKHOOKSDEBUG
|
|
META_CONPRINTF("DEBUG: Adding to hooklist (ent%d, type%s, cb%d). Total hook count %d\n", entity, g_szHookNames[type], callback, g_HookList.Count());
|
|
#endif
|
|
return HookRet_Successful;
|
|
}
|
|
|
|
void SDKHooks::Unhook(int index)
|
|
{
|
|
CBaseEntity *pEnt = gamehelpers->ReferenceToEntity(g_HookList[index].entity);
|
|
if(!pEnt)
|
|
return;
|
|
|
|
int iHooks = 0;
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity == g_HookList[index].entity && g_HookList[i].type == g_HookList[index].type)
|
|
{
|
|
iHooks++;
|
|
#ifdef SDKHOOKSDEBUG
|
|
META_CONPRINTF("DEBUG: Found hook %d on entity %d\n", i, g_HookList[index].entity);
|
|
#endif
|
|
}
|
|
}
|
|
if (iHooks == 1)
|
|
{
|
|
#ifdef SDKHOOKSDEBUG
|
|
META_CONPRINTF("DEBUG: Removing hook for hooktype %d\n", g_HookList[index].type);
|
|
#endif
|
|
switch(g_HookList[index].type)
|
|
{
|
|
case SDKHook_EndTouch:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(EndTouch, pEnt, &g_Interface, &SDKHooks::Hook_EndTouch, false);
|
|
break;
|
|
case SDKHook_EndTouchPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(EndTouch, pEnt, &g_Interface, &SDKHooks::Hook_EndTouchPost, true);
|
|
break;
|
|
case SDKHook_FireBulletsPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(FireBullets, pEnt, &g_Interface, &SDKHooks::Hook_FireBulletsPost, true);
|
|
break;
|
|
#ifdef GETMAXHEALTH_IS_VIRTUAL
|
|
case SDKHook_GetMaxHealth:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(GetMaxHealth, pEnt, &g_Interface, &SDKHooks::Hook_GetMaxHealth, false);
|
|
break;
|
|
#endif
|
|
case SDKHook_GroundEntChangedPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(GroundEntChanged, pEnt, &g_Interface, &SDKHooks::Hook_GroundEntChangedPost, true);
|
|
break;
|
|
case SDKHook_OnTakeDamage:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(OnTakeDamage, pEnt, &g_Interface, &SDKHooks::Hook_OnTakeDamage, false);
|
|
break;
|
|
case SDKHook_OnTakeDamagePost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(OnTakeDamage, pEnt, &g_Interface, &SDKHooks::Hook_OnTakeDamagePost, true);
|
|
break;
|
|
case SDKHook_PreThink:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(PreThink, pEnt, &g_Interface, &SDKHooks::Hook_PreThink, false);
|
|
break;
|
|
case SDKHook_PreThinkPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(PreThink, pEnt, &g_Interface, &SDKHooks::Hook_PreThinkPost, true);
|
|
break;
|
|
case SDKHook_PostThink:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(PostThink, pEnt, &g_Interface, &SDKHooks::Hook_PostThink, false);
|
|
break;
|
|
case SDKHook_PostThinkPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(PostThink, pEnt, &g_Interface, &SDKHooks::Hook_PostThinkPost, true);
|
|
break;
|
|
case SDKHook_Reload:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Reload, pEnt, &g_Interface, &SDKHooks::Hook_Reload, false);
|
|
break;
|
|
case SDKHook_ReloadPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Reload, pEnt, &g_Interface, &SDKHooks::Hook_ReloadPost, true);
|
|
break;
|
|
case SDKHook_SetTransmit:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(SetTransmit, pEnt, &g_Interface, &SDKHooks::Hook_SetTransmit, false);
|
|
break;
|
|
case SDKHook_Spawn:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Spawn, pEnt, &g_Interface, &SDKHooks::Hook_Spawn, false);
|
|
break;
|
|
case SDKHook_SpawnPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Spawn, pEnt, &g_Interface, &SDKHooks::Hook_SpawnPost, true);
|
|
break;
|
|
case SDKHook_StartTouch:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(StartTouch, pEnt, &g_Interface, &SDKHooks::Hook_StartTouch, false);
|
|
break;
|
|
case SDKHook_StartTouchPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(StartTouch, pEnt, &g_Interface, &SDKHooks::Hook_StartTouchPost, true);
|
|
break;
|
|
case SDKHook_Think:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Think, pEnt, &g_Interface, &SDKHooks::Hook_Think, false);
|
|
break;
|
|
case SDKHook_ThinkPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Think, pEnt, &g_Interface, &SDKHooks::Hook_ThinkPost, true);
|
|
break;
|
|
case SDKHook_Touch:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Touch, pEnt, &g_Interface, &SDKHooks::Hook_Touch, false);
|
|
break;
|
|
case SDKHook_TouchPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Touch, pEnt, &g_Interface, &SDKHooks::Hook_TouchPost, true);
|
|
break;
|
|
case SDKHook_TraceAttack:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(TraceAttack, pEnt, &g_Interface, &SDKHooks::Hook_TraceAttack, false);
|
|
break;
|
|
case SDKHook_TraceAttackPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(TraceAttack, pEnt, &g_Interface, &SDKHooks::Hook_TraceAttackPost, true);
|
|
break;
|
|
case SDKHook_Use:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Use, pEnt, &g_Interface, &SDKHooks::Hook_Use, false);
|
|
break;
|
|
case SDKHook_UsePost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Use, pEnt, &g_Interface, &SDKHooks::Hook_UsePost, true);
|
|
break;
|
|
case SDKHook_VPhysicsUpdate:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(VPhysicsUpdate, pEnt, &g_Interface, &SDKHooks::Hook_VPhysicsUpdate, false);
|
|
break;
|
|
case SDKHook_VPhysicsUpdatePost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(VPhysicsUpdate, pEnt, &g_Interface, &SDKHooks::Hook_VPhysicsUpdatePost, true);
|
|
break;
|
|
case SDKHook_WeaponCanSwitchTo:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_CanSwitchTo, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanSwitchTo, false);
|
|
break;
|
|
case SDKHook_WeaponCanSwitchToPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_CanSwitchTo, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanSwitchToPost, true);
|
|
break;
|
|
case SDKHook_WeaponCanUse:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_CanUse, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanUse, false);
|
|
break;
|
|
case SDKHook_WeaponCanUsePost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_CanUse, pEnt, &g_Interface, &SDKHooks::Hook_WeaponCanUsePost, true);
|
|
break;
|
|
case SDKHook_WeaponDrop:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_Drop, pEnt, &g_Interface, &SDKHooks::Hook_WeaponDrop, false);
|
|
break;
|
|
case SDKHook_WeaponDropPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_Drop, pEnt, &g_Interface, &SDKHooks::Hook_WeaponDropPost, true);
|
|
break;
|
|
case SDKHook_WeaponEquip:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_Equip, pEnt, &g_Interface, &SDKHooks::Hook_WeaponEquip, false);
|
|
break;
|
|
case SDKHook_WeaponEquipPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_Equip, pEnt, &g_Interface, &SDKHooks::Hook_WeaponEquipPost, true);
|
|
break;
|
|
case SDKHook_WeaponSwitch:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_Switch, pEnt, &g_Interface, &SDKHooks::Hook_WeaponSwitch, false);
|
|
break;
|
|
case SDKHook_WeaponSwitchPost:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(Weapon_Switch, pEnt, &g_Interface, &SDKHooks::Hook_WeaponSwitchPost, true);
|
|
break;
|
|
case SDKHook_ShouldCollide:
|
|
SH_REMOVE_MANUALHOOK_MEMFUNC(ShouldCollide, pEnt, &g_Interface, &SDKHooks::Hook_ShouldCollide, false);
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
g_HookList.Remove(index);
|
|
}
|
|
|
|
|
|
/**
|
|
* IEntityFactoryDictionary, IServerGameDLL & IVEngineServer Hook Handlers
|
|
*/
|
|
void SDKHooks::OnEntityCreated(CBaseEntity *pEntity)
|
|
{
|
|
// Call OnEntityCreated forward
|
|
int entity = gamehelpers->ReferenceToIndex(gamehelpers->EntityToBCompatRef(pEntity));
|
|
if (m_EntityExists.IsBitSet(entity) || (entity > 0 && entity <= playerhelpers->GetMaxClients()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
g_pOnEntityCreated->PushCell(gamehelpers->EntityToBCompatRef(pEntity));
|
|
|
|
const char * pName = gamehelpers->GetEntityClassname(pEntity);
|
|
g_pOnEntityCreated->PushString(pName ? pName : "");
|
|
|
|
g_pOnEntityCreated->Execute(NULL);
|
|
|
|
m_EntityExists.Set(entity);
|
|
}
|
|
|
|
#ifdef GAMEDESC_CAN_CHANGE
|
|
const char *SDKHooks::Hook_GetGameDescription()
|
|
{
|
|
static char szGameDesc[64];
|
|
cell_t result = Pl_Continue;
|
|
|
|
g_pSM->Format(szGameDesc, sizeof(szGameDesc), "%s",
|
|
SH_CALL(gamedll, &IServerGameDLL::GetGameDescription)());
|
|
|
|
// Call OnGetGameDescription forward
|
|
g_pOnGetGameNameDescription->PushStringEx(szGameDesc, sizeof(szGameDesc), SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);
|
|
g_pOnGetGameNameDescription->Execute(&result);
|
|
|
|
if(result == Pl_Changed)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, szGameDesc);
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, NULL);
|
|
}
|
|
#endif
|
|
|
|
const char *SDKHooks::Hook_GetMapEntitiesString()
|
|
{
|
|
if(g_szMapEntities[0])
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, g_szMapEntities);
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, NULL);
|
|
}
|
|
|
|
bool SDKHooks::Hook_LevelInit(char const *pMapName, char const *pMapEntities, char const *pOldLevel, char const *pLandmarkName, bool loadGame, bool background)
|
|
{
|
|
strcpy(g_szMapEntities, pMapEntities);
|
|
cell_t result = Pl_Continue;
|
|
|
|
// Call OnLevelInit forward
|
|
g_pOnLevelInit->PushString(pMapName);
|
|
g_pOnLevelInit->PushStringEx(g_szMapEntities, sizeof(g_szMapEntities), SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);
|
|
g_pOnLevelInit->Execute(&result);
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, false);
|
|
|
|
if(result == Pl_Changed)
|
|
RETURN_META_VALUE_NEWPARAMS(MRES_HANDLED, true, &IServerGameDLL::LevelInit, (pMapName, g_szMapEntities, pOldLevel, pLandmarkName, loadGame, background));
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
|
|
/**
|
|
* CBaseEntity Hook Handlers
|
|
*/
|
|
void SDKHooks::Hook_EndTouch(CBaseEntity *pOther)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_EndTouch, pOther);
|
|
if(result >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_EndTouchPost(CBaseEntity *pOther)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_EndTouchPost, pOther);
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_FireBulletsPost(const FireBulletsInfo_t &info)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
|
|
IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(entity);
|
|
if(!pPlayer)
|
|
RETURN_META(MRES_IGNORED);
|
|
|
|
IPlayerInfo *pInfo = pPlayer->GetPlayerInfo();
|
|
if(!pInfo)
|
|
RETURN_META(MRES_IGNORED);
|
|
|
|
const char *weapon = pInfo->GetWeaponName();
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_FireBulletsPost)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCell(info.m_iShots);
|
|
callback->PushString(weapon?weapon:"");
|
|
callback->Execute(NULL);
|
|
}
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
#ifdef GETMAXHEALTH_IS_VIRTUAL
|
|
int SDKHooks::Hook_GetMaxHealth()
|
|
{
|
|
CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
|
|
int original_max = SH_MCALL(pEntity, GetMaxHealth)();
|
|
int entity = gamehelpers->EntityToBCompatRef(pEntity);
|
|
|
|
int new_max = original_max;
|
|
|
|
cell_t res;
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_GetMaxHealth)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCellByRef(&new_max);
|
|
callback->Execute(&res);
|
|
}
|
|
|
|
if (res >= Pl_Changed)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, new_max);
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, original_max);
|
|
}
|
|
#endif
|
|
|
|
void SDKHooks::Hook_GroundEntChangedPost()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_GroundEntChangedPost);
|
|
}
|
|
|
|
int SDKHooks::Hook_OnTakeDamage(CTakeDamageInfoHack &info)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
int attacker = info.GetAttacker();
|
|
int inflictor = info.GetInflictor();
|
|
float damage = info.GetDamage();
|
|
int damagetype = info.GetDamageType();
|
|
int weapon = info.GetWeapon();
|
|
|
|
Vector force = info.GetDamageForce();
|
|
cell_t damageForce[3] = {sp_ftoc(force.x), sp_ftoc(force.y), sp_ftoc(force.z)};
|
|
|
|
Vector pos = info.GetDamagePosition();
|
|
cell_t damagePosition[3] = {sp_ftoc(pos.x), sp_ftoc(pos.y), sp_ftoc(pos.z)};
|
|
|
|
IPluginFunction *callback = NULL;
|
|
cell_t res, ret = Pl_Continue;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_OnTakeDamage)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCellByRef(&attacker);
|
|
callback->PushCellByRef(&inflictor);
|
|
callback->PushFloatByRef(&damage);
|
|
callback->PushCellByRef(&damagetype);
|
|
callback->PushCellByRef(&weapon);
|
|
callback->PushArray(damageForce, 3, SM_PARAM_COPYBACK);
|
|
callback->PushArray(damagePosition, 3, SM_PARAM_COPYBACK);
|
|
callback->PushCell(info.GetDamageCustom());
|
|
callback->Execute(&res);
|
|
|
|
if(res > ret)
|
|
ret = res;
|
|
}
|
|
|
|
if(ret >= Pl_Handled)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, 1);
|
|
|
|
if(ret == Pl_Changed)
|
|
{
|
|
CBaseEntity *pEntAttacker = gamehelpers->ReferenceToEntity(attacker);
|
|
if(!pEntAttacker)
|
|
{
|
|
callback->GetParentContext()->ThrowNativeError("Entity %d for attacker is invalid", attacker);
|
|
RETURN_META_VALUE(MRES_IGNORED, 0);
|
|
}
|
|
CBaseEntity *pEntInflictor = gamehelpers->ReferenceToEntity(inflictor);
|
|
if(!pEntInflictor)
|
|
{
|
|
callback->GetParentContext()->ThrowNativeError("Entity %d for inflictor is invalid", inflictor);
|
|
RETURN_META_VALUE(MRES_IGNORED, 0);
|
|
}
|
|
|
|
info.SetAttacker(pEntAttacker);
|
|
info.SetInflictor(pEntInflictor);
|
|
info.SetDamage(damage);
|
|
info.SetDamageType(damagetype);
|
|
info.SetWeapon(gamehelpers->ReferenceToEntity(weapon));
|
|
info.SetDamageForce(
|
|
sp_ctof(damageForce[0]),
|
|
sp_ctof(damageForce[1]),
|
|
sp_ctof(damageForce[2]));
|
|
info.SetDamagePosition(
|
|
sp_ctof(damagePosition[0]),
|
|
sp_ctof(damagePosition[1]),
|
|
sp_ctof(damagePosition[2]));
|
|
|
|
RETURN_META_VALUE(MRES_HANDLED, 1);
|
|
}
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, 0);
|
|
}
|
|
|
|
int SDKHooks::Hook_OnTakeDamagePost(CTakeDamageInfoHack &info)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_OnTakeDamagePost)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCell(info.GetAttacker());
|
|
callback->PushCell(info.GetInflictor());
|
|
callback->PushFloat(info.GetDamage());
|
|
callback->PushCell(info.GetDamageType());
|
|
callback->PushCell(info.GetWeapon());
|
|
|
|
Vector force = info.GetDamageForce();
|
|
cell_t damageForce[3] = {sp_ftoc(force.x), sp_ftoc(force.y), sp_ftoc(force.z)};
|
|
callback->PushArray(damageForce, 3);
|
|
|
|
Vector pos = info.GetDamagePosition();
|
|
cell_t damagePosition[3] = {sp_ftoc(pos.x), sp_ftoc(pos.y), sp_ftoc(pos.z)};
|
|
callback->PushArray(damagePosition, 3);
|
|
|
|
callback->PushCell(info.GetDamageCustom());
|
|
|
|
callback->Execute(NULL);
|
|
}
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, 0);
|
|
}
|
|
|
|
void SDKHooks::Hook_PreThink()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_PreThink);
|
|
}
|
|
|
|
void SDKHooks::Hook_PreThinkPost()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_PreThinkPost);
|
|
}
|
|
|
|
void SDKHooks::Hook_PostThink()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_PostThink);
|
|
}
|
|
|
|
void SDKHooks::Hook_PostThinkPost()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_PostThinkPost);
|
|
}
|
|
|
|
bool SDKHooks::Hook_Reload()
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
cell_t res;
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_Reload)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->Execute(&res);
|
|
}
|
|
|
|
if (res >= Pl_Handled)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, false);
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
bool SDKHooks::Hook_ReloadPost()
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_ReloadPost)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCell(META_RESULT_OVERRIDE_RET(bool) ? 1 : 0);
|
|
callback->Execute(NULL);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void SDKHooks::Hook_SetTransmit(CCheckTransmitInfo *pInfo, bool bAlways)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_SetTransmit, gamehelpers->IndexOfEdict(pInfo->m_pClientEnt));
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
bool SDKHooks::Hook_ShouldCollide(int collisionGroup, int contentsMask)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
IPluginFunction *callback = NULL;
|
|
bool origRet = ((META_RESULT_STATUS >= MRES_OVERRIDE)?(META_RESULT_OVERRIDE_RET(bool)):(META_RESULT_ORIG_RET(bool)));
|
|
cell_t res;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_ShouldCollide)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCell(collisionGroup);
|
|
callback->PushCell(contentsMask);
|
|
callback->PushCell(origRet ? 1 : 0);
|
|
callback->Execute(&res);
|
|
}
|
|
|
|
bool ret = false;
|
|
if (res != 0)
|
|
{
|
|
ret = true;
|
|
}
|
|
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, ret);
|
|
}
|
|
|
|
void SDKHooks::Hook_Spawn()
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
IPluginFunction *callback = NULL;
|
|
cell_t res;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_Spawn)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->Execute(&res);
|
|
}
|
|
|
|
if (res >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_SpawnPost()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_SpawnPost);
|
|
}
|
|
|
|
void SDKHooks::Hook_StartTouch(CBaseEntity *pOther)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_StartTouch, pOther);
|
|
if(result >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_StartTouchPost(CBaseEntity *pOther)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_StartTouchPost, pOther);
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_Think()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_Think);
|
|
}
|
|
|
|
void SDKHooks::Hook_ThinkPost()
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_ThinkPost);
|
|
}
|
|
|
|
void SDKHooks::Hook_Touch(CBaseEntity *pOther)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_Touch, pOther);
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_TouchPost(CBaseEntity *pOther)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_TouchPost, pOther);
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
#if SOURCE_ENGINE == SE_ORANGEBOXVALVE || SOURCE_ENGINE == SE_CSS
|
|
void SDKHooks::Hook_TraceAttack(CTakeDamageInfoHack &info, const Vector &vecDir, trace_t *ptr, void *pUnknownJK)
|
|
#else
|
|
void SDKHooks::Hook_TraceAttack(CTakeDamageInfoHack &info, const Vector &vecDir, trace_t *ptr)
|
|
#endif
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
int attacker = info.GetAttacker();
|
|
int inflictor = info.GetInflictor();
|
|
float damage = info.GetDamage();
|
|
int damagetype = info.GetDamageType();
|
|
int ammotype = info.GetAmmoType();
|
|
IPluginFunction *callback = NULL;
|
|
cell_t res, ret = Pl_Continue;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_TraceAttack)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCellByRef(&attacker);
|
|
callback->PushCellByRef(&inflictor);
|
|
callback->PushFloatByRef(&damage);
|
|
callback->PushCellByRef(&damagetype);
|
|
callback->PushCellByRef(&ammotype);
|
|
callback->PushCell(ptr->hitbox);
|
|
callback->PushCell(ptr->hitgroup);
|
|
callback->Execute(&res);
|
|
|
|
if(res > ret)
|
|
ret = res;
|
|
}
|
|
|
|
if(ret >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
if(ret == Pl_Changed)
|
|
{
|
|
CBaseEntity *pEntAttacker = gamehelpers->ReferenceToEntity(attacker);
|
|
if(!pEntAttacker)
|
|
{
|
|
callback->GetParentContext()->ThrowNativeError("Entity %d for attacker is invalid", attacker);
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
CBaseEntity *pEntInflictor = gamehelpers->ReferenceToEntity(inflictor);
|
|
if(!pEntInflictor)
|
|
{
|
|
callback->GetParentContext()->ThrowNativeError("Entity %d for inflictor is invalid", inflictor);
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
info.SetAttacker(gamehelpers->ReferenceToEntity(attacker));
|
|
info.SetInflictor(gamehelpers->ReferenceToEntity(inflictor));
|
|
info.SetDamage(damage);
|
|
info.SetDamageType(damagetype);
|
|
info.SetAmmoType(ammotype);
|
|
|
|
RETURN_META(MRES_HANDLED);
|
|
}
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
#if SOURCE_ENGINE == SE_ORANGEBOXVALVE || SOURCE_ENGINE == SE_CSS
|
|
void SDKHooks::Hook_TraceAttackPost(CTakeDamageInfoHack &info, const Vector &vecDir, trace_t *ptr, void *pUnknownJK)
|
|
#else
|
|
void SDKHooks::Hook_TraceAttackPost(CTakeDamageInfoHack &info, const Vector &vecDir, trace_t *ptr)
|
|
#endif
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_TraceAttackPost)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCell(info.GetAttacker());
|
|
callback->PushCell(info.GetInflictor());
|
|
callback->PushFloat(info.GetDamage());
|
|
callback->PushCell(info.GetDamageType());
|
|
callback->PushCell(info.GetAmmoType());
|
|
callback->PushCell(ptr->hitbox);
|
|
callback->PushCell(ptr->hitgroup);
|
|
callback->Execute(NULL);
|
|
}
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
int activator = gamehelpers->EntityToBCompatRef(pActivator);
|
|
int caller = gamehelpers->EntityToBCompatRef(pCaller);
|
|
|
|
cell_t ret;
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_Use)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCell(activator);
|
|
callback->PushCell(caller);
|
|
callback->PushCell(useType);
|
|
callback->PushFloat(value);
|
|
callback->Execute(&ret);
|
|
}
|
|
|
|
if (ret >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_UsePost(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(META_IFACEPTR(CBaseEntity));
|
|
int activator = gamehelpers->EntityToBCompatRef(pActivator);
|
|
int caller = gamehelpers->EntityToBCompatRef(pCaller);
|
|
|
|
IPluginFunction *callback = NULL;
|
|
|
|
HOOKLOOP
|
|
{
|
|
if (g_HookList[i].entity != entity || g_HookList[i].type != SDKHook_UsePost)
|
|
continue;
|
|
|
|
callback = g_HookList[i].callback;
|
|
callback->PushCell(entity);
|
|
callback->PushCell(activator);
|
|
callback->PushCell(caller);
|
|
callback->PushCell(useType);
|
|
callback->PushFloat(value);
|
|
callback->Execute(NULL);
|
|
}
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::OnEntityDeleted(CBaseEntity *pEntity)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(pEntity);
|
|
|
|
// Call OnEntityDestroyed forward
|
|
g_pOnEntityDestroyed->PushCell(entity);
|
|
g_pOnEntityDestroyed->Execute(NULL);
|
|
|
|
SDKHooks::RemoveEntityHooks(pEntity);
|
|
|
|
m_EntityExists.Set(gamehelpers->ReferenceToIndex(entity), false);
|
|
}
|
|
|
|
void SDKHooks::Hook_VPhysicsUpdate(IPhysicsObject *pPhysics)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_VPhysicsUpdate);
|
|
}
|
|
|
|
void SDKHooks::Hook_VPhysicsUpdatePost(IPhysicsObject *pPhysics)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_VPhysicsUpdatePost);
|
|
}
|
|
|
|
bool SDKHooks::Hook_WeaponCanSwitchTo(CBaseCombatWeapon *pWeapon)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponCanSwitchTo, pWeapon);
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, false);
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
bool SDKHooks::Hook_WeaponCanSwitchToPost(CBaseCombatWeapon *pWeapon)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponCanSwitchToPost, pWeapon);
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
bool SDKHooks::Hook_WeaponCanUse(CBaseCombatWeapon *pWeapon)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponCanUse, pWeapon);
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, false);
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
bool SDKHooks::Hook_WeaponCanUsePost(CBaseCombatWeapon *pWeapon)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponCanUsePost, pWeapon);
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
void SDKHooks::Hook_WeaponDrop(CBaseCombatWeapon *pWeapon, const Vector *pvecTarget, const Vector *pVelocity)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponDrop, pWeapon);
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_WeaponDropPost(CBaseCombatWeapon *pWeapon, const Vector *pvecTarget, const Vector *pVelocity)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponDropPost, pWeapon);
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_WeaponEquip(CBaseCombatWeapon *pWeapon)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponEquip, pWeapon);
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META(MRES_SUPERCEDE);
|
|
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
void SDKHooks::Hook_WeaponEquipPost(CBaseCombatWeapon *pWeapon)
|
|
{
|
|
Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponEquipPost, pWeapon);
|
|
RETURN_META(MRES_IGNORED);
|
|
}
|
|
|
|
bool SDKHooks::Hook_WeaponSwitch(CBaseCombatWeapon *pWeapon, int viewmodelindex)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponSwitch, pWeapon);
|
|
|
|
if(result >= Pl_Handled)
|
|
RETURN_META_VALUE(MRES_SUPERCEDE, false);
|
|
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
bool SDKHooks::Hook_WeaponSwitchPost(CBaseCombatWeapon *pWeapon, int viewmodelindex)
|
|
{
|
|
cell_t result = Call(META_IFACEPTR(CBaseEntity), SDKHook_WeaponSwitchPost, pWeapon);
|
|
RETURN_META_VALUE(MRES_IGNORED, true);
|
|
}
|
|
|
|
|
|
void SDKHooks::RemoveEntityHooks(CBaseEntity *pEnt)
|
|
{
|
|
int entity = gamehelpers->EntityToBCompatRef(pEnt);
|
|
|
|
// Remove hooks
|
|
HOOKLOOP
|
|
{
|
|
if(g_HookList[i].entity == entity)
|
|
{
|
|
#ifdef SDKHOOKSDEBUG
|
|
META_CONPRINTF("DEBUG: Removing hook #%d on entity %d (UpdateOnRemove or clientdisconnect)\n", i, entity);
|
|
#endif
|
|
Unhook(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
CON_COMMAND(sdkhooks_listhooks, "Lists all current hooks")
|
|
{
|
|
META_CONPRINTF(" %-24.23s %-18.17s %s\n", "Plugin", "Type", "Entity");
|
|
|
|
IPlugin *pPlugin;
|
|
const sm_plugininfo_t *info;
|
|
for(int i = g_HookList.Count() - 1; i >= 0; i--)
|
|
{
|
|
g_HookList[i].callback->GetParentRuntime()->GetDefaultContext()->GetKey(2, (void **)&pPlugin);
|
|
info = pPlugin->GetPublicInfo();
|
|
META_CONPRINTF("%2d. %-24.23s %-18.17s %d\n", i + 1, info->name[0] ? info->name : pPlugin->GetFilename(), g_HookTypes[g_HookList[i].type].name, g_HookList[i].entity);
|
|
}
|
|
}
|