318 lines
9.2 KiB
C++
318 lines
9.2 KiB
C++
/**
|
|
* vim: set ts=4 :
|
|
* =============================================================================
|
|
* Source SDK Hooks Extension
|
|
* Copyright (C) 2010-2012 Nicholas Hastings
|
|
* Copyright (C) 2009-2010 Erik Minekus
|
|
* =============================================================================
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License, version 3.0, as published by the
|
|
* Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* As a special exception, AlliedModders LLC gives you permission to link the
|
|
* code of this program (as well as its derivative works) to "Half-Life 2," the
|
|
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
|
|
* by the Valve Corporation. You must obey the GNU General Public License in
|
|
* all respects for all other code used. Additionally, AlliedModders LLC grants
|
|
* this exception to all derivative works. AlliedModders LLC defines further
|
|
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
|
|
* or <http://www.sourcemod.net/license.php>.
|
|
*
|
|
* Version: $Id$
|
|
*/
|
|
|
|
#include "extension.h"
|
|
#include "natives.h"
|
|
#include <compat_wrappers.h>
|
|
#include <IBinTools.h>
|
|
#include <sm_argbuffer.h>
|
|
|
|
using namespace SourceMod;
|
|
|
|
SH_DECL_MANUALEXTERN1(OnTakeDamage, int, CTakeDamageInfoHack &);
|
|
SH_DECL_MANUALEXTERN3_void(Weapon_Drop, CBaseCombatWeapon *, const Vector *, const Vector *);
|
|
|
|
cell_t Native_Hook(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
int entity = (int)params[1];
|
|
SDKHookType type = (SDKHookType)params[2];
|
|
IPluginFunction *callback = pContext->GetFunctionById(params[3]);
|
|
HookReturn ret = g_Interface.Hook(entity, type, callback);
|
|
switch (ret)
|
|
{
|
|
case HookRet_InvalidEntity:
|
|
pContext->ThrowNativeError("Entity %d is invalid", entity);
|
|
break;
|
|
case HookRet_InvalidHookType:
|
|
pContext->ThrowNativeError("Invalid hook type specified");
|
|
break;
|
|
case HookRet_NotSupported:
|
|
pContext->ThrowNativeError("Hook type not supported on this game");
|
|
break;
|
|
case HookRet_BadEntForHookType:
|
|
{
|
|
CBaseEntity *pEnt = gamehelpers->ReferenceToEntity(params[1]);
|
|
const char *pClassname = pEnt ? gamehelpers->GetEntityClassname(pEnt) : NULL;
|
|
if (!pClassname)
|
|
{
|
|
pContext->ThrowNativeError("Hook type not valid for this type of entity (%i).", entity);
|
|
}
|
|
else
|
|
{
|
|
pContext->ThrowNativeError("Hook type not valid for this type of entity (%i/%s)", entity, pClassname);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
cell_t Native_HookEx(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
int entity = (int)params[1];
|
|
SDKHookType type = (SDKHookType)params[2];
|
|
IPluginFunction *callback = pContext->GetFunctionById(params[3]);
|
|
HookReturn ret = g_Interface.Hook(entity, type, callback);
|
|
if (ret == HookRet_Successful)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
cell_t Native_Unhook(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
int entity = (int)params[1];
|
|
SDKHookType type = (SDKHookType)params[2];
|
|
IPluginFunction *callback = pContext->GetFunctionById(params[3]);
|
|
g_Interface.Unhook(entity, type, callback);
|
|
|
|
return 0;
|
|
}
|
|
|
|
cell_t Native_TakeDamage(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
CBaseEntity *pVictim = gamehelpers->ReferenceToEntity(params[1]);
|
|
if (!pVictim)
|
|
return pContext->ThrowNativeError("Invalid entity index %d for victim", params[1]);
|
|
|
|
CBaseEntity *pInflictor = gamehelpers->ReferenceToEntity(params[2]);
|
|
if (!pInflictor)
|
|
return pContext->ThrowNativeError("Invalid entity index %d for inflictor", params[2]);
|
|
|
|
CBaseEntity *pAttacker;
|
|
if (params[3] != -1)
|
|
{
|
|
pAttacker = gamehelpers->ReferenceToEntity(params[3]);
|
|
if (!pAttacker)
|
|
{
|
|
return pContext->ThrowNativeError("Invalid entity index %d for attackerr", params[3]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pAttacker = NULL;
|
|
}
|
|
|
|
float flDamage = sp_ctof(params[4]);
|
|
int iDamageType = params[5];
|
|
|
|
CBaseEntity *pWeapon;
|
|
if (params[6] != -1)
|
|
{
|
|
pWeapon = gamehelpers->ReferenceToEntity(params[6]);
|
|
if (!pWeapon)
|
|
{
|
|
return pContext->ThrowNativeError("Invalid entity index %d for weapon", params[6]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pWeapon = NULL;
|
|
}
|
|
|
|
cell_t *addr;
|
|
int err;
|
|
if ((err = pContext->LocalToPhysAddr(params[7], &addr)) != SP_ERROR_NONE)
|
|
{
|
|
return pContext->ThrowNativeError("Could not read damageForce vector");
|
|
}
|
|
|
|
Vector vecDamageForce;
|
|
if (addr != pContext->GetNullRef(SP_NULL_VECTOR))
|
|
{
|
|
vecDamageForce.Init(sp_ctof(addr[0]), sp_ctof(addr[1]), sp_ctof(addr[2]));
|
|
}
|
|
else
|
|
{
|
|
vecDamageForce.Init();
|
|
}
|
|
|
|
if ((err = pContext->LocalToPhysAddr(params[8], &addr)) != SP_ERROR_NONE)
|
|
{
|
|
return pContext->ThrowNativeError("Could not read damagePosition vector");
|
|
}
|
|
|
|
Vector vecDamagePosition;
|
|
if (addr != pContext->GetNullRef(SP_NULL_VECTOR))
|
|
{
|
|
vecDamagePosition.Init(sp_ctof(addr[0]), sp_ctof(addr[1]), sp_ctof(addr[2]));
|
|
}
|
|
else
|
|
{
|
|
vecDamagePosition = vec3_origin;
|
|
}
|
|
|
|
CTakeDamageInfoHack info(pInflictor, pAttacker, flDamage, iDamageType, pWeapon, vecDamageForce, vecDamagePosition);
|
|
|
|
if (params[0] < 9 || params[9] != 0)
|
|
{
|
|
SH_MCALL(pVictim, OnTakeDamage)((CTakeDamageInfoHack&)info);
|
|
}
|
|
else
|
|
{
|
|
static ICallWrapper *pCall = nullptr;
|
|
if (!pCall)
|
|
{
|
|
int offset;
|
|
if (!g_pGameConf->GetOffset("OnTakeDamage", &offset))
|
|
{
|
|
return pContext->ThrowNativeError("Could not find OnTakeDamage offset");
|
|
}
|
|
|
|
PassInfo pass[2];
|
|
pass[0].type = PassType_Object;
|
|
pass[0].size = sizeof(CTakeDamageInfoHack &);
|
|
pass[0].flags = PASSFLAG_BYREF | PASSFLAG_OCTOR;
|
|
pass[1].type = PassType_Basic;
|
|
pass[1].size = sizeof(int);
|
|
pass[1].flags = PASSFLAG_BYVAL;
|
|
|
|
pCall = g_pBinTools->CreateVCall(offset, 0, 0, &pass[1], &pass[0], 1);
|
|
}
|
|
|
|
// Can't ArgBuffer here until we upgrade our Clang version on the Linux builder
|
|
unsigned char vstk[sizeof(CBaseEntity *) + sizeof(CTakeDamageInfoHack &)];
|
|
unsigned char* vptr = vstk;
|
|
|
|
*(CBaseEntity **)vptr = pVictim;
|
|
vptr += sizeof(CBaseEntity *);
|
|
*(CTakeDamageInfoHack *&)vptr = info;
|
|
|
|
int ret;
|
|
pCall->Execute(vstk, &ret);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
cell_t Native_DropWeapon(IPluginContext *pContext, const cell_t *params)
|
|
{
|
|
CBaseEntity *pPlayer = gamehelpers->ReferenceToEntity(params[1]);
|
|
if (!pPlayer)
|
|
return pContext->ThrowNativeError("Invalid client index %d", params[1]);
|
|
|
|
IGamePlayer *pGamePlayer = playerhelpers->GetGamePlayer(gamehelpers->ReferenceToIndex(params[1]));
|
|
if (!pGamePlayer || !pGamePlayer->IsInGame())
|
|
return pContext->ThrowNativeError("Client index %d not in game", params[1]);
|
|
|
|
CBaseEntity *pWeapon = gamehelpers->ReferenceToEntity(params[2]);
|
|
if (!pWeapon)
|
|
return pContext->ThrowNativeError("Invalid entity index %d for weapon", params[2]);
|
|
|
|
IServerUnknown *pUnk = (IServerUnknown *)pWeapon;
|
|
IServerNetworkable *pNet = pUnk->GetNetworkable();
|
|
|
|
if (!UTIL_ContainsDataTable(pNet->GetServerClass()->m_pTable, "DT_BaseCombatWeapon"))
|
|
return pContext->ThrowNativeError("Entity index %d is not a weapon", params[2]);
|
|
|
|
sm_sendprop_info_t spi;
|
|
if (!gamehelpers->FindSendPropInfo("CBaseCombatWeapon", "m_hOwnerEntity", &spi))
|
|
return pContext->ThrowNativeError("Invalid entity index %d for weapon", params[2]);
|
|
|
|
CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pWeapon + spi.actual_offset);
|
|
if (params[1] != hndl.GetEntryIndex())
|
|
return pContext->ThrowNativeError("Weapon %d is not owned by client %d", params[2], params[1]);
|
|
|
|
cell_t *addr;
|
|
int err;
|
|
|
|
Vector vecTarget;
|
|
Vector *pVecTarget = nullptr;
|
|
|
|
if ((err = pContext->LocalToPhysAddr(params[3], &addr)) != SP_ERROR_NONE)
|
|
{
|
|
return pContext->ThrowNativeError("Could not read vecTarget vector");
|
|
}
|
|
|
|
if (addr != pContext->GetNullRef(SP_NULL_VECTOR))
|
|
{
|
|
vecTarget = Vector(
|
|
sp_ctof(addr[0]),
|
|
sp_ctof(addr[1]),
|
|
sp_ctof(addr[2]));
|
|
pVecTarget = &vecTarget;
|
|
}
|
|
|
|
Vector vecVelocity;
|
|
Vector *pVecVelocity = nullptr;
|
|
|
|
if ((err = pContext->LocalToPhysAddr(params[4], &addr)) != SP_ERROR_NONE)
|
|
{
|
|
return pContext->ThrowNativeError("Could not read vecVelocity vector");
|
|
}
|
|
|
|
if (addr != pContext->GetNullRef(SP_NULL_VECTOR))
|
|
{
|
|
vecVelocity = Vector(
|
|
sp_ctof(addr[0]),
|
|
sp_ctof(addr[1]),
|
|
sp_ctof(addr[2]));
|
|
pVecVelocity = &vecVelocity;
|
|
}
|
|
|
|
if (params[0] < 5 || params[5] != 0)
|
|
{
|
|
SH_MCALL(pPlayer, Weapon_Drop)((CBaseCombatWeapon*)pWeapon, pVecTarget, pVecVelocity);
|
|
}
|
|
else
|
|
{
|
|
static ICallWrapper* pCall = nullptr;
|
|
if (!pCall)
|
|
{
|
|
int offset;
|
|
if (!g_pGameConf->GetOffset("Weapon_Drop", &offset))
|
|
{
|
|
return pContext->ThrowNativeError("Could not find Weapon_Drop offset");
|
|
}
|
|
|
|
PassInfo pass[3];
|
|
pass[0].type = PassType_Basic;
|
|
pass[0].size = sizeof(CBaseEntity *);
|
|
pass[0].flags = PASSFLAG_BYVAL;
|
|
pass[1].type = PassType_Basic;
|
|
pass[1].size = sizeof(Vector *);
|
|
pass[1].flags = PASSFLAG_BYVAL;
|
|
pass[2].type = PassType_Basic;
|
|
pass[2].size = sizeof(Vector *);
|
|
pass[2].flags = PASSFLAG_BYVAL;
|
|
|
|
pCall = g_pBinTools->CreateVCall(offset, 0, 0, nullptr, pass, 3);
|
|
}
|
|
|
|
pCall->Execute(ArgBuffer<CBaseEntity *, CBaseEntity *, Vector *, Vector *>(pPlayer, pWeapon, pVecTarget, pVecVelocity), nullptr);
|
|
}
|
|
|
|
return 0;
|
|
}
|