mirror of https://github.com/r4sas/ExtraMirror
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
490 lines
23 KiB
490 lines
23 KiB
/*** |
|
* |
|
* Copyright (c) 1999, Valve LLC. All rights reserved. |
|
* |
|
* This product contains software technology licensed from Id |
|
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc. |
|
* All Rights Reserved. |
|
* |
|
* Use, distribution, and modification of this source code and/or resulting |
|
* object code is restricted to non-commercial enhancements to products from |
|
* Valve LLC. All other use, distribution, or modification is prohibited |
|
* without written permission from Valve LLC. |
|
* |
|
****/ |
|
#ifndef EIFACE_H |
|
#define EIFACE_H |
|
|
|
#ifdef HLDEMO_BUILD |
|
#define INTERFACE_VERSION 001 |
|
#else // !HLDEMO_BUILD, i.e., regular version of HL |
|
#define INTERFACE_VERSION 140 |
|
#endif // !HLDEMO_BUILD |
|
|
|
#include <stdio.h> |
|
#include "custom.h" |
|
#include "cvardef.h" |
|
// |
|
// Defines entity interface between engine and DLLs. |
|
// This header file included by engine files and DLL files. |
|
// |
|
// Before including this header, DLLs must: |
|
// include progdefs.h |
|
// This is conveniently done for them in extdll.h |
|
// |
|
|
|
#ifdef _WIN32 |
|
#define DLLEXPORT __stdcall |
|
#else |
|
#define DLLEXPORT /* */ |
|
#endif |
|
|
|
typedef enum |
|
{ |
|
at_notice, |
|
at_console, // same as at_notice, but forces a ConPrintf, not a message box |
|
at_aiconsole, // same as at_console, but only shown if developer level is 2! |
|
at_warning, |
|
at_error, |
|
at_logged // Server print to console ( only in multiplayer games ). |
|
} ALERT_TYPE; |
|
|
|
// 4-22-98 JOHN: added for use in pfnClientPrintf |
|
typedef enum |
|
{ |
|
print_console, |
|
print_center, |
|
print_chat, |
|
} PRINT_TYPE; |
|
|
|
// For integrity checking of content on clients |
|
typedef enum |
|
{ |
|
force_exactfile, // File on client must exactly match server's file |
|
force_model_samebounds, // For model files only, the geometry must fit in the same bbox |
|
force_model_specifybounds, // For model files only, the geometry must fit in the specified bbox |
|
} FORCE_TYPE; |
|
|
|
// Returned by TraceLine |
|
typedef struct |
|
{ |
|
int fAllSolid; // if true, plane is not valid |
|
int fStartSolid; // if true, the initial point was in a solid area |
|
int fInOpen; |
|
int fInWater; |
|
float flFraction; // time completed, 1.0 = didn't hit anything |
|
vec3_t vecEndPos; // final position |
|
float flPlaneDist; |
|
vec3_t vecPlaneNormal; // surface normal at impact |
|
edict_t *pHit; // entity the surface is on |
|
int iHitgroup; // 0 == generic, non zero is specific body part |
|
} TraceResult; |
|
|
|
// CD audio status |
|
typedef struct |
|
{ |
|
int fPlaying;// is sound playing right now? |
|
int fWasPlaying;// if not, CD is paused if WasPlaying is true. |
|
int fInitialized; |
|
int fEnabled; |
|
int fPlayLooping; |
|
float cdvolume; |
|
//BYTE remap[100]; |
|
int fCDRom; |
|
int fPlayTrack; |
|
} CDStatus; |
|
|
|
#include "../common/crc.h" |
|
|
|
// Engine hands this to DLLs for functionality callbacks |
|
typedef struct enginefuncs_s |
|
{ |
|
int (*pfnPrecacheModel) (char* s); |
|
int (*pfnPrecacheSound) (char* s); |
|
void (*pfnSetModel) (edict_t *e, const char *m); |
|
int (*pfnModelIndex) (const char *m); |
|
int (*pfnModelFrames) (int modelIndex); |
|
void (*pfnSetSize) (edict_t *e, const float *rgflMin, const float *rgflMax); |
|
void (*pfnChangeLevel) (char* s1, char* s2); |
|
void (*pfnGetSpawnParms) (edict_t *ent); |
|
void (*pfnSaveSpawnParms) (edict_t *ent); |
|
float (*pfnVecToYaw) (const float *rgflVector); |
|
void (*pfnVecToAngles) (const float *rgflVectorIn, float *rgflVectorOut); |
|
void (*pfnMoveToOrigin) (edict_t *ent, const float *pflGoal, float dist, int iMoveType); |
|
void (*pfnChangeYaw) (edict_t* ent); |
|
void (*pfnChangePitch) (edict_t* ent); |
|
edict_t* (*pfnFindEntityByString) (edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue); |
|
int (*pfnGetEntityIllum) (edict_t* pEnt); |
|
edict_t* (*pfnFindEntityInSphere) (edict_t *pEdictStartSearchAfter, const float *org, float rad); |
|
edict_t* (*pfnFindClientInPVS) (edict_t *pEdict); |
|
edict_t* (*pfnEntitiesInPVS) (edict_t *pplayer); |
|
void (*pfnMakeVectors) (const float *rgflVector); |
|
void (*pfnAngleVectors) (const float *rgflVector, float *forward, float *right, float *up); |
|
edict_t* (*pfnCreateEntity) (void); |
|
void (*pfnRemoveEntity) (edict_t* e); |
|
edict_t* (*pfnCreateNamedEntity) (int className); |
|
void (*pfnMakeStatic) (edict_t *ent); |
|
int (*pfnEntIsOnFloor) (edict_t *e); |
|
int (*pfnDropToFloor) (edict_t* e); |
|
int (*pfnWalkMove) (edict_t *ent, float yaw, float dist, int iMode); |
|
void (*pfnSetOrigin) (edict_t *e, const float *rgflOrigin); |
|
void (*pfnEmitSound) (edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch); |
|
void (*pfnEmitAmbientSound) (edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch); |
|
void (*pfnTraceLine) (const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); |
|
void (*pfnTraceToss) (edict_t* pent, edict_t* pentToIgnore, TraceResult *ptr); |
|
int (*pfnTraceMonsterHull) (edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); |
|
void (*pfnTraceHull) (const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr); |
|
void (*pfnTraceModel) (const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr); |
|
const char *(*pfnTraceTexture) (edict_t *pTextureEntity, const float *v1, const float *v2 ); |
|
void (*pfnTraceSphere) (const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr); |
|
void (*pfnGetAimVector) (edict_t* ent, float speed, float *rgflReturn); |
|
void (*pfnServerCommand) (char* str); |
|
void (*pfnServerExecute) (void); |
|
void (*pfnClientCommand) (edict_t* pEdict, char* szFmt, ...); |
|
void (*pfnParticleEffect) (const float *org, const float *dir, float color, float count); |
|
void (*pfnLightStyle) (int style, char* val); |
|
int (*pfnDecalIndex) (const char *name); |
|
int (*pfnPointContents) (const float *rgflVector); |
|
void (*pfnMessageBegin) (int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); |
|
void (*pfnMessageEnd) (void); |
|
void (*pfnWriteByte) (int iValue); |
|
void (*pfnWriteChar) (int iValue); |
|
void (*pfnWriteShort) (int iValue); |
|
void (*pfnWriteLong) (int iValue); |
|
void (*pfnWriteAngle) (float flValue); |
|
void (*pfnWriteCoord) (float flValue); |
|
void (*pfnWriteString) (const char *sz); |
|
void (*pfnWriteEntity) (int iValue); |
|
void (*pfnCVarRegister) (cvar_t *pCvar); |
|
float (*pfnCVarGetFloat) (const char *szVarName); |
|
const char* (*pfnCVarGetString) (const char *szVarName); |
|
void (*pfnCVarSetFloat) (const char *szVarName, float flValue); |
|
void (*pfnCVarSetString) (const char *szVarName, const char *szValue); |
|
void (*pfnAlertMessage) (ALERT_TYPE atype, char *szFmt, ...); |
|
void (*pfnEngineFprintf) (FILE *pfile, char *szFmt, ...); |
|
void* (*pfnPvAllocEntPrivateData) (edict_t *pEdict, long cb); |
|
void* (*pfnPvEntPrivateData) (edict_t *pEdict); |
|
void (*pfnFreeEntPrivateData) (edict_t *pEdict); |
|
const char* (*pfnSzFromIndex) (int iString); |
|
int (*pfnAllocString) (const char *szValue); |
|
struct entvars_s* (*pfnGetVarsOfEnt) (edict_t *pEdict); |
|
edict_t* (*pfnPEntityOfEntOffset) (int iEntOffset); |
|
int (*pfnEntOffsetOfPEntity) (const edict_t *pEdict); |
|
int (*pfnIndexOfEdict) (const edict_t *pEdict); |
|
edict_t* (*pfnPEntityOfEntIndex) (int iEntIndex); |
|
edict_t* (*pfnFindEntityByVars) (struct entvars_s* pvars); |
|
void* (*pfnGetModelPtr) (edict_t* pEdict); |
|
int (*pfnRegUserMsg) (const char *pszName, int iSize); |
|
void (*pfnAnimationAutomove) (const edict_t* pEdict, float flTime); |
|
void (*pfnGetBonePosition) (const edict_t* pEdict, int iBone, float *rgflOrigin, float *rgflAngles ); |
|
unsigned long (*pfnFunctionFromName) ( const char *pName ); |
|
const char *(*pfnNameForFunction) ( unsigned long function ); |
|
void (*pfnClientPrintf) ( edict_t* pEdict, PRINT_TYPE ptype, const char *szMsg ); // JOHN: engine callbacks so game DLL can print messages to individual clients |
|
void (*pfnServerPrint) ( const char *szMsg ); |
|
const char *(*pfnCmd_Args) ( void ); // these 3 added |
|
const char *(*pfnCmd_Argv) ( int argc ); // so game DLL can easily |
|
int (*pfnCmd_Argc) ( void ); // access client 'cmd' strings |
|
void (*pfnGetAttachment) (const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ); |
|
void (*pfnCRC32_Init) (CRC32_t *pulCRC); |
|
void (*pfnCRC32_ProcessBuffer) (CRC32_t *pulCRC, void *p, int len); |
|
void (*pfnCRC32_ProcessByte) (CRC32_t *pulCRC, unsigned char ch); |
|
CRC32_t (*pfnCRC32_Final) (CRC32_t pulCRC); |
|
long (*pfnRandomLong) (long lLow, long lHigh); |
|
float (*pfnRandomFloat) (float flLow, float flHigh); |
|
void (*pfnSetView) (const edict_t *pClient, const edict_t *pViewent ); |
|
float (*pfnTime) ( void ); |
|
void (*pfnCrosshairAngle) (const edict_t *pClient, float pitch, float yaw); |
|
byte * (*pfnLoadFileForMe) (char *filename, int *pLength); |
|
void (*pfnFreeFile) (void *buffer); |
|
void (*pfnEndSection) (const char *pszSectionName); // trigger_endsection |
|
int (*pfnCompareFileTime) (char *filename1, char *filename2, int *iCompare); |
|
void (*pfnGetGameDir) (char *szGetGameDir); |
|
void (*pfnCvar_RegisterVariable) (cvar_t *variable); |
|
void (*pfnFadeClientVolume) (const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds); |
|
void (*pfnSetClientMaxspeed) (const edict_t *pEdict, float fNewMaxspeed); |
|
edict_t * (*pfnCreateFakeClient) (const char *netname); // returns NULL if fake client can't be created |
|
void (*pfnRunPlayerMove) (edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec ); |
|
int (*pfnNumberOfEntities) (void); |
|
char* (*pfnGetInfoKeyBuffer) (edict_t *e); // passing in NULL gets the serverinfo |
|
char* (*pfnInfoKeyValue) (char *infobuffer, char *key); |
|
void (*pfnSetKeyValue) (char *infobuffer, char *key, char *value); |
|
void (*pfnSetClientKeyValue) (int clientIndex, char *infobuffer, char *key, char *value); |
|
int (*pfnIsMapValid) (char *filename); |
|
void (*pfnStaticDecal) ( const float *origin, int decalIndex, int entityIndex, int modelIndex ); |
|
int (*pfnPrecacheGeneric) (char* s); |
|
int (*pfnGetPlayerUserId) (edict_t *e ); // returns the server assigned userid for this player. useful for logging frags, etc. returns -1 if the edict couldn't be found in the list of clients |
|
void (*pfnBuildSoundMsg) (edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); |
|
int (*pfnIsDedicatedServer) (void);// is this a dedicated server? |
|
cvar_t *(*pfnCVarGetPointer) (const char *szVarName); |
|
unsigned int (*pfnGetPlayerWONId) (edict_t *e); // returns the server assigned WONid for this player. useful for logging frags, etc. returns -1 if the edict couldn't be found in the list of clients |
|
|
|
// YWB 8/1/99 TFF Physics additions |
|
void (*pfnInfo_RemoveKey) ( char *s, const char *key ); |
|
const char *(*pfnGetPhysicsKeyValue) ( const edict_t *pClient, const char *key ); |
|
void (*pfnSetPhysicsKeyValue) ( const edict_t *pClient, const char *key, const char *value ); |
|
const char *(*pfnGetPhysicsInfoString) ( const edict_t *pClient ); |
|
unsigned short (*pfnPrecacheEvent) ( int type, const char*psz ); |
|
void (*pfnPlaybackEvent) ( int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 ); |
|
|
|
unsigned char *(*pfnSetFatPVS) ( float *org ); |
|
unsigned char *(*pfnSetFatPAS) ( float *org ); |
|
|
|
int (*pfnCheckVisibility ) ( const edict_t *entity, unsigned char *pset ); |
|
|
|
void (*pfnDeltaSetField) ( struct delta_s *pFields, const char *fieldname ); |
|
void (*pfnDeltaUnsetField) ( struct delta_s *pFields, const char *fieldname ); |
|
void (*pfnDeltaAddEncoder) ( char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ); |
|
int (*pfnGetCurrentPlayer) ( void ); |
|
int (*pfnCanSkipPlayer) ( const edict_t *player ); |
|
int (*pfnDeltaFindField) ( struct delta_s *pFields, const char *fieldname ); |
|
void (*pfnDeltaSetFieldByIndex) ( struct delta_s *pFields, int fieldNumber ); |
|
void (*pfnDeltaUnsetFieldByIndex)( struct delta_s *pFields, int fieldNumber ); |
|
|
|
void (*pfnSetGroupMask) ( int mask, int op ); |
|
|
|
int (*pfnCreateInstancedBaseline) ( int classname, struct entity_state_s *baseline ); |
|
void (*pfnCvar_DirectSet) ( struct cvar_s *var, char *value ); |
|
|
|
// Forces the client and server to be running with the same version of the specified file |
|
// ( e.g., a player model ). |
|
// Calling this has no effect in single player |
|
void (*pfnForceUnmodified) ( FORCE_TYPE type, float *mins, float *maxs, const char *filename ); |
|
|
|
void (*pfnGetPlayerStats) ( const edict_t *pClient, int *ping, int *packet_loss ); |
|
|
|
void (*pfnAddServerCommand) ( char *cmd_name, void (*function) (void) ); |
|
|
|
// For voice communications, set which clients hear eachother. |
|
// NOTE: these functions take player entity indices (starting at 1). |
|
qboolean (*pfnVoice_GetClientListening)(int iReceiver, int iSender); |
|
qboolean (*pfnVoice_SetClientListening)(int iReceiver, int iSender, qboolean bListen); |
|
} enginefuncs_t; |
|
// ONLY ADD NEW FUNCTIONS TO THE END OF THIS STRUCT. INTERFACE VERSION IS FROZEN AT 138 |
|
|
|
// Passed to pfnKeyValue |
|
typedef struct KeyValueData_s |
|
{ |
|
char *szClassName; // in: entity classname |
|
char *szKeyName; // in: name of key |
|
char *szValue; // in: value of key |
|
long fHandled; // out: DLL sets to true if key-value pair was understood |
|
} KeyValueData; |
|
|
|
|
|
typedef struct |
|
{ |
|
char mapName[ 32 ]; |
|
char landmarkName[ 32 ]; |
|
edict_t *pentLandmark; |
|
vec3_t vecLandmarkOrigin; |
|
} LEVELLIST; |
|
#define MAX_LEVEL_CONNECTIONS 16 // These are encoded in the lower 16bits of ENTITYTABLE->flags |
|
|
|
typedef struct |
|
{ |
|
int id; // Ordinal ID of this entity (used for entity <--> pointer conversions) |
|
edict_t *pent; // Pointer to the in-game entity |
|
|
|
int location; // Offset from the base data of this entity |
|
int size; // Byte size of this entity's data |
|
int flags; // This could be a short -- bit mask of transitions that this entity is in the PVS of |
|
string_t classname; // entity class name |
|
|
|
} ENTITYTABLE; |
|
|
|
#define FENTTABLE_PLAYER 0x80000000 |
|
#define FENTTABLE_REMOVED 0x40000000 |
|
#define FENTTABLE_MOVEABLE 0x20000000 |
|
#define FENTTABLE_GLOBAL 0x10000000 |
|
|
|
typedef struct saverestore_s SAVERESTOREDATA; |
|
|
|
#ifdef _WIN32 |
|
typedef |
|
#endif |
|
struct saverestore_s |
|
{ |
|
char *pBaseData; // Start of all entity save data |
|
char *pCurrentData; // Current buffer pointer for sequential access |
|
int size; // Current data size |
|
int bufferSize; // Total space for data |
|
int tokenSize; // Size of the linear list of tokens |
|
int tokenCount; // Number of elements in the pTokens table |
|
char **pTokens; // Hash table of entity strings (sparse) |
|
int currentIndex; // Holds a global entity table ID |
|
int tableCount; // Number of elements in the entity table |
|
int connectionCount;// Number of elements in the levelList[] |
|
ENTITYTABLE *pTable; // Array of ENTITYTABLE elements (1 for each entity) |
|
LEVELLIST levelList[ MAX_LEVEL_CONNECTIONS ]; // List of connections from this level |
|
|
|
// smooth transition |
|
int fUseLandmark; |
|
char szLandmarkName[20];// landmark we'll spawn near in next level |
|
vec3_t vecLandmarkOffset;// for landmark transitions |
|
float time; |
|
char szCurrentMapName[32]; // To check global entities |
|
|
|
} |
|
#ifdef _WIN32 |
|
SAVERESTOREDATA |
|
#endif |
|
; |
|
|
|
typedef enum _fieldtypes |
|
{ |
|
FIELD_FLOAT = 0, // Any floating point value |
|
FIELD_STRING, // A string ID (return from ALLOC_STRING) |
|
FIELD_ENTITY, // An entity offset (EOFFSET) |
|
FIELD_CLASSPTR, // CBaseEntity * |
|
FIELD_EHANDLE, // Entity handle |
|
FIELD_EVARS, // EVARS * |
|
FIELD_EDICT, // edict_t *, or edict_t * (same thing) |
|
FIELD_VECTOR, // Any vector |
|
FIELD_POSITION_VECTOR, // A world coordinate (these are fixed up across level transitions automagically) |
|
FIELD_POINTER, // Arbitrary data pointer... to be removed, use an array of FIELD_CHARACTER |
|
FIELD_INTEGER, // Any integer or enum |
|
FIELD_FUNCTION, // A class function pointer (Think, Use, etc) |
|
FIELD_BOOLEAN, // boolean, implemented as an int, I may use this as a hint for compression |
|
FIELD_SHORT, // 2 byte integer |
|
FIELD_CHARACTER, // a byte |
|
FIELD_TIME, // a floating point time (these are fixed up automatically too!) |
|
FIELD_MODELNAME, // Engine string that is a model name (needs precache) |
|
FIELD_SOUNDNAME, // Engine string that is a sound name (needs precache) |
|
|
|
FIELD_TYPECOUNT, // MUST BE LAST |
|
} FIELDTYPE; |
|
|
|
#ifndef offsetof |
|
#define offsetof(s,m) (size_t)&(((s *)0)->m) |
|
#endif |
|
|
|
#define _FIELD(type,name,fieldtype,count,flags) { fieldtype, #name, offsetof(type, name), count, flags } |
|
#define DEFINE_FIELD(type,name,fieldtype) _FIELD(type, name, fieldtype, 1, 0) |
|
#define DEFINE_ARRAY(type,name,fieldtype,count) _FIELD(type, name, fieldtype, count, 0) |
|
#define DEFINE_ENTITY_FIELD(name,fieldtype) _FIELD(entvars_t, name, fieldtype, 1, 0 ) |
|
#define DEFINE_ENTITY_GLOBAL_FIELD(name,fieldtype) _FIELD(entvars_t, name, fieldtype, 1, FTYPEDESC_GLOBAL ) |
|
#define DEFINE_GLOBAL_FIELD(type,name,fieldtype) _FIELD(type, name, fieldtype, 1, FTYPEDESC_GLOBAL ) |
|
|
|
|
|
#define FTYPEDESC_GLOBAL 0x0001 // This field is masked for global entity save/restore |
|
|
|
typedef struct |
|
{ |
|
FIELDTYPE fieldType; |
|
char *fieldName; |
|
int fieldOffset; |
|
short fieldSize; |
|
short flags; |
|
} TYPEDESCRIPTION; |
|
|
|
#define ARRAYSIZE(p) (sizeof(p)/sizeof(p[0])) |
|
|
|
typedef struct |
|
{ |
|
// Initialize/shutdown the game (one-time call after loading of game .dll ) |
|
void (*pfnGameInit) ( void ); |
|
int (*pfnSpawn) ( edict_t *pent ); |
|
void (*pfnThink) ( edict_t *pent ); |
|
void (*pfnUse) ( edict_t *pentUsed, edict_t *pentOther ); |
|
void (*pfnTouch) ( edict_t *pentTouched, edict_t *pentOther ); |
|
void (*pfnBlocked) ( edict_t *pentBlocked, edict_t *pentOther ); |
|
void (*pfnKeyValue) ( edict_t *pentKeyvalue, KeyValueData *pkvd ); |
|
void (*pfnSave) ( edict_t *pent, SAVERESTOREDATA *pSaveData ); |
|
int (*pfnRestore) ( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity ); |
|
void (*pfnSetAbsBox) ( edict_t *pent ); |
|
|
|
void (*pfnSaveWriteFields) ( SAVERESTOREDATA *, const char *, void *, TYPEDESCRIPTION *, int ); |
|
void (*pfnSaveReadFields) ( SAVERESTOREDATA *, const char *, void *, TYPEDESCRIPTION *, int ); |
|
|
|
void (*pfnSaveGlobalState) ( SAVERESTOREDATA * ); |
|
void (*pfnRestoreGlobalState) ( SAVERESTOREDATA * ); |
|
void (*pfnResetGlobalState) ( void ); |
|
|
|
qboolean (*pfnClientConnect) ( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] ); |
|
|
|
void (*pfnClientDisconnect) ( edict_t *pEntity ); |
|
void (*pfnClientKill) ( edict_t *pEntity ); |
|
void (*pfnClientPutInServer) ( edict_t *pEntity ); |
|
void (*pfnClientCommand) ( edict_t *pEntity ); |
|
void (*pfnClientUserInfoChanged)( edict_t *pEntity, char *infobuffer ); |
|
|
|
void (*pfnServerActivate) ( edict_t *pEdictList, int edictCount, int clientMax ); |
|
void (*pfnServerDeactivate) ( void ); |
|
|
|
void (*pfnPlayerPreThink) ( edict_t *pEntity ); |
|
void (*pfnPlayerPostThink) ( edict_t *pEntity ); |
|
|
|
void (*pfnStartFrame) ( void ); |
|
void (*pfnParmsNewLevel) ( void ); |
|
void (*pfnParmsChangeLevel) ( void ); |
|
|
|
// Returns string describing current .dll. E.g., TeamFotrress 2, Half-Life |
|
const char *(*pfnGetGameDescription)( void ); |
|
|
|
// Notify dll about a player customization. |
|
void (*pfnPlayerCustomization) ( edict_t *pEntity, customization_t *pCustom ); |
|
|
|
// Spectator funcs |
|
void (*pfnSpectatorConnect) ( edict_t *pEntity ); |
|
void (*pfnSpectatorDisconnect) ( edict_t *pEntity ); |
|
void (*pfnSpectatorThink) ( edict_t *pEntity ); |
|
|
|
// Notify game .dll that engine is going to shut down. Allows mod authors to set a breakpoint. |
|
void (*pfnSys_Error) ( const char *error_string ); |
|
|
|
void (*pfnPM_Move) ( struct playermove_s *ppmove, qboolean server ); |
|
void (*pfnPM_Init) ( struct playermove_s *ppmove ); |
|
char (*pfnPM_FindTextureType)( char *name ); |
|
void (*pfnSetupVisibility)( struct edict_s *pViewEntity, struct edict_s *pClient, unsigned char **pvs, unsigned char **pas ); |
|
void (*pfnUpdateClientData) ( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd ); |
|
int (*pfnAddToFullPack)( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet ); |
|
void (*pfnCreateBaseline) ( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs ); |
|
void (*pfnRegisterEncoders) ( void ); |
|
int (*pfnGetWeaponData) ( struct edict_s *player, struct weapon_data_s *info ); |
|
|
|
void (*pfnCmdStart) ( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed ); |
|
void (*pfnCmdEnd) ( const edict_t *player ); |
|
|
|
// Return 1 if the packet is valid. Set response_buffer_size if you want to send a response packet. Incoming, it holds the max |
|
// size of the response_buffer, so you must zero it out if you choose not to respond. |
|
int (*pfnConnectionlessPacket ) ( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size ); |
|
|
|
// Enumerates player hulls. Returns 0 if the hull number doesn't exist, 1 otherwise |
|
int (*pfnGetHullBounds) ( int hullnumber, float *mins, float *maxs ); |
|
|
|
// Create baselines for certain "unplaced" items. |
|
void (*pfnCreateInstancedBaselines) ( void ); |
|
|
|
// One of the pfnForceUnmodified files failed the consistency check for the specified player |
|
// Return 0 to allow the client to continue, 1 to force immediate disconnection ( with an optional disconnect message of up to 256 characters ) |
|
int (*pfnInconsistentFile)( const struct edict_s *player, const char *filename, char *disconnect_message ); |
|
|
|
// The game .dll should return 1 if lag compensation should be allowed ( could also just set |
|
// the sv_unlag cvar. |
|
// Most games right now should return 0, until client-side weapon prediction code is written |
|
// and tested for them. |
|
int (*pfnAllowLagCompensation)( void ); |
|
} DLL_FUNCTIONS; |
|
|
|
extern DLL_FUNCTIONS gEntityInterface; |
|
|
|
// Current version. |
|
#define NEW_DLL_FUNCTIONS_VERSION 1 |
|
|
|
typedef struct |
|
{ |
|
// Called right before the object's memory is freed. |
|
// Calls its destructor. |
|
void (*pfnOnFreeEntPrivateData)(edict_t *pEnt); |
|
void (*pfnGameShutdown)(void); |
|
int (*pfnShouldCollide)( edict_t *pentTouched, edict_t *pentOther ); |
|
} NEW_DLL_FUNCTIONS; |
|
typedef int (*NEW_DLL_FUNCTIONS_FN)( NEW_DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion ); |
|
|
|
// Pointers will be null if the game DLL doesn't support this API. |
|
extern NEW_DLL_FUNCTIONS gNewDLLFunctions; |
|
|
|
typedef int (*APIFUNCTION)( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion ); |
|
typedef int (*APIFUNCTION2)( DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion ); |
|
|
|
#endif EIFACE_H
|
|
|