/*** * * Copyright (c) 1996-2002, 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; int fCDRom; int fPlayTrack; } CDStatus; typedef unsigned int CRC32_t; typedef struct delta_s delta_t; struct entity_state_s; // Engine hands this to DLLs for functionality callbacks typedef struct enginefuncs_s { int (*pfnPrecacheModel)( const char* s ); int (*pfnPrecacheSound)( const 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)( const char* s1, const 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)( const 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, const 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, const void *p, int len ); void (*pfnCRC32_ProcessByte)( CRC32_t *pulCRC, unsigned char ch ); CRC32_t (*pfnCRC32_Final)( CRC32_t pulCRC ); int (*pfnRandomLong)( int lLow, int 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)( const char *filename, int *pLength ); void (*pfnFreeFile)( void *buffer ); void (*pfnEndSection)( const char *pszSectionName ); // trigger_endsection int (*pfnCompareFileTime)( const char *filename1, const 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 const char* (*pfnInfoKeyValue)( const char *infobuffer, const 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)( const 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)( const float *org ); unsigned char *(*pfnSetFatPAS)( const 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, const 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)( const 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); const char *(*pfnGetPlayerAuthId) ( edict_t *e ); void* (*pfnSequenceGet) ( const char* fileName, const char* entryName ); void* (*pfnSequencePickSentence) ( const char* groupName, int pickMethod, int *picked ); int (*pfnGetFileSize) ( const char *filename ); unsigned int (*pfnGetApproxWavePlayLen) (const char *filepath); int (*pfnIsCareerMatch) ( void ); int (*pfnGetLocalizedStringLength) (const char *label); void (*pfnRegisterTutorMessageShown) (int mid); int (*pfnGetTimesTutorMessageShown) (int mid); void (*pfnProcessTutorMessageDecayBuffer) (int *buffer, int bufferLength); void (*pfnConstructTutorMessageDecayBuffer) (int *buffer, int bufferLength); void (*pfnResetTutorMessageDecayData) ( void ); // three useable funcs void (*pfnQueryClientCvarValue)( const edict_t *player, const char *cvarName ); void (*pfnQueryClientCvarValue2)( const edict_t *player, const char *cvarName, int requestID ); int (*pfnCheckParm)( char *parm, char **ppnext ); // added in 8279 edict_t* (*pfnPEntityOfEntIndexAllEntities)( int iEntIndex ); } 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 int 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; 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 MAX_LEVEL_CONNECTIONS 16 // These are encoded in the lower 16bits of ENTITYTABLE->flags #define FENTTABLE_PLAYER 0x80000000 #define FENTTABLE_REMOVED 0x40000000 #define FENTTABLE_MOVEABLE 0x20000000 #define FENTTABLE_GLOBAL 0x10000000 typedef 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 } SAVERESTOREDATA; 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 #ifdef __GNUC__ #define offsetof(s,m) __builtin_offsetof(s,m) #else #define offsetof(s,m) (size_t)&(((s *)0)->m) #endif #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 #define FTYPEDESC_SAVE 0x0002 // This field is saved to disk #define FTYPEDESC_KEY 0x0004 // This field can be requested and written to by string name at load time #define FTYPEDESC_FUNCTIONTABLE 0x0008 // This is a table entry for a member function pointer typedef struct { FIELDTYPE fieldType; const char *fieldName; int fieldOffset; short fieldSize; short flags; } TYPEDESCRIPTION; #undef ARRAYSIZE #define ARRAYSIZE(p) (sizeof(p)/sizeof(p[0])) struct weapon_data_s; struct playermove_s; struct clientdata_s; struct usercmd_s; struct edict_s; struct netadr_s; 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 ); void (*pfnCvarValue)( const edict_t *pEnt, const char *value ); void (*pfnCvarValue2)( const edict_t *pEnt, int requestID, const char *cvarName, const char *value ); } 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