-
Notifications
You must be signed in to change notification settings - Fork 2k
/
eiface.h
825 lines (653 loc) · 38 KB
/
eiface.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#ifndef EIFACE_H
#define EIFACE_H
#ifdef _WIN32
#pragma once
#endif
#include "convar.h"
#include "icvar.h"
#include "edict.h"
#include "mathlib/vplane.h"
#include "iserverentity.h"
#include "engine/ivmodelinfo.h"
#include "soundflags.h"
#include "bitvec.h"
#include "engine/iserverplugin.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< ABSOLUTE_PLAYER_LIMIT >& 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<MAX_EDICTS>* 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/<mapname>.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