I do have one question about this.
What do these structs contain:
sequenceEntry_s
sentenceEntry_s
?




-omega
http://www.frontline2.com


> -----Original Message-----
> From: [EMAIL PROTECTED] [mailto:hlcoders-
> [EMAIL PROTECTED] On Behalf Of Jeffrey "botman" Broome
> Sent: November 10, 2003 10:12 PM
> To: [EMAIL PROTECTED]
> Subject: [hlcoders] [Fwd: [hlds_apps] Engine interface changes]
>
> Any reason this wasn't sent to hlcoders?
>
> Alfred, will this only effect dedicated servers or will there be a
> client update coming in the "near" future?
>
>
>
> -------- Original Message --------
> Subject: [hlds_apps] Engine interface changes
> Date: Mon, 10 Nov 2003 13:49:44 -0800
> From: Alfred Reynolds <[EMAIL PROTECTED]>
> Reply-To: [EMAIL PROTECTED]
> To: <[EMAIL PROTECTED]>, <[EMAIL PROTECTED]>
>
> We will be releasing a new engine soon (within the next couple of days
> we expect), we have added some new functions to the engine function
> structure (from eiface.h). If you are responsible for a third party
> program such as MetaMod you will need to update this engine structure
> and recompile your program. Not updating will cause a crash when your
> users try to use the new engine with the old engine interface
structure.
>
> - Alfred
>
>
>
> // 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 );
>
>       //
>       //
>       //  **************** New functions ***************
>       //
>       //
>
>
>       sequenceEntry_s*        (*pfnSequenceGet)
> ( const char* fileName, const char* entryName );
>       sentenceEntry_s*        (*pfnSequencePickSentence)      ( const
> char* groupName, int pickMethod, int *picked );
>       int                     (*pfnGetFileSize)
> ( 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 (*ProcessTutorMessageDecayBuffer)(int *buffer, int
> bufferLength);
>       void (*ConstructTutorMessageDecayBuffer)(int *buffer, int
> bufferLength);
>       void (*ResetTutorMessageDecayData)( void );
>
> } enginefuncs_t;
>
>
> _______________________________________________
> hlds_apps mailing list
> [EMAIL PROTECTED]
> http://list.valvesoftware.com/mailman/listinfo/hlds_apps
>
>
>
> --
> Jeffrey "botman" Broome
>
>
> _______________________________________________
> To unsubscribe, edit your list preferences, or view the list archives,
> please visit:
> http://list.valvesoftware.com/mailman/listinfo/hlcoders
>



_______________________________________________
To unsubscribe, edit your list preferences, or view the list archives, please visit:
http://list.valvesoftware.com/mailman/listinfo/hlcoders

Reply via email to