//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //===========================================================================// #ifndef EIFACE_H #define EIFACE_H #ifdef _WIN32 #pragma once #endif #include "bitvec.h" #include "convar.h" #include "edict.h" #include "engine/iserverplugin.h" #include "engine/ivmodelinfo.h" #include "icvar.h" #include "iserverentity.h" #include "mathlib/vplane.h" #include "soundflags.h" #include "tier1/bitbuf.h" //----------------------------------------------------------------------------- // forward declarations //----------------------------------------------------------------------------- class SendTable; class ServerClass; class IMoveHelper; struct Ray_t; class CGameTrace; typedef CGameTrace trace_t; struct typedescription_t; class CSaveRestoreData; struct datamap_t; class SendTable; class ServerClass; class IMoveHelper; struct Ray_t; struct studiohdr_t; class CBaseEntity; class CRestore; class CSave; class variant_t; struct vcollide_t; class IRecipientFilter; class CBaseEntity; class ITraceFilter; struct client_textmessage_t; class INetChannelInfo; class ISpatialPartition; class IScratchPad3D; class CStandardSendProxies; class IAchievementMgr; class CGamestatsData; class CSteamID; class IReplayFactory; class IReplaySystem; class IServer; typedef struct player_info_s player_info_t; //----------------------------------------------------------------------------- // defines //----------------------------------------------------------------------------- #ifdef _WIN32 #define DLLEXPORT __stdcall #else #define DLLEXPORT /* */ #endif #define INTERFACEVERSION_VENGINESERVER_VERSION_21 "VEngineServer021" #define INTERFACEVERSION_VENGINESERVER_VERSION_22 "VEngineServer022" #define INTERFACEVERSION_VENGINESERVER "VEngineServer023" #define INTERFACEVERSION_VENGINESERVER_INT 23 struct bbox_t { Vector mins; Vector maxs; }; //----------------------------------------------------------------------------- // Purpose: Interface the engine exposes to the game DLL //----------------------------------------------------------------------------- abstract_class IVEngineServer { public: // Tell engine to change level ( "changelevel s1\n" or "changelevel2 s1 // s2\n" ) virtual void ChangeLevel(const char *s1, const char *s2) = 0; // Ask engine whether the specified map is a valid map file (exists and has // valid version number). virtual int IsMapValid(const char *filename) = 0; // Is this a dedicated server? virtual bool IsDedicatedServer(void) = 0; // Is in Hammer editing mode? virtual int IsInEditMode(void) = 0; // Add to the server/client lookup/precache table, the specified string is // given a unique index NOTE: The indices for PrecacheModel are 1 based // a 0 returned from those methods indicates the model or sound was not // correctly precached // However, generic and decal are 0 based // If preload is specified, the file is loaded into the server/client's // cache memory before level startup, otherwise // it'll only load when actually used (which can cause a disk i/o hitch if // it occurs during play of a level). virtual int PrecacheModel(const char *s, bool preload = false) = 0; virtual int PrecacheSentenceFile(const char *s, bool preload = false) = 0; virtual int PrecacheDecal(const char *name, bool preload = false) = 0; virtual int PrecacheGeneric(const char *s, bool preload = false) = 0; // Check's if the name is precached, but doesn't actually precache the name // if not... virtual bool IsModelPrecached(char const *s) const = 0; virtual bool IsDecalPrecached(char const *s) const = 0; virtual bool IsGenericPrecached(char const *s) const = 0; // Note that sounds are precached using the IEngineSound interface // Special purpose PVS checking // Get the cluster # for the specified position virtual int GetClusterForOrigin(const Vector &org) = 0; // Get the PVS bits for a specified cluster and copy the bits into // outputpvs. Returns the number of bytes needed to pack the PVS virtual int GetPVSForCluster(int cluster, int outputpvslength, unsigned char *outputpvs) = 0; // Check whether the specified origin is inside the specified PVS virtual bool CheckOriginInPVS( const Vector &org, const unsigned char *checkpvs, int checkpvssize) = 0; // Check whether the specified worldspace bounding box is inside the // specified PVS virtual bool CheckBoxInPVS(const Vector &mins, const Vector &maxs, const unsigned char *checkpvs, int checkpvssize) = 0; // 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 players. virtual int GetPlayerUserId(const edict_t *e) = 0; virtual const char *GetPlayerNetworkIDString(const edict_t *e) = 0; // Return the current number of used edict slots virtual int GetEntityCount(void) = 0; // Given an edict, returns the entity index virtual int IndexOfEdict(const edict_t *pEdict) = 0; // Given and entity index, returns the corresponding edict pointer virtual edict_t *PEntityOfEntIndex(int iEntIndex) = 0; // Get stats info interface for a client netchannel virtual INetChannelInfo *GetPlayerNetInfo(int playerIndex) = 0; // Allocate space for string and return index/offset of string in global // string list If iForceEdictIndex is not -1, then it will return the edict // with that index. If that edict index is already used, it'll return null. virtual edict_t *CreateEdict(int iForceEdictIndex = -1) = 0; // Remove the specified edict and place back into the free edict list virtual void RemoveEdict(edict_t * e) = 0; // Memory allocation for entity class data virtual void *PvAllocEntPrivateData(long cb) = 0; virtual void FreeEntPrivateData(void *pEntity) = 0; // Save/restore uses a special memory allocator (which zeroes newly // allocated memory, etc.) virtual void *SaveAllocMemory(size_t num, size_t size) = 0; virtual void SaveFreeMemory(void *pSaveMem) = 0; // Emit an ambient sound associated with the specified entity virtual void EmitAmbientSound( int entindex, const Vector &pos, const char *samp, float vol, soundlevel_t soundlevel, int fFlags, int pitch, float delay = 0.0f) = 0; // Fade out the client's volume level toward silence (or fadePercent) virtual void FadeClientVolume(const edict_t *pEdict, float fadePercent, float fadeOutSeconds, float holdTime, float fadeInSeconds) = 0; // Sentences / sentence groups virtual int SentenceGroupPick(int groupIndex, char *name, int nameBufLen) = 0; virtual int SentenceGroupPickSequential(int groupIndex, char *name, int nameBufLen, int sentenceIndex, int reset) = 0; virtual int SentenceIndexFromName(const char *pSentenceName) = 0; virtual const char *SentenceNameFromIndex(int sentenceIndex) = 0; virtual int SentenceGroupIndexFromName(const char *pGroupName) = 0; virtual const char *SentenceGroupNameFromIndex(int groupIndex) = 0; virtual float SentenceLength(int sentenceIndex) = 0; // Issue a command to the command parser as if it was typed at the server // console. virtual void ServerCommand(const char *str) = 0; // Execute any commands currently in the command parser immediately (instead // of once per frame) virtual void ServerExecute(void) = 0; // Issue the specified command to the specified client (mimics that client // typing the command at the console). virtual void ClientCommand(edict_t * pEdict, PRINTF_FORMAT_STRING const char *szFmt, ...) = 0; // Set the lightstyle to the specified value and network the change to any // connected clients. Note that val must not // change place in memory (use MAKE_STRING) for anything that's not // compiled into your mod. virtual void LightStyle(int style, const char *val) = 0; // Project a static decal onto the specified entity / model (for level // placed decals in the .bsp) virtual void StaticDecal(const Vector &originInEntitySpace, int decalIndex, int entityIndex, int modelIndex, bool lowpriority) = 0; // Given the current PVS(or PAS) and origin, determine which players should // hear/receive the message virtual void Message_DetermineMulticastRecipients( bool usepas, const Vector &origin, CBitVec &playerbits) = 0; // Begin a message from a server side entity to its client side counterpart // (func_breakable glass, e.g.) virtual bf_write *EntityMessageBegin(int ent_index, ServerClass *ent_class, bool reliable) = 0; // Begin a usermessage from the server to the client .dll virtual bf_write *UserMessageBegin(IRecipientFilter * filter, int msg_type) = 0; // Finish the Entity or UserMessage and dispatch to network layer virtual void MessageEnd(void) = 0; // Print szMsg to the client console. virtual void ClientPrintf(edict_t * pEdict, const char *szMsg) = 0; // SINGLE PLAYER/LISTEN SERVER ONLY (just matching the client .dll api for // this) Prints the formatted string to the notification area of the screen // ( down the right hand edge // numbered lines starting at position 0 virtual void Con_NPrintf(int pos, PRINTF_FORMAT_STRING const char *fmt, ...) = 0; // SINGLE PLAYER/LISTEN SERVER ONLY(just matching the client .dll api for // this) Similar to Con_NPrintf, but allows specifying custom text color and // duration information virtual void Con_NXPrintf(const struct con_nprint_s *info, PRINTF_FORMAT_STRING const char *fmt, ...) = 0; // Change a specified player's "view entity" (i.e., use the view entity // position/orientation for rendering the client view) virtual void SetView(const edict_t *pClient, const edict_t *pViewent) = 0; // Get a high precision timer for doing profiling work virtual float Time(void) = 0; // Set the player's crosshair angle virtual void CrosshairAngle(const edict_t *pClient, float pitch, float yaw) = 0; // Get the current game directory (hl2, tf2, hl1, cstrike, etc.) virtual void GetGameDir(char *szGetGameDir, int maxlength) = 0; // Used by AI node graph code to determine if .bsp and .ain files are out of // date virtual int CompareFileTime(const char *filename1, const char *filename2, int *iCompare) = 0; // Locks/unlocks the network string tables (.e.g, when adding bots to // server, this needs to happen). Be sure to reset the lock after executing // your code!!! virtual bool LockNetworkStringTables(bool lock) = 0; // Create a bot with the given name. Returns NULL if fake client can't be // created virtual edict_t *CreateFakeClient(const char *netname) = 0; // Get a convar keyvalue for s specified client virtual const char *GetClientConVarValue(int clientIndex, const char *name) = 0; // Parse a token from a file virtual const char *ParseFile(const char *data, char *token, int maxlen) = 0; // Copies a file virtual bool CopyFile(const char *source, const char *destination) = 0; // Reset the pvs, pvssize is the size in bytes of the buffer pointed to by // pvs. This should be called right before any calls to AddOriginToPVS virtual void ResetPVS(byte * pvs, int pvssize) = 0; // Merge the pvs bits into the current accumulated pvs based on the // specified origin ( not that each pvs origin has an 8 world unit fudge // factor ) virtual void AddOriginToPVS(const Vector &origin) = 0; // Mark a specified area portal as open/closed. // Use SetAreaPortalStates if you want to set a bunch of them at a time. virtual void SetAreaPortalState(int portalNumber, int isOpen) = 0; // Queue a temp entity for transmission virtual void PlaybackTempEntity(IRecipientFilter & filter, float delay, const void *pSender, const SendTable *pST, int classID) = 0; // Given a node number and the specified PVS, return with the node is in the // PVS virtual int CheckHeadnodeVisible(int nodenum, const byte *pvs, int vissize) = 0; // Using area bits, cheeck whether area1 flows into area2 and vice versa // (depends on area portal state) virtual int CheckAreasConnected(int area1, int area2) = 0; // Given an origin, determine which area index the origin is within virtual int GetArea(const Vector &origin) = 0; // Get area portal bit set virtual void GetAreaBits(int area, unsigned char *bits, int buflen) = 0; // Given a view origin (which tells us the area to start looking in) and a // portal key, fill in the plane that leads out of this area (it points into // whatever area it leads to). virtual bool GetAreaPortalPlane(Vector const &vViewOrigin, int portalKey, VPlane *pPlane) = 0; // Save/restore wrapper - FIXME: At some point we should move this to it's // own interface virtual bool LoadGameState(char const *pMapName, bool createPlayers) = 0; virtual void LoadAdjacentEnts(const char *pOldLevel, const char *pLandmarkName) = 0; virtual void ClearSaveDir() = 0; // Get the pristine map entity lump string. (e.g., used by CS to reload the // map entities when restarting a round.) virtual const char *GetMapEntitiesString() = 0; // Text message system -- lookup the text message of the specified name virtual client_textmessage_t *TextMessageGet(const char *pName) = 0; // Print a message to the server log file virtual void LogPrint(const char *msg) = 0; // Builds PVS information for an entity virtual void BuildEntityClusterList(edict_t * pEdict, PVSInfo_t * pPVSInfo) = 0; // A solid entity moved, update spatial partition virtual void SolidMoved(edict_t * pSolidEnt, ICollideable * pSolidCollide, const Vector *pPrevAbsOrigin, bool testSurroundingBoundsOnly) = 0; // A trigger entity moved, update spatial partition virtual void TriggerMoved(edict_t * pTriggerEnt, bool testSurroundingBoundsOnly) = 0; // Create/destroy a custom spatial partition virtual ISpatialPartition *CreateSpatialPartition( const Vector &worldmin, const Vector &worldmax) = 0; virtual void DestroySpatialPartition(ISpatialPartition *) = 0; // Draw the brush geometry in the map into the scratch pad. // Flags is currently unused. virtual void DrawMapToScratchPad(IScratchPad3D * pPad, unsigned long iFlags) = 0; // This returns which entities, to the best of the server's knowledge, the // client currently knows about. This is really which entities were in the // snapshot that this client last acked. This returns a bit vector with one // bit for each entity. // // USE WITH CARE. Whatever tick the client is really currently on is subject // to timing and ordering differences, so you should account for about a // quarter-second discrepancy in here. Also, this will return NULL if the // client doesn't exist or if this client hasn't acked any frames yet. // // iClientIndex is the CLIENT index, so if you use pPlayer->entindex(), // subtract 1. virtual const CBitVec *GetEntityTransmitBitsForClient( int iClientIndex) = 0; // Is the game paused? virtual bool IsPaused() = 0; // Marks the filename for consistency checking. This should be called after // precaching the file. virtual void ForceExactFile(const char *s) = 0; virtual void ForceModelBounds(const char *s, const Vector &mins, const Vector &maxs) = 0; virtual void ClearSaveDirAfterClientLoad() = 0; // Sets a USERINFO client ConVar for a fakeclient virtual void SetFakeClientConVarValue(edict_t * pEntity, const char *cvar, const char *value) = 0; // Marks the material (vmt file) for consistency checking. If the client // and server have different contents for the file, the client's vmt can // only use the VertexLitGeneric shader, and can only contain $baseTexture // and $bumpmap vars. virtual void ForceSimpleMaterial(const char *s) = 0; // Is the engine in Commentary mode? virtual int IsInCommentaryMode(void) = 0; // Mark some area portals as open/closed. It's more efficient to use this // than a bunch of individual SetAreaPortalState calls. virtual void SetAreaPortalStates(const int *portalNumbers, const int *isOpen, int nPortals) = 0; // Called when relevant edict state flags change. virtual void NotifyEdictFlagsChange(int iEdict) = 0; // Only valid during CheckTransmit. Also, only the PVS, networked areas, and // m_pTransmitInfo are valid in the returned strucutre. virtual const CCheckTransmitInfo *GetPrevCheckTransmitInfo( edict_t * pPlayerEdict) = 0; virtual CSharedEdictChangeInfo *GetSharedEdictChangeInfo() = 0; // Tells the engine we can immdiately re-use all edict indices // even though we may not have waited enough time virtual void AllowImmediateEdictReuse() = 0; // Returns true if the engine is an internal build. i.e. is using the // internal bugreporter. virtual bool IsInternalBuild(void) = 0; virtual IChangeInfoAccessor *GetChangeAccessor(const edict_t *pEdict) = 0; // Name of most recently load .sav file virtual char const *GetMostRecentlyLoadedFileName() = 0; virtual char const *GetSaveFileName() = 0; // Matchmaking virtual void MultiplayerEndGame() = 0; virtual void ChangeTeam(const char *pTeamName) = 0; // Cleans up the cluster list virtual void CleanUpEntityClusterList(PVSInfo_t * pPVSInfo) = 0; virtual void SetAchievementMgr(IAchievementMgr * pAchievementMgr) = 0; virtual IAchievementMgr *GetAchievementMgr() = 0; virtual int GetAppID() = 0; virtual bool IsLowViolence() = 0; // Call this to find out the value of a cvar on the client. // // It is an asynchronous query, and it will call // IServerGameDLL::OnQueryCvarValueFinished when the value comes in from the // client. // // Store the return value if you want to match this specific query to the // OnQueryCvarValueFinished call. Returns InvalidQueryCvarCookie if the // entity is invalid. virtual QueryCvarCookie_t StartQueryCvarValue(edict_t * pPlayerEntity, const char *pName) = 0; virtual void InsertServerCommand(const char *str) = 0; // Fill in the player info structure for the specified player index (name, // model, etc.) virtual bool GetPlayerInfo(int ent_num, player_info_t *pinfo) = 0; // Returns true if this client has been fully authenticated by Steam virtual bool IsClientFullyAuthenticated(edict_t * pEdict) = 0; // This makes the host run 1 tick per frame instead of checking the system // timer to see how many ticks to run in a certain frame. i.e. it does the // same thing timedemo does. virtual void SetDedicatedServerBenchmarkMode(bool bBenchmarkMode) = 0; // Methods to set/get a gamestats data container so client & server running // in same process can send combined data virtual void SetGamestatsData(CGamestatsData * pGamestatsData) = 0; virtual CGamestatsData *GetGamestatsData() = 0; // Returns the SteamID of the specified player. It'll be NULL if the player // hasn't authenticated yet. virtual const CSteamID *GetClientSteamID(edict_t * pPlayerEdict) = 0; // Returns the SteamID of the game server virtual const CSteamID *GetGameServerSteamID() = 0; // Send a client command keyvalues // keyvalues are deleted inside the function virtual void ClientCommandKeyValues(edict_t * pEdict, KeyValues * pCommand) = 0; // Returns the SteamID of the specified player. It'll be NULL if the player // hasn't authenticated yet. virtual const CSteamID *GetClientSteamIDByPlayerIndex(int entnum) = 0; // Gets a list of all clusters' bounds. Returns total number of clusters. virtual int GetClusterCount() = 0; virtual int GetAllClusterBounds(bbox_t * pBBoxList, int maxBBox) = 0; // Create a bot with the given name. Returns NULL if fake client can't be // created virtual edict_t *CreateFakeClientEx(const char *netname, bool bReportFakeClient = true) = 0; // Server version from the steam.inf, this will be compared to the GC // version virtual int GetServerVersion() const = 0; // Get sv.GetTime() virtual float GetServerTime() const = 0; // Exposed for server plugin authors virtual IServer *GetIServer() = 0; virtual bool IsPlayerNameLocked(const edict_t *pEdict) = 0; virtual bool CanPlayerChangeName(const edict_t *pEdict) = 0; // Find the canonical name of a map, given a partial or non-canonical map // name. Except in the case of an exact match, pMapName is updated to the // canonical name of the match. NOTE That this is subject to the same // limitation as ServerGameDLL::CanProvideLevel -- This is non-blocking, so // it // is possible that blocking ServerGameDLL::PrepareLevelResources call // may be able to pull a better match than is immediately available to // this call (e.g. blocking lookups of cloud maps) enum eFindMapResult { // A direct match for this name was found eFindMap_Found, // No match for this map name could be found. eFindMap_NotFound, // A fuzzy match for this mapname was found and pMapName was updated to // the full name. // Ex: cp_dust -> cp_dustbowl eFindMap_FuzzyMatch, // A match for this map name was found, and the map name was updated to // the canonical version of the // name. // Ex: workshop/1234 -> workshop/cp_qualified_name.ugc1234 eFindMap_NonCanonical, // No currently available match for this map name could be found, but it // may be possible to load ( see caveat // about PrepareLevelResources above ) eFindMap_PossiblyAvailable }; virtual eFindMapResult FindMap(/* in/out */ char *pMapName, int nMapNameMax) = 0; }; // These only differ in new items added to the end typedef IVEngineServer IVEngineServer021; typedef IVEngineServer IVEngineServer022; #define INTERFACEVERSION_SERVERGAMEDLL_VERSION_8 "ServerGameDLL008" #define INTERFACEVERSION_SERVERGAMEDLL_VERSION_9 "ServerGameDLL009" #define INTERFACEVERSION_SERVERGAMEDLL "ServerGameDLL010" #define INTERFACEVERSION_SERVERGAMEDLL_INT 10 class IServerGCLobby; //----------------------------------------------------------------------------- // Purpose: These are the interfaces that the game .dll exposes to the engine //----------------------------------------------------------------------------- abstract_class IServerGameDLL { public: // Initialize the game (one-time call when the DLL is first loaded ) // Return false if there is an error during startup. virtual bool DLLInit( CreateInterfaceFn engineFactory, CreateInterfaceFn physicsFactory, CreateInterfaceFn fileSystemFactory, CGlobalVars * pGlobals) = 0; // Setup replay interfaces on the server virtual bool ReplayInit(CreateInterfaceFn fnReplayFactory) = 0; // This is called when a new game is started. (restart, map) virtual bool GameInit(void) = 0; // Called any time a new level is started (after GameInit() also on level // transitions within a game) virtual bool LevelInit(char const *pMapName, char const *pMapEntities, char const *pOldLevel, char const *pLandmarkName, bool loadGame, bool background) = 0; // The server is about to activate virtual void ServerActivate(edict_t * pEdictList, int edictCount, int clientMax) = 0; // The server should run physics/think on all edicts virtual void GameFrame(bool simulating) = 0; // Called once per simulation frame on the final tick virtual void PreClientUpdate(bool simulating) = 0; // Called when a level is shutdown (including changing levels) virtual void LevelShutdown(void) = 0; // This is called when a game ends (server disconnect, death, restart, load) // NOT on level transitions within a game virtual void GameShutdown(void) = 0; // Called once during DLL shutdown virtual void DLLShutdown(void) = 0; // Get the simulation interval (must be compiled with identical values into // both client and game .dll for MOD!!!) Right now this is only requested at // server startup time so it can't be changed on the fly, etc. virtual float GetTickInterval(void) const = 0; // Give the list of datatable classes to the engine. The engine matches // class names from here with // edict_t::classname to figure out how to encode a class's data for // networking virtual ServerClass *GetAllServerClasses(void) = 0; // Returns string describing current .dll. e.g., TeamFortress 2, // Half-Life 2. // Hey, it's more descriptive than just the name of the game directory virtual const char *GetGameDescription(void) = 0; // Let the game .dll allocate it's own network/shared string tables virtual void CreateNetworkStringTables(void) = 0; // Save/restore system hooks virtual CSaveRestoreData *SaveInit(int size) = 0; virtual void SaveWriteFields(CSaveRestoreData *, const char *, void *, datamap_t *, typedescription_t *, int) = 0; virtual void SaveReadFields(CSaveRestoreData *, const char *, void *, datamap_t *, typedescription_t *, int) = 0; virtual void SaveGlobalState(CSaveRestoreData *) = 0; virtual void RestoreGlobalState(CSaveRestoreData *) = 0; virtual void PreSave(CSaveRestoreData *) = 0; virtual void Save(CSaveRestoreData *) = 0; virtual void GetSaveComment(char *comment, int maxlength, float flMinutes, float flSeconds, bool bNoTime = false) = 0; virtual void WriteSaveHeaders(CSaveRestoreData *) = 0; virtual void ReadRestoreHeaders(CSaveRestoreData *) = 0; virtual void Restore(CSaveRestoreData *, bool) = 0; virtual bool IsRestoring() = 0; // Returns the number of entities moved across the transition virtual int CreateEntityTransitionList(CSaveRestoreData *, int) = 0; // Build the list of maps adjacent to the current map virtual void BuildAdjacentMapList(void) = 0; // Retrieve info needed for parsing the specified user message virtual bool GetUserMessageInfo(int msg_type, char *name, int maxnamelength, int &size) = 0; // Hand over the StandardSendProxies in the game DLL's module. virtual CStandardSendProxies *GetStandardSendProxies() = 0; // Called once during startup, after the game .dll has been loaded and after // the client .dll has also been loaded virtual void PostInit() = 0; // Called once per frame even when no level is loaded... virtual void Think(bool finalTick) = 0; #ifdef _XBOX virtual void GetTitleName(const char *pMapName, char *pTitleBuff, int titleBuffSize) = 0; #endif virtual void PreSaveGameLoaded(char const *pSaveName, bool bCurrentlyInGame) = 0; // Returns true if the game DLL wants the server not to be made public. // Used by commentary system to hide multiplayer commentary servers from the // master. virtual bool ShouldHideServer(void) = 0; virtual void InvalidateMdlCache() = 0; // * This function is new with version 6 of the interface. // // This is called when a query from // IServerPluginHelpers::StartQueryCvarValue is finished. iCookie is the // value returned by IServerPluginHelpers::StartQueryCvarValue. Added with // version 2 of the interface. virtual void OnQueryCvarValueFinished( QueryCvarCookie_t iCookie, edict_t * pPlayerEntity, EQueryCvarValueStatus eStatus, const char *pCvarName, const char *pCvarValue) = 0; // Called after the steam API has been activated post-level startup virtual void GameServerSteamAPIActivated(void) = 0; // Called after the steam API has been shutdown post-level startup virtual void GameServerSteamAPIShutdown(void) = 0; virtual void SetServerHibernation(bool bHibernating) = 0; // interface to the new GC based lobby system virtual IServerGCLobby *GetServerGCLobby() = 0; // Return override string to show in the server browser // "map" column, or NULL to just use the default value // (the map name) virtual const char *GetServerBrowserMapOverride() = 0; // Get gamedata string to send to the master serer updater. virtual const char *GetServerBrowserGameData() = 0; // Called to add output to the status command virtual void Status(void (*print)(const char *fmt, ...)) = 0; // Informs the game we would like to load this level, giving it a chance to // prepare dynamic resources. // // - pszMapName is the name of the map we're looking for, and may be // overridden to e.g. the canonical name of the // map. // // - pszMapFile is the file we intend to use for this map ( e.g. // maps/.bsp ), and may be overridden to the // file representing this map name. ( e.g. // /path/to/steamapps/workshop/cp_mymap.ugc12345.bsp ) // // This call is blocking, and may block for extended periods. See // AsyncPrepareLevelResources below. virtual void PrepareLevelResources( /* in/out */ char *pszMapName, size_t nMapNameSize, /* in/out */ char *pszMapFile, size_t nMapFileSize) = 0; // Asynchronous version of PrepareLevelResources. Returns preparation status // of map when called. If passed, flProgress is filled with the current // progress percentage [ 0.f to 1.f ] for the InProgress result enum ePrepareLevelResourcesResult { // Good to go ePrepareLevelResources_Prepared, // Game DLL is async preparing (e.g. streaming resources). flProgress // will be filled if passed. ePrepareLevelResources_InProgress }; virtual ePrepareLevelResourcesResult AsyncPrepareLevelResources( /* in/out */ char *pszMapName, size_t nMapNameSize, /* in/out */ char *pszMapFile, size_t nMapFileSize, float *flProgress = NULL) = 0; // Ask the game DLL to evaluate what it would do with this map name were it // passed to PrepareLevelResources. NOTE That this is this is syncronous and // non-blocking, so it is possible that async PrepareLevelResources call // may be able to pull a better match than is immediately available to // this call (e.g. blocking lookups of cloud maps) enum eCanProvideLevelResult { // Have no knowledge of this level name, it will be up to the engine to // provide. (e.g. as maps/levelname.bsp) eCanProvideLevel_CannotProvide, // Can provide resources for this level, and pMapName has been updated // to the canonical name we would provide it // under (as with PrepareLevelResources) eCanProvideLevel_CanProvide, // We recognize this level name as something we might be able to // prepare, but without a blocking/async call to // PrepareLevelResources, it is not possible to say whether it is // available. eCanProvideLevel_Possibly }; virtual eCanProvideLevelResult CanProvideLevel(/* in/out */ char *pMapName, int nMapNameMax) = 0; // Called to see if the game server is okay with a manual changelevel or map // command virtual bool IsManualMapChangeOkay(const char **pszReason) = 0; }; typedef IServerGameDLL IServerGameDLL008; //----------------------------------------------------------------------------- // Just an interface version name for the random number interface // See vstdlib/random.h for the interface definition // NOTE: If you change this, also change VENGINE_CLIENT_RANDOM_INTERFACE_VERSION // in cdll_int.h //----------------------------------------------------------------------------- #define VENGINE_SERVER_RANDOM_INTERFACE_VERSION "VEngineRandom001" #define INTERFACEVERSION_SERVERGAMEENTS "ServerGameEnts001" //----------------------------------------------------------------------------- // Purpose: Interface to get at server entities //----------------------------------------------------------------------------- abstract_class IServerGameEnts { public: virtual ~IServerGameEnts() {} // Only for debugging. Set the edict base so you can get an edict's index in // the debugger while debugging the game .dll virtual void SetDebugEdictBase(edict_t * base) = 0; // The engine wants to mark two entities as touching virtual void MarkEntitiesAsTouching(edict_t * e1, edict_t * e2) = 0; // Frees the entity attached to this edict virtual void FreeContainingEntity(edict_t *) = 0; // This allows the engine to get at edicts in a CGameTrace. virtual edict_t *BaseEntityToEdict(CBaseEntity * pEnt) = 0; virtual CBaseEntity *EdictToBaseEntity(edict_t * pEdict) = 0; // This sets a bit in pInfo for each edict in the list that wants to be // transmitted to the client specified in pInfo. // // This is also where an entity can force other entities to be transmitted // if it refers to them with ehandles. virtual void CheckTransmit(CCheckTransmitInfo * pInfo, const unsigned short *pEdictIndices, int nEdicts) = 0; }; #define INTERFACEVERSION_SERVERGAMECLIENTS_VERSION_3 "ServerGameClients003" #define INTERFACEVERSION_SERVERGAMECLIENTS "ServerGameClients004" //----------------------------------------------------------------------------- // Purpose: Player / Client related functions //----------------------------------------------------------------------------- abstract_class IServerGameClients { public: // Get server maxplayers and lower bound for same virtual void GetPlayerLimits(int &minplayers, int &maxplayers, int &defaultMaxPlayers) const = 0; // Client is connecting to server ( return false to reject the connection ) // You can specify a rejection message by writing it into reject virtual bool ClientConnect(edict_t * pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen) = 0; // Client is going active // If bLoadGame is true, don't spawn the player because its state is already // setup. virtual void ClientActive(edict_t * pEntity, bool bLoadGame) = 0; // Client is disconnecting from server virtual void ClientDisconnect(edict_t * pEntity) = 0; // Client is connected and should be put in the game virtual void ClientPutInServer(edict_t * pEntity, char const *playername) = 0; // The client has typed a command at the console virtual void ClientCommand(edict_t * pEntity, const CCommand &args) = 0; // Sets the client index for the client who typed the command into his/her // console virtual void SetCommandClient(int index) = 0; // A player changed one/several replicated cvars (name etc) virtual void ClientSettingsChanged(edict_t * pEdict) = 0; // Determine PVS origin and set PVS for the player/viewentity virtual void ClientSetupVisibility(edict_t * pViewEntity, edict_t * pClient, unsigned char *pvs, int pvssize) = 0; // A block of CUserCmds has arrived from the user, decode them and buffer // for execution during player simulation virtual float ProcessUsercmds(edict_t * player, bf_read * buf, int numcmds, int totalcmds, int dropped_packets, bool ignore, bool paused) = 0; // Let the game .dll do stuff after messages have been sent to all of the // clients once the server frame is complete virtual void PostClientMessagesSent_DEPRECIATED(void) = 0; // For players, looks up the CPlayerState structure corresponding to the // player virtual CPlayerState *GetPlayerState(edict_t * player) = 0; // Get the ear position for a specified client virtual void ClientEarPosition(edict_t * pEntity, Vector * pEarOrigin) = 0; // returns number of delay ticks if player is in Replay mode (0 = no delay) virtual int GetReplayDelay(edict_t * player, int &entity) = 0; // Anything this game .dll wants to add to the bug reporter text (e.g., the // entity/model under the picker crosshair) // can be added here virtual void GetBugReportInfo(char *buf, int buflen) = 0; // A user has had their network id setup and validated virtual void NetworkIDValidated(const char *pszUserName, const char *pszNetworkID) = 0; // The client has submitted a keyvalues command virtual void ClientCommandKeyValues(edict_t * pEntity, KeyValues * pKeyValues) = 0; // Hook for player spawning virtual void ClientSpawned(edict_t * pPlayer) = 0; }; typedef IServerGameClients IServerGameClients003; #define INTERFACEVERSION_UPLOADGAMESTATS "ServerUploadGameStats001" abstract_class IUploadGameStats { public: // Note that this call will block the server until the upload is completed, // so use only at levelshutdown if at all. virtual bool UploadGameStats( char const *mapname, // Game map name unsigned int blobversion, // Version of the binary blob data unsigned int blobsize, // Size in bytes of blob data const void *pvBlobData) = 0; // Pointer to the blob data. // Call when created to init the CSER connection virtual void InitConnection(void) = 0; // Call periodically to poll steam for a CSER connection virtual void UpdateConnection(void) = 0; // If user has disabled stats tracking, do nothing virtual bool IsGameStatsLoggingEnabled() = 0; // Gets a non-personally identifiable unique ID for this steam user, used // for tracking total gameplay time across // multiple stats sessions, but isn't trackable back to their Steam account // or id. // Buffer should be 16 bytes, ID will come back as a hexadecimal string // version of a GUID virtual void GetPseudoUniqueId(char *buf, size_t bufsize) = 0; // For determining general % of users running using cyber cafe accounts... virtual bool IsCyberCafeUser(void) = 0; // Only works in single player virtual bool IsHDREnabled(void) = 0; }; #define INTERFACEVERSION_PLUGINHELPERSCHECK "PluginHelpersCheck001" //----------------------------------------------------------------------------- // Purpose: allows the game dll to control which plugin functions can be run //----------------------------------------------------------------------------- abstract_class IPluginHelpersCheck { public: virtual bool CreateMessage(const char *plugin, edict_t *pEntity, DIALOG_TYPE type, KeyValues *data) = 0; }; //----------------------------------------------------------------------------- // Purpose: Interface exposed from the client .dll back to the engine for // specifying shared .dll IAppSystems (e.g., ISoundEmitterSystem) //----------------------------------------------------------------------------- abstract_class IServerDLLSharedAppSystems { public: virtual int Count() = 0; virtual char const *GetDllName(int idx) = 0; virtual char const *GetInterfaceName(int idx) = 0; }; #define SERVER_DLL_SHARED_APPSYSTEMS "VServerDllSharedAppSystems001" #define INTERFACEVERSION_SERVERGAMETAGS "ServerGameTags001" //----------------------------------------------------------------------------- // Purpose: querying the game dll for Server cvar tags //----------------------------------------------------------------------------- abstract_class IServerGameTags { public: // Get the list of cvars that require tags to show differently in the server // browser virtual void GetTaggedConVarList(KeyValues * pCvarTagList) = 0; }; //----------------------------------------------------------------------------- // Purpose: Provide hooks for the GC based lobby system //----------------------------------------------------------------------------- abstract_class IServerGCLobby { public: virtual bool HasLobby() const = 0; virtual bool SteamIDAllowedToConnect(const CSteamID &steamId) const = 0; virtual void UpdateServerDetails(void) = 0; virtual bool ShouldHibernate() = 0; }; #endif // EIFACE_H