mirror of
https://github.com/alliedmodders/amxmodx.git
synced 2024-12-25 14:25:38 +03:00
3275 lines
133 KiB
C++
3275 lines
133 KiB
C++
/* Ham Sandwich
|
|
*
|
|
* by the AMX Mod X Dev Team
|
|
*
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at
|
|
* your option) any later version.
|
|
*
|
|
* 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, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* In addition, as a special exception, the author gives permission to
|
|
* link the code of this program with the Half-Life Game Engine ("HL
|
|
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
|
|
* L.L.C ("Valve"). You must obey the GNU General Public License in all
|
|
* respects for all of the code used other than the HL Engine and MODs
|
|
* from Valve. If you modify this file, you may extend this exception
|
|
* to your version of the file, but you are not obligated to do so. If
|
|
* you do not wish to do so, delete this exception statement from your
|
|
* version.
|
|
*/
|
|
|
|
|
|
#ifndef VTABLEENTRIES_H
|
|
#define VTABLEENTRIES_H
|
|
|
|
#ifdef _WIN32
|
|
#define HAM_CDECL __cdecl
|
|
#else
|
|
#define HAM_CDECL __attribute__((cdecl))
|
|
#endif
|
|
|
|
#include "CVector.h"
|
|
|
|
class VTableManager;
|
|
|
|
class VTableEntryBase
|
|
{
|
|
public:
|
|
void *function; /**< The pointer to the original function that is being hooked. */
|
|
void **location; /**< The location of the vtable entry that is being hooked. */
|
|
void *trampoline; /**< Our trampoline (needs to be freed when it's not hooking any more!). */
|
|
CVector<int> Forwards; /**< Vector of forwards to call for this hook.*/
|
|
CVector<int> PostForwards; /**< Vector of forwards to call for this post hook.*/
|
|
|
|
/**
|
|
* Saves virtual table location, trampoline and function pointers.
|
|
*
|
|
* @param vt Pointer to the index in the virtual table.
|
|
* @param tramp Pointer to the trampoline.
|
|
* @param func Pointer to the original function.
|
|
* @noreturn
|
|
*/
|
|
void Setup(void **vt,void *tramp, void *func)
|
|
{
|
|
location=vt;
|
|
trampoline=tramp;
|
|
function=func;
|
|
|
|
};
|
|
|
|
/**
|
|
* Manually called by VTableManager at destruction. Treat this like a dtor.
|
|
*
|
|
* @see VTableManager::Cleanup()
|
|
* @noreturn
|
|
*/
|
|
void Destroy()
|
|
{
|
|
// restore original location
|
|
if (location)
|
|
{
|
|
#if defined _WIN32
|
|
DWORD OldFlags;
|
|
VirtualProtect(location,sizeof(int*),PAGE_READWRITE,&OldFlags);
|
|
#elif defined __linux__
|
|
mprotect(location,sizeof(int*),PROT_READ|PROT_WRITE);
|
|
#endif
|
|
|
|
*location=function;
|
|
}
|
|
|
|
// free the trampoline
|
|
free(trampoline);
|
|
|
|
Forwards.clear();
|
|
PostForwards.clear();
|
|
|
|
};
|
|
/**
|
|
* Tells whether the given pointer is this entry's trampoline.
|
|
*
|
|
* @param ptr Pointer (cast to void*) of the function in question.
|
|
* @return true: Yes, the pointer in question is this entry's trampoline.
|
|
* fase: No, the pointer in question is not this entry's trampoline.
|
|
*/
|
|
bool IsTrampoline(void *ptr)
|
|
{
|
|
return (ptr==trampoline);
|
|
};
|
|
|
|
/**
|
|
* Returns the pointer (cast to void*) of the original function which is being hooked.
|
|
*
|
|
* @return Original function pointer, cast to void*.
|
|
*/
|
|
void *GetOriginalFunction(void)
|
|
{
|
|
return function;
|
|
};
|
|
|
|
/**
|
|
* Returns the location of this entry's virtual table entry itself.
|
|
*
|
|
* @return Pointer to this entry's virtual table entry.
|
|
*/
|
|
void **GetLocation(void)
|
|
{
|
|
return location;
|
|
};
|
|
|
|
/**
|
|
* Returns a pointer to this entry's trampoline.
|
|
*
|
|
* @return Trampoline pointer, cast to void*.
|
|
*/
|
|
void *GetTrampoline(void)
|
|
{
|
|
return trampoline;
|
|
};
|
|
/**
|
|
* Adds a forward to this entry's forward vector.
|
|
*
|
|
* @param fwd Forward index to add.
|
|
* @noreturn
|
|
*/
|
|
void AddForward(int fwd)
|
|
{
|
|
Forwards.push_back(fwd);
|
|
};
|
|
|
|
/**
|
|
* Adds a forward to this entry's post forward vector.
|
|
*
|
|
* @param fwd Forward index to add.
|
|
* @noreturn
|
|
*/
|
|
void AddPostForward(int fwd)
|
|
{
|
|
PostForwards.push_back(fwd);
|
|
};
|
|
|
|
/**
|
|
* Creates a generic trampoline.
|
|
*
|
|
* @param manager The VTableManager this entry belongs to.
|
|
* @param vtable Pointer to the virtual table to molest.
|
|
* @param vindex VTable index to replace.
|
|
* @param id The unique id of this trampoline.
|
|
* @param outtrampoline Gets set to the location of the trampoline.
|
|
* @param origfunc Gets set to the original function which is being hooked.
|
|
* @param calee Target function this trampoline will call.
|
|
* @param paramcount How many parameters this trampoline pushes.
|
|
* @param voidcall Set to 1, this function does not return. 0 otherwise.
|
|
* @param thiscall Set to 1, treat this function like a thiscall.
|
|
*/
|
|
static void CreateGenericTrampoline(VTableManager *manager, void **vtable, int vtableindex, int id, void **outtrampoline, void **origfunc, void *calee, int paramcount, int voidcall=1, int thiscall=1);
|
|
|
|
};
|
|
|
|
|
|
// int ObjectCaps(void) TODO
|
|
class VTableObjectCaps : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
// int Classify(void) TODO
|
|
class VTableClassify : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
class VTableTraceAttack : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param inflictor Damage inflictor.
|
|
* @param attacker The attacker who caused the inflictor to damage the victim.
|
|
* @param damage How much damage was caused.
|
|
* @param type Damage type (usually in bitmask form).
|
|
* @return Unsure. Does not appear to be used.
|
|
*/
|
|
int Execute(void *pthis, void *pevattacker, float flDamage, float *direction, void *tr, int bitsDamageType);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis,void *pevattacker,float flDamage,float *direction,void *tr,int bits);
|
|
};
|
|
// int TakeDamage(entvars_t *inflictor, entvars_t *attacker, float damage, int type);
|
|
class VTableTakeDamage : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param inflictor Damage inflictor.
|
|
* @param attacker The attacker who caused the inflictor to damage the victim.
|
|
* @param damage How much damage was caused.
|
|
* @param type Damage type (usually in bitmask form).
|
|
* @return Unsure. Does not appear to be used.
|
|
*/
|
|
int Execute(void *pthis, void *inflictor, void *attacker, float damage, int type);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis,void *inflictor,void *attacker,float damage,int type);
|
|
};
|
|
// int BloodColor(void) TODO
|
|
class VTableBloodColor : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
|
|
// void Killed(entvars_t *attacker, int gib)
|
|
class VTableKilled : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param attacker The attacker who caused the inflictor to damage the victim.
|
|
* @param gib Whether to gib or not.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis, void *attacker, int gib);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis,void *attacker, int gib);
|
|
};
|
|
// void Restart(void) CS ONLY
|
|
class VTableRestart : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
// int GetToggleState(void) TODO
|
|
class VTableGetToggleState : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
|
|
// void AddPoints(int points, int allownegative)
|
|
class VTableAddPoints : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis, int points, int allowneg);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis,int points,int allownegative);
|
|
};
|
|
// void AddPointsToTeam(int points, int allownegative)
|
|
class VTableAddPointsToTeam : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis, int points, int allowneg);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis,int points,int allownegative);
|
|
};
|
|
|
|
// int AddPlayerItem(CBasePlayerItem *item);
|
|
class VTableAddPlayerItem : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param item The private data of the item being added.
|
|
* @return Unsure. Does not appear to be used.
|
|
*/
|
|
int Execute(void *pthis, void *item);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
* @param item The private data of the item being added.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis,void *item);
|
|
};
|
|
// int RemovePlayerItem(CBasePlayerItem *item);
|
|
class VTableRemovePlayerItem : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param item The private data of the item being added.
|
|
* @return Unsure. Does not appear to be used.
|
|
*/
|
|
int Execute(void *pthis, void *item);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
* @param item The private data of the item being added.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis,void *item);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// int Is(void) TODO
|
|
class VTableIsMoving : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
|
|
// int Is(void) TODO
|
|
class VTableDamageDecal : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
|
|
|
|
// int Is(void) TODO
|
|
class VTableIsSneaking : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
// int Is(void) TODO
|
|
class VTableIsAlive : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
// int Is(void) TODO
|
|
class VTableIsBSPModel : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
// int IsInWorld(void) TODO
|
|
class VTableIsInWorld : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
// int IsPlayer(void) TODO
|
|
class VTableIsPlayer : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
// int IsNetClient(void) TODO
|
|
class VTableIsNetClient : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
*/
|
|
int Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static int HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
// const char *TeamID(void) TODO
|
|
class VTableTeamID : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
const char *Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static const char* HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
// void Think(void) TODO
|
|
class VTableThink : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
// void Touch(void *pOther) TODO
|
|
class VTableTouch : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis, void *other);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis,void *other);
|
|
};
|
|
// void Use(CBaseEntity *activator, CBaseEntity *caller, USE_TYPE type, float value)
|
|
class VTableUse : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param activator Entity causing the opening.
|
|
* @param caller Entity controlling the caller.
|
|
* @param type USE_TYPE (USE_{ON,OFF,SET}
|
|
* @param value Use value, only seen set when USE_SET is used.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis, void *activator, void *caller, int type, float value);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis, void *activator, void *caller, int type, float value);
|
|
|
|
};
|
|
// void Blocked(CBaseEntity *pOther)
|
|
class VTableBlocked : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis, void *other);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis,void *other);
|
|
};
|
|
|
|
// CBaseEntity *Respawn(void)
|
|
class VTableRespawn : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void *Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void* HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
// void UpdateOwner(void) TODO
|
|
class VTableUpdateOwner : public VTableEntryBase
|
|
{
|
|
public:
|
|
static unsigned int *pevoffset; /**< Offset of pev value (globally stored) */
|
|
static unsigned int *pevset; /**< Whether or not pev entry has been set */
|
|
static unsigned int *baseoffset; /**< Offset of the base class (only needed for GCC 2.95). */
|
|
static unsigned int *baseset; /**< Whether or base offset value has been set. */
|
|
static unsigned int index; /**< This entry's virtual table index. */
|
|
static unsigned int indexset; /**< Whether or not this entry's virtual table index has been set. */
|
|
|
|
/**
|
|
* Initialize this table hook. This also registers our required keyvalue suffixes to the file parser.
|
|
*
|
|
* @param poffset Pointer to an integer that stores the pev offset for this mod.
|
|
* @param pset Pointer to an integer that tells whether pev offset was set or not.
|
|
* @param baseoffs Pointer to an integer that stores the class base offset for this mod. (GCC 2.95 only required)
|
|
* @param baseset Pointer to an integer that tells whether class base offset has been set.
|
|
* @noreturn
|
|
*/
|
|
static void Initialize(unsigned int *poffset, unsigned int *pset, unsigned int *baseoffs, unsigned int *baseset);
|
|
|
|
/**
|
|
* Called when one of this table entry's keyvalues is caught in a config file.
|
|
*
|
|
* @param key The keyvalue suffix ("<mod>_<os>_" is removed)
|
|
* @param data The data this keyvalue is set to.
|
|
* @noreturn
|
|
*/
|
|
static void KeyValue(const char *key, const char *data);
|
|
|
|
/**
|
|
* Called immediately after the config file is done being parsed. Register our natives here.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
static void ConfigDone(void);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is registering this entry's virtual hook. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell RegisterIDNative(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell NativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* A plugin is requesting a direct call of this entry's virtual function, and will be exposed to all hooks. This is a normal native callback.
|
|
*
|
|
* @param amx The AMX structure for the plugin.
|
|
* @param params The parameters passed from the plugin.
|
|
* @return 1 on success, 0 on failure. It only fails if the callback function is not found.
|
|
*/
|
|
static cell ENativeCall(AMX *amx, cell *params);
|
|
|
|
/**
|
|
* Hook this entry's function! This creates our trampoline and modifies the virtual table.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param outtrampoline The trampoline that was created.
|
|
* @param origfunc The original function that was hooked.
|
|
* @noreturn
|
|
*/
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
|
|
/**
|
|
* Checks if the virtual function is already being hooked or not. If it's not, it begins hooking it. Either way it registers a forward and adds it to our vector.
|
|
*
|
|
* @param manager The VTableManager this is a child of.
|
|
* @param vtable The virtual table we're molesting.
|
|
* @param plugin The plugin that's requesting this.
|
|
* @param funcid The function id of the callback.
|
|
* @noreturn
|
|
*/
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid, int post);
|
|
|
|
/**
|
|
* Execute the command. This is called directly from our global hook function.
|
|
*
|
|
* @param pthis The "this" pointer, cast to a void. The victim.
|
|
* @param other Entity that's blocking.
|
|
* @noreturn
|
|
*/
|
|
void Execute(void *pthis);
|
|
|
|
/**
|
|
* The hook that is directly called by the trampoline.
|
|
*
|
|
* @param id The index of the hook to call.
|
|
* @param pthis The "this" pointer.
|
|
*/
|
|
static void HAM_CDECL EntryPoint(int id,void *pthis);
|
|
};
|
|
|
|
|
|
|
|
//TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
|
|
/*class VTableTraceAttack : public VTableEntryBase
|
|
{
|
|
public:
|
|
static void CreateHook(VTableManager *manager, void **vtable, int id, void **outtrampoline, void **origfunc);
|
|
static void Hook(VTableManager *manager, void **vtable, AMX *plugin, int funcid);
|
|
void Execute(void *pthis, entvars_t *attacker, float damage, float *direction, TraceResult *tr, int damagetype);
|
|
};
|
|
*/
|
|
#endif // VTABLEENTRIES_H
|