mirror of
https://github.com/s1lentq/ReGameDLL_CS.git
synced 2024-10-17 15:56:54 +03:00
859 lines
20 KiB
C++
859 lines
20 KiB
C++
#include "precompiled.h"
|
|
#include "game_shared/perf_counter.h"
|
|
|
|
/*
|
|
* Globals initialization
|
|
*/
|
|
#ifndef HOOK_GAMEDLL
|
|
|
|
static DLL_FUNCTIONS gFunctionTable =
|
|
{
|
|
GameDLLInit,
|
|
DispatchSpawn,
|
|
DispatchThink,
|
|
DispatchUse,
|
|
DispatchTouch,
|
|
DispatchBlocked,
|
|
DispatchKeyValue,
|
|
DispatchSave,
|
|
DispatchRestore,
|
|
DispatchObjectCollsionBox,
|
|
SaveWriteFields,
|
|
SaveReadFields,
|
|
SaveGlobalState,
|
|
RestoreGlobalState,
|
|
ResetGlobalState,
|
|
ClientConnect,
|
|
ClientDisconnect,
|
|
ClientKill,
|
|
ClientPutInServer,
|
|
ClientCommand,
|
|
ClientUserInfoChanged,
|
|
ServerActivate,
|
|
ServerDeactivate,
|
|
PlayerPreThink,
|
|
PlayerPostThink,
|
|
StartFrame,
|
|
ParmsNewLevel,
|
|
ParmsChangeLevel,
|
|
GetGameDescription,
|
|
PlayerCustomization,
|
|
SpectatorConnect,
|
|
SpectatorDisconnect,
|
|
SpectatorThink,
|
|
Sys_Error,
|
|
PM_Move,
|
|
PM_Init,
|
|
PM_FindTextureType,
|
|
SetupVisibility,
|
|
UpdateClientData,
|
|
AddToFullPack,
|
|
CreateBaseline,
|
|
RegisterEncoders,
|
|
GetWeaponData,
|
|
CmdStart,
|
|
CmdEnd,
|
|
ConnectionlessPacket,
|
|
GetHullBounds,
|
|
CreateInstancedBaselines,
|
|
InconsistentFile,
|
|
AllowLagCompensation
|
|
};
|
|
|
|
static NEW_DLL_FUNCTIONS gNewDLLFunctions
|
|
{
|
|
OnFreeEntPrivateData,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
CMemoryPool hashItemMemPool(sizeof(hash_item_t), 64);
|
|
BOOL gTouchDisabled = FALSE;
|
|
|
|
#else // HOOK_GAMEDLL
|
|
|
|
DLL_FUNCTIONS gFunctionTable;
|
|
NEW_DLL_FUNCTIONS gNewDLLFunctions;
|
|
|
|
CMemoryPool hashItemMemPool;
|
|
BOOL gTouchDisabled;
|
|
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
/* <30850> ../cstrike/dlls/cbase.cpp:117 */
|
|
int CaseInsensitiveHash(const char *string, int iBounds)
|
|
{
|
|
unsigned int hash = 0;
|
|
if (!*string)
|
|
return 0;
|
|
|
|
while (*string)
|
|
{
|
|
if (*string < 'A' || *string > 'Z')
|
|
hash = *string + 2 * hash;
|
|
else
|
|
hash = *string + 2 * hash + ' ';
|
|
string++;
|
|
}
|
|
return (hash % iBounds);
|
|
}
|
|
|
|
/* <30d81> ../cstrike/dlls/cbase.cpp:136 */
|
|
void EmptyEntityHashTable(void)
|
|
{
|
|
int i;
|
|
hash_item_t *item;
|
|
hash_item_t *temp;
|
|
hash_item_t *free;
|
|
|
|
for (i = 0; i < stringsHashTable.Count(); i++)
|
|
{
|
|
item = &stringsHashTable[i];
|
|
temp = item->next;
|
|
|
|
item->pev = NULL;
|
|
item->pevIndex = 0;
|
|
item->lastHash = 0;
|
|
item->next = NULL;
|
|
|
|
while (temp)
|
|
{
|
|
free = temp;
|
|
temp = temp->next;
|
|
hashItemMemPool.Free(free);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* <2f053> ../cstrike/dlls/cbase.cpp:156 */
|
|
void AddEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType)
|
|
{
|
|
int count;
|
|
hash_item_t *item;
|
|
hash_item_t *next;
|
|
hash_item_t *temp;
|
|
hash_item_t *newp;
|
|
int hash;
|
|
int pevIndex;
|
|
entvars_t *pevtemp;
|
|
|
|
if (fieldType != CLASSNAME)
|
|
return;
|
|
|
|
if (FStringNull(pev->classname))
|
|
return;
|
|
|
|
count = stringsHashTable.Count();
|
|
hash = CaseInsensitiveHash(value, count);
|
|
pevIndex = ENTINDEX(ENT(pev));
|
|
item = &stringsHashTable[hash];
|
|
|
|
while (item->pev)
|
|
{
|
|
if (!strcmp(STRING(item->pev->classname), STRING(pev->classname)))
|
|
break;
|
|
|
|
hash = (hash + 1) % count;
|
|
item = &stringsHashTable[hash];
|
|
}
|
|
if (item->pev)
|
|
{
|
|
next = item->next;
|
|
while (next)
|
|
{
|
|
if (item->pev == pev || item->pevIndex >= pevIndex)
|
|
break;
|
|
|
|
item = next;
|
|
next = next->next;
|
|
}
|
|
if (pevIndex < item->pevIndex)
|
|
{
|
|
pevtemp = item->pev;
|
|
item->pev = pev;
|
|
item->lastHash = NULL;
|
|
item->pevIndex = pevIndex;
|
|
|
|
pevIndex = ENTINDEX(ENT(pevtemp));
|
|
}
|
|
else
|
|
pevtemp = pev;
|
|
|
|
if (item->pev != pevtemp)
|
|
{
|
|
temp = item->next;
|
|
newp = (hash_item_t *)hashItemMemPool.Alloc(sizeof(hash_item_t));
|
|
|
|
item->next = newp;
|
|
newp->pev = pevtemp;
|
|
newp->lastHash = NULL;
|
|
newp->pevIndex = pevIndex;
|
|
|
|
if (next)
|
|
newp->next = temp;
|
|
else
|
|
newp->next = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
item->pev = pev;
|
|
item->lastHash = NULL;
|
|
item->pevIndex = ENTINDEX(ENT(pev));
|
|
}
|
|
}
|
|
|
|
/* <2f0c8> ../cstrike/dlls/cbase.cpp:255 */
|
|
void RemoveEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType)
|
|
{
|
|
int hash;
|
|
hash_item_t *item;
|
|
hash_item_t *last;
|
|
int pevIndex;
|
|
int count;
|
|
|
|
count = stringsHashTable.Count();
|
|
hash = CaseInsensitiveHash(value, count);
|
|
pevIndex = ENTINDEX(ENT(pev));
|
|
|
|
if (fieldType != CLASSNAME)
|
|
return;
|
|
|
|
hash = hash % count;
|
|
item = &stringsHashTable[hash];
|
|
|
|
while (item->pev)
|
|
{
|
|
if (!strcmp(STRING(item->pev->classname), STRING(pev->classname)))
|
|
break;
|
|
|
|
hash = (hash + 1) % count;
|
|
item = &stringsHashTable[hash];
|
|
}
|
|
if (item->pev)
|
|
{
|
|
last = item;
|
|
while (item->next)
|
|
{
|
|
if (item->pev == pev)
|
|
break;
|
|
|
|
last = item;
|
|
item = item->next;
|
|
}
|
|
if (item->pev == pev)
|
|
{
|
|
if (last == item)
|
|
{
|
|
if (item->next)
|
|
{
|
|
item->pev = item->next->pev;
|
|
item->pevIndex = item->next->pevIndex;
|
|
item->lastHash = NULL;
|
|
item->next = item->next->next;
|
|
}
|
|
else
|
|
{
|
|
item->pev = NULL;
|
|
item->lastHash = NULL;
|
|
item->pevIndex = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (stringsHashTable[hash].lastHash == item)
|
|
stringsHashTable[hash].lastHash = NULL;
|
|
|
|
last->next = item->next;
|
|
hashItemMemPool.Free(item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* <31125> ../cstrike/dlls/cbase.cpp:337 */
|
|
NOBODY void printEntities(void)
|
|
{
|
|
// {
|
|
// int i; // 339
|
|
// {
|
|
// class hash_item_t *item; // 345
|
|
// operator[](CUtlVector<hash_item_t> *const this,
|
|
// int i); // 341
|
|
// ENTINDEX(edict_t *pEdict); // 343
|
|
// ENTINDEX(edict_t *pEdict); // 348
|
|
// }
|
|
// }
|
|
}
|
|
|
|
/* <311e9> ../cstrike/dlls/cbase.cpp:354 */
|
|
edict_t *CREATE_NAMED_ENTITY(string_t iClass)
|
|
{
|
|
edict_t *named = g_engfuncs.pfnCreateNamedEntity(iClass);
|
|
if (named)
|
|
AddEntityHashValue(&named->v, STRING(iClass), CLASSNAME);
|
|
return named;
|
|
}
|
|
|
|
/* <31249> ../cstrike/dlls/cbase.cpp:366 */
|
|
void REMOVE_ENTITY(edict_t *e)
|
|
{
|
|
if (e)
|
|
(*g_engfuncs.pfnRemoveEntity)(e);
|
|
}
|
|
|
|
/* <30158> ../cstrike/dlls/cbase.cpp:375 */
|
|
//NOBODY void CONSOLE_ECHO(char *pszMsg, ...)
|
|
//{
|
|
// {
|
|
// va_list argptr; // 377
|
|
// char szStr; // 378
|
|
// }
|
|
//}
|
|
|
|
/* <31273> ../cstrike/dlls/cbase.cpp:386 */
|
|
NOBODY void loopPerformance(void)
|
|
{
|
|
// {
|
|
// class CPerformanceCounter loopCounter; // 390
|
|
// double start; // 393
|
|
// int i; // 395
|
|
// double end; // 419
|
|
// GetCurTime(CPerformanceCounter *const this); // 393
|
|
// {
|
|
// class CBaseEntity *pSpot; // 398
|
|
// }
|
|
// GetCurTime(CPerformanceCounter *const this); // 419
|
|
// GetCurTime(CPerformanceCounter *const this); // 422
|
|
// {
|
|
// class CBaseEntity *pSpot; // 426
|
|
// }
|
|
// GetCurTime(CPerformanceCounter *const this); // 447
|
|
// }
|
|
}
|
|
|
|
/* <313df> ../cstrike/dlls/cbase.cpp:451 */
|
|
C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion)
|
|
{
|
|
if (!pFunctionTable || interfaceVersion != INTERFACE_VERSION)
|
|
return 0;
|
|
|
|
Q_memcpy(pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS));
|
|
stringsHashTable.AddMultipleToTail(2048);
|
|
for (int i = 0; i < stringsHashTable.Count(); i++)
|
|
stringsHashTable[i].next = NULL;
|
|
|
|
EmptyEntityHashTable();
|
|
return 1;
|
|
}
|
|
|
|
/* <3161a> ../cstrike/dlls/cbase.cpp:471 */
|
|
NOXREF extern "C" C_EXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
|
|
{
|
|
if (!pFunctionTable || *interfaceVersion != INTERFACE_VERSION)
|
|
{
|
|
*interfaceVersion = INTERFACE_VERSION;
|
|
return 0;
|
|
}
|
|
Q_memcpy(pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS));
|
|
return 1;
|
|
}
|
|
|
|
/* <3165b> ../cstrike/dlls/cbase.cpp:485 */
|
|
extern "C" C_EXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
|
|
{
|
|
if (!pFunctionTable || *interfaceVersion != NEW_DLL_FUNCTIONS_VERSION)
|
|
{
|
|
*interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
|
|
return 0;
|
|
}
|
|
Q_memcpy(pFunctionTable, &gNewDLLFunctions, sizeof(NEW_DLL_FUNCTIONS));
|
|
return 1;
|
|
}
|
|
|
|
int (*pDispatchSpawn)(edict_t *);
|
|
|
|
/* <30ab0> ../cstrike/dlls/cbase.cpp:498 */
|
|
NOBODY int __declspec(naked) DispatchSpawn(edict_t *pent)
|
|
{
|
|
//Reverse me
|
|
__asm
|
|
{
|
|
jmp pDispatchSpawn;
|
|
}
|
|
|
|
// {
|
|
// class CBaseEntity *pEntity; // 500
|
|
// GET_PRIVATE(edict_t *pent); // 500
|
|
// operator-(const class Vector *const this,
|
|
// const class Vector &v); // 505
|
|
// operator+(const class Vector *const this,
|
|
// const class Vector &v); // 506
|
|
// GET_PRIVATE(edict_t *pent); // 513
|
|
// {
|
|
// const globalentity_t *pGlobal; // 527
|
|
// FStrEq(const char *sz1,
|
|
// const char *sz2); // 533
|
|
// MakeDormant(CBaseEntity *const this); // 534
|
|
// }
|
|
// }
|
|
}
|
|
|
|
/* <2e8a0> ../cstrike/dlls/cbase.cpp:549 */
|
|
void DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd)
|
|
{
|
|
if (!pkvd || !pentKeyvalue)
|
|
return;
|
|
|
|
EntvarsKeyvalue(VARS(pentKeyvalue), pkvd);
|
|
|
|
if (pkvd->fHandled || !pkvd->szClassName)
|
|
return;
|
|
|
|
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentKeyvalue);
|
|
|
|
if (pEntity)
|
|
pEntity->KeyValue(pkvd);
|
|
}
|
|
|
|
/* <2e7db> ../cstrike/dlls/cbase.cpp:574 */
|
|
void DispatchTouch(edict_t *pentTouched, edict_t *pentOther)
|
|
{
|
|
if (gTouchDisabled)
|
|
return;
|
|
|
|
CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentTouched);
|
|
CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE(pentOther);
|
|
|
|
if (pEntity && pOther && !((pEntity->pev->flags | pOther->pev->flags) & FL_KILLME))
|
|
pEntity->Touch(pOther);
|
|
}
|
|
|
|
/* <2fa9b> ../cstrike/dlls/cbase.cpp:587 */
|
|
NOBODY void DispatchUse(edict_t *pentUsed, edict_t *pentOther)
|
|
{
|
|
// {
|
|
// class CBaseEntity *pEntity; // 589
|
|
// class CBaseEntity *pOther; // 590
|
|
// GET_PRIVATE(edict_t *pent); // 589
|
|
// GET_PRIVATE(edict_t *pent); // 590
|
|
// }
|
|
}
|
|
|
|
/* <2fb2f> ../cstrike/dlls/cbase.cpp:596 */
|
|
NOBODY void DispatchThink(edict_t *pent)
|
|
{
|
|
// {
|
|
// class CBaseEntity *pEntity; // 598
|
|
// GET_PRIVATE(edict_t *pent); // 598
|
|
// }
|
|
}
|
|
|
|
/* <2fb89> ../cstrike/dlls/cbase.cpp:612 */
|
|
NOBODY void DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther)
|
|
{
|
|
// {
|
|
// class CBaseEntity *pEntity; // 614
|
|
// class CBaseEntity *pOther; // 615
|
|
// GET_PRIVATE(edict_t *pent); // 614
|
|
// GET_PRIVATE(edict_t *pent); // 615
|
|
// }
|
|
}
|
|
|
|
/* <2ff56> ../cstrike/dlls/cbase.cpp:621 */
|
|
NOBODY void DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData)
|
|
{
|
|
// {
|
|
// class CBaseEntity *pEntity; // 623
|
|
// GET_PRIVATE(edict_t *pent); // 623
|
|
// {
|
|
// ENTITYTABLE *pTable; // 627
|
|
// class CSave saveHelper; // 646
|
|
// {
|
|
// float delta; // 638
|
|
// }
|
|
// CSave(CSave *const this,
|
|
// SAVERESTOREDATA *pdata); // 646
|
|
// ~CSave(CSave *const this,
|
|
// intconst __in_chrg); // 646
|
|
// }
|
|
// }
|
|
}
|
|
|
|
/* <31697> ../cstrike/dlls/cbase.cpp:656 */
|
|
CBaseEntity *FindGlobalEntity(string_t classname, string_t globalname)
|
|
{
|
|
edict_t *pent = FIND_ENTITY_BY_STRING(NULL, "globalname", STRING(globalname));
|
|
CBaseEntity *pReturn = CBaseEntity::Instance(pent);
|
|
if (pReturn)
|
|
{
|
|
if (!FClassnameIs(pReturn->pev, STRING(classname)))
|
|
{
|
|
ALERT(at_console, "Global entity found %s, wrong class %s\n", STRING(globalname), STRING(pReturn->pev->classname));
|
|
pReturn = NULL;
|
|
}
|
|
}
|
|
return pReturn;
|
|
}
|
|
|
|
/* <3179c> ../cstrike/dlls/cbase.cpp:673 */
|
|
NOBODY int DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity)
|
|
{
|
|
// {
|
|
// class CBaseEntity *pEntity; // 675
|
|
// GET_PRIVATE(edict_t *pent); // 675
|
|
// {
|
|
// entvars_t tmpVars; // 679
|
|
// class Vector oldOffset; // 680
|
|
// class CRestore restoreHelper; // 682
|
|
// CRestore(CRestore *const this,
|
|
// SAVERESTOREDATA *pdata); // 682
|
|
// {
|
|
// class CRestore tmpRestore; // 685
|
|
// const globalentity_t *pGlobal; // 695
|
|
// class CBaseEntity *pNewEntity; // 706
|
|
// CRestore(CRestore *const this,
|
|
// SAVERESTOREDATA *pdata); // 685
|
|
// PrecacheMode(CRestore *const this,
|
|
// BOOL mode); // 686
|
|
// FStrEq(const char *sz1,
|
|
// const char *sz2); // 701
|
|
// SetGlobalMode(CRestore *const this,
|
|
// int global); // 710
|
|
// operator-(const class Vector *const this,
|
|
// const class Vector &v); // 711
|
|
// operator+(const class Vector *const this,
|
|
// const class Vector &v); // 711
|
|
// ~CRestore(CRestore *const this,
|
|
// intconst __in_chrg); // 685
|
|
// ~CRestore(CRestore *const this,
|
|
// intconst __in_chrg); // 685
|
|
// }
|
|
// GET_PRIVATE(edict_t *pent); // 738
|
|
// {
|
|
// const globalentity_t *pGlobal; // 752
|
|
// FStrEq(const char *sz1,
|
|
// const char *sz2); // 758
|
|
// MakeDormant(CBaseEntity *const this); // 760
|
|
// }
|
|
// ~CRestore(CRestore *const this,
|
|
// intconst __in_chrg); // 682
|
|
// ~CRestore(CRestore *const this,
|
|
// intconst __in_chrg); // 682
|
|
// }
|
|
// }
|
|
}
|
|
|
|
/* <2fdcd> ../cstrike/dlls/cbase.cpp:776 */
|
|
NOBODY void DispatchObjectCollsionBox(edict_t *pent)
|
|
{
|
|
// {
|
|
// class CBaseEntity *pEntity; // 778
|
|
// GET_PRIVATE(edict_t *pent); // 778
|
|
// }
|
|
}
|
|
|
|
/* <2fe94> ../cstrike/dlls/cbase.cpp:788 */
|
|
NOBODY void SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount)
|
|
{
|
|
// {
|
|
// class CSave saveHelper; // 790
|
|
// CSave(CSave *const this,
|
|
// SAVERESTOREDATA *pdata); // 790
|
|
// ~CSave(CSave *const this,
|
|
// intconst __in_chrg); // 790
|
|
// }
|
|
}
|
|
|
|
/* <30047> ../cstrike/dlls/cbase.cpp:795 */
|
|
NOBODY void SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount)
|
|
{
|
|
// {
|
|
// class CRestore restoreHelper; // 797
|
|
// CRestore(CRestore *const this,
|
|
// SAVERESTOREDATA *pdata); // 797
|
|
// ~CRestore(CRestore *const this,
|
|
// intconst __in_chrg); // 797
|
|
// }
|
|
}
|
|
|
|
/* <31a74> ../cstrike/dlls/cbase.cpp:802 */
|
|
edict_t *EHANDLE::Get(void)
|
|
{
|
|
if (!m_pent || m_pent->serialnumber != m_serialnumber)
|
|
return NULL;
|
|
|
|
return m_pent;
|
|
}
|
|
|
|
/* <31a95> ../cstrike/dlls/cbase.cpp:814 */
|
|
edict_t *EHANDLE::Set(edict_t *pent)
|
|
{
|
|
m_pent = pent;
|
|
if (pent)
|
|
m_serialnumber = pent->serialnumber;
|
|
|
|
return pent;
|
|
}
|
|
|
|
/* <31ace> ../cstrike/dlls/cbase.cpp:823 */
|
|
EHANDLE::operator CBaseEntity *(void)
|
|
{
|
|
return (CBaseEntity *)GET_PRIVATE(Get());
|
|
}
|
|
|
|
/* <31b30> ../cstrike/dlls/cbase.cpp:829 */
|
|
CBaseEntity *EHANDLE::operator=(CBaseEntity *pEntity)
|
|
{
|
|
if (pEntity)
|
|
{
|
|
m_pent = ENT(pEntity->pev);
|
|
if (m_pent)
|
|
m_serialnumber = m_pent->serialnumber;
|
|
}
|
|
else
|
|
{
|
|
m_pent = NULL;
|
|
m_serialnumber = 0;
|
|
}
|
|
return pEntity;
|
|
}
|
|
|
|
/* <31b69> ../cstrike/dlls/cbase.cpp:845 */
|
|
EHANDLE::operator int(void)
|
|
{
|
|
return Get() != NULL;
|
|
}
|
|
|
|
/* <31bac> ../cstrike/dlls/cbase.cpp:850 */
|
|
CBaseEntity *EHANDLE::operator->(void)
|
|
{
|
|
return (CBaseEntity *)GET_PRIVATE(Get());
|
|
}
|
|
|
|
/* <301be> ../cstrike/dlls/cbase.cpp:857 */
|
|
int CBaseEntity::TakeHealth_(float flHealth, int bitsDamageType)
|
|
{
|
|
if (pev->takedamage == DAMAGE_NO)
|
|
return 0;
|
|
|
|
if (pev->health >= pev->max_health)
|
|
return 0;
|
|
|
|
pev->health += flHealth;
|
|
|
|
if (pev->health > pev->max_health)
|
|
pev->health = pev->max_health;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* <305af> ../cstrike/dlls/cbase.cpp:876 */
|
|
NOBODY int CBaseEntity::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
|
|
{
|
|
// {
|
|
// class Vector vecTemp; // 878
|
|
// }
|
|
// TakeDamage(CBaseEntity *const this,
|
|
// entvars_t *pevInflictor,
|
|
// entvars_t *pevAttacker,
|
|
// float flDamage,
|
|
// int bitsDamageType); // 876
|
|
return 0;
|
|
}
|
|
|
|
/* <2fe50> ../cstrike/dlls/cbase.cpp:927 */
|
|
NOBODY void CBaseEntity::Killed_(entvars_t *pevAttacker, int iGib)
|
|
{
|
|
}
|
|
|
|
/* <2fc1c> ../cstrike/dlls/cbase.cpp:935 */
|
|
NOBODY CBaseEntity *CBaseEntity::GetNextTarget_(void)
|
|
{
|
|
// {
|
|
// edict_t *pTarget; // 939
|
|
// FIND_ENTITY_BY_TARGETNAME(edict_t *entStart,
|
|
// const char *pszName); // 939
|
|
// FNullEnt(const edict_t *pent); // 940
|
|
// Instance(edict_t *pent); // 943
|
|
// }
|
|
return NULL;
|
|
}
|
|
|
|
/* <302a6> ../cstrike/dlls/cbase.cpp:958 */
|
|
NOBODY int CBaseEntity::Save(CSave &save)
|
|
{
|
|
// Save(CBaseEntity *const this,
|
|
// class CSave &save); // 958
|
|
return 0;
|
|
}
|
|
|
|
/* <30440> ../cstrike/dlls/cbase.cpp:966 */
|
|
NOBODY int CBaseEntity::Restore(CRestore &restore)
|
|
{
|
|
// {
|
|
// int status; // 968
|
|
// }
|
|
// Restore(CBaseEntity *const this,
|
|
// class CRestore &restore); // 966
|
|
return 0;
|
|
}
|
|
|
|
/* <2fcf6> ../cstrike/dlls/cbase.cpp:991 */
|
|
NOBODY void SetObjectCollisionBox(entvars_t *pev)
|
|
{
|
|
// operator+(const class Vector *const this,
|
|
// const class Vector &v); // 1017
|
|
// operator+(const class Vector *const this,
|
|
// const class Vector &v); // 1018
|
|
// {
|
|
// float max; // 996
|
|
// float v; // 996
|
|
// int i; // 997
|
|
// fabs(double __x); // 1002
|
|
// fabs(double __x); // 1005
|
|
// }
|
|
}
|
|
|
|
/* <2fe2a> ../cstrike/dlls/cbase.cpp:1030 */
|
|
NOBODY void CBaseEntity::SetObjectCollisionBox(void)
|
|
{
|
|
::SetObjectCollisionBox(pev);
|
|
}
|
|
|
|
/* <31c0e> ../cstrike/dlls/cbase.cpp:1036 */
|
|
NOBODY int CBaseEntity::Intersects(CBaseEntity *pOther)
|
|
{
|
|
}
|
|
|
|
/* <31c43> ../cstrike/dlls/cbase.cpp:1048 */
|
|
void CBaseEntity::MakeDormant(void)
|
|
{
|
|
pev->flags |= FL_DORMANT;
|
|
pev->solid = SOLID_NOT;
|
|
pev->movetype = MOVETYPE_NONE;
|
|
pev->effects |= EF_NODRAW;
|
|
pev->nextthink = 0;
|
|
UTIL_SetOrigin(pev, pev->origin);
|
|
}
|
|
|
|
/* <31c66> ../cstrike/dlls/cbase.cpp:1064 */
|
|
NOBODY int CBaseEntity::IsDormant(void)
|
|
{
|
|
return (pev->flags & FL_DORMANT) == FL_DORMANT;
|
|
}
|
|
|
|
/* <30221> ../cstrike/dlls/cbase.cpp:1069 */
|
|
NOBODY BOOL CBaseEntity::IsInWorld_(void)
|
|
{
|
|
// IsInWorld(CBaseEntity *const this); // 1069
|
|
return FALSE;
|
|
}
|
|
|
|
/* <31c8c> ../cstrike/dlls/cbase.cpp:1089 */
|
|
int CBaseEntity::ShouldToggle(USE_TYPE useType, BOOL currentState)
|
|
{
|
|
if (useType != USE_TOGGLE && useType != USE_SET)
|
|
{
|
|
if ((currentState && useType == USE_ON) || (!currentState && useType == USE_OFF))
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* <30258> ../cstrike/dlls/cbase.cpp:1100 */
|
|
NOBODY int CBaseEntity::DamageDecal_(int bitsDamageType)
|
|
{
|
|
// DamageDecal(CBaseEntity *const this,
|
|
// int bitsDamageType); // 1100
|
|
return 0;
|
|
}
|
|
|
|
/* <31cd1> ../cstrike/dlls/cbase.cpp:1115 */
|
|
CBaseEntity *CBaseEntity::Create(char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner)
|
|
{
|
|
edict_t *pent;
|
|
CBaseEntity *pEntity;
|
|
|
|
pent = CREATE_NAMED_ENTITY(MAKE_STRING(szName));
|
|
if (FNullEnt(pent))
|
|
{
|
|
ALERT(at_console, "NULL Ent in Create!\n");
|
|
return NULL;
|
|
}
|
|
|
|
pEntity = Instance(pent);
|
|
|
|
pEntity->pev->owner = pentOwner;
|
|
pEntity->pev->origin = vecOrigin;
|
|
pEntity->pev->angles = vecAngles;
|
|
|
|
DispatchSpawn(pEntity->edict());
|
|
|
|
return pEntity;
|
|
}
|
|
|
|
/* <30885> ../cstrike/dlls/cbase.cpp:1134 */
|
|
NOBODY void OnFreeEntPrivateData(edict_t *pEnt)
|
|
{
|
|
CBaseEntity *pEntity = CBaseEntity::Instance(pEnt);
|
|
if (!pEntity)
|
|
return;
|
|
|
|
pEntity->UpdateOnRemove();
|
|
RemoveEntityHashValue(pEntity->pev, STRING(pEntity->pev->classname), CLASSNAME);
|
|
}
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
|
|
void CBaseEntity::TraceAttack(entvars_t *pevAttacker,float flDamage,Vector vecDir,TraceResult *ptr,int bitsDamageType)
|
|
{
|
|
TraceAttack_(pevAttacker,flDamage,vecDir,ptr,bitsDamageType);
|
|
}
|
|
|
|
int CBaseEntity::TakeDamage(entvars_t *pevInflictor,entvars_t *pevAttacker,float flDamage,int bitsDamageType)
|
|
{
|
|
return TakeDamage_(pevInflictor,pevAttacker,flDamage,bitsDamageType);
|
|
}
|
|
|
|
int CBaseEntity::TakeHealth(float flHealth,int bitsDamageType)
|
|
{
|
|
return TakeHealth_(flHealth, bitsDamageType);
|
|
}
|
|
|
|
void CBaseEntity::Killed(entvars_t *pevAttacker,int iGib)
|
|
{
|
|
Killed_(pevAttacker,iGib);
|
|
}
|
|
|
|
void CBaseEntity::TraceBleed(float flDamage,Vector vecDir,TraceResult *ptr,int bitsDamageType)
|
|
{
|
|
TraceBleed_(flDamage,vecDir,ptr,bitsDamageType);
|
|
}
|
|
|
|
int CBaseEntity::DamageDecal(int bitsDamageType)
|
|
{
|
|
return DamageDecal_(bitsDamageType);
|
|
}
|
|
|
|
BOOL CBaseEntity::IsInWorld(void)
|
|
{
|
|
return IsInWorld_();
|
|
}
|
|
|
|
CBaseEntity *CBaseEntity::GetNextTarget(void)
|
|
{
|
|
return GetNextTarget();
|
|
}
|
|
|
|
BOOL CBaseEntity::FVisible(CBaseEntity *pEntity)
|
|
{
|
|
return FVisible_(pEntity);
|
|
}
|
|
|
|
BOOL CBaseEntity::FVisible(Vector &vecOrigin)
|
|
{
|
|
return FVisible_(vecOrigin);
|
|
}
|
|
|
|
#endif // HOOK_GAMEDLL
|