.:: Bots United ::. - CZ released!!!

Then the DoX reference on the metamod website must be outdated.

Here's the current eiface.h as I have it:
Code:
/***

*

* 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

#include "archtypes.h"         // DAL

#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"

#include "Sequence.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_model_specifybounds_if_avail, // For Steam model files only, the geometry must fit in the specified bbox (if the file is available)

} 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)   (void *pfile, char *szFmt, ...);

 void*  (*pfnPvAllocEntPrivateData) (edict_t *pEdict, int32 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 );

 uint32 (*pfnFunctionFromName) ( const char *pName );

 const char *(*pfnNameForFunction)  ( uint32 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);

 int32  (*pfnRandomLong)   (int32  lLow,  int32  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);

 const char *(*pfnGetPlayerAuthId)  ( edict_t *e );

 // PSV: Added for CZ training map

// const char *(*pfnKeyNameForBinding)  ( const char* pBinding );

 

 void* (*pfnSequenceGet)   ( const char* fileName, const char* entryName );

 void* (*pfnSequencePickSentence) ( const char* groupName, int pickMethod, int *picked );

 // LH: Give access to filesize via filesystem

 int   (*pfnGetFileSize)   ( char *filename );

 unsigned int (*pfnGetApproxWavePlayLen) (const char *filepath);

 // MDC: Added for CZ career-mode

 int   (*pfnIsCareerMatch)   ( void );

 // BGC: return the number of characters of the localized string referenced by using "label"

 int   (*pfnGetLocalizedStringLength)(const char *label);

 // BGC: added to facilitate persistent storage of tutor message decay values for

 // different career game profiles.  Also needs to persist regardless of mp.dll being

 // destroyed and recreated.

 void (*pfnRegisterTutorMessageShown)(int mid);

 int (*pfnGetTimesTutorMessageShown)(int mid);

 void (*pfnProcessTutorMessageDecayBuffer)(int *buffer, int bufferLength);

 void (*pfnConstructTutorMessageDecayBuffer)(int *buffer, int bufferLength);

 void (*pfnResetTutorMessageDecayData)( void );

} 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

 int32 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