UNLOZE/sourcemod
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
1.10-fork
sourcemod/core/smn_entities.cpp

2718 lines
63 KiB
C++
Raw Permalink Blame History

/**
* vim: set ts=4 :
* =============================================================================
* SourceMod
* Copyright (C) 2004-2010 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* 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 "sm_globals.h"
#include "sourcemod.h"
#include "sourcemm_api.h"
#include "PlayerManager.h"
#include "HalfLife2.h"
#include <IGameConfigs.h>
#include "sm_stringutil.h"
#include "logic_bridge.h"
// These values need to mirror the values in entity_prop_stocks
#define ENTFLAG_ONGROUND (1 << 0)
#define ENTFLAG_DUCKING (1 << 1)
#define ENTFLAG_WATERJUMP (1 << 2)
#define ENTFLAG_ONTRAIN (1 << 3)
#define ENTFLAG_INRAIN (1 << 4)
#define ENTFLAG_FROZEN (1 << 5)
#define ENTFLAG_ATCONTROLS (1 << 6)
#define ENTFLAG_CLIENT (1 << 7)
#define ENTFLAG_FAKECLIENT (1 << 8)
#define ENTFLAG_INWATER (1 << 9)
#define ENTFLAG_FLY (1 << 10)
#define ENTFLAG_SWIM (1 << 11)
#define ENTFLAG_CONVEYOR (1 << 12)
#define ENTFLAG_NPC (1 << 13)
#define ENTFLAG_GODMODE (1 << 14)
#define ENTFLAG_NOTARGET (1 << 15)
#define ENTFLAG_AIMTARGET (1 << 16)
#define ENTFLAG_PARTIALGROUND (1 << 17)
#define ENTFLAG_STATICPROP (1 << 18)
#define ENTFLAG_GRAPHED (1 << 19)
#define ENTFLAG_GRENADE (1 << 20)
#define ENTFLAG_STEPMOVEMENT (1 << 21)
#define ENTFLAG_DONTTOUCH (1 << 22)
#define ENTFLAG_BASEVELOCITY (1 << 23)
#define ENTFLAG_WORLDBRUSH (1 << 24)
#define ENTFLAG_OBJECT (1 << 25)
#define ENTFLAG_KILLME (1 << 26)
#define ENTFLAG_ONFIRE (1 << 27)
#define ENTFLAG_DISSOLVING (1 << 28)
#define ENTFLAG_TRANSRAGDOLL (1 << 29)
#define ENTFLAG_UNBLOCKABLE_BY_PLAYER (1 << 30)
#define ENTFLAG_FREEZING (1 << 31)
#define ENTFLAG_EP2V_UNKNOWN1 (1 << 31)
// Not defined in the sdk as we have no clue what it is
#define FL_EP2V_UNKNOWN (1 << 2)
enum PropType
{
Prop_Send = 0,
Prop_Data
};
enum PropFieldType
{
PropField_Unsupported, /**< The type is unsupported. */
PropField_Integer, /**< Valid for SendProp and Data fields */
PropField_Float, /**< Valid for SendProp and Data fields */
PropField_Entity, /**< Valid for Data fields only (SendProp shows as int) */
PropField_Vector, /**< Valid for SendProp and Data fields */
PropField_String, /**< Valid for SendProp and Data fields */
PropField_String_T, /**< Valid for Data fields. Read only! */
PropField_Variant, /**< Valid for variants/any. (User must know type) */
};
// From game/server/variant_t.h, same on all supported games.
class variant_t
{
public:
union
{
bool bVal;
string_t iszVal;
int iVal;
float flVal;
float vecVal[3];
color32 rgbaVal;
};
CBaseHandle eVal;
fieldtype_t fieldType;
};
// From game/server/baseentity.h, same on all supported games.
struct inputdata_t
{
CBaseEntity *pActivator; // The entity that initially caused this chain of output events.
CBaseEntity *pCaller; // The entity that fired this particular output.
variant_t value; // The data parameter for this output.
int nOutputID; // The unique ID of the output that was fired.
};
inline bool CanSetPropName(const char *pszPropName)
{
#if SOURCE_ENGINE == SE_CSGO
return g_HL2.CanSetCSGOEntProp(pszPropName);
#else
return true;
#endif
}
inline edict_t *BaseEntityToEdict(CBaseEntity *pEntity)
{
IServerUnknown *pUnk = (IServerUnknown *)pEntity;
IServerNetworkable *pNet = pUnk->GetNetworkable();
if (!pNet)
{
return NULL;
}
return pNet->GetEdict();
}
inline edict_t *GetEdict(cell_t num)
{
edict_t *pEdict;
if (!IndexToAThings(num, NULL, &pEdict))
{
return NULL;
}
return pEdict;
}
inline CBaseEntity *GetEntity(cell_t num)
{
CBaseEntity *pEntity;
if (!IndexToAThings(num, &pEntity, NULL))
{
return NULL;
}
return pEntity;
}
/* Given an entity reference or index, fill out a CBaseEntity and/or edict.
If lookup is successful, returns true and writes back the two parameters.
If lookup fails, returns false and doesn't touch the params. */
bool IndexToAThings(cell_t num, CBaseEntity **pEntData, edict_t **pEdictData)
{
CBaseEntity *pEntity = g_HL2.ReferenceToEntity(num);
if (!pEntity)
{
return false;
}
int index = g_HL2.ReferenceToIndex(num);
if (index > 0 && index <= g_Players.GetMaxClients())
{
CPlayer *pPlayer = g_Players.GetPlayerByIndex(index);
if (!pPlayer || !pPlayer->IsConnected())
{
return false;
}
}
if (pEntData)
{
*pEntData = pEntity;
}
if (pEdictData)
{
edict_t *pEdict = ::BaseEntityToEdict(pEntity);
if (!pEdict || pEdict->IsFree())
{
pEdict = NULL;
}
*pEdictData = pEdict;
}
return true;
}
/*
<predcrab> AThings is like guaranteed r+ by dvander though
<predcrab> he wont even read the rest of the patch to nit stuff
<Fyren> Like I wasn't going to r? you anyway!
<predcrab> he still sees!
<predcrab> he's everywhere
*/
class VEmptyClass {};
datamap_t *VGetDataDescMap(CBaseEntity *pThisPtr, int offset)
{
void **this_ptr = *reinterpret_cast<void ***>(&pThisPtr);
void **vtable = *reinterpret_cast<void ***>(pThisPtr);
void *vfunc = vtable[offset];
union
{
datamap_t *(VEmptyClass::*mfpnew)();
#ifndef PLATFORM_POSIX
void *addr;
} u;
u.addr = vfunc;
#else
struct
{
void *addr;
intptr_t adjustor;
} s;
} u;
u.s.addr = vfunc;
u.s.adjustor = 0;
#endif
return (datamap_t *)(reinterpret_cast<VEmptyClass *>(this_ptr)->*u.mfpnew)();
}
inline datamap_t *CBaseEntity_GetDataDescMap(CBaseEntity *pEntity)
{
int offset;
if (!g_pGameConf->GetOffset("GetDataDescMap", &offset) || !offset)
{
return NULL;
}
return VGetDataDescMap(pEntity, offset);
}
/* :TODO: Move this! */
datamap_t *CHalfLife2::GetDataMap(CBaseEntity *pEntity)
{
return CBaseEntity_GetDataDescMap(pEntity);
}
static cell_t GetMaxEntities(IPluginContext *pContext, const cell_t *params)
{
return gpGlobals->maxEntities;
}
static cell_t CreateEdict(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = engine->CreateEdict();
if (!pEdict)
{
return 0;
}
return IndexOfEdict(pEdict);
}
static cell_t RemoveEdict(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = GetEdict(params[1]);
if (!pEdict)
{
return pContext->ThrowNativeError("Edict %d (%d) is not a valid edict", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
engine->RemoveEdict(pEdict);
return 1;
}
static cell_t RemoveEntity(IPluginContext *pContext, const cell_t *params)
{
auto *pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is not a valid entity", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
// Some games have UTIL_Remove exposed on IServerTools, but for consistence, we'll
// use this method for all. Results in DeathNotice( this ) being called on parent,
// and parent being cleared (both if any parent) before UTIL_Remove is called.
static inputfunc_t fnKillEntity = nullptr;
if (!fnKillEntity)
{
// Get world, as other ents aren't guaranteed to inherit full datadesc (but kill func is same for all)
CBaseEntity *pGetterEnt = g_HL2.ReferenceToEntity(0);
if (pGetterEnt == nullptr)
{
// If we don't have a world entity yet, we'll have to rely on the given entity. Does this even make sense???
pGetterEnt = pEntity;
}
datamap_t *pMap = g_HL2.GetDataMap(pGetterEnt);
sm_datatable_info_t info;
if (!g_HL2.FindDataMapInfo(pMap, "InputKill", &info))
{
return pContext->ThrowNativeError("Failed to find Kill input!");
}
fnKillEntity = info.prop->inputFunc;
}
// Input data is ignored for this. No need to initialize
static inputdata_t data;
(pEntity->*fnKillEntity)(data);
return 1;
}
static cell_t IsValidEdict(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = GetEdict(params[1]);
if (!pEdict)
{
return 0;
}
/* Shouldn't be necessary... not sure though */
return pEdict->IsFree() ? 0 : 1;
}
static cell_t IsValidEntity(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = g_HL2.ReferenceToEntity(params[1]);
return (pEntity != NULL) ? 1 : 0;
}
static cell_t IsEntNetworkable(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = GetEdict(params[1]);
if (!pEdict)
{
return 0;
}
return (pEdict->GetNetworkable() != NULL) ? 1 : 0;
}
static cell_t GetEntityCount(IPluginContext *pContext, const cell_t *params)
{
return engine->GetEntityCount();
}
static cell_t GetEdictFlags(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = GetEdict(params[1]);
if (!pEdict)
{
return pContext->ThrowNativeError("Invalid edict (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
return pEdict->m_fStateFlags;
}
static cell_t SetEdictFlags(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = GetEdict(params[1]);
if (!pEdict)
{
return pContext->ThrowNativeError("Invalid edict (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pEdict->m_fStateFlags = params[2];
return 1;
}
static cell_t GetEdictClassname(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = GetEdict(params[1]);
if (!pEdict)
{
return pContext->ThrowNativeError("Invalid edict (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
const char *cls = g_HL2.GetEntityClassname(pEdict);
if (!cls || cls[0] == '\0')
{
return 0;
}
pContext->StringToLocal(params[2], params[3], cls);
return 1;
}
static cell_t GetEntityNetClass(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = g_HL2.ReferenceToEntity(params[1]);
IServerUnknown *pUnk = (IServerUnknown *)pEntity;
if (!pEntity)
{
return pContext->ThrowNativeError("Invalid entity (%d - %d)", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
IServerNetworkable *pNet = pUnk->GetNetworkable();
if (!pNet)
{
return 0;
}
ServerClass *pClass = pNet->GetServerClass();
pContext->StringToLocal(params[2], params[3], pClass->GetName());
return 1;
}
static cell_t GetEntData(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
switch (params[3])
{
case 4:
return *(int *)((uint8_t *)pEntity + offset);
case 2:
return *(short *)((uint8_t *)pEntity + offset);
case 1:
return *((uint8_t *)pEntity + offset);
default:
return pContext->ThrowNativeError("Integer size %d is invalid", params[3]);
}
}
static cell_t SetEntData(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
edict_t *pEdict;
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
if (params[5] && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
switch (params[4])
{
case 4:
{
*(int *)((uint8_t *)pEntity + offset) = params[3];
break;
}
case 2:
{
*(short *)((uint8_t *)pEntity + offset) = params[3];
break;
}
case 1:
{
*((uint8_t *)pEntity + offset) = params[3];
break;
}
default:
return pContext->ThrowNativeError("Integer size %d is invalid", params[4]);
}
return 1;
}
static cell_t GetEntDataFloat(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
float f = *(float *)((uint8_t *)pEntity + offset);
return sp_ftoc(f);
}
static cell_t SetEntDataFloat(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
edict_t *pEdict;
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
*(float *)((uint8_t *)pEntity + offset) = sp_ctof(params[3]);
if (params[4] && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return 1;
}
static cell_t GetEntDataVector(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
Vector *v = (Vector *)((uint8_t *)pEntity + offset);
cell_t *vec;
pContext->LocalToPhysAddr(params[3], &vec);
vec[0] = sp_ftoc(v->x);
vec[1] = sp_ftoc(v->y);
vec[2] = sp_ftoc(v->z);
return 1;
}
static cell_t SetEntDataVector(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
edict_t *pEdict;
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
Vector *v = (Vector *)((uint8_t *)pEntity + offset);
cell_t *vec;
pContext->LocalToPhysAddr(params[3], &vec);
v->x = sp_ctof(vec[0]);
v->y = sp_ctof(vec[1]);
v->z = sp_ctof(vec[2]);
if (params[4] && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return 1;
}
/* THIS GUY IS DEPRECATED. */
static cell_t GetEntDataEnt(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pEntity + offset);
if (!hndl.IsValid())
{
return 0;
}
int ref = g_HL2.IndexToReference(hndl.GetEntryIndex());
return g_HL2.ReferenceToBCompatRef(ref);
}
int CheckBaseHandle(CBaseHandle &hndl)
{
if (!hndl.IsValid())
{
return -1;
}
int index = hndl.GetEntryIndex();
edict_t *pStoredEdict;
CBaseEntity *pStoredEntity;
if (!IndexToAThings(index, &pStoredEntity, &pStoredEdict))
{
return -1;
}
if (pStoredEdict == NULL || pStoredEntity == NULL)
{
return -1;
}
IServerEntity *pSE = pStoredEdict->GetIServerEntity();
if (pSE == NULL)
{
return -1;
}
if (pSE->GetRefEHandle() != hndl)
{
return -1;
}
return index;
}
static cell_t GetEntDataEnt2(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = GetEntity(params[1]);
if (pEntity == NULL)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pEntity + offset);
CBaseEntity *pHandleEntity = g_HL2.ReferenceToEntity(hndl.GetEntryIndex());
if (!pHandleEntity || hndl != reinterpret_cast<IHandleEntity *>(pHandleEntity)->GetRefEHandle())
return -1;
return g_HL2.EntityToBCompatRef(pHandleEntity);
}
/* THIS GUY IS DEPRECATED. */
static cell_t SetEntDataEnt(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
edict_t *pEdict;
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pEntity + offset);
if (params[3] == 0 || (unsigned)params[3] == INVALID_EHANDLE_INDEX)
{
hndl.Set(NULL);
} else {
CBaseEntity *pOther = GetEntity(params[3]);
if (!pOther)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[3]), params[3]);
}
IHandleEntity *pHandleEnt = (IHandleEntity *)pOther;
hndl.Set(pHandleEnt);
}
if (params[4] && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return 1;
}
static cell_t SetEntDataEnt2(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
edict_t *pEdict;
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset <= 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
CBaseHandle &hndl = *(CBaseHandle *)((uint8_t *)pEntity + offset);
if ((unsigned)params[3] == INVALID_EHANDLE_INDEX)
{
hndl.Set(NULL);
}
else
{
CBaseEntity *pOther = GetEntity(params[3]);
if (!pOther)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[3]), params[3]);
}
IHandleEntity *pHandleEnt = (IHandleEntity *)pOther;
hndl.Set(pHandleEnt);
}
if (params[4] && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return 1;
}
static cell_t ChangeEdictState(IPluginContext *pContext, const cell_t *params)
{
edict_t *pEdict = GetEdict(params[1]);
if (!pEdict)
{
return pContext->ThrowNativeError("Edict %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
g_HL2.SetEdictStateChanged(pEdict, params[2]);
return 1;
}
static cell_t FindSendPropOffs(IPluginContext *pContext, const cell_t *params)
{
char *cls, *prop;
pContext->LocalToString(params[1], &cls);
pContext->LocalToString(params[2], &prop);
SendProp *pSend = g_HL2.FindInSendTable(cls, prop);
if (!pSend)
{
return -1;
}
return pSend->GetOffset();
}
static cell_t FindSendPropInfo(IPluginContext *pContext, const cell_t *params)
{
char *cls, *prop;
sm_sendprop_info_t info;
cell_t *pType, *pBits, *pLocal;
pContext->LocalToString(params[1], &cls);
pContext->LocalToString(params[2], &prop);
if (!g_HL2.FindSendPropInfo(cls, prop, &info))
{
return -1;
}
pContext->LocalToPhysAddr(params[3], &pType);
pContext->LocalToPhysAddr(params[4], &pBits);
pContext->LocalToPhysAddr(params[5], &pLocal);
switch (info.prop->GetType())
{
case DPT_Int:
{
*pType = PropField_Integer;
break;
}
case DPT_Float:
{
*pType = PropField_Float;
break;
}
case DPT_String:
{
*pType = PropField_String;
break;
}
case DPT_Vector:
{
*pType = PropField_Vector;
break;
}
default:
{
*pType = PropField_Unsupported;
break;
}
}
*pBits = info.prop->m_nBits;
*pLocal = info.prop->GetOffset();
return info.actual_offset;
}
static void GuessDataPropTypes(typedescription_t *td, cell_t * pSize, cell_t * pType)
{
switch (td->fieldType)
{
case FIELD_TICK:
case FIELD_MODELINDEX:
case FIELD_MATERIALINDEX:
case FIELD_INTEGER:
case FIELD_COLOR32:
{
*pType = PropField_Integer;
*pSize = 32;
return;
}
case FIELD_VECTOR:
case FIELD_POSITION_VECTOR:
{
*pType = PropField_Vector;
*pSize = 96;
return;
}
case FIELD_SHORT:
{
*pType = PropField_Integer;
*pSize = 16;
return;
}
case FIELD_BOOLEAN:
{
*pType = PropField_Integer;
*pSize = 1;
return;
}
case FIELD_CHARACTER:
{
if (td->fieldSize == 1)
{
*pType = PropField_Integer;
*pSize = 8;
}
else
{
*pType = PropField_String;
*pSize = 8 * td->fieldSize;
}
return;
}
case FIELD_MODELNAME:
case FIELD_SOUNDNAME:
case FIELD_STRING:
{
*pSize = sizeof(string_t);
*pType = PropField_String_T;
return;
}
case FIELD_FLOAT:
case FIELD_TIME:
{
*pType = PropField_Float;
*pSize = 32;
return;
}
case FIELD_EHANDLE:
{
*pType = PropField_Entity;
*pSize = 32;
return;
}
case FIELD_CUSTOM:
{
if ((td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
*pType = PropField_Variant;
*pSize = 0;
return;
}
}
}
*pType = PropField_Unsupported;
*pSize = 0;
}
static cell_t FindDataMapOffs(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
datamap_t *pMap;
typedescription_t *td;
char *offset;
pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
if ((pMap=CBaseEntity_GetDataDescMap(pEntity)) == NULL)
{
return pContext->ThrowNativeError("Unable to retrieve GetDataDescMap offset");
}
pContext->LocalToString(params[2], &offset);
sm_datatable_info_t info;
if (!g_HL2.FindDataMapInfo(pMap, offset, &info))
{
return -1;
}
td = info.prop;
if (params[0] == 4)
{
cell_t *pType, *pSize;
pContext->LocalToPhysAddr(params[3], &pType);
pContext->LocalToPhysAddr(params[4], &pSize);
GuessDataPropTypes(td, pSize, pType);
}
return GetTypeDescOffs(td);
}
static cell_t FindDataMapInfo(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
datamap_t *pMap;
typedescription_t *td;
char *offset;
pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
if ((pMap=CBaseEntity_GetDataDescMap(pEntity)) == NULL)
{
return pContext->ThrowNativeError("Unable to retrieve GetDataDescMap offset");
}
pContext->LocalToString(params[2], &offset);
sm_datatable_info_t info;
if (!g_HL2.FindDataMapInfo(pMap, offset, &info))
{
return -1;
}
td = info.prop;
if (params[0] >= 4)
{
cell_t *pType, *pSize;
pContext->LocalToPhysAddr(params[3], &pType);
pContext->LocalToPhysAddr(params[4], &pSize);
GuessDataPropTypes(td, pSize, pType);
if (params[0] == 5)
{
cell_t *pLocalOffs;
pContext->LocalToPhysAddr(params[5], &pLocalOffs);
*pLocalOffs = GetTypeDescOffs(info.prop);
}
}
return info.actual_offset;
}
static cell_t GetEntDataString(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset < 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
size_t len;
char *src = (char *)((uint8_t *)pEntity + offset);
pContext->StringToLocalUTF8(params[3], params[4], src, &len);
return len;
}
static cell_t SetEntDataString(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
edict_t *pEdict;
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
int offset = params[2];
if (offset < 0 || offset > 32768)
{
return pContext->ThrowNativeError("Offset %d is invalid", offset);
}
char *src;
char *dest = (char *)((uint8_t *)pEntity + offset);
pContext->LocalToString(params[3], &src);
size_t len = ke::SafeStrcpy(dest, params[4], src);
if (params[5] && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return len;
}
#define FIND_PROP_DATA(td) \
datamap_t *pMap; \
if ((pMap = CBaseEntity_GetDataDescMap(pEntity)) == NULL) \
{ \
return pContext->ThrowNativeError("Could not retrieve datamap"); \
} \
sm_datatable_info_t info; \
if (!g_HL2.FindDataMapInfo(pMap, prop, &info)) \
{ \
const char *class_name = g_HL2.GetEntityClassname(pEntity); \
return pContext->ThrowNativeError("Property \"%s\" not found (entity %d/%s)", \
prop, \
params[1], \
((class_name) ? class_name : "")); \
} \
td = info.prop;
#define CHECK_SET_PROP_DATA_OFFSET() \
if (element < 0 || element >= td->fieldSize) \
{ \
return pContext->ThrowNativeError("Element %d is out of bounds (Prop %s has %d elements).", \
element, \
prop, \
td->fieldSize); \
} \
\
offset = info.actual_offset + (element * (td->fieldSizeInBytes / td->fieldSize));
#define CHECK_TYPE_VALID_IF_VARIANT(type, typeName) \
if (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT) \
{ \
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset); \
if (pVariant->fieldType != type) \
{ \
return pContext->ThrowNativeError("Variant value for %s is not %s (%d)", \
prop, \
typeName, \
pVariant->fieldType); \
} \
}
#define SET_TYPE_IF_VARIANT(type) \
if (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT) \
{ \
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset); \
pVariant->fieldType = type; \
}
#define FIND_PROP_SEND(type, type_name) \
sm_sendprop_info_t info;\
SendProp *pProp; \
IServerUnknown *pUnk = (IServerUnknown *)pEntity; \
IServerNetworkable *pNet = pUnk->GetNetworkable(); \
if (!pNet) \
{ \
return pContext->ThrowNativeError("Edict %d (%d) is not networkable", g_HL2.ReferenceToIndex(params[1]), params[1]); \
} \
if (!g_HL2.FindSendPropInfo(pNet->GetServerClass()->GetName(), prop, &info)) \
{ \
const char *class_name = g_HL2.GetEntityClassname(pEntity); \
return pContext->ThrowNativeError("Property \"%s\" not found (entity %d/%s)", \
prop, \
params[1], \
((class_name) ? class_name : "")); \
} \
\
offset = info.actual_offset; \
pProp = info.prop; \
bit_count = pProp->m_nBits; \
\
switch (pProp->GetType()) \
{ \
case type: \
{ \
if (element != 0) \
{ \
return pContext->ThrowNativeError("SendProp %s is not an array. Element %d is invalid.", \
prop, \
element); \
} \
break; \
} \
case DPT_DataTable: \
{ \
FIND_PROP_SEND_IN_SENDTABLE(info, pProp, element, type, type_name); \
\
offset += pProp->GetOffset(); \
bit_count = pProp->m_nBits; \
break; \
} \
default: \
{ \
return pContext->ThrowNativeError("SendProp %s type is not " type_name " (%d != %d)", \
prop, \
pProp->GetType(), \
type); \
} \
} \
#define FIND_PROP_SEND_IN_SENDTABLE(info, pProp, element, type, type_name) \
SendTable *pTable = pProp->GetDataTable(); \
if (!pTable) \
{ \
return pContext->ThrowNativeError("Error looking up DataTable for prop %s", \
prop); \
} \
\
int elementCount = pTable->GetNumProps(); \
if (element < 0 || element >= elementCount) \
{ \
return pContext->ThrowNativeError("Element %d is out of bounds (Prop %s has %d elements).", \
element, \
prop, \
elementCount); \
} \
\
pProp = pTable->GetProp(element); \
if (pProp->GetType() != type) \
{ \
return pContext->ThrowNativeError("SendProp %s type is not " type_name " ([%d,%d] != %d)", \
prop, \
pProp->GetType(), \
pProp->m_nBits, \
type); \
}
inline int MatchTypeDescAsInteger(_fieldtypes type, int flags)
{
switch (type)
{
case FIELD_TICK:
case FIELD_MODELINDEX:
case FIELD_MATERIALINDEX:
case FIELD_INTEGER:
case FIELD_COLOR32:
return 32;
case FIELD_CUSTOM:
if ((flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
// Variant, read as int32.
return 32;
}
break;
case FIELD_SHORT:
return 16;
case FIELD_CHARACTER:
return 8;
case FIELD_BOOLEAN:
return 1;
default:
return 0;
}
return 0;
}
static cell_t GetEntPropArraySize(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
edict_t *pEdict;
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
return td->fieldSize;
}
case Prop_Send:
{
sm_sendprop_info_t info;
IServerUnknown *pUnk = (IServerUnknown *)pEntity;
IServerNetworkable *pNet = pUnk->GetNetworkable();
if (!pNet)
{
return pContext->ThrowNativeError("Edict %d (%d) is not networkable", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
if (!g_HL2.FindSendPropInfo(pNet->GetServerClass()->GetName(), prop, &info))
{
const char *class_name = g_HL2.GetEntityClassname(pEntity);
return pContext->ThrowNativeError("Property \"%s\" not found (entity %d/%s)",
prop,
params[1],
((class_name) ? class_name : ""));
}
if (info.prop->GetType() != DPT_DataTable)
{
return 0;
}
SendTable *pTable = info.prop->GetDataTable();
if (!pTable)
{
return pContext->ThrowNativeError("Error looking up DataTable for prop %s", prop);
}
return pTable->GetNumProps();
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
return 1;
}
static cell_t GetEntProp(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
edict_t *pEdict;
int bit_count;
bool is_unsigned = false;
int element = 0;
if (params[0] >= 5)
{
element = params[5];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
if ((bit_count = MatchTypeDescAsInteger(td->fieldType, td->flags)) == 0)
{
return pContext->ThrowNativeError("Data field %s is not an integer (%d)",
prop,
td->fieldType);
}
CHECK_SET_PROP_DATA_OFFSET();
if (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset);
if ((bit_count = MatchTypeDescAsInteger(pVariant->fieldType, 0)) == 0)
{
return pContext->ThrowNativeError("Variant value for %s is not an integer (%d)",
prop,
pVariant->fieldType);
} \
}
break;
}
case Prop_Send:
{
FIND_PROP_SEND(DPT_Int, "integer");
is_unsigned = ((pProp->GetFlags() & SPROP_UNSIGNED) == SPROP_UNSIGNED);
// This isn't in CS:S yet, but will be, doesn't hurt to add now, and will save us a build later
#if SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_HL2DM || SOURCE_ENGINE == SE_DODS \
|| SOURCE_ENGINE == SE_BMS || SOURCE_ENGINE == SE_SDK2013 || SOURCE_ENGINE == SE_TF2 \
|| SOURCE_ENGINE == SE_CSGO
if (pProp->GetFlags() & SPROP_VARINT)
{
bit_count = sizeof(int) * 8;
}
#endif
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
if (bit_count < 1)
{
bit_count = params[4] * 8;
}
if (bit_count >= 17)
{
return *(int32_t *)((uint8_t *)pEntity + offset);
}
else if (bit_count >= 9)
{
if (is_unsigned)
{
return *(uint16_t *)((uint8_t *)pEntity + offset);
}
else
{
return *(int16_t *)((uint8_t *)pEntity + offset);
}
}
else if (bit_count >= 2)
{
if (is_unsigned)
{
return *(uint8_t *)((uint8_t *)pEntity + offset);
}
else
{
return *(int8_t *)((uint8_t *)pEntity + offset);
}
}
else
{
return *(bool *)((uint8_t *)pEntity + offset) ? 1 : 0;
}
return 0;
}
static cell_t SetEntProp(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
edict_t *pEdict;
int bit_count;
int element = 0;
if (params[0] >= 6)
{
element = params[6];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
if ((bit_count = MatchTypeDescAsInteger(td->fieldType, td->flags)) == 0)
{
return pContext->ThrowNativeError("Data field %s is not an integer (%d)",
prop,
td->fieldType);
}
CHECK_SET_PROP_DATA_OFFSET();
if (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset);
// These are the only three int-ish types that variants support. If set to valid one that isn't
// (32-bit) integer, leave it alone. It's probably the intended type.
if (pVariant->fieldType != FIELD_COLOR32 && pVariant->fieldType != FIELD_BOOLEAN)
{
pVariant->fieldType = FIELD_INTEGER;
}
bit_count = MatchTypeDescAsInteger(pVariant->fieldType, 0);
}
SET_TYPE_IF_VARIANT(FIELD_INTEGER);
break;
}
case Prop_Send:
{
FIND_PROP_SEND(DPT_Int, "integer");
if (!CanSetPropName(prop))
{
return pContext->ThrowNativeError("Cannot set %s with \"FollowCSGOServerGuidelines\" option enabled.", prop);
}
// This isn't in CS:S yet, but will be, doesn't hurt to add now, and will save us a build later
#if SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_HL2DM || SOURCE_ENGINE == SE_DODS \
|| SOURCE_ENGINE == SE_BMS || SOURCE_ENGINE == SE_SDK2013 || SOURCE_ENGINE == SE_TF2 \
|| SOURCE_ENGINE == SE_CSGO
if (pProp->GetFlags() & SPROP_VARINT)
{
bit_count = sizeof(int) * 8;
}
#endif
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
if (bit_count < 1)
{
bit_count = params[5] * 8;
}
if (bit_count >= 17)
{
*(int32_t *)((uint8_t *)pEntity + offset) = params[4];
}
else if (bit_count >= 9)
{
*(int16_t *)((uint8_t *)pEntity + offset) = (int16_t)params[4];
}
else if (bit_count >= 2)
{
*(int8_t *)((uint8_t *)pEntity + offset) = (int8_t)params[4];
}
else
{
*(bool *)((uint8_t *)pEntity + offset) = params[4] ? true : false;
}
if (params[2] == Prop_Send && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return 0;
}
static cell_t GetEntPropFloat(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
int bit_count;
edict_t *pEdict;
int element = 0;
if (params[0] >= 4)
{
element = params[4];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
if (td->fieldType != FIELD_FLOAT
&& td->fieldType != FIELD_TIME)
{
return pContext->ThrowNativeError("Data field %s is not a float (%d != [%d,%d])",
prop,
td->fieldType,
FIELD_FLOAT,
FIELD_TIME);
}
CHECK_SET_PROP_DATA_OFFSET();
CHECK_TYPE_VALID_IF_VARIANT(FIELD_FLOAT, "float");
break;
}
case Prop_Send:
{
FIND_PROP_SEND(DPT_Float, "float");
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
float val = *(float *)((uint8_t *)pEntity + offset);
return sp_ftoc(val);
}
static cell_t SetEntPropFloat(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
int bit_count;
edict_t *pEdict;
int element = 0;
if (params[0] >= 5)
{
element = params[5];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
if (td->fieldType != FIELD_FLOAT
&& td->fieldType != FIELD_TIME)
{
return pContext->ThrowNativeError("Data field %s is not a float (%d != [%d,%d])",
prop,
td->fieldType,
FIELD_FLOAT,
FIELD_TIME);
}
CHECK_SET_PROP_DATA_OFFSET();
SET_TYPE_IF_VARIANT(FIELD_FLOAT);
break;
}
case Prop_Send:
{
FIND_PROP_SEND(DPT_Float, "float");
if (!CanSetPropName(prop))
{
return pContext->ThrowNativeError("Cannot set %s with \"FollowCSGOServerGuidelines\" option enabled.", prop);
}
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
*(float *)((uint8_t *)pEntity + offset) = sp_ctof(params[4]);
if (params[2] == Prop_Send && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return 1;
}
enum PropEntType
{
PropEnt_Unknown,
PropEnt_Handle,
PropEnt_Entity,
PropEnt_Edict,
PropEnt_Variant,
};
static cell_t GetEntPropEnt(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
int bit_count;
edict_t *pEdict;
PropEntType type = PropEnt_Unknown;
int element = 0;
if (params[0] >= 4)
{
element = params[4];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
switch (td->fieldType)
{
case FIELD_EHANDLE:
type = PropEnt_Handle;
break;
case FIELD_CLASSPTR:
type = PropEnt_Entity;
break;
case FIELD_EDICT:
type = PropEnt_Edict;
break;
case FIELD_CUSTOM:
if ((td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
type = PropEnt_Variant;
}
break;
}
if (type == PropEnt_Unknown)
{
return pContext->ThrowNativeError("Data field %s is not an entity nor edict (%d)",
prop,
td->fieldType);
}
CHECK_SET_PROP_DATA_OFFSET();
CHECK_TYPE_VALID_IF_VARIANT(FIELD_EHANDLE, "ehandle");
break;
}
case Prop_Send:
{
type = PropEnt_Handle;
FIND_PROP_SEND(DPT_Int, "integer");
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
switch (type)
{
case PropEnt_Handle:
case PropEnt_Variant:
{
CBaseHandle *hndl;
if (type == PropEnt_Handle)
{
hndl = (CBaseHandle *)((uint8_t *)pEntity + offset);
}
else // PropEnt_Variant
{
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset);
hndl = &pVariant->eVal;
}
CBaseEntity *pHandleEntity = g_HL2.ReferenceToEntity(hndl->GetEntryIndex());
if (!pHandleEntity || *hndl != reinterpret_cast<IHandleEntity *>(pHandleEntity)->GetRefEHandle())
return -1;
return g_HL2.EntityToBCompatRef(pHandleEntity);
}
case PropEnt_Entity:
{
CBaseEntity *pPropEntity = *(CBaseEntity **) ((uint8_t *) pEntity + offset);
return g_HL2.EntityToBCompatRef(pPropEntity);
}
case PropEnt_Edict:
{
edict_t *pEdict = *(edict_t **) ((uint8_t *) pEntity + offset);
if (!pEdict || pEdict->IsFree())
return -1;
return IndexOfEdict(pEdict);
}
}
return -1;
}
static cell_t SetEntPropEnt(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
int bit_count;
edict_t *pEdict;
PropEntType type = PropEnt_Unknown;
int element = 0;
if (params[0] >= 5)
{
element = params[5];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
switch (td->fieldType)
{
case FIELD_EHANDLE:
type = PropEnt_Handle;
break;
case FIELD_CLASSPTR:
type = PropEnt_Entity;
break;
case FIELD_EDICT:
type = PropEnt_Edict;
if (!pEdict)
return pContext->ThrowNativeError("Edict %d is invalid", params[1]);
break;
case FIELD_CUSTOM:
if ((td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
type = PropEnt_Variant;
}
break;
}
if (type == PropEnt_Unknown)
{
return pContext->ThrowNativeError("Data field %s is not an entity nor edict (%d)",
prop,
td->fieldType);
}
CHECK_SET_PROP_DATA_OFFSET();
SET_TYPE_IF_VARIANT(FIELD_EHANDLE);
break;
}
case Prop_Send:
{
type = PropEnt_Handle;
FIND_PROP_SEND(DPT_Int, "integer");
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
CBaseEntity *pOther = GetEntity(params[4]);
if (!pOther && params[4] != -1)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[4]), params[4]);
}
switch (type)
{
case PropEnt_Handle:
case PropEnt_Variant:
{
CBaseHandle *hndl;
if (type == PropEnt_Handle)
{
hndl = (CBaseHandle *)((uint8_t *)pEntity + offset);
}
else // PropEnt_Variant
{
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset);
hndl = &pVariant->eVal;
}
hndl->Set((IHandleEntity *) pOther);
if (params[2] == Prop_Send && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
}
break;
case PropEnt_Entity:
{
*(CBaseEntity **) ((uint8_t *) pEntity + offset) = pOther;
break;
}
case PropEnt_Edict:
{
edict_t *pOtherEdict = NULL;
if (pOther)
{
IServerNetworkable *pNetworkable = ((IServerUnknown *) pOther)->GetNetworkable();
if (!pNetworkable)
{
return pContext->ThrowNativeError("Entity %d (%d) does not have a valid edict", g_HL2.ReferenceToIndex(params[4]), params[4]);
}
pOtherEdict = pNetworkable->GetEdict();
if (!pOtherEdict || pOtherEdict->IsFree())
{
return pContext->ThrowNativeError("Entity %d (%d) does not have a valid edict", g_HL2.ReferenceToIndex(params[4]), params[4]);
}
}
*(edict_t **) ((uint8_t *) pEntity + offset) = pOtherEdict;
break;
}
}
return 1;
}
static cell_t GetEntPropVector(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
int bit_count;
edict_t *pEdict;
int element = 0;
if (params[0] >= 5)
{
element = params[5];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
if (td->fieldType != FIELD_VECTOR
&& td->fieldType != FIELD_POSITION_VECTOR)
{
return pContext->ThrowNativeError("Data field %s is not a vector (%d != [%d,%d])",
prop,
td->fieldType,
FIELD_VECTOR,
FIELD_POSITION_VECTOR);
}
CHECK_SET_PROP_DATA_OFFSET();
if (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset);
if (pVariant->fieldType != FIELD_VECTOR && pVariant->fieldType != FIELD_POSITION_VECTOR)
{
return pContext->ThrowNativeError("Variant value for %s is not vector (%d)",
prop,
pVariant->fieldType);
}
}
break;
}
case Prop_Send:
{
FIND_PROP_SEND(DPT_Vector, "vector");
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
Vector *v = (Vector *)((uint8_t *)pEntity + offset);
cell_t *vec;
pContext->LocalToPhysAddr(params[4], &vec);
vec[0] = sp_ftoc(v->x);
vec[1] = sp_ftoc(v->y);
vec[2] = sp_ftoc(v->z);
return 1;
}
static cell_t SetEntPropVector(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
int bit_count;
edict_t *pEdict;
int element = 0;
if (params[0] >= 5)
{
element = params[5];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
switch (params[2])
{
case Prop_Data:
{
typedescription_t *td;
FIND_PROP_DATA(td);
if (td->fieldType != FIELD_VECTOR
&& td->fieldType != FIELD_POSITION_VECTOR)
{
return pContext->ThrowNativeError("Data field %s is not a vector (%d != [%d,%d])",
prop,
td->fieldType,
FIELD_VECTOR,
FIELD_POSITION_VECTOR);
}
CHECK_SET_PROP_DATA_OFFSET();
if (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) == FTYPEDESC_OUTPUT)
{
auto *pVariant = (variant_t *)((intptr_t)pEntity + offset);
// Both of these are supported and we don't know which is intended. But, if it's already
// a pos vector, we probably want to keep that.
if (pVariant->fieldType != FIELD_POSITION_VECTOR)
{
pVariant->fieldType = FIELD_VECTOR;
}
}
break;
}
case Prop_Send:
{
FIND_PROP_SEND(DPT_Vector, "vector");
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
Vector *v = (Vector *)((uint8_t *)pEntity + offset);
cell_t *vec;
pContext->LocalToPhysAddr(params[4], &vec);
v->x = sp_ctof(vec[0]);
v->y = sp_ctof(vec[1]);
v->z = sp_ctof(vec[2]);
if (params[2] == Prop_Send && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return 1;
}
static cell_t GetEntPropString(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
edict_t *pEdict;
int element = 0;
if (params[0] >= 6)
{
element = params[6];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
pContext->LocalToString(params[3], &prop);
const char *src;
switch (params[2])
{
case Prop_Data:
{
bool bIsStringIndex = false;
typedescription_t *td;
FIND_PROP_DATA(td);
if ((td->fieldType != FIELD_CHARACTER
&& td->fieldType != FIELD_STRING
&& td->fieldType != FIELD_MODELNAME
&& td->fieldType != FIELD_SOUNDNAME)
|| (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) != FTYPEDESC_OUTPUT))
{
return pContext->ThrowNativeError("Data field %s is not a string (%d != %d)",
prop,
td->fieldType,
FIELD_CHARACTER);
}
bIsStringIndex = (td->fieldType != FIELD_CHARACTER);
if (element != 0)
{
if (bIsStringIndex)
{
if (element < 0 || element >= td->fieldSize)
{
return pContext->ThrowNativeError("Element %d is out of bounds (Prop %s has %d elements).",
element,
prop,
td->fieldSize);
}
}
else
{
return pContext->ThrowNativeError("Prop %s is not an array. Element %d is invalid.",
prop,
element);
}
}
offset = info.actual_offset;
if (bIsStringIndex)
{
offset += (element * (td->fieldSizeInBytes / td->fieldSize));
string_t idx;
idx = *(string_t *) ((uint8_t *) pEntity + offset);
src = (idx == NULL_STRING) ? "" : STRING(idx);
}
else
{
src = (char *) ((uint8_t *) pEntity + offset);
}
break;
}
case Prop_Send:
{
sm_sendprop_info_t info;
IServerUnknown *pUnk = (IServerUnknown *)pEntity;
IServerNetworkable *pNet = pUnk->GetNetworkable();
if (!pNet)
{
return pContext->ThrowNativeError("Edict %d (%d) is not networkable", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
if (!g_HL2.FindSendPropInfo(pNet->GetServerClass()->GetName(), prop, &info))
{
const char *class_name = g_HL2.GetEntityClassname(pEntity);
return pContext->ThrowNativeError("Property \"%s\" not found (entity %d/%s)",
prop,
params[1],
((class_name) ? class_name : ""));
}
offset = info.actual_offset;
if (info.prop->GetType() != DPT_String)
{
return pContext->ThrowNativeError("SendProp %s is not a string (%d != %d)",
prop,
info.prop->GetType(),
DPT_String);
}
else if (element != 0)
{
return pContext->ThrowNativeError("SendProp %s is not an array. Element %d is invalid.",
prop,
element);
}
if (info.prop->GetProxyFn())
{
DVariant var;
info.prop->GetProxyFn()(info.prop, pEntity, (const void *) ((intptr_t) pEntity + offset), &var, element, params[1]);
src = var.m_pString;
}
else
{
src = (char *) ((uint8_t *) pEntity + offset);
}
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
size_t len;
pContext->StringToLocalUTF8(params[4], params[5], src, &len);
return len;
}
static cell_t SetEntPropString(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity;
char *prop;
int offset;
int maxlen;
edict_t *pEdict;
bool bIsStringIndex;
int element = 0;
if (params[0] >= 5)
{
element = params[5];
}
if (!IndexToAThings(params[1], &pEntity, &pEdict))
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
switch (params[2])
{
case Prop_Data:
{
datamap_t *pMap;
if ((pMap=CBaseEntity_GetDataDescMap(pEntity)) == NULL)
{
return pContext->ThrowNativeError("Unable to retrieve GetDataDescMap offset");
}
pContext->LocalToString(params[3], &prop);
sm_datatable_info_t info;
if (!g_HL2.FindDataMapInfo(pMap, prop, &info))
{
return pContext->ThrowNativeError("Property \"%s\" not found for entity %d", prop, params[1]);
}
typedescription_t *td = info.prop;
if ((td->fieldType != FIELD_CHARACTER
&& td->fieldType != FIELD_STRING
&& td->fieldType != FIELD_MODELNAME
&& td->fieldType != FIELD_SOUNDNAME)
|| (td->fieldType == FIELD_CUSTOM && (td->flags & FTYPEDESC_OUTPUT) != FTYPEDESC_OUTPUT))
{
return pContext->ThrowNativeError("Property \"%s\" is not a valid string", prop);
}
offset = info.actual_offset;
bIsStringIndex = (td->fieldType != FIELD_CHARACTER);
if (element != 0)
{
if (bIsStringIndex)
{
if (element < 0 || element >= td->fieldSize)
{
return pContext->ThrowNativeError("Element %d is out of bounds (Prop %s has %d elements).",
element,
prop,
td->fieldSize);
}
}
else
{
return pContext->ThrowNativeError("Prop %s is not an array. Element %d is invalid.",
prop,
element);
}
}
if (!CanSetPropName(prop))
{
return pContext->ThrowNativeError("Cannot set %s with \"FollowCSGOServerGuidelines\" option enabled.", prop);
}
if (bIsStringIndex)
{
offset += (element * (td->fieldSizeInBytes / td->fieldSize));
}
else
{
maxlen = td->fieldSize;
}
SET_TYPE_IF_VARIANT(FIELD_STRING);
break;
}
case Prop_Send:
{
sm_sendprop_info_t info;
IServerUnknown *pUnk = (IServerUnknown *)pEntity;
IServerNetworkable *pNet = pUnk->GetNetworkable();
if (!pNet)
{
return pContext->ThrowNativeError("The edict is not networkable");
}
pContext->LocalToString(params[3], &prop);
if (!g_HL2.FindSendPropInfo(pNet->GetServerClass()->GetName(), prop, &info))
{
return pContext->ThrowNativeError("Property \"%s\" not found for entity %d", prop, params[1]);
}
offset = info.prop->GetOffset();
if (info.prop->GetType() != DPT_String)
{
return pContext->ThrowNativeError("Property \"%s\" is not a valid string", prop);
}
else if (element != 0)
{
return pContext->ThrowNativeError("SendProp %s is not an array. Element %d is invalid.",
prop,
element);
}
bIsStringIndex = false;
if (info.prop->GetProxyFn())
{
DVariant var;
info.prop->GetProxyFn()(info.prop, pEntity, (const void *) ((intptr_t) pEntity + offset), &var, element, params[1]);
if (var.m_pString == ((string_t *) ((intptr_t) pEntity + offset))->ToCStr())
{
bIsStringIndex = true;
}
}
// Only used if not string index.
maxlen = DT_MAX_STRING_BUFFERSIZE;
break;
}
default:
{
return pContext->ThrowNativeError("Invalid Property type %d", params[2]);
}
}
char *src;
size_t len;
pContext->LocalToString(params[4], &src);
if (bIsStringIndex)
{
#if SOURCE_ENGINE < SE_ORANGEBOX
return pContext->ThrowNativeError("Cannot set %s. Setting string_t values not supported on this game.", prop);
#else
*(string_t *) ((intptr_t) pEntity + offset) = g_HL2.AllocPooledString(src);
len = strlen(src);
#endif
}
else
{
char *dest = (char *) ((uint8_t *) pEntity + offset);
len = ke::SafeStrcpy(dest, maxlen, src);
}
if (params[2] == Prop_Send && (pEdict != NULL))
{
g_HL2.SetEdictStateChanged(pEdict, offset);
}
return len;
}
static int32_t SDKEntFlagToSMEntFlag(int flag)
{
switch (flag)
{
case FL_ONGROUND:
return ENTFLAG_ONGROUND;
case FL_DUCKING:
return ENTFLAG_DUCKING;
case FL_WATERJUMP:
return ENTFLAG_WATERJUMP;
case FL_ONTRAIN:
return ENTFLAG_ONTRAIN;
case FL_INRAIN:
return ENTFLAG_INRAIN;
case FL_FROZEN:
return ENTFLAG_FROZEN;
case FL_ATCONTROLS:
return ENTFLAG_ATCONTROLS;
case FL_CLIENT:
return ENTFLAG_CLIENT;
case FL_FAKECLIENT:
return ENTFLAG_FAKECLIENT;
case FL_INWATER:
return ENTFLAG_INWATER;
case FL_FLY:
return ENTFLAG_FLY;
case FL_SWIM:
return ENTFLAG_SWIM;
case FL_CONVEYOR:
return ENTFLAG_CONVEYOR;
case FL_NPC:
return ENTFLAG_NPC;
case FL_GODMODE:
return ENTFLAG_GODMODE;
case FL_NOTARGET:
return ENTFLAG_NOTARGET;
case FL_AIMTARGET:
return ENTFLAG_AIMTARGET;
case FL_PARTIALGROUND:
return ENTFLAG_PARTIALGROUND;
case FL_STATICPROP:
return ENTFLAG_STATICPROP;
case FL_GRAPHED:
return ENTFLAG_GRAPHED;
case FL_GRENADE:
return ENTFLAG_GRENADE;
case FL_STEPMOVEMENT:
return ENTFLAG_STEPMOVEMENT;
case FL_DONTTOUCH:
return ENTFLAG_DONTTOUCH;
case FL_BASEVELOCITY:
return ENTFLAG_BASEVELOCITY;
case FL_WORLDBRUSH:
return ENTFLAG_WORLDBRUSH;
case FL_OBJECT:
return ENTFLAG_OBJECT;
case FL_KILLME:
return ENTFLAG_KILLME;
case FL_ONFIRE:
return ENTFLAG_ONFIRE;
case FL_DISSOLVING:
return ENTFLAG_DISSOLVING;
case FL_TRANSRAGDOLL:
return ENTFLAG_TRANSRAGDOLL;
case FL_UNBLOCKABLE_BY_PLAYER:
return ENTFLAG_UNBLOCKABLE_BY_PLAYER;
#if SOURCE_ENGINE == SE_ALIENSWARM
case FL_FREEZING:
return ENTFLAG_FREEZING;
#elif SOURCE_ENGINE == SE_HL2DM || SOURCE_ENGINE == SE_DODS || SOURCE_ENGINE == SE_SDK2013 \
|| SOURCE_ENGINE == SE_BMS || SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_TF2
case FL_EP2V_UNKNOWN:
return ENTFLAG_EP2V_UNKNOWN1;
#endif
default:
return 0;
}
}
static int32_t SMEntFlagToSDKEntFlag(int32_t flag)
{
switch (flag)
{
case ENTFLAG_ONGROUND:
return FL_ONGROUND;
case ENTFLAG_DUCKING:
return FL_DUCKING;
case ENTFLAG_WATERJUMP:
return FL_WATERJUMP;
case ENTFLAG_ONTRAIN:
return FL_ONTRAIN;
case ENTFLAG_INRAIN:
return FL_INRAIN;
case ENTFLAG_FROZEN:
return FL_FROZEN;
case ENTFLAG_ATCONTROLS:
return FL_ATCONTROLS;
case ENTFLAG_CLIENT:
return FL_CLIENT;
case ENTFLAG_FAKECLIENT:
return FL_FAKECLIENT;
case ENTFLAG_INWATER:
return FL_INWATER;
case ENTFLAG_FLY:
return FL_FLY;
case ENTFLAG_SWIM:
return FL_SWIM;
case ENTFLAG_CONVEYOR:
return FL_CONVEYOR;
case ENTFLAG_NPC:
return FL_NPC;
case ENTFLAG_GODMODE:
return FL_GODMODE;
case ENTFLAG_NOTARGET:
return FL_NOTARGET;
case ENTFLAG_AIMTARGET:
return FL_AIMTARGET;
case ENTFLAG_PARTIALGROUND:
return FL_PARTIALGROUND;
case ENTFLAG_STATICPROP:
return FL_STATICPROP;
case ENTFLAG_GRAPHED:
return FL_GRAPHED;
case ENTFLAG_GRENADE:
return FL_GRENADE;
case ENTFLAG_STEPMOVEMENT:
return FL_STEPMOVEMENT;
case ENTFLAG_DONTTOUCH:
return FL_DONTTOUCH;
case ENTFLAG_BASEVELOCITY:
return FL_BASEVELOCITY;
case ENTFLAG_WORLDBRUSH:
return FL_WORLDBRUSH;
case ENTFLAG_OBJECT:
return FL_OBJECT;
case ENTFLAG_KILLME:
return FL_KILLME;
case ENTFLAG_ONFIRE:
return FL_ONFIRE;
case ENTFLAG_DISSOLVING:
return FL_DISSOLVING;
case ENTFLAG_TRANSRAGDOLL:
return FL_TRANSRAGDOLL;
case ENTFLAG_UNBLOCKABLE_BY_PLAYER:
return FL_UNBLOCKABLE_BY_PLAYER;
#if SOURCE_ENGINE == SE_ALIENSWARM
case ENTFLAG_FREEZING:
return FL_FREEZING;
#elif SOURCE_ENGINE == SE_HL2DM || SOURCE_ENGINE == SE_DODS || SOURCE_ENGINE == SE_SDK2013 \
|| SOURCE_ENGINE == SE_BMS || SOURCE_ENGINE == SE_CSS || SOURCE_ENGINE == SE_TF2
case ENTFLAG_EP2V_UNKNOWN1:
return FL_EP2V_UNKNOWN;
#endif
default:
return 0;
}
}
static cell_t GetEntityFlags(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = g_HL2.ReferenceToEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
const char *prop = g_pGameConf->GetKeyValue("m_fFlags");
if (!prop)
{
return pContext->ThrowNativeError("Could not find m_fFlags prop in gamedata");
}
datamap_t *pMap;
if ((pMap = CBaseEntity_GetDataDescMap(pEntity)) == NULL)
{
return pContext->ThrowNativeError("Could not retrieve datamap");
}
sm_datatable_info_t info;
if (!g_HL2.FindDataMapInfo(pMap, prop, &info))
{
return pContext->ThrowNativeError("Property \"%s\" not found (entity %d)",
prop,
params[1]);
}
int offset = info.actual_offset;
int32_t actual_flags = *(int32_t *)((uint8_t *)pEntity + offset);
int32_t sm_flags = 0;
for (int32_t i = 0; i < 32; i++)
{
int32_t flag = (1U<<i);
if ((actual_flags & flag) == flag)
{
sm_flags |= SDKEntFlagToSMEntFlag(flag);
}
}
return sm_flags;
}
static cell_t SetEntityFlags(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity *pEntity = g_HL2.ReferenceToEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
const char *prop = g_pGameConf->GetKeyValue("m_fFlags");
if (!prop)
{
return pContext->ThrowNativeError("Could not find m_fFlags prop in gamedata");
}
datamap_t *pMap;
if ((pMap = CBaseEntity_GetDataDescMap(pEntity)) == NULL)
{
return pContext->ThrowNativeError("Could not retrieve datamap");
}
sm_datatable_info_t info;
if (!g_HL2.FindDataMapInfo(pMap, prop, &info))
{
return pContext->ThrowNativeError("Property \"%s\" not found (entity %d)",
prop,
params[1]);
}
int offset = info.actual_offset;
int32_t sm_flags = params[2];
int32_t actual_flags = 0;
for (int32_t i = 0; i < 32; i++)
{
int32_t flag = (1U<<i);
if ((sm_flags & flag) == flag)
{
actual_flags |= SMEntFlagToSDKEntFlag(flag);
}
}
*(int32_t *)((uint8_t *)pEntity + offset) = actual_flags;
return 0;
}
static cell_t GetEntityAddress(IPluginContext *pContext, const cell_t *params)
{
CBaseEntity * pEntity = GetEntity(params[1]);
if (!pEntity)
{
return pContext->ThrowNativeError("Entity %d (%d) is invalid", g_HL2.ReferenceToIndex(params[1]), params[1]);
}
#ifdef PLATFORM_X86
return reinterpret_cast<cell_t>(pEntity);
#else
return g_SourceMod.ToPseudoAddress(pEntity);
#endif
}
REGISTER_NATIVES(entityNatives)
{
{"ChangeEdictState", ChangeEdictState},
{"CreateEdict", CreateEdict},
{"FindDataMapOffs", FindDataMapOffs},
{"FindSendPropInfo", FindSendPropInfo},
{"FindSendPropOffs", FindSendPropOffs},
{"GetEdictClassname", GetEdictClassname},
{"GetEdictFlags", GetEdictFlags},
{"GetEntData", GetEntData},
{"GetEntDataEnt", GetEntDataEnt}, /** DEPRECATED */
{"GetEntDataEnt2", GetEntDataEnt2},
{"GetEntDataFloat", GetEntDataFloat},
{"GetEntDataString", GetEntDataString},
{"GetEntDataVector", GetEntDataVector},
{"GetEntProp", GetEntProp},
{"GetEntPropArraySize", GetEntPropArraySize},
{"GetEntPropEnt", GetEntPropEnt},
{"GetEntPropFloat", GetEntPropFloat},
{"GetEntPropString", GetEntPropString},
{"GetEntPropVector", GetEntPropVector},
{"GetEntityCount", GetEntityCount},
{"GetEntityFlags", GetEntityFlags},
{"GetEntityNetClass", GetEntityNetClass},
{"GetMaxEntities", GetMaxEntities},
{"IsEntNetworkable", IsEntNetworkable},
{"IsValidEdict", IsValidEdict},
{"IsValidEntity", IsValidEntity},
{"RemoveEntity", RemoveEntity},
{"RemoveEdict", RemoveEdict},
{"SetEdictFlags", SetEdictFlags},
{"SetEntData", SetEntData},
{"SetEntDataEnt", SetEntDataEnt}, /** DEPRECATED */
{"SetEntDataEnt2", SetEntDataEnt2},
{"SetEntDataFloat", SetEntDataFloat},
{"SetEntDataVector", SetEntDataVector},
{"SetEntDataString", SetEntDataString},
{"SetEntityFlags", SetEntityFlags},
{"SetEntProp", SetEntProp},
{"SetEntPropEnt", SetEntPropEnt},
{"SetEntPropFloat", SetEntPropFloat},
{"SetEntPropString", SetEntPropString},
{"SetEntPropVector", SetEntPropVector},
{"GetEntityAddress", GetEntityAddress},
{"FindDataMapInfo", FindDataMapInfo},
{NULL, NULL}
};
Reference in New Issue View Git Blame Copy Permalink