3503 lines
104 KiB
C++
3503 lines
104 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: encapsulates and implements all the accessing of the game dll from external
|
|
// sources (only the engine at the time of writing)
|
|
// This files ONLY contains functions and data necessary to build an interface
|
|
// to external modules
|
|
//===========================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "gamestringpool.h"
|
|
#include "mapentities_shared.h"
|
|
#include "game.h"
|
|
#include "entityapi.h"
|
|
#include "client.h"
|
|
#include "saverestore.h"
|
|
#include "entitylist.h"
|
|
#include "gamerules.h"
|
|
#include "soundent.h"
|
|
#include "player.h"
|
|
#include "server_class.h"
|
|
#include "ai_node.h"
|
|
#include "ai_link.h"
|
|
#include "ai_saverestore.h"
|
|
#include "ai_networkmanager.h"
|
|
#include "ndebugoverlay.h"
|
|
#include "ivoiceserver.h"
|
|
#include <stdarg.h>
|
|
#include "movehelper_server.h"
|
|
#include "networkstringtable_gamedll.h"
|
|
#include "filesystem.h"
|
|
#include "func_areaportalwindow.h"
|
|
#include "igamesystem.h"
|
|
#include "init_factory.h"
|
|
#include "vstdlib/random.h"
|
|
#include "env_wind_shared.h"
|
|
#include "engine/IEngineSound.h"
|
|
#include "ispatialpartition.h"
|
|
#include "textstatsmgr.h"
|
|
#include "bitbuf.h"
|
|
#include "saverestoretypes.h"
|
|
#include "physics_saverestore.h"
|
|
#include "achievement_saverestore.h"
|
|
#include "tier0/vprof.h"
|
|
#include "effect_dispatch_data.h"
|
|
#include "engine/IStaticPropMgr.h"
|
|
#include "TemplateEntities.h"
|
|
#include "ai_speech.h"
|
|
#include "soundenvelope.h"
|
|
#include "usermessages.h"
|
|
#include "physics.h"
|
|
#include "igameevents.h"
|
|
#include "EventLog.h"
|
|
#include "datacache/idatacache.h"
|
|
#include "engine/ivdebugoverlay.h"
|
|
#include "shareddefs.h"
|
|
#include "props.h"
|
|
#include "timedeventmgr.h"
|
|
#include "gameinterface.h"
|
|
#include "eventqueue.h"
|
|
#include "hltvdirector.h"
|
|
#if defined( REPLAY_ENABLED )
|
|
#include "replay/iserverreplaycontext.h"
|
|
#endif
|
|
#include "SoundEmitterSystem/isoundemittersystembase.h"
|
|
#include "AI_ResponseSystem.h"
|
|
#include "saverestore_stringtable.h"
|
|
#include "util.h"
|
|
#include "tier0/icommandline.h"
|
|
#include "datacache/imdlcache.h"
|
|
#include "engine/iserverplugin.h"
|
|
#ifdef _WIN32
|
|
#include "ienginevgui.h"
|
|
#endif
|
|
#include "ragdoll_shared.h"
|
|
#include "toolframework/iserverenginetools.h"
|
|
#include "sceneentity.h"
|
|
#include "appframework/IAppSystemGroup.h"
|
|
#include "scenefilecache/ISceneFileCache.h"
|
|
#include "tier2/tier2.h"
|
|
#include "particles/particles.h"
|
|
#include "gamestats.h"
|
|
#include "ixboxsystem.h"
|
|
#include "engine/imatchmaking.h"
|
|
#include "hl2orange.spa.h"
|
|
#include "particle_parse.h"
|
|
#ifndef NO_STEAM
|
|
#include "steam/steam_gameserver.h"
|
|
#endif
|
|
#include "tier3/tier3.h"
|
|
#include "serverbenchmark_base.h"
|
|
#include "querycache.h"
|
|
|
|
|
|
#ifdef TF_DLL
|
|
#include "gc_clientsystem.h"
|
|
#include "econ_item_inventory.h"
|
|
#include "steamworks_gamestats.h"
|
|
#include "tf/tf_gc_server.h"
|
|
#include "tf_gamerules.h"
|
|
#include "player_vs_environment/tf_population_manager.h"
|
|
#include "workshop/maps_workshop.h"
|
|
|
|
extern ConVar tf_mm_trusted;
|
|
extern ConVar tf_mm_servermode;
|
|
#endif
|
|
|
|
#ifdef USE_NAV_MESH
|
|
#include "nav_mesh.h"
|
|
#endif
|
|
|
|
#ifdef NEXT_BOT
|
|
#include "NextBotManager.h"
|
|
#endif
|
|
|
|
#ifdef USES_ECON_ITEMS
|
|
#include "econ_item_system.h"
|
|
#endif // USES_ECON_ITEMS
|
|
|
|
#ifdef CSTRIKE_DLL // BOTPORT: TODO: move these ifdefs out
|
|
#include "bot/bot.h"
|
|
#endif
|
|
|
|
#ifdef PORTAL
|
|
#include "prop_portal_shared.h"
|
|
#include "portal_player.h"
|
|
#endif
|
|
|
|
#if defined( REPLAY_ENABLED )
|
|
#include "replay/ireplaysystem.h"
|
|
#endif
|
|
|
|
extern IToolFrameworkServer *g_pToolFrameworkServer;
|
|
extern IParticleSystemQuery *g_pParticleSystemQuery;
|
|
|
|
extern ConVar commentary;
|
|
|
|
#ifndef NO_STEAM
|
|
// this context is not available on dedicated servers
|
|
// WARNING! always check if interfaces are available before using
|
|
static CSteamAPIContext s_SteamAPIContext;
|
|
CSteamAPIContext *steamapicontext = &s_SteamAPIContext;
|
|
|
|
// this context is not available on a pure client connected to a remote server.
|
|
// WARNING! always check if interfaces are available before using
|
|
static CSteamGameServerAPIContext s_SteamGameServerAPIContext;
|
|
CSteamGameServerAPIContext *steamgameserverapicontext = &s_SteamGameServerAPIContext;
|
|
#endif
|
|
|
|
IUploadGameStats *gamestatsuploader = NULL;
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
CTimedEventMgr g_NetworkPropertyEventMgr;
|
|
|
|
ISaveRestoreBlockHandler *GetEventQueueSaveRestoreBlockHandler();
|
|
ISaveRestoreBlockHandler *GetCommentarySaveRestoreBlockHandler();
|
|
|
|
CUtlLinkedList<CMapEntityRef, unsigned short> g_MapEntityRefs;
|
|
|
|
// Engine interfaces.
|
|
IVEngineServer *engine = NULL;
|
|
IVoiceServer *g_pVoiceServer = NULL;
|
|
#if !defined(_STATIC_LINKED)
|
|
IFileSystem *filesystem = NULL;
|
|
#else
|
|
extern IFileSystem *filesystem;
|
|
#endif
|
|
INetworkStringTableContainer *networkstringtable = NULL;
|
|
IStaticPropMgrServer *staticpropmgr = NULL;
|
|
IUniformRandomStream *random = NULL;
|
|
IEngineSound *enginesound = NULL;
|
|
ISpatialPartition *partition = NULL;
|
|
IVModelInfo *modelinfo = NULL;
|
|
IEngineTrace *enginetrace = NULL;
|
|
IGameEventManager2 *gameeventmanager = NULL;
|
|
IDataCache *datacache = NULL;
|
|
IVDebugOverlay * debugoverlay = NULL;
|
|
ISoundEmitterSystemBase *soundemitterbase = NULL;
|
|
IServerPluginHelpers *serverpluginhelpers = NULL;
|
|
IServerEngineTools *serverenginetools = NULL;
|
|
ISceneFileCache *scenefilecache = NULL;
|
|
IXboxSystem *xboxsystem = NULL; // Xbox 360 only
|
|
IMatchmaking *matchmaking = NULL; // Xbox 360 only
|
|
#if defined( REPLAY_ENABLED )
|
|
IReplaySystem *g_pReplay = NULL;
|
|
IServerReplayContext *g_pReplayServerContext = NULL;
|
|
#endif
|
|
|
|
IGameSystem *SoundEmitterSystem();
|
|
|
|
bool ModelSoundsCacheInit();
|
|
void ModelSoundsCacheShutdown();
|
|
|
|
void SceneManager_ClientActive( CBasePlayer *player );
|
|
|
|
class IMaterialSystem;
|
|
class IStudioRender;
|
|
|
|
#ifdef _DEBUG
|
|
static ConVar s_UseNetworkVars( "UseNetworkVars", "1", FCVAR_CHEAT, "For profiling, toggle network vars." );
|
|
#endif
|
|
|
|
extern ConVar sv_noclipduringpause;
|
|
ConVar sv_massreport( "sv_massreport", "0" );
|
|
ConVar sv_force_transmit_ents( "sv_force_transmit_ents", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Will transmit all entities to client, regardless of PVS conditions (will still skip based on transmit flags, however)." );
|
|
|
|
ConVar sv_autosave( "sv_autosave", "1", 0, "Set to 1 to autosave game on level transition. Does not affect autosave triggers." );
|
|
ConVar *sv_maxreplay = NULL;
|
|
static ConVar *g_pcv_commentary = NULL;
|
|
static ConVar *g_pcv_ThreadMode = NULL;
|
|
static ConVar *g_pcv_hideServer = NULL;
|
|
|
|
// String tables
|
|
INetworkStringTable *g_pStringTableParticleEffectNames = NULL;
|
|
INetworkStringTable *g_pStringTableEffectDispatch = NULL;
|
|
INetworkStringTable *g_pStringTableVguiScreen = NULL;
|
|
INetworkStringTable *g_pStringTableMaterials = NULL;
|
|
INetworkStringTable *g_pStringTableInfoPanel = NULL;
|
|
INetworkStringTable *g_pStringTableClientSideChoreoScenes = NULL;
|
|
INetworkStringTable *g_pStringTableServerMapCycle = NULL;
|
|
|
|
#ifdef TF_DLL
|
|
INetworkStringTable *g_pStringTableServerPopFiles = NULL;
|
|
INetworkStringTable *g_pStringTableServerMapCycleMvM = NULL;
|
|
#endif
|
|
|
|
CStringTableSaveRestoreOps g_VguiScreenStringOps;
|
|
|
|
// Holds global variables shared between engine and game.
|
|
CGlobalVars *gpGlobals;
|
|
edict_t *g_pDebugEdictBase = 0;
|
|
static int g_nCommandClientIndex = 0;
|
|
|
|
// The chapter number of the current
|
|
static int g_nCurrentChapterIndex = -1;
|
|
|
|
#ifdef _DEBUG
|
|
static ConVar sv_showhitboxes( "sv_showhitboxes", "-1", FCVAR_CHEAT, "Send server-side hitboxes for specified entity to client (NOTE: this uses lots of bandwidth, use on listen server only)." );
|
|
#endif
|
|
|
|
void PrecachePointTemplates();
|
|
|
|
static ClientPutInServerOverrideFn g_pClientPutInServerOverride = NULL;
|
|
static void UpdateChapterRestrictions( const char *mapname );
|
|
|
|
static void UpdateRichPresence ( void );
|
|
|
|
|
|
#if !defined( _XBOX ) // Don't doubly define this symbol.
|
|
CSharedEdictChangeInfo *g_pSharedChangeInfo = NULL;
|
|
|
|
#endif
|
|
|
|
IChangeInfoAccessor *CBaseEdict::GetChangeAccessor()
|
|
{
|
|
return engine->GetChangeAccessor( (const edict_t *)this );
|
|
}
|
|
|
|
const IChangeInfoAccessor *CBaseEdict::GetChangeAccessor() const
|
|
{
|
|
return engine->GetChangeAccessor( (const edict_t *)this );
|
|
}
|
|
|
|
const char *GetHintTypeDescription( CAI_Hint *pHint );
|
|
|
|
void ClientPutInServerOverride( ClientPutInServerOverrideFn fn )
|
|
{
|
|
g_pClientPutInServerOverride = fn;
|
|
}
|
|
|
|
ConVar ai_post_frame_navigation( "ai_post_frame_navigation", "0" );
|
|
class CPostFrameNavigationHook;
|
|
extern CPostFrameNavigationHook *PostFrameNavigationSystem( void );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int UTIL_GetCommandClientIndex( void )
|
|
{
|
|
// -1 == unknown,dedicated server console
|
|
// 0 == player 1
|
|
|
|
// Convert to 1 based offset
|
|
return (g_nCommandClientIndex+1);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : CBasePlayer
|
|
//-----------------------------------------------------------------------------
|
|
CBasePlayer *UTIL_GetCommandClient( void )
|
|
{
|
|
int idx = UTIL_GetCommandClientIndex();
|
|
if ( idx > 0 )
|
|
{
|
|
return UTIL_PlayerByIndex( idx );
|
|
}
|
|
|
|
// HLDS console issued command
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Retrieves the MOD directory for the active game (ie. "hl2")
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool UTIL_GetModDir( char *lpszTextOut, unsigned int nSize )
|
|
{
|
|
// Must pass in a buffer at least large enough to hold the desired string
|
|
const char *pGameDir = CommandLine()->ParmValue( "-game", "hl2" );
|
|
Assert( strlen(pGameDir) <= nSize );
|
|
if ( strlen(pGameDir) > nSize )
|
|
return false;
|
|
|
|
Q_strncpy( lpszTextOut, pGameDir, nSize );
|
|
if ( Q_strnchr( lpszTextOut, '/', nSize ) || Q_strnchr( lpszTextOut, '\\', nSize ) )
|
|
{
|
|
// Strip the last directory off (which will be our game dir)
|
|
Q_StripLastDir( lpszTextOut, nSize );
|
|
|
|
// Find the difference in string lengths and take that difference from the original string as the mod dir
|
|
int dirlen = Q_strlen( lpszTextOut );
|
|
Q_strncpy( lpszTextOut, pGameDir + dirlen, Q_strlen( pGameDir ) - dirlen + 1 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
extern void InitializeCvars( void );
|
|
|
|
CBaseEntity* FindPickerEntity( CBasePlayer* pPlayer );
|
|
CAI_Node* FindPickerAINode( CBasePlayer* pPlayer, NodeType_e nNodeType );
|
|
CAI_Link* FindPickerAILink( CBasePlayer* pPlayer );
|
|
float GetFloorZ(const Vector &origin);
|
|
void UpdateAllClientData( void );
|
|
void DrawMessageEntities();
|
|
|
|
#include "ai_network.h"
|
|
|
|
// For now just using one big AI network
|
|
extern ConVar think_limit;
|
|
|
|
|
|
#if 0
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw output overlays for any measure sections
|
|
// Input :
|
|
//-----------------------------------------------------------------------------
|
|
void DrawMeasuredSections(void)
|
|
{
|
|
int row = 1;
|
|
float rowheight = 0.025;
|
|
|
|
CMeasureSection *p = CMeasureSection::GetList();
|
|
while ( p )
|
|
{
|
|
char str[256];
|
|
Q_snprintf(str,sizeof(str),"%s",p->GetName());
|
|
NDebugOverlay::ScreenText( 0.01,0.51+(row*rowheight),str, 255,255,255,255, 0.0 );
|
|
|
|
Q_snprintf(str,sizeof(str),"%5.2f\n",p->GetTime().GetMillisecondsF());
|
|
//Q_snprintf(str,sizeof(str),"%3.3f\n",p->GetTime().GetSeconds() * 100.0 / engine->Time());
|
|
NDebugOverlay::ScreenText( 0.28,0.51+(row*rowheight),str, 255,255,255,255, 0.0 );
|
|
|
|
Q_snprintf(str,sizeof(str),"%5.2f\n",p->GetMaxTime().GetMillisecondsF());
|
|
//Q_snprintf(str,sizeof(str),"%3.3f\n",p->GetTime().GetSeconds() * 100.0 / engine->Time());
|
|
NDebugOverlay::ScreenText( 0.34,0.51+(row*rowheight),str, 255,255,255,255, 0.0 );
|
|
|
|
|
|
row++;
|
|
|
|
p = p->GetNext();
|
|
}
|
|
|
|
bool sort_reset = false;
|
|
|
|
// Time to redo sort?
|
|
if ( measure_resort.GetFloat() > 0.0 &&
|
|
engine->Time() >= CMeasureSection::m_dNextResort )
|
|
{
|
|
// Redo it
|
|
CMeasureSection::SortSections();
|
|
// Set next time
|
|
CMeasureSection::m_dNextResort = engine->Time() + measure_resort.GetFloat();
|
|
// Flag to reset sort accumulator, too
|
|
sort_reset = true;
|
|
}
|
|
|
|
// Iterate through the sections now
|
|
p = CMeasureSection::GetList();
|
|
while ( p )
|
|
{
|
|
// Update max
|
|
p->UpdateMax();
|
|
|
|
// Reset regular accum.
|
|
p->Reset();
|
|
// Reset sort accum less often
|
|
if ( sort_reset )
|
|
{
|
|
p->SortReset();
|
|
}
|
|
p = p->GetNext();
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void DrawAllDebugOverlays( void )
|
|
{
|
|
// If in debug select mode print the selection entities name or classname
|
|
if (CBaseEntity::m_bInDebugSelect)
|
|
{
|
|
CBasePlayer* pPlayer = UTIL_PlayerByIndex( CBaseEntity::m_nDebugPlayer );
|
|
|
|
if (pPlayer)
|
|
{
|
|
// First try to trace a hull to an entity
|
|
CBaseEntity *pEntity = FindPickerEntity( pPlayer );
|
|
|
|
if ( pEntity )
|
|
{
|
|
pEntity->DrawDebugTextOverlays();
|
|
pEntity->DrawBBoxOverlay();
|
|
pEntity->SendDebugPivotOverlay();
|
|
}
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------
|
|
// Draw debug overlay lines
|
|
// --------------------------------------------------------
|
|
UTIL_DrawOverlayLines();
|
|
|
|
// ------------------------------------------------------------------------
|
|
// If in wc_edit mode draw a box to highlight which node I'm looking at
|
|
// ------------------------------------------------------------------------
|
|
if (engine->IsInEditMode())
|
|
{
|
|
CBasePlayer* pPlayer = UTIL_PlayerByIndex( CBaseEntity::m_nDebugPlayer );
|
|
if (pPlayer)
|
|
{
|
|
if (g_pAINetworkManager->GetEditOps()->m_bLinkEditMode)
|
|
{
|
|
CAI_Link* pAILink = FindPickerAILink(pPlayer);
|
|
if (pAILink)
|
|
{
|
|
// For now just using one big AI network
|
|
Vector startPos = g_pBigAINet->GetNode(pAILink->m_iSrcID)->GetPosition(g_pAINetworkManager->GetEditOps()->m_iHullDrawNum);
|
|
Vector endPos = g_pBigAINet->GetNode(pAILink->m_iDestID)->GetPosition(g_pAINetworkManager->GetEditOps()->m_iHullDrawNum);
|
|
Vector linkDir = startPos-endPos;
|
|
float linkLen = VectorNormalize( linkDir );
|
|
|
|
// Draw in green if link that's been turned off
|
|
if (pAILink->m_LinkInfo & bits_LINK_OFF)
|
|
{
|
|
NDebugOverlay::BoxDirection(startPos, Vector(-4,-4,-4), Vector(-linkLen,4,4), linkDir, 0,255,0,40,0);
|
|
}
|
|
else
|
|
{
|
|
NDebugOverlay::BoxDirection(startPos, Vector(-4,-4,-4), Vector(-linkLen,4,4), linkDir, 255,0,0,40,0);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CAI_Node* pAINode;
|
|
if (g_pAINetworkManager->GetEditOps()->m_bAirEditMode)
|
|
{
|
|
pAINode = FindPickerAINode(pPlayer,NODE_AIR);
|
|
}
|
|
else
|
|
{
|
|
pAINode = FindPickerAINode(pPlayer,NODE_GROUND);
|
|
}
|
|
|
|
if (pAINode)
|
|
{
|
|
Vector vecPos = pAINode->GetPosition(g_pAINetworkManager->GetEditOps()->m_iHullDrawNum);
|
|
NDebugOverlay::Box( vecPos, Vector(-8,-8,-8), Vector(8,8,8), 255,0,0,40,0);
|
|
|
|
if ( pAINode->GetHint() )
|
|
{
|
|
CBaseEntity *pEnt = (CBaseEntity *)pAINode->GetHint();
|
|
if ( pEnt->GetEntityName() != NULL_STRING )
|
|
{
|
|
NDebugOverlay::Text( vecPos + Vector(0,0,6), STRING(pEnt->GetEntityName()), false, 0 );
|
|
}
|
|
NDebugOverlay::Text( vecPos, GetHintTypeDescription( pAINode->GetHint() ), false, 0 );
|
|
}
|
|
}
|
|
}
|
|
// ------------------------------------
|
|
// If in air edit mode draw guide line
|
|
// ------------------------------------
|
|
if (g_pAINetworkManager->GetEditOps()->m_bAirEditMode)
|
|
{
|
|
UTIL_DrawPositioningOverlay(g_pAINetworkManager->GetEditOps()->m_flAirEditDistance);
|
|
}
|
|
else
|
|
{
|
|
NDebugOverlay::DrawGroundCrossHairOverlay();
|
|
}
|
|
}
|
|
}
|
|
|
|
// For not just using one big AI Network
|
|
if ( g_pAINetworkManager )
|
|
{
|
|
g_pAINetworkManager->GetEditOps()->DrawAINetworkOverlay();
|
|
}
|
|
|
|
// PERFORMANCE: only do this in developer mode
|
|
if ( g_pDeveloper->GetInt() && !engine->IsDedicatedServer() )
|
|
{
|
|
// iterate through all objects for debug overlays
|
|
const CEntInfo *pInfo = gEntList.FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
// HACKHACK: to flag off these calls
|
|
if ( ent->m_debugOverlays || ent->m_pTimedOverlay )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
ent->DrawDebugGeometryOverlays();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( sv_massreport.GetInt() )
|
|
{
|
|
// iterate through all objects for debug overlays
|
|
const CEntInfo *pInfo = gEntList.FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
if (!ent->VPhysicsGetObject())
|
|
continue;
|
|
|
|
char tempstr[512];
|
|
Q_snprintf(tempstr, sizeof(tempstr),"%s: Mass: %.2f kg / %.2f lb (%s)",
|
|
STRING( ent->GetModelName() ), ent->VPhysicsGetObject()->GetMass(),
|
|
kg2lbs(ent->VPhysicsGetObject()->GetMass()),
|
|
GetMassEquivalent(ent->VPhysicsGetObject()->GetMass()));
|
|
ent->EntityText(0, tempstr, 0);
|
|
}
|
|
}
|
|
|
|
// A hack to draw point_message entities w/o developer required
|
|
DrawMessageEntities();
|
|
}
|
|
|
|
CServerGameDLL g_ServerGameDLL;
|
|
// INTERFACEVERSION_SERVERGAMEDLL_VERSION_8 is compatible with the latest since we're only adding things to the end, so expose that as well.
|
|
//EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CServerGameDLL, IServerGameDLL008, INTERFACEVERSION_SERVERGAMEDLL_VERSION_8, g_ServerGameDLL );
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CServerGameDLL, IServerGameDLL, INTERFACEVERSION_SERVERGAMEDLL, g_ServerGameDLL);
|
|
|
|
// When bumping the version to this interface, check that our assumption is still valid and expose the older version in the same way
|
|
COMPILE_TIME_ASSERT( INTERFACEVERSION_SERVERGAMEDLL_INT == 10 );
|
|
|
|
bool CServerGameDLL::DLLInit( CreateInterfaceFn appSystemFactory,
|
|
CreateInterfaceFn physicsFactory, CreateInterfaceFn fileSystemFactory,
|
|
CGlobalVars *pGlobals)
|
|
{
|
|
ConnectTier1Libraries( &appSystemFactory, 1 );
|
|
ConnectTier2Libraries( &appSystemFactory, 1 );
|
|
ConnectTier3Libraries( &appSystemFactory, 1 );
|
|
|
|
// Connected in ConnectTier1Libraries
|
|
if ( cvar == NULL )
|
|
return false;
|
|
|
|
#ifndef _X360
|
|
s_SteamAPIContext.Init();
|
|
s_SteamGameServerAPIContext.Init();
|
|
#endif
|
|
|
|
// init each (seperated for ease of debugging)
|
|
if ( (engine = (IVEngineServer*)appSystemFactory(INTERFACEVERSION_VENGINESERVER, NULL)) == NULL )
|
|
return false;
|
|
if ( (g_pVoiceServer = (IVoiceServer*)appSystemFactory(INTERFACEVERSION_VOICESERVER, NULL)) == NULL )
|
|
return false;
|
|
if ( (networkstringtable = (INetworkStringTableContainer *)appSystemFactory(INTERFACENAME_NETWORKSTRINGTABLESERVER,NULL)) == NULL )
|
|
return false;
|
|
if ( (staticpropmgr = (IStaticPropMgrServer *)appSystemFactory(INTERFACEVERSION_STATICPROPMGR_SERVER,NULL)) == NULL )
|
|
return false;
|
|
if ( (random = (IUniformRandomStream *)appSystemFactory(VENGINE_SERVER_RANDOM_INTERFACE_VERSION, NULL)) == NULL )
|
|
return false;
|
|
if ( (enginesound = (IEngineSound *)appSystemFactory(IENGINESOUND_SERVER_INTERFACE_VERSION, NULL)) == NULL )
|
|
return false;
|
|
if ( (::partition = (ISpatialPartition *)appSystemFactory(INTERFACEVERSION_SPATIALPARTITION, NULL)) == NULL )
|
|
return false;
|
|
if ( (modelinfo = (IVModelInfo *)appSystemFactory(VMODELINFO_SERVER_INTERFACE_VERSION, NULL)) == NULL )
|
|
return false;
|
|
if ( (enginetrace = (IEngineTrace *)appSystemFactory(INTERFACEVERSION_ENGINETRACE_SERVER,NULL)) == NULL )
|
|
return false;
|
|
if ( (filesystem = (IFileSystem *)fileSystemFactory(FILESYSTEM_INTERFACE_VERSION,NULL)) == NULL )
|
|
return false;
|
|
if ( (gameeventmanager = (IGameEventManager2 *)appSystemFactory(INTERFACEVERSION_GAMEEVENTSMANAGER2,NULL)) == NULL )
|
|
return false;
|
|
if ( (datacache = (IDataCache*)appSystemFactory(DATACACHE_INTERFACE_VERSION, NULL )) == NULL )
|
|
return false;
|
|
if ( (soundemitterbase = (ISoundEmitterSystemBase *)appSystemFactory(SOUNDEMITTERSYSTEM_INTERFACE_VERSION, NULL)) == NULL )
|
|
return false;
|
|
#ifndef _XBOX
|
|
if ( (gamestatsuploader = (IUploadGameStats *)appSystemFactory( INTERFACEVERSION_UPLOADGAMESTATS, NULL )) == NULL )
|
|
return false;
|
|
#endif
|
|
if ( !mdlcache )
|
|
return false;
|
|
if ( (serverpluginhelpers = (IServerPluginHelpers *)appSystemFactory(INTERFACEVERSION_ISERVERPLUGINHELPERS, NULL)) == NULL )
|
|
return false;
|
|
if ( (scenefilecache = (ISceneFileCache *)appSystemFactory( SCENE_FILE_CACHE_INTERFACE_VERSION, NULL )) == NULL )
|
|
return false;
|
|
if ( IsX360() && (xboxsystem = (IXboxSystem *)appSystemFactory( XBOXSYSTEM_INTERFACE_VERSION, NULL )) == NULL )
|
|
return false;
|
|
if ( IsX360() && (matchmaking = (IMatchmaking *)appSystemFactory( VENGINE_MATCHMAKING_VERSION, NULL )) == NULL )
|
|
return false;
|
|
|
|
// If not running dedicated, grab the engine vgui interface
|
|
if ( !engine->IsDedicatedServer() )
|
|
{
|
|
#ifdef _WIN32
|
|
// This interface is optional, and is only valid when running with -tools
|
|
serverenginetools = ( IServerEngineTools * )appSystemFactory( VSERVERENGINETOOLS_INTERFACE_VERSION, NULL );
|
|
#endif
|
|
}
|
|
|
|
// Yes, both the client and game .dlls will try to Connect, the soundemittersystem.dll will handle this gracefully
|
|
if ( !soundemitterbase->Connect( appSystemFactory ) )
|
|
return false;
|
|
|
|
// cache the globals
|
|
gpGlobals = pGlobals;
|
|
|
|
g_pSharedChangeInfo = engine->GetSharedEdictChangeInfo();
|
|
|
|
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
|
|
|
|
// save these in case other system inits need them
|
|
factorylist_t factories;
|
|
factories.engineFactory = appSystemFactory;
|
|
factories.fileSystemFactory = fileSystemFactory;
|
|
factories.physicsFactory = physicsFactory;
|
|
FactoryList_Store( factories );
|
|
|
|
// load used game events
|
|
gameeventmanager->LoadEventsFromFile("resource/gameevents.res");
|
|
|
|
// init the cvar list first in case inits want to reference them
|
|
InitializeCvars();
|
|
|
|
// Initialize the particle system
|
|
if ( !g_pParticleSystemMgr->Init( g_pParticleSystemQuery ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
sv_cheats = g_pCVar->FindVar( "sv_cheats" );
|
|
if ( !sv_cheats )
|
|
return false;
|
|
|
|
g_pcv_commentary = g_pCVar->FindVar( "commentary" );
|
|
g_pcv_ThreadMode = g_pCVar->FindVar( "host_thread_mode" );
|
|
g_pcv_hideServer = g_pCVar->FindVar( "hide_server" );
|
|
|
|
sv_maxreplay = g_pCVar->FindVar( "sv_maxreplay" );
|
|
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetEntitySaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetPhysSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetAISaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetTemplateSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetDefaultResponseSystemSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetCommentarySaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetEventQueueSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetAchievementSaveRestoreBlockHandler() );
|
|
|
|
// The string system must init first + shutdown last
|
|
IGameSystem::Add( GameStringSystem() );
|
|
|
|
// Physics must occur before the sound envelope manager
|
|
IGameSystem::Add( PhysicsGameSystem() );
|
|
|
|
// Used to service deferred navigation queries for NPCs
|
|
IGameSystem::Add( (IGameSystem *) PostFrameNavigationSystem() );
|
|
|
|
// Add game log system
|
|
IGameSystem::Add( GameLogSystem() );
|
|
#ifndef _XBOX
|
|
// Add HLTV director
|
|
IGameSystem::Add( HLTVDirectorSystem() );
|
|
#endif
|
|
// Add sound emitter
|
|
IGameSystem::Add( SoundEmitterSystem() );
|
|
|
|
// load Mod specific game events ( MUST be before InitAllSystems() so it can pickup the mod specific events)
|
|
gameeventmanager->LoadEventsFromFile("resource/ModEvents.res");
|
|
|
|
#ifdef CSTRIKE_DLL // BOTPORT: TODO: move these ifdefs out
|
|
InstallBotControl();
|
|
#endif
|
|
|
|
if ( !IGameSystem::InitAllSystems() )
|
|
return false;
|
|
|
|
#if defined( REPLAY_ENABLED )
|
|
if ( gameeventmanager->LoadEventsFromFile( "resource/replayevents.res" ) <= 0 )
|
|
{
|
|
Warning( "\n*\n* replayevents.res MISSING.\n*\n\n" );
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
// Due to dependencies, these are not autogamesystems
|
|
if ( !ModelSoundsCacheInit() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
InvalidateQueryCache();
|
|
|
|
// Parse the particle manifest file & register the effects within it
|
|
ParseParticleEffects( false, false );
|
|
|
|
// try to get debug overlay, may be NULL if on HLDS
|
|
debugoverlay = (IVDebugOverlay *)appSystemFactory( VDEBUG_OVERLAY_INTERFACE_VERSION, NULL );
|
|
|
|
#ifndef _XBOX
|
|
#ifdef USE_NAV_MESH
|
|
// create the Navigation Mesh interface
|
|
TheNavMesh = NavMeshFactory();
|
|
#endif
|
|
|
|
// init the gamestatsupload connection
|
|
gamestatsuploader->InitConnection();
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
void CServerGameDLL::PostInit()
|
|
{
|
|
IGameSystem::PostInitAllSystems();
|
|
}
|
|
|
|
void CServerGameDLL::DLLShutdown( void )
|
|
{
|
|
|
|
// Due to dependencies, these are not autogamesystems
|
|
ModelSoundsCacheShutdown();
|
|
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetAchievementSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetCommentarySaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetEventQueueSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetDefaultResponseSystemSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetTemplateSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetAISaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetPhysSaveRestoreBlockHandler() );
|
|
g_pGameSaveRestoreBlockSet->RemoveBlockHandler( GetEntitySaveRestoreBlockHandler() );
|
|
|
|
char *pFilename = g_TextStatsMgr.GetStatsFilename();
|
|
if ( !pFilename || !pFilename[0] )
|
|
{
|
|
g_TextStatsMgr.SetStatsFilename( "stats.txt" );
|
|
}
|
|
g_TextStatsMgr.WriteFile( filesystem );
|
|
|
|
IGameSystem::ShutdownAllSystems();
|
|
|
|
#ifdef CSTRIKE_DLL // BOTPORT: TODO: move these ifdefs out
|
|
RemoveBotControl();
|
|
#endif
|
|
|
|
#ifndef _XBOX
|
|
#ifdef USE_NAV_MESH
|
|
// destroy the Navigation Mesh interface
|
|
if ( TheNavMesh )
|
|
{
|
|
delete TheNavMesh;
|
|
TheNavMesh = NULL;
|
|
}
|
|
#endif
|
|
// reset (shutdown) the gamestatsupload connection
|
|
gamestatsuploader->InitConnection();
|
|
#endif
|
|
|
|
#ifndef _X360
|
|
s_SteamAPIContext.Clear(); // Steam API context shutdown
|
|
s_SteamGameServerAPIContext.Clear();
|
|
#endif
|
|
|
|
gameeventmanager = NULL;
|
|
|
|
DisconnectTier3Libraries();
|
|
DisconnectTier2Libraries();
|
|
ConVar_Unregister();
|
|
DisconnectTier1Libraries();
|
|
}
|
|
|
|
bool CServerGameDLL::ReplayInit( CreateInterfaceFn fnReplayFactory )
|
|
{
|
|
#if defined( REPLAY_ENABLED )
|
|
if ( !IsPC() )
|
|
return false;
|
|
if ( (g_pReplay = ( IReplaySystem *)fnReplayFactory( REPLAY_INTERFACE_VERSION, NULL )) == NULL )
|
|
return false;
|
|
if ( (g_pReplayServerContext = g_pReplay->SV_GetContext()) == NULL )
|
|
return false;
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: See shareddefs.h for redefining this. Don't even think about it, though, for HL2. Or you will pay. ywb 9/22/03
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float CServerGameDLL::GetTickInterval( void ) const
|
|
{
|
|
float tickinterval = DEFAULT_TICK_INTERVAL;
|
|
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [Forrest] For Counter-Strike, set default tick rate of 66 and removed -tickrate command line parameter.
|
|
//=============================================================================
|
|
// Ignoring this for now, server ops are abusing it
|
|
#if !defined( TF_DLL ) && !defined( CSTRIKE_DLL ) && !defined( DOD_DLL )
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
// override if tick rate specified in command line
|
|
if ( CommandLine()->CheckParm( "-tickrate" ) )
|
|
{
|
|
float tickrate = CommandLine()->ParmValue( "-tickrate", 0 );
|
|
if ( tickrate > 10 )
|
|
tickinterval = 1.0f / tickrate;
|
|
}
|
|
#endif
|
|
|
|
return tickinterval;
|
|
}
|
|
|
|
// This is called when a new game is started. (restart, map)
|
|
bool CServerGameDLL::GameInit( void )
|
|
{
|
|
ResetGlobalState();
|
|
engine->ServerCommand( "exec game.cfg\n" );
|
|
engine->ServerExecute( );
|
|
CBaseEntity::sm_bAccurateTriggerBboxChecks = true;
|
|
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "game_init" );
|
|
if ( event )
|
|
{
|
|
gameeventmanager->FireEvent( event );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// This is called when a game ends (server disconnect, death, restart, load)
|
|
// NOT on level transitions within a game
|
|
void CServerGameDLL::GameShutdown( void )
|
|
{
|
|
ResetGlobalState();
|
|
}
|
|
|
|
static bool g_OneWayTransition = false;
|
|
void Game_SetOneWayTransition( void )
|
|
{
|
|
g_OneWayTransition = true;
|
|
}
|
|
|
|
static CUtlVector<EHANDLE> g_RestoredEntities;
|
|
// just for debugging, assert that this is the only time this function is called
|
|
static bool g_InRestore = false;
|
|
|
|
void AddRestoredEntity( CBaseEntity *pEntity )
|
|
{
|
|
Assert(g_InRestore);
|
|
if ( !pEntity )
|
|
return;
|
|
|
|
g_RestoredEntities.AddToTail( EHANDLE(pEntity) );
|
|
}
|
|
|
|
void EndRestoreEntities()
|
|
{
|
|
if ( !g_InRestore )
|
|
return;
|
|
|
|
// The entire hierarchy is restored, so we can call GetAbsOrigin again.
|
|
//CBaseEntity::SetAbsQueriesValid( true );
|
|
|
|
// Call all entities' OnRestore handlers
|
|
for ( int i = g_RestoredEntities.Count()-1; i >=0; --i )
|
|
{
|
|
CBaseEntity *pEntity = g_RestoredEntities[i].Get();
|
|
if ( pEntity && !pEntity->IsDormant() )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
pEntity->OnRestore();
|
|
}
|
|
}
|
|
|
|
g_RestoredEntities.Purge();
|
|
|
|
IGameSystem::OnRestoreAllSystems();
|
|
|
|
g_InRestore = false;
|
|
gEntList.CleanupDeleteList();
|
|
|
|
// HACKHACK: UNDONE: We need to redesign the main loop with respect to save/load/server activate
|
|
g_ServerGameDLL.ServerActivate( NULL, 0, 0 );
|
|
CBaseEntity::SetAllowPrecache( false );
|
|
}
|
|
|
|
void BeginRestoreEntities()
|
|
{
|
|
if ( g_InRestore )
|
|
{
|
|
DevMsg( "BeginRestoreEntities without previous EndRestoreEntities.\n" );
|
|
gEntList.CleanupDeleteList();
|
|
}
|
|
g_RestoredEntities.Purge();
|
|
g_InRestore = true;
|
|
|
|
CBaseEntity::SetAllowPrecache( true );
|
|
|
|
// No calls to GetAbsOrigin until the entire hierarchy is restored!
|
|
//CBaseEntity::SetAbsQueriesValid( false );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This prevents sv.tickcount/gpGlobals->tickcount from advancing during restore which
|
|
// would cause a lot of the NPCs to fast forward their think times to the same
|
|
// tick due to some ticks being elapsed during restore where there was no simulation going on
|
|
//-----------------------------------------------------------------------------
|
|
bool CServerGameDLL::IsRestoring()
|
|
{
|
|
return g_InRestore;
|
|
}
|
|
|
|
// Called any time a new level is started (after GameInit() also on level transitions within a game)
|
|
bool CServerGameDLL::LevelInit( const char *pMapName, char const *pMapEntities, char const *pOldLevel, char const *pLandmarkName, bool loadGame, bool background )
|
|
{
|
|
VPROF("CServerGameDLL::LevelInit");
|
|
|
|
#ifdef USES_ECON_ITEMS
|
|
GameItemSchema_t *pItemSchema = ItemSystem()->GetItemSchema();
|
|
if ( pItemSchema )
|
|
{
|
|
pItemSchema->BInitFromDelayedBuffer();
|
|
}
|
|
#endif // USES_ECON_ITEMS
|
|
|
|
ResetWindspeed();
|
|
UpdateChapterRestrictions( pMapName );
|
|
|
|
if ( IsX360() && !background && (gpGlobals->maxClients == 1) && (g_nCurrentChapterIndex >= 0) )
|
|
{
|
|
// Single player games tell xbox live what game & chapter the user is playing
|
|
UpdateRichPresence();
|
|
}
|
|
|
|
//Tony; parse custom manifest if exists!
|
|
ParseParticleEffectsMap( pMapName, false );
|
|
|
|
// IGameSystem::LevelInitPreEntityAllSystems() is called when the world is precached
|
|
// That happens either in LoadGameState() or in MapEntity_ParseAllEntities()
|
|
if ( loadGame )
|
|
{
|
|
if ( pOldLevel )
|
|
{
|
|
gpGlobals->eLoadType = MapLoad_Transition;
|
|
}
|
|
else
|
|
{
|
|
gpGlobals->eLoadType = MapLoad_LoadGame;
|
|
}
|
|
|
|
BeginRestoreEntities();
|
|
if ( !engine->LoadGameState( pMapName, 1 ) )
|
|
{
|
|
if ( pOldLevel )
|
|
{
|
|
MapEntity_ParseAllEntities( pMapEntities );
|
|
}
|
|
else
|
|
{
|
|
// Regular save load case
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( pOldLevel )
|
|
{
|
|
engine->LoadAdjacentEnts( pOldLevel, pLandmarkName );
|
|
}
|
|
|
|
if ( g_OneWayTransition )
|
|
{
|
|
engine->ClearSaveDirAfterClientLoad();
|
|
}
|
|
|
|
if ( pOldLevel && sv_autosave.GetBool() == true )
|
|
{
|
|
// This is a single-player style level transition.
|
|
// Queue up an autosave one second into the level
|
|
CBaseEntity *pAutosave = CBaseEntity::Create( "logic_autosave", vec3_origin, vec3_angle, NULL );
|
|
if ( pAutosave )
|
|
{
|
|
g_EventQueue.AddEvent( pAutosave, "Save", 1.0, NULL, NULL );
|
|
g_EventQueue.AddEvent( pAutosave, "Kill", 1.1, NULL, NULL );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( background )
|
|
{
|
|
gpGlobals->eLoadType = MapLoad_Background;
|
|
}
|
|
else
|
|
{
|
|
gpGlobals->eLoadType = MapLoad_NewGame;
|
|
}
|
|
|
|
// Clear out entity references, and parse the entities into it.
|
|
g_MapEntityRefs.Purge();
|
|
CMapLoadEntityFilter filter;
|
|
MapEntity_ParseAllEntities( pMapEntities, &filter );
|
|
|
|
g_pServerBenchmark->StartBenchmark();
|
|
|
|
// Now call the mod specific parse
|
|
LevelInit_ParseAllEntities( pMapEntities );
|
|
}
|
|
|
|
// Check low violence settings for this map
|
|
g_RagdollLVManager.SetLowViolence( pMapName );
|
|
|
|
// Now that all of the active entities have been loaded in, precache any entities who need point_template parameters
|
|
// to be parsed (the above code has loaded all point_template entities)
|
|
PrecachePointTemplates();
|
|
|
|
// load MOTD from file into stringtable
|
|
LoadMessageOfTheDay();
|
|
|
|
// Sometimes an ent will Remove() itself during its precache, so RemoveImmediate won't happen.
|
|
// This makes sure those ents get cleaned up.
|
|
gEntList.CleanupDeleteList();
|
|
|
|
g_AIFriendliesTalkSemaphore.Release();
|
|
g_AIFoesTalkSemaphore.Release();
|
|
g_OneWayTransition = false;
|
|
|
|
// clear any pending autosavedangerous
|
|
m_fAutoSaveDangerousTime = 0.0f;
|
|
m_fAutoSaveDangerousMinHealthToCommit = 0.0f;
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: called after every level change and load game, iterates through all the
|
|
// active entities and gives them a chance to fix up their state
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef DEBUG
|
|
bool g_bReceivedChainedActivate;
|
|
bool g_bCheckForChainedActivate;
|
|
#define BeginCheckChainedActivate() if (0) ; else { g_bCheckForChainedActivate = true; g_bReceivedChainedActivate = false; }
|
|
#define EndCheckChainedActivate( bCheck ) \
|
|
if (0) ; else \
|
|
{ \
|
|
if ( bCheck ) \
|
|
{ \
|
|
AssertMsg( g_bReceivedChainedActivate, "Entity (%i/%s/%s) failed to call base class Activate()\n", pClass->entindex(), pClass->GetClassname(), STRING( pClass->GetEntityName() ) ); \
|
|
} \
|
|
g_bCheckForChainedActivate = false; \
|
|
}
|
|
#else
|
|
#define BeginCheckChainedActivate() ((void)0)
|
|
#define EndCheckChainedActivate( bCheck ) ((void)0)
|
|
#endif
|
|
|
|
void CServerGameDLL::ServerActivate( edict_t *pEdictList, int edictCount, int clientMax )
|
|
{
|
|
// HACKHACK: UNDONE: We need to redesign the main loop with respect to save/load/server activate
|
|
if ( g_InRestore )
|
|
return;
|
|
|
|
if ( gEntList.ResetDeleteList() != 0 )
|
|
{
|
|
Msg( "%s", "ERROR: Entity delete queue not empty on level start!\n" );
|
|
}
|
|
|
|
for ( CBaseEntity *pClass = gEntList.FirstEnt(); pClass != NULL; pClass = gEntList.NextEnt(pClass) )
|
|
{
|
|
if ( pClass && !pClass->IsDormant() )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
|
|
BeginCheckChainedActivate();
|
|
pClass->Activate();
|
|
|
|
// We don't care if it finished activating if it decided to remove itself.
|
|
EndCheckChainedActivate( !( pClass->GetEFlags() & EFL_KILLME ) );
|
|
}
|
|
}
|
|
|
|
IGameSystem::LevelInitPostEntityAllSystems();
|
|
// No more precaching after PostEntityAllSystems!!!
|
|
CBaseEntity::SetAllowPrecache( false );
|
|
|
|
// only display the think limit when the game is run with "developer" mode set
|
|
if ( !g_pDeveloper->GetInt() )
|
|
{
|
|
think_limit.SetValue( 0 );
|
|
}
|
|
|
|
#ifndef _XBOX
|
|
#ifdef USE_NAV_MESH
|
|
// load the Navigation Mesh for this map
|
|
TheNavMesh->Load();
|
|
TheNavMesh->OnServerActivate();
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef CSTRIKE_DLL // BOTPORT: TODO: move these ifdefs out
|
|
TheBots->ServerActivate();
|
|
#endif
|
|
|
|
#ifdef NEXT_BOT
|
|
TheNextBots().OnMapLoaded();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called after the steam API has been activated post-level startup
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::GameServerSteamAPIActivated( void )
|
|
{
|
|
#ifndef NO_STEAM
|
|
steamgameserverapicontext->Clear();
|
|
steamgameserverapicontext->Init();
|
|
if ( steamgameserverapicontext->SteamGameServer() && engine->IsDedicatedServer() )
|
|
{
|
|
steamgameserverapicontext->SteamGameServer()->GetGameplayStats();
|
|
}
|
|
#endif
|
|
|
|
#ifdef TF_DLL
|
|
GCClientSystem()->GameServerActivate();
|
|
InventoryManager()->GameServerSteamAPIActivated();
|
|
TFMapsWorkshop()->GameServerSteamAPIActivated();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called after the steam API has been activated post-level startup
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::GameServerSteamAPIShutdown( void )
|
|
{
|
|
#if !defined( NO_STEAM )
|
|
if ( steamgameserverapicontext )
|
|
{
|
|
steamgameserverapicontext->Clear();
|
|
}
|
|
#endif
|
|
#ifdef TF_DLL
|
|
GCClientSystem()->Shutdown();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called at the start of every game frame
|
|
//-----------------------------------------------------------------------------
|
|
ConVar trace_report( "trace_report", "0" );
|
|
|
|
void CServerGameDLL::GameFrame( bool simulating )
|
|
{
|
|
VPROF( "CServerGameDLL::GameFrame" );
|
|
|
|
// Don't run frames until fully restored
|
|
if ( g_InRestore )
|
|
return;
|
|
|
|
if ( CBaseEntity::IsSimulatingOnAlternateTicks() )
|
|
{
|
|
// only run simulation on even numbered ticks
|
|
if ( gpGlobals->tickcount & 1 )
|
|
{
|
|
UpdateAllClientData();
|
|
return;
|
|
}
|
|
// If we're skipping frames, then the frametime is 2x the normal tick
|
|
gpGlobals->frametime *= 2.0f;
|
|
}
|
|
|
|
float oldframetime = gpGlobals->frametime;
|
|
|
|
#ifdef _DEBUG
|
|
// For profiling.. let them enable/disable the networkvar manual mode stuff.
|
|
g_bUseNetworkVars = s_UseNetworkVars.GetBool();
|
|
#endif
|
|
|
|
extern void GameStartFrame( void );
|
|
extern void ServiceEventQueue( void );
|
|
extern void Physics_RunThinkFunctions( bool simulating );
|
|
|
|
// Delete anything that was marked for deletion
|
|
// outside of server frameloop (e.g., in response to concommand)
|
|
gEntList.CleanupDeleteList();
|
|
|
|
IGameSystem::FrameUpdatePreEntityThinkAllSystems();
|
|
GameStartFrame();
|
|
|
|
#ifndef _XBOX
|
|
#ifdef USE_NAV_MESH
|
|
TheNavMesh->Update();
|
|
#endif
|
|
|
|
#ifdef NEXT_BOT
|
|
TheNextBots().Update();
|
|
#endif
|
|
|
|
gamestatsuploader->UpdateConnection();
|
|
#endif
|
|
|
|
UpdateQueryCache();
|
|
g_pServerBenchmark->UpdateBenchmark();
|
|
|
|
Physics_RunThinkFunctions( simulating );
|
|
|
|
IGameSystem::FrameUpdatePostEntityThinkAllSystems();
|
|
|
|
// UNDONE: Make these systems IGameSystems and move these calls into FrameUpdatePostEntityThink()
|
|
// service event queue, firing off any actions whos time has come
|
|
ServiceEventQueue();
|
|
|
|
// free all ents marked in think functions
|
|
gEntList.CleanupDeleteList();
|
|
|
|
// FIXME: Should this only occur on the final tick?
|
|
UpdateAllClientData();
|
|
|
|
if ( g_pGameRules )
|
|
{
|
|
g_pGameRules->EndGameFrame();
|
|
}
|
|
|
|
if ( trace_report.GetBool() )
|
|
{
|
|
int total = 0, totals[3];
|
|
for ( int i = 0; i < 3; i++ )
|
|
{
|
|
totals[i] = enginetrace->GetStatByIndex( i, true );
|
|
if ( totals[i] > 0 )
|
|
{
|
|
total += totals[i];
|
|
}
|
|
}
|
|
|
|
if ( total )
|
|
{
|
|
Msg("Trace: %d, contents %d, enumerate %d\n", totals[0], totals[1], totals[2] );
|
|
}
|
|
}
|
|
|
|
// Any entities that detect network state changes on a timer do it here.
|
|
g_NetworkPropertyEventMgr.FireEvents();
|
|
|
|
gpGlobals->frametime = oldframetime;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called every frame even if not ticking
|
|
// Input : simulating -
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::PreClientUpdate( bool simulating )
|
|
{
|
|
if ( !simulating )
|
|
return;
|
|
|
|
/*
|
|
if (game_speeds.GetInt())
|
|
{
|
|
DrawMeasuredSections();
|
|
}
|
|
*/
|
|
|
|
//#ifdef _DEBUG - allow this in release for now
|
|
DrawAllDebugOverlays();
|
|
//#endif
|
|
|
|
IGameSystem::PreClientUpdateAllSystems();
|
|
|
|
#ifdef _DEBUG
|
|
if ( sv_showhitboxes.GetInt() == -1 )
|
|
return;
|
|
|
|
if ( sv_showhitboxes.GetInt() == 0 )
|
|
{
|
|
// assume it's text
|
|
CBaseEntity *pEntity = NULL;
|
|
|
|
while (1)
|
|
{
|
|
pEntity = gEntList.FindEntityByName( pEntity, sv_showhitboxes.GetString() );
|
|
if ( !pEntity )
|
|
break;
|
|
|
|
CBaseAnimating *anim = dynamic_cast< CBaseAnimating * >( pEntity );
|
|
|
|
if (anim)
|
|
{
|
|
anim->DrawServerHitboxes();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
CBaseAnimating *anim = dynamic_cast< CBaseAnimating * >( CBaseEntity::Instance( engine->PEntityOfEntIndex( sv_showhitboxes.GetInt() ) ) );
|
|
if ( !anim )
|
|
return;
|
|
|
|
anim->DrawServerHitboxes();
|
|
#endif
|
|
}
|
|
|
|
void CServerGameDLL::Think( bool finalTick )
|
|
{
|
|
if ( m_fAutoSaveDangerousTime != 0.0f && m_fAutoSaveDangerousTime < gpGlobals->curtime )
|
|
{
|
|
// The safety timer for a dangerous auto save has expired
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( 1 );
|
|
|
|
if ( pPlayer && ( pPlayer->GetDeathTime() == 0.0f || pPlayer->GetDeathTime() > gpGlobals->curtime )
|
|
&& !pPlayer->IsSinglePlayerGameEnding()
|
|
)
|
|
{
|
|
if( pPlayer->GetHealth() >= m_fAutoSaveDangerousMinHealthToCommit )
|
|
{
|
|
// The player isn't dead, so make the dangerous auto save safe
|
|
engine->ServerCommand( "autosavedangerousissafe\n" );
|
|
}
|
|
}
|
|
|
|
m_fAutoSaveDangerousTime = 0.0f;
|
|
m_fAutoSaveDangerousMinHealthToCommit = 0.0f;
|
|
}
|
|
}
|
|
|
|
void CServerGameDLL::OnQueryCvarValueFinished( QueryCvarCookie_t iCookie, edict_t *pPlayerEntity, EQueryCvarValueStatus eStatus, const char *pCvarName, const char *pCvarValue )
|
|
{
|
|
}
|
|
|
|
|
|
// Called when a level is shutdown (including changing levels)
|
|
void CServerGameDLL::LevelShutdown( void )
|
|
{
|
|
#ifndef NO_STEAM
|
|
IGameSystem::LevelShutdownPreClearSteamAPIContextAllSystems();
|
|
|
|
steamgameserverapicontext->Clear();
|
|
#endif
|
|
|
|
g_pServerBenchmark->EndBenchmark();
|
|
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
IGameSystem::LevelShutdownPreEntityAllSystems();
|
|
|
|
// YWB:
|
|
// This entity pointer is going away now and is corrupting memory on level transitions/restarts
|
|
CSoundEnt::ShutdownSoundEnt();
|
|
|
|
gEntList.Clear();
|
|
|
|
InvalidateQueryCache();
|
|
|
|
IGameSystem::LevelShutdownPostEntityAllSystems();
|
|
|
|
// In case we quit out during initial load
|
|
CBaseEntity::SetAllowPrecache( false );
|
|
|
|
g_nCurrentChapterIndex = -1;
|
|
|
|
#ifndef _XBOX
|
|
#ifdef USE_NAV_MESH
|
|
// reset the Navigation Mesh
|
|
if ( TheNavMesh )
|
|
{
|
|
TheNavMesh->Reset();
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input :
|
|
// Output : ServerClass*
|
|
//-----------------------------------------------------------------------------
|
|
ServerClass* CServerGameDLL::GetAllServerClasses()
|
|
{
|
|
return g_pServerClassHead;
|
|
}
|
|
|
|
|
|
const char *CServerGameDLL::GetGameDescription( void )
|
|
{
|
|
return ::GetGameDescription();
|
|
}
|
|
|
|
void CServerGameDLL::CreateNetworkStringTables( void )
|
|
{
|
|
// Create any shared string tables here (and only here!)
|
|
// E.g.: xxx = networkstringtable->CreateStringTable( "SceneStrings", 512 );
|
|
g_pStringTableParticleEffectNames = networkstringtable->CreateStringTable( "ParticleEffectNames", MAX_PARTICLESYSTEMS_STRINGS );
|
|
g_pStringTableEffectDispatch = networkstringtable->CreateStringTable( "EffectDispatch", MAX_EFFECT_DISPATCH_STRINGS );
|
|
g_pStringTableVguiScreen = networkstringtable->CreateStringTable( "VguiScreen", MAX_VGUI_SCREEN_STRINGS );
|
|
g_pStringTableMaterials = networkstringtable->CreateStringTable( "Materials", MAX_MATERIAL_STRINGS );
|
|
g_pStringTableInfoPanel = networkstringtable->CreateStringTable( "InfoPanel", MAX_INFOPANEL_STRINGS );
|
|
g_pStringTableClientSideChoreoScenes = networkstringtable->CreateStringTable( "Scenes", MAX_CHOREO_SCENES_STRINGS );
|
|
g_pStringTableServerMapCycle = networkstringtable->CreateStringTable( "ServerMapCycle", 128 );
|
|
|
|
#ifdef TF_DLL
|
|
g_pStringTableServerPopFiles = networkstringtable->CreateStringTable( "ServerPopFiles", 128 );
|
|
g_pStringTableServerMapCycleMvM = networkstringtable->CreateStringTable( "ServerMapCycleMvM", 128 );
|
|
#endif
|
|
|
|
bool bPopFilesValid = true;
|
|
(void)bPopFilesValid; // Avoid unreferenced variable warning
|
|
|
|
#ifdef TF_DLL
|
|
bPopFilesValid = ( g_pStringTableServerPopFiles != NULL );
|
|
#endif
|
|
|
|
Assert( g_pStringTableParticleEffectNames &&
|
|
g_pStringTableEffectDispatch &&
|
|
g_pStringTableVguiScreen &&
|
|
g_pStringTableMaterials &&
|
|
g_pStringTableInfoPanel &&
|
|
g_pStringTableClientSideChoreoScenes &&
|
|
g_pStringTableServerMapCycle &&
|
|
bPopFilesValid
|
|
);
|
|
|
|
// Need this so we have the error material always handy
|
|
PrecacheMaterial( "debug/debugempty" );
|
|
Assert( GetMaterialIndex( "debug/debugempty" ) == 0 );
|
|
|
|
PrecacheParticleSystem( "error" ); // ensure error particle system is handy
|
|
Assert( GetParticleSystemIndex( "error" ) == 0 );
|
|
|
|
CreateNetworkStringTables_GameRules();
|
|
|
|
// Set up save/load utilities for string tables
|
|
g_VguiScreenStringOps.Init( g_pStringTableVguiScreen );
|
|
}
|
|
|
|
CSaveRestoreData *CServerGameDLL::SaveInit( int size )
|
|
{
|
|
return ::SaveInit(size);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Saves data from a struct into a saverestore object, to be saved to disk
|
|
// Input : *pSaveData - the saverestore object
|
|
// char *pname - the name of the data to write
|
|
// *pBaseData - the struct into which the data is to be read
|
|
// *pFields - pointer to an array of data field descriptions
|
|
// fieldCount - the size of the array (number of field descriptions)
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::SaveWriteFields( CSaveRestoreData *pSaveData, const char *pname, void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldCount )
|
|
{
|
|
CSave saveHelper( pSaveData );
|
|
saveHelper.WriteFields( pname, pBaseData, pMap, pFields, fieldCount );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reads data from a save/restore block into a structure
|
|
// Input : *pSaveData - the saverestore object
|
|
// char *pname - the name of the data to extract from
|
|
// *pBaseData - the struct into which the data is to be restored
|
|
// *pFields - pointer to an array of data field descriptions
|
|
// fieldCount - the size of the array (number of field descriptions)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CServerGameDLL::SaveReadFields( CSaveRestoreData *pSaveData, const char *pname, void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldCount )
|
|
{
|
|
CRestore restoreHelper( pSaveData );
|
|
restoreHelper.ReadFields( pname, pBaseData, pMap, pFields, fieldCount );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CServerGameDLL::SaveGlobalState( CSaveRestoreData *s )
|
|
{
|
|
::SaveGlobalState(s);
|
|
}
|
|
|
|
void CServerGameDLL::RestoreGlobalState(CSaveRestoreData *s)
|
|
{
|
|
::RestoreGlobalState(s);
|
|
}
|
|
|
|
void CServerGameDLL::Save( CSaveRestoreData *s )
|
|
{
|
|
CSave saveHelper( s );
|
|
g_pGameSaveRestoreBlockSet->Save( &saveHelper );
|
|
}
|
|
|
|
void CServerGameDLL::Restore( CSaveRestoreData *s, bool b)
|
|
{
|
|
CRestore restore(s);
|
|
g_pGameSaveRestoreBlockSet->Restore( &restore, b );
|
|
g_pGameSaveRestoreBlockSet->PostRestore();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : msg_type -
|
|
// *name -
|
|
// size -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool CServerGameDLL::GetUserMessageInfo( int msg_type, char *name, int maxnamelength, int& size )
|
|
{
|
|
if ( !usermessages->IsValidIndex( msg_type ) )
|
|
return false;
|
|
|
|
Q_strncpy( name, usermessages->GetUserMessageName( msg_type ), maxnamelength );
|
|
size = usermessages->GetUserMessageSize( msg_type );
|
|
return true;
|
|
}
|
|
|
|
CStandardSendProxies* CServerGameDLL::GetStandardSendProxies()
|
|
{
|
|
return &g_StandardSendProxies;
|
|
}
|
|
|
|
int CServerGameDLL::CreateEntityTransitionList( CSaveRestoreData *s, int a)
|
|
{
|
|
CRestore restoreHelper( s );
|
|
// save off file base
|
|
int base = restoreHelper.GetReadPos();
|
|
|
|
int movedCount = ::CreateEntityTransitionList(s, a);
|
|
if ( movedCount )
|
|
{
|
|
g_pGameSaveRestoreBlockSet->CallBlockHandlerRestore( GetPhysSaveRestoreBlockHandler(), base, &restoreHelper, false );
|
|
g_pGameSaveRestoreBlockSet->CallBlockHandlerRestore( GetAISaveRestoreBlockHandler(), base, &restoreHelper, false );
|
|
}
|
|
|
|
GetPhysSaveRestoreBlockHandler()->PostRestore();
|
|
GetAISaveRestoreBlockHandler()->PostRestore();
|
|
|
|
return movedCount;
|
|
}
|
|
|
|
void CServerGameDLL::PreSave( CSaveRestoreData *s )
|
|
{
|
|
g_pGameSaveRestoreBlockSet->PreSave( s );
|
|
}
|
|
|
|
#include "client_textmessage.h"
|
|
|
|
// This little hack lets me marry BSP names to messages in titles.txt
|
|
typedef struct
|
|
{
|
|
const char *pBSPName;
|
|
const char *pTitleName;
|
|
} TITLECOMMENT;
|
|
|
|
// this list gets searched for the first partial match, so some are out of order
|
|
static TITLECOMMENT gTitleComments[] =
|
|
{
|
|
#ifdef HL1_DLL
|
|
{ "t0a0", "#T0A0TITLE" },
|
|
{ "c0a0", "#HL1_Chapter1_Title" },
|
|
{ "c1a0", "#HL1_Chapter2_Title" },
|
|
{ "c1a1", "#HL1_Chapter3_Title" },
|
|
{ "c1a2", "#HL1_Chapter4_Title" },
|
|
{ "c1a3", "#HL1_Chapter5_Title" },
|
|
{ "c1a4", "#HL1_Chapter6_Title" },
|
|
{ "c2a1", "#HL1_Chapter7_Title" },
|
|
{ "c2a2", "#HL1_Chapter8_Title" },
|
|
{ "c2a3", "#HL1_Chapter9_Title" },
|
|
{ "c2a4d", "#HL1_Chapter11_Title" }, // These must appear before "C2A4" so all other map names starting with C2A4 get that title
|
|
{ "c2a4e", "#HL1_Chapter11_Title" },
|
|
{ "c2a4f", "#HL1_Chapter11_Title" },
|
|
{ "c2a4g", "#HL1_Chapter11_Title" },
|
|
{ "c2a4", "#HL1_Chapter10_Title" },
|
|
{ "c2a5", "#HL1_Chapter12_Title" },
|
|
{ "c3a1", "#HL1_Chapter13_Title" },
|
|
{ "c3a2", "#HL1_Chapter14_Title" },
|
|
{ "c4a1a", "#HL1_Chapter17_Title" }, // Order is important, see above
|
|
{ "c4a1b", "#HL1_Chapter17_Title" },
|
|
{ "c4a1c", "#HL1_Chapter17_Title" },
|
|
{ "c4a1d", "#HL1_Chapter17_Title" },
|
|
{ "c4a1e", "#HL1_Chapter17_Title" },
|
|
{ "c4a1", "#HL1_Chapter15_Title" },
|
|
{ "c4a2", "#HL1_Chapter16_Title" },
|
|
{ "c4a3", "#HL1_Chapter18_Title" },
|
|
{ "c5a1", "#HL1_Chapter19_Title" },
|
|
#elif defined PORTAL
|
|
{ "testchmb_a_00", "#Portal_Chapter1_Title" },
|
|
{ "testchmb_a_01", "#Portal_Chapter1_Title" },
|
|
{ "testchmb_a_02", "#Portal_Chapter2_Title" },
|
|
{ "testchmb_a_03", "#Portal_Chapter2_Title" },
|
|
{ "testchmb_a_04", "#Portal_Chapter3_Title" },
|
|
{ "testchmb_a_05", "#Portal_Chapter3_Title" },
|
|
{ "testchmb_a_06", "#Portal_Chapter4_Title" },
|
|
{ "testchmb_a_07", "#Portal_Chapter4_Title" },
|
|
{ "testchmb_a_08_advanced", "#Portal_Chapter5_Title" },
|
|
{ "testchmb_a_08", "#Portal_Chapter5_Title" },
|
|
{ "testchmb_a_09_advanced", "#Portal_Chapter6_Title" },
|
|
{ "testchmb_a_09", "#Portal_Chapter6_Title" },
|
|
{ "testchmb_a_10_advanced", "#Portal_Chapter7_Title" },
|
|
{ "testchmb_a_10", "#Portal_Chapter7_Title" },
|
|
{ "testchmb_a_11_advanced", "#Portal_Chapter8_Title" },
|
|
{ "testchmb_a_11", "#Portal_Chapter8_Title" },
|
|
{ "testchmb_a_13_advanced", "#Portal_Chapter9_Title" },
|
|
{ "testchmb_a_13", "#Portal_Chapter9_Title" },
|
|
{ "testchmb_a_14_advanced", "#Portal_Chapter10_Title" },
|
|
{ "testchmb_a_14", "#Portal_Chapter10_Title" },
|
|
{ "testchmb_a_15", "#Portal_Chapter11_Title" },
|
|
{ "escape_", "#Portal_Chapter11_Title" },
|
|
{ "background2", "#Portal_Chapter12_Title" },
|
|
#else
|
|
{ "intro", "#HL2_Chapter1_Title" },
|
|
|
|
{ "d1_trainstation_05", "#HL2_Chapter2_Title" },
|
|
{ "d1_trainstation_06", "#HL2_Chapter2_Title" },
|
|
|
|
{ "d1_trainstation_", "#HL2_Chapter1_Title" },
|
|
|
|
{ "d1_canals_06", "#HL2_Chapter4_Title" },
|
|
{ "d1_canals_07", "#HL2_Chapter4_Title" },
|
|
{ "d1_canals_08", "#HL2_Chapter4_Title" },
|
|
{ "d1_canals_09", "#HL2_Chapter4_Title" },
|
|
{ "d1_canals_1", "#HL2_Chapter4_Title" },
|
|
|
|
{ "d1_canals_0", "#HL2_Chapter3_Title" },
|
|
|
|
{ "d1_eli_", "#HL2_Chapter5_Title" },
|
|
|
|
{ "d1_town_", "#HL2_Chapter6_Title" },
|
|
|
|
{ "d2_coast_09", "#HL2_Chapter8_Title" },
|
|
{ "d2_coast_1", "#HL2_Chapter8_Title" },
|
|
{ "d2_prison_01", "#HL2_Chapter8_Title" },
|
|
|
|
{ "d2_coast_", "#HL2_Chapter7_Title" },
|
|
|
|
{ "d2_prison_06", "#HL2_Chapter9a_Title" },
|
|
{ "d2_prison_07", "#HL2_Chapter9a_Title" },
|
|
{ "d2_prison_08", "#HL2_Chapter9a_Title" },
|
|
|
|
{ "d2_prison_", "#HL2_Chapter9_Title" },
|
|
|
|
{ "d3_c17_01", "#HL2_Chapter9a_Title" },
|
|
{ "d3_c17_09", "#HL2_Chapter11_Title" },
|
|
{ "d3_c17_1", "#HL2_Chapter11_Title" },
|
|
|
|
{ "d3_c17_", "#HL2_Chapter10_Title" },
|
|
|
|
{ "d3_citadel_", "#HL2_Chapter12_Title" },
|
|
|
|
{ "d3_breen_", "#HL2_Chapter13_Title" },
|
|
{ "credits", "#HL2_Chapter14_Title" },
|
|
|
|
{ "ep1_citadel_00", "#episodic_Chapter1_Title" },
|
|
{ "ep1_citadel_01", "#episodic_Chapter1_Title" },
|
|
{ "ep1_citadel_02b", "#episodic_Chapter1_Title" },
|
|
{ "ep1_citadel_02", "#episodic_Chapter1_Title" },
|
|
{ "ep1_citadel_03", "#episodic_Chapter2_Title" },
|
|
{ "ep1_citadel_04", "#episodic_Chapter2_Title" },
|
|
{ "ep1_c17_00a", "#episodic_Chapter3_Title" },
|
|
{ "ep1_c17_00", "#episodic_Chapter3_Title" },
|
|
{ "ep1_c17_01", "#episodic_Chapter4_Title" },
|
|
{ "ep1_c17_02b", "#episodic_Chapter4_Title" },
|
|
{ "ep1_c17_02", "#episodic_Chapter4_Title" },
|
|
{ "ep1_c17_05", "#episodic_Chapter5_Title" },
|
|
{ "ep1_c17_06", "#episodic_Chapter5_Title" },
|
|
|
|
{ "ep2_outland_01a", "#ep2_Chapter1_Title" },
|
|
{ "ep2_outland_01", "#ep2_Chapter1_Title" },
|
|
{ "ep2_outland_02", "#ep2_Chapter2_Title" },
|
|
{ "ep2_outland_03", "#ep2_Chapter2_Title" },
|
|
{ "ep2_outland_04", "#ep2_Chapter2_Title" },
|
|
{ "ep2_outland_05", "#ep2_Chapter3_Title" },
|
|
|
|
{ "ep2_outland_06a", "#ep2_Chapter4_Title" },
|
|
{ "ep2_outland_06", "#ep2_Chapter3_Title" },
|
|
|
|
{ "ep2_outland_07", "#ep2_Chapter4_Title" },
|
|
{ "ep2_outland_08", "#ep2_Chapter4_Title" },
|
|
{ "ep2_outland_09", "#ep2_Chapter5_Title" },
|
|
|
|
{ "ep2_outland_10a", "#ep2_Chapter5_Title" },
|
|
{ "ep2_outland_10", "#ep2_Chapter5_Title" },
|
|
|
|
{ "ep2_outland_11a", "#ep2_Chapter6_Title" },
|
|
{ "ep2_outland_11", "#ep2_Chapter6_Title" },
|
|
|
|
{ "ep2_outland_12a", "#ep2_Chapter7_Title" },
|
|
{ "ep2_outland_12", "#ep2_Chapter6_Title" },
|
|
#endif
|
|
};
|
|
|
|
#ifdef _XBOX
|
|
void CServerGameDLL::GetTitleName( const char *pMapName, char* pTitleBuff, int titleBuffSize )
|
|
{
|
|
// Try to find a matching title comment for this mapname
|
|
for ( int i = 0; i < ARRAYSIZE(gTitleComments); i++ )
|
|
{
|
|
if ( !Q_strnicmp( pMapName, gTitleComments[i].pBSPName, strlen(gTitleComments[i].pBSPName) ) )
|
|
{
|
|
Q_strncpy( pTitleBuff, gTitleComments[i].pTitleName, titleBuffSize );
|
|
return;
|
|
}
|
|
}
|
|
Q_strncpy( pTitleBuff, pMapName, titleBuffSize );
|
|
}
|
|
#endif
|
|
|
|
void CServerGameDLL::GetSaveComment( char *text, int maxlength, float flMinutes, float flSeconds, bool bNoTime )
|
|
{
|
|
char comment[64];
|
|
const char *pName;
|
|
int i;
|
|
|
|
char const *mapname = STRING( gpGlobals->mapname );
|
|
|
|
pName = NULL;
|
|
|
|
// Try to find a matching title comment for this mapname
|
|
for ( i = 0; i < ARRAYSIZE(gTitleComments) && !pName; i++ )
|
|
{
|
|
if ( !Q_strnicmp( mapname, gTitleComments[i].pBSPName, strlen(gTitleComments[i].pBSPName) ) )
|
|
{
|
|
// found one
|
|
int j;
|
|
|
|
// Got a message, post-process it to be save name friendly
|
|
Q_strncpy( comment, gTitleComments[i].pTitleName, sizeof( comment ) );
|
|
pName = comment;
|
|
j = 0;
|
|
// Strip out CRs
|
|
while ( j < 64 && comment[j] )
|
|
{
|
|
if ( comment[j] == '\n' || comment[j] == '\r' )
|
|
comment[j] = 0;
|
|
else
|
|
j++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we didn't get one, use the designer's map name, or the BSP name itself
|
|
if ( !pName )
|
|
{
|
|
pName = mapname;
|
|
}
|
|
|
|
if ( bNoTime )
|
|
{
|
|
Q_snprintf( text, maxlength, "%-64.64s", pName );
|
|
}
|
|
else
|
|
{
|
|
int minutes = flMinutes;
|
|
int seconds = flSeconds;
|
|
|
|
// Wow, this guy/gal must suck...!
|
|
if ( minutes >= 1000 )
|
|
{
|
|
minutes = 999;
|
|
seconds = 59;
|
|
}
|
|
|
|
int minutesAdd = ( seconds / 60 );
|
|
seconds %= 60;
|
|
|
|
// add the elapsed time at the end of the comment, for the ui to parse out
|
|
Q_snprintf( text, maxlength, "%-64.64s %03d:%02d", pName, (minutes + minutesAdd), seconds );
|
|
}
|
|
}
|
|
|
|
void CServerGameDLL::WriteSaveHeaders( CSaveRestoreData *s )
|
|
{
|
|
CSave saveHelper( s );
|
|
g_pGameSaveRestoreBlockSet->WriteSaveHeaders( &saveHelper );
|
|
g_pGameSaveRestoreBlockSet->PostSave();
|
|
}
|
|
|
|
void CServerGameDLL::ReadRestoreHeaders( CSaveRestoreData *s )
|
|
{
|
|
CRestore restoreHelper( s );
|
|
g_pGameSaveRestoreBlockSet->PreRestore();
|
|
g_pGameSaveRestoreBlockSet->ReadRestoreHeaders( &restoreHelper );
|
|
}
|
|
|
|
void CServerGameDLL::PreSaveGameLoaded( char const *pSaveName, bool bInGame )
|
|
{
|
|
gamestats->Event_PreSaveGameLoaded( pSaveName, bInGame );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: 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.
|
|
//-----------------------------------------------------------------------------
|
|
bool CServerGameDLL::ShouldHideServer( void )
|
|
{
|
|
if ( g_pcv_commentary && g_pcv_commentary->GetBool() )
|
|
return true;
|
|
|
|
if ( g_pcv_hideServer && g_pcv_hideServer->GetBool() )
|
|
return true;
|
|
|
|
if ( gpGlobals->eLoadType == MapLoad_Background )
|
|
return true;
|
|
|
|
#if defined( TF_DLL )
|
|
if ( GTFGCClientSystem()->ShouldHideServer() )
|
|
return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::InvalidateMdlCache()
|
|
{
|
|
CBaseAnimating *pAnimating;
|
|
for ( CBaseEntity *pEntity = gEntList.FirstEnt(); pEntity != NULL; pEntity = gEntList.NextEnt(pEntity) )
|
|
{
|
|
pAnimating = dynamic_cast<CBaseAnimating *>(pEntity);
|
|
if ( pAnimating )
|
|
{
|
|
pAnimating->InvalidateMdlCache();
|
|
}
|
|
}
|
|
}
|
|
|
|
// interface to the new GC based lobby system
|
|
IServerGCLobby *CServerGameDLL::GetServerGCLobby()
|
|
{
|
|
#ifdef TF_DLL
|
|
return GTFGCClientSystem();
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
|
|
void CServerGameDLL::SetServerHibernation( bool bHibernating )
|
|
{
|
|
m_bIsHibernating = bHibernating;
|
|
|
|
#ifdef INFESTED_DLL
|
|
if ( engine && engine->IsDedicatedServer() && m_bIsHibernating && ASWGameRules() )
|
|
{
|
|
ASWGameRules()->OnServerHibernating();
|
|
}
|
|
#endif
|
|
|
|
#ifdef TF_DLL
|
|
GTFGCClientSystem()->SetHibernation( bHibernating );
|
|
#endif
|
|
}
|
|
|
|
const char *CServerGameDLL::GetServerBrowserMapOverride()
|
|
{
|
|
#ifdef TF_DLL
|
|
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
|
|
{
|
|
const char *pszFilenameShort = g_pPopulationManager ? g_pPopulationManager->GetPopulationFilenameShort() : NULL;
|
|
if ( pszFilenameShort && pszFilenameShort[0] )
|
|
{
|
|
return pszFilenameShort;
|
|
}
|
|
}
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
const char *CServerGameDLL::GetServerBrowserGameData()
|
|
{
|
|
CUtlString sResult;
|
|
|
|
#ifdef TF_DLL
|
|
sResult.Format( "tf_mm_trusted:%d,tf_mm_servermode:%d", tf_mm_trusted.GetInt(), tf_mm_servermode.GetInt() );
|
|
|
|
CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
|
|
if ( !pMatch )
|
|
{
|
|
sResult.Append( ",lobby:0" );
|
|
}
|
|
else
|
|
{
|
|
sResult.Append( CFmtStr( ",lobby:%016llx", pMatch->m_nLobbyID ) );
|
|
}
|
|
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
|
|
{
|
|
bool bMannup = pMatch && pMatch->m_eMatchGroup == k_nMatchGroup_MvM_MannUp;
|
|
sResult.Append( CFmtStr( ",mannup:%d", (int)bMannup ) );
|
|
}
|
|
#endif
|
|
|
|
static char rchResult[2048];
|
|
V_strcpy_safe( rchResult, sResult );
|
|
return rchResult;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::Status( void (*print) (const char *fmt, ...) )
|
|
{
|
|
if ( g_pGameRules )
|
|
{
|
|
g_pGameRules->Status( print );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::PrepareLevelResources( /* in/out */ char *pszMapName, size_t nMapNameSize,
|
|
/* in/out */ char *pszMapFile, size_t nMapFileSize )
|
|
{
|
|
#ifdef TF_DLL
|
|
TFMapsWorkshop()->PrepareLevelResources( pszMapName, nMapNameSize, pszMapFile, nMapFileSize );
|
|
#endif // TF_DLL
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
IServerGameDLL::ePrepareLevelResourcesResult
|
|
CServerGameDLL::AsyncPrepareLevelResources( /* in/out */ char *pszMapName, size_t nMapNameSize,
|
|
/* in/out */ char *pszMapFile, size_t nMapFileSize,
|
|
float *flProgress /* = NULL */ )
|
|
{
|
|
#ifdef TF_DLL
|
|
return TFMapsWorkshop()->AsyncPrepareLevelResources( pszMapName, nMapNameSize, pszMapFile, nMapFileSize, flProgress );
|
|
#endif // TF_DLL
|
|
|
|
if ( flProgress )
|
|
{
|
|
*flProgress = 1.f;
|
|
}
|
|
return IServerGameDLL::ePrepareLevelResources_Prepared;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
IServerGameDLL::eCanProvideLevelResult CServerGameDLL::CanProvideLevel( /* in/out */ char *pMapName, int nMapNameMax )
|
|
{
|
|
#ifdef TF_DLL
|
|
return TFMapsWorkshop()->OnCanProvideLevel( pMapName, nMapNameMax );
|
|
#endif // TF_DLL
|
|
return IServerGameDLL::eCanProvideLevel_CannotProvide;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CServerGameDLL::IsManualMapChangeOkay( const char **pszReason )
|
|
{
|
|
if ( GameRules() )
|
|
{
|
|
return GameRules()->IsManualMapChangeOkay( pszReason );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called during a transition, to build a map adjacency list
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameDLL::BuildAdjacentMapList( void )
|
|
{
|
|
// retrieve the pointer to the save data
|
|
CSaveRestoreData *pSaveData = gpGlobals->pSaveData;
|
|
|
|
if ( pSaveData )
|
|
pSaveData->levelInfo.connectionCount = BuildChangeList( pSaveData->levelInfo.levelList, MAX_LEVEL_CONNECTIONS );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sanity-check to verify that a path is a relative path inside the game dir
|
|
// Taken From: engine/cmd.cpp
|
|
//-----------------------------------------------------------------------------
|
|
static bool IsValidPath( const char *pszFilename )
|
|
{
|
|
if ( !pszFilename )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Q_strlen( pszFilename ) <= 0 ||
|
|
Q_IsAbsolutePath( pszFilename ) || // to protect absolute paths
|
|
Q_strstr( pszFilename, ".." ) ) // to protect relative paths
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void ValidateMOTDFilename( IConVar *pConVar, const char *oldValue, float flOldValue )
|
|
{
|
|
ConVarRef var( pConVar );
|
|
if ( !IsValidPath( var.GetString() ) )
|
|
{
|
|
var.SetValue( var.GetDefault() );
|
|
}
|
|
}
|
|
|
|
static ConVar motdfile( "motdfile", "motd.txt", 0, "The MOTD file to load.", ValidateMOTDFilename );
|
|
static ConVar motdfile_text( "motdfile_text", "motd_text.txt", 0, "The text-only MOTD file to use for clients that have disabled HTML MOTDs.", ValidateMOTDFilename );
|
|
void CServerGameDLL::LoadMessageOfTheDay()
|
|
{
|
|
LoadSpecificMOTDMsg( motdfile, "motd" );
|
|
LoadSpecificMOTDMsg( motdfile_text, "motd_text" );
|
|
}
|
|
|
|
void CServerGameDLL::LoadSpecificMOTDMsg( const ConVar &convar, const char *pszStringName )
|
|
{
|
|
#ifndef _XBOX
|
|
CUtlBuffer buf;
|
|
|
|
// Generate preferred filename, which is in the cfg folder.
|
|
char szPreferredFilename[ MAX_PATH ];
|
|
V_sprintf_safe( szPreferredFilename, "cfg/%s", convar.GetString() );
|
|
|
|
// Check the preferred filename first
|
|
char szResolvedFilename[ MAX_PATH ];
|
|
V_strcpy_safe( szResolvedFilename, szPreferredFilename );
|
|
bool bFound = filesystem->ReadFile( szResolvedFilename, "GAME", buf );
|
|
|
|
// Not found? Try in the root, which is the old place it used to go.
|
|
if ( !bFound )
|
|
{
|
|
|
|
V_strcpy_safe( szResolvedFilename, convar.GetString() );
|
|
bFound = filesystem->ReadFile( szResolvedFilename, "GAME", buf );
|
|
}
|
|
|
|
// Still not found? See if we can try the default.
|
|
if ( !bFound && !V_stricmp( convar.GetString(), convar.GetDefault() ) )
|
|
{
|
|
V_strcpy_safe( szResolvedFilename, szPreferredFilename );
|
|
char *dotTxt = V_stristr( szResolvedFilename, ".txt" );
|
|
Assert ( dotTxt != NULL );
|
|
if ( dotTxt ) V_strcpy( dotTxt, "_default.txt" );
|
|
bFound = filesystem->ReadFile( szResolvedFilename, "GAME", buf );
|
|
}
|
|
|
|
if ( !bFound )
|
|
{
|
|
Msg( "'%s' not found; not loaded\n", szPreferredFilename );
|
|
return;
|
|
}
|
|
|
|
if ( buf.TellPut() > 2048 )
|
|
{
|
|
Warning("'%s' is too big; not loaded\n", szResolvedFilename );
|
|
return;
|
|
}
|
|
buf.PutChar( '\0' );
|
|
|
|
if ( V_stricmp( szPreferredFilename, szResolvedFilename ) == 0)
|
|
{
|
|
Msg( "Set %s from file '%s'\n", pszStringName, szResolvedFilename );
|
|
}
|
|
else
|
|
{
|
|
Msg( "Set %s from file '%s'. ('%s' was not found.)\n", pszStringName, szResolvedFilename, szPreferredFilename );
|
|
}
|
|
|
|
g_pStringTableInfoPanel->AddString( CBaseEntity::IsServer(), pszStringName, buf.TellPut(), buf.Base() );
|
|
#endif
|
|
}
|
|
|
|
// keeps track of which chapters the user has unlocked
|
|
ConVar sv_unlockedchapters( "sv_unlockedchapters", "1", FCVAR_ARCHIVE | FCVAR_ARCHIVE_XBOX );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Updates which chapters are unlocked
|
|
//-----------------------------------------------------------------------------
|
|
void UpdateChapterRestrictions( const char *mapname )
|
|
{
|
|
// look at the chapter for this map
|
|
char chapterTitle[64];
|
|
chapterTitle[0] = 0;
|
|
for ( int i = 0; i < ARRAYSIZE(gTitleComments); i++ )
|
|
{
|
|
if ( !Q_strnicmp( mapname, gTitleComments[i].pBSPName, strlen(gTitleComments[i].pBSPName) ) )
|
|
{
|
|
// found
|
|
Q_strncpy( chapterTitle, gTitleComments[i].pTitleName, sizeof( chapterTitle ) );
|
|
int j = 0;
|
|
while ( j < 64 && chapterTitle[j] )
|
|
{
|
|
if ( chapterTitle[j] == '\n' || chapterTitle[j] == '\r' )
|
|
chapterTitle[j] = 0;
|
|
else
|
|
j++;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !chapterTitle[0] )
|
|
return;
|
|
|
|
// make sure the specified chapter title is unlocked
|
|
strlwr( chapterTitle );
|
|
|
|
// Get our active mod directory name
|
|
char modDir[MAX_PATH];
|
|
if ( UTIL_GetModDir( modDir, sizeof(modDir) ) == false )
|
|
return;
|
|
|
|
char chapterNumberPrefix[64];
|
|
Q_snprintf(chapterNumberPrefix, sizeof(chapterNumberPrefix), "#%s_chapter", modDir);
|
|
|
|
const char *newChapterNumber = strstr( chapterTitle, chapterNumberPrefix );
|
|
if ( newChapterNumber )
|
|
{
|
|
// cut off the front
|
|
newChapterNumber += strlen( chapterNumberPrefix );
|
|
char newChapter[32];
|
|
Q_strncpy( newChapter, newChapterNumber, sizeof(newChapter) );
|
|
|
|
// cut off the end
|
|
char *end = strstr( newChapter, "_title" );
|
|
if ( end )
|
|
{
|
|
*end = 0;
|
|
}
|
|
|
|
int nNewChapter = atoi( newChapter );
|
|
|
|
// HACK: HL2 added a zany chapter "9a" which wreaks
|
|
// havoc in this stupid atoi-based chapter code.
|
|
if ( !Q_stricmp( modDir, "hl2" ) )
|
|
{
|
|
if ( !Q_stricmp( newChapter, "9a" ) )
|
|
{
|
|
nNewChapter = 10;
|
|
}
|
|
else if ( nNewChapter > 9 )
|
|
{
|
|
nNewChapter++;
|
|
}
|
|
}
|
|
|
|
// ok we have the string, see if it's newer
|
|
const char *unlockedChapter = sv_unlockedchapters.GetString();
|
|
int nUnlockedChapter = atoi( unlockedChapter );
|
|
|
|
if ( nUnlockedChapter < nNewChapter )
|
|
{
|
|
// ok we're at a higher chapter, unlock
|
|
sv_unlockedchapters.SetValue( nNewChapter );
|
|
|
|
// HACK: Call up through a better function than this? 7/23/07 - jdw
|
|
if ( IsX360() )
|
|
{
|
|
engine->ServerCommand( "host_writeconfig\n" );
|
|
}
|
|
}
|
|
|
|
g_nCurrentChapterIndex = nNewChapter;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Update xbox live data for the user's presence
|
|
//-----------------------------------------------------------------------------
|
|
void UpdateRichPresence ( void )
|
|
{
|
|
// This assumes we're playing a single player game
|
|
Assert ( gpGlobals->maxClients == 1 );
|
|
|
|
// Shouldn't get here unless we're playing a map and we've updated sv_unlockedchapters
|
|
Assert ( g_nCurrentChapterIndex >= 0 );
|
|
|
|
// Get our active mod directory name
|
|
char modDir[MAX_PATH];
|
|
if ( UTIL_GetModDir( modDir, sizeof(modDir) ) == false )
|
|
return;
|
|
|
|
// Get presence data based on the game we're playing
|
|
uint iGameID, iChapterIndex, iChapterID, iGamePresenceID;
|
|
iGameID = iChapterIndex = iChapterID = iGamePresenceID = 0;
|
|
if ( Q_stristr( modDir, "hl2" ) )
|
|
{
|
|
iGameID = CONTEXT_GAME_GAME_HALF_LIFE_2;
|
|
iChapterID = CONTEXT_CHAPTER_HL2;
|
|
iChapterIndex = g_nCurrentChapterIndex - 1;
|
|
iGamePresenceID = CONTEXT_PRESENCE_HL2_INGAME;
|
|
}
|
|
else if ( Q_stristr( modDir, "episodic" ) )
|
|
{
|
|
iGameID = CONTEXT_GAME_GAME_EPISODE_ONE;
|
|
iChapterID = CONTEXT_CHAPTER_EP1;
|
|
iChapterIndex = g_nCurrentChapterIndex - 1;
|
|
iGamePresenceID = CONTEXT_PRESENCE_EP1_INGAME;
|
|
}
|
|
else if ( Q_stristr( modDir, "ep2" ) )
|
|
{
|
|
iGameID = CONTEXT_GAME_GAME_EPISODE_TWO;
|
|
iChapterID = CONTEXT_CHAPTER_EP2;
|
|
iChapterIndex = g_nCurrentChapterIndex - 1;
|
|
iGamePresenceID = CONTEXT_PRESENCE_EP2_INGAME;
|
|
}
|
|
else if ( Q_stristr( modDir, "portal" ) )
|
|
{
|
|
iGameID = CONTEXT_GAME_GAME_PORTAL;
|
|
iChapterID = CONTEXT_CHAPTER_PORTAL;
|
|
iChapterIndex = g_nCurrentChapterIndex - 1;
|
|
iGamePresenceID = CONTEXT_PRESENCE_PORTAL_INGAME;
|
|
}
|
|
else
|
|
{
|
|
Warning( "UpdateRichPresence failed in GameInterface. Didn't recognize -game parameter." );
|
|
}
|
|
|
|
#if defined( _X360 )
|
|
|
|
// Set chapter context based on mapname
|
|
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), iChapterID, iChapterIndex, true ) )
|
|
{
|
|
Warning( "GameInterface: UserSetContext failed.\n" );
|
|
}
|
|
|
|
if ( commentary.GetBool() )
|
|
{
|
|
// Set presence to show the user is playing developer commentary
|
|
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_COMMENTARY, true ) )
|
|
{
|
|
Warning( "GameInterface: UserSetContext failed.\n" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Set presence to show the user is in-game
|
|
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, iGamePresenceID, true ) )
|
|
{
|
|
Warning( "GameInterface: UserSetContext failed.\n" );
|
|
}
|
|
}
|
|
|
|
// Set which game the user is playing
|
|
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), CONTEXT_GAME, iGameID, true ) )
|
|
{
|
|
Warning( "GameInterface: UserSetContext failed.\n" );
|
|
}
|
|
|
|
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_GAME_TYPE, X_CONTEXT_GAME_TYPE_STANDARD, true ) )
|
|
{
|
|
Warning( "GameInterface: UserSetContext failed.\n" );
|
|
}
|
|
|
|
if ( !xboxsystem->UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_GAME_MODE, CONTEXT_GAME_MODE_SINGLEPLAYER, true ) )
|
|
{
|
|
Warning( "GameInterface: UserSetContext failed.\n" );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Precaches a vgui screen overlay material
|
|
//-----------------------------------------------------------------------------
|
|
void PrecacheMaterial( const char *pMaterialName )
|
|
{
|
|
Assert( pMaterialName && pMaterialName[0] );
|
|
g_pStringTableMaterials->AddString( CBaseEntity::IsServer(), pMaterialName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a previously precached material into an index
|
|
//-----------------------------------------------------------------------------
|
|
int GetMaterialIndex( const char *pMaterialName )
|
|
{
|
|
if (pMaterialName)
|
|
{
|
|
int nIndex = g_pStringTableMaterials->FindStringIndex( pMaterialName );
|
|
|
|
if (nIndex != INVALID_STRING_INDEX )
|
|
{
|
|
return nIndex;
|
|
}
|
|
else
|
|
{
|
|
DevMsg("Warning! GetMaterialIndex: couldn't find material %s\n ", pMaterialName );
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// This is the invalid string index
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a previously precached material index into a string
|
|
//-----------------------------------------------------------------------------
|
|
const char *GetMaterialNameFromIndex( int nMaterialIndex )
|
|
{
|
|
return g_pStringTableMaterials->GetString( nMaterialIndex );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Precaches a vgui screen overlay material
|
|
//-----------------------------------------------------------------------------
|
|
void PrecacheParticleSystem( const char *pParticleSystemName )
|
|
{
|
|
Assert( pParticleSystemName && pParticleSystemName[0] );
|
|
g_pStringTableParticleEffectNames->AddString( CBaseEntity::IsServer(), pParticleSystemName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a previously precached material into an index
|
|
//-----------------------------------------------------------------------------
|
|
int GetParticleSystemIndex( const char *pParticleSystemName )
|
|
{
|
|
if ( pParticleSystemName )
|
|
{
|
|
int nIndex = g_pStringTableParticleEffectNames->FindStringIndex( pParticleSystemName );
|
|
if (nIndex != INVALID_STRING_INDEX )
|
|
return nIndex;
|
|
|
|
DevWarning("Server: Missing precache for particle system \"%s\"!\n", pParticleSystemName );
|
|
}
|
|
|
|
// This is the invalid string index
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Converts a previously precached material index into a string
|
|
//-----------------------------------------------------------------------------
|
|
const char *GetParticleSystemNameFromIndex( int nMaterialIndex )
|
|
{
|
|
if ( nMaterialIndex < g_pStringTableParticleEffectNames->GetMaxStrings() )
|
|
return g_pStringTableParticleEffectNames->GetString( nMaterialIndex );
|
|
return "error";
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns true if host_thread_mode is set to non-zero (and engine is running in threaded mode)
|
|
//-----------------------------------------------------------------------------
|
|
bool IsEngineThreaded()
|
|
{
|
|
if ( g_pcv_ThreadMode )
|
|
{
|
|
return g_pcv_ThreadMode->GetBool();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
class CServerGameEnts : public IServerGameEnts
|
|
{
|
|
public:
|
|
virtual void SetDebugEdictBase(edict_t *base);
|
|
virtual void MarkEntitiesAsTouching( edict_t *e1, edict_t *e2 );
|
|
virtual void FreeContainingEntity( edict_t * );
|
|
virtual edict_t* BaseEntityToEdict( CBaseEntity *pEnt );
|
|
virtual CBaseEntity* EdictToBaseEntity( edict_t *pEdict );
|
|
virtual void CheckTransmit( CCheckTransmitInfo *pInfo, const unsigned short *pEdictIndices, int nEdicts );
|
|
};
|
|
EXPOSE_SINGLE_INTERFACE(CServerGameEnts, IServerGameEnts, INTERFACEVERSION_SERVERGAMEENTS);
|
|
|
|
void CServerGameEnts::SetDebugEdictBase(edict_t *base)
|
|
{
|
|
g_pDebugEdictBase = base;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks entities as touching
|
|
// Input : *e1 -
|
|
// *e2 -
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameEnts::MarkEntitiesAsTouching( edict_t *e1, edict_t *e2 )
|
|
{
|
|
CBaseEntity *entity = GetContainingEntity( e1 );
|
|
CBaseEntity *entityTouched = GetContainingEntity( e2 );
|
|
if ( entity && entityTouched )
|
|
{
|
|
// HACKHACK: UNDONE: Pass in the trace here??!?!?
|
|
trace_t tr;
|
|
UTIL_ClearTrace( tr );
|
|
tr.endpos = (entity->GetAbsOrigin() + entityTouched->GetAbsOrigin()) * 0.5;
|
|
entity->PhysicsMarkEntitiesAsTouching( entityTouched, tr );
|
|
}
|
|
}
|
|
|
|
void CServerGameEnts::FreeContainingEntity( edict_t *e )
|
|
{
|
|
::FreeContainingEntity(e);
|
|
}
|
|
|
|
edict_t* CServerGameEnts::BaseEntityToEdict( CBaseEntity *pEnt )
|
|
{
|
|
if ( pEnt )
|
|
return pEnt->edict();
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
CBaseEntity* CServerGameEnts::EdictToBaseEntity( edict_t *pEdict )
|
|
{
|
|
if ( pEdict )
|
|
return CBaseEntity::Instance( pEdict );
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* Yuck.. ideally this would be in CServerNetworkProperty's header, but it requires CBaseEntity and
|
|
// inlining it gives a nice speedup.
|
|
inline void CServerNetworkProperty::CheckTransmit( CCheckTransmitInfo *pInfo )
|
|
{
|
|
// If we have a transmit proxy, let it hook our ShouldTransmit return value.
|
|
if ( m_pTransmitProxy )
|
|
{
|
|
nShouldTransmit = m_pTransmitProxy->ShouldTransmit( pInfo, nShouldTransmit );
|
|
}
|
|
|
|
if ( m_pOuter->ShouldTransmit( pInfo ) )
|
|
{
|
|
m_pOuter->SetTransmit( pInfo );
|
|
}
|
|
} */
|
|
|
|
void CServerGameEnts::CheckTransmit( CCheckTransmitInfo *pInfo, const unsigned short *pEdictIndices, int nEdicts )
|
|
{
|
|
// NOTE: for speed's sake, this assumes that all networkables are CBaseEntities and that the edict list
|
|
// is consecutive in memory. If either of these things change, then this routine needs to change, but
|
|
// ideally we won't be calling any virtual from this routine. This speedy routine was added as an
|
|
// optimization which would be nice to keep.
|
|
edict_t *pBaseEdict = engine->PEntityOfEntIndex( 0 );
|
|
|
|
// get recipient player's skybox:
|
|
CBaseEntity *pRecipientEntity = CBaseEntity::Instance( pInfo->m_pClientEnt );
|
|
|
|
Assert( pRecipientEntity && pRecipientEntity->IsPlayer() );
|
|
if ( !pRecipientEntity )
|
|
return;
|
|
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
CBasePlayer *pRecipientPlayer = static_cast<CBasePlayer*>( pRecipientEntity );
|
|
const int skyBoxArea = pRecipientPlayer->m_Local.m_skybox3d.area;
|
|
|
|
#ifndef _X360
|
|
const bool bIsHLTV = pRecipientPlayer->IsHLTV();
|
|
const bool bIsReplay = pRecipientPlayer->IsReplay();
|
|
|
|
// m_pTransmitAlways must be set if HLTV client
|
|
Assert( bIsHLTV == ( pInfo->m_pTransmitAlways != NULL) ||
|
|
bIsReplay == ( pInfo->m_pTransmitAlways != NULL) );
|
|
#endif
|
|
|
|
for ( int i=0; i < nEdicts; i++ )
|
|
{
|
|
int iEdict = pEdictIndices[i];
|
|
|
|
edict_t *pEdict = &pBaseEdict[iEdict];
|
|
Assert( pEdict == engine->PEntityOfEntIndex( iEdict ) );
|
|
int nFlags = pEdict->m_fStateFlags & (FL_EDICT_DONTSEND|FL_EDICT_ALWAYS|FL_EDICT_PVSCHECK|FL_EDICT_FULLCHECK);
|
|
|
|
// entity needs no transmit
|
|
if ( nFlags & FL_EDICT_DONTSEND )
|
|
continue;
|
|
|
|
// entity is already marked for sending
|
|
if ( pInfo->m_pTransmitEdict->Get( iEdict ) )
|
|
continue;
|
|
|
|
if ( nFlags & FL_EDICT_ALWAYS )
|
|
{
|
|
// FIXME: Hey! Shouldn't this be using SetTransmit so as
|
|
// to also force network down dependent entities?
|
|
while ( true )
|
|
{
|
|
// mark entity for sending
|
|
pInfo->m_pTransmitEdict->Set( iEdict );
|
|
|
|
#ifndef _X360
|
|
if ( bIsHLTV || bIsReplay )
|
|
{
|
|
pInfo->m_pTransmitAlways->Set( iEdict );
|
|
}
|
|
#endif
|
|
CServerNetworkProperty *pEnt = static_cast<CServerNetworkProperty*>( pEdict->GetNetworkable() );
|
|
if ( !pEnt )
|
|
break;
|
|
|
|
CServerNetworkProperty *pParent = pEnt->GetNetworkParent();
|
|
if ( !pParent )
|
|
break;
|
|
|
|
pEdict = pParent->edict();
|
|
iEdict = pParent->entindex();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// FIXME: Would like to remove all dependencies
|
|
CBaseEntity *pEnt = ( CBaseEntity * )pEdict->GetUnknown();
|
|
Assert( dynamic_cast< CBaseEntity* >( pEdict->GetUnknown() ) == pEnt );
|
|
|
|
if ( nFlags == FL_EDICT_FULLCHECK )
|
|
{
|
|
// do a full ShouldTransmit() check, may return FL_EDICT_CHECKPVS
|
|
nFlags = pEnt->ShouldTransmit( pInfo );
|
|
|
|
Assert( !(nFlags & FL_EDICT_FULLCHECK) );
|
|
|
|
if ( nFlags & FL_EDICT_ALWAYS )
|
|
{
|
|
pEnt->SetTransmit( pInfo, true );
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// don't send this entity
|
|
if ( !( nFlags & FL_EDICT_PVSCHECK ) )
|
|
continue;
|
|
|
|
CServerNetworkProperty *netProp = static_cast<CServerNetworkProperty*>( pEdict->GetNetworkable() );
|
|
|
|
#ifndef _X360
|
|
if ( bIsHLTV || bIsReplay )
|
|
{
|
|
// for the HLTV/Replay we don't cull against PVS
|
|
if ( netProp->AreaNum() == skyBoxArea )
|
|
{
|
|
pEnt->SetTransmit( pInfo, true );
|
|
}
|
|
else
|
|
{
|
|
pEnt->SetTransmit( pInfo, false );
|
|
}
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
// Always send entities in the player's 3d skybox.
|
|
// Sidenote: call of AreaNum() ensures that PVS data is up to date for this entity
|
|
bool bSameAreaAsSky = netProp->AreaNum() == skyBoxArea;
|
|
if ( bSameAreaAsSky )
|
|
{
|
|
pEnt->SetTransmit( pInfo, true );
|
|
continue;
|
|
}
|
|
|
|
bool bInPVS = netProp->IsInPVS( pInfo );
|
|
if ( bInPVS || sv_force_transmit_ents.GetBool() )
|
|
{
|
|
// only send if entity is in PVS
|
|
pEnt->SetTransmit( pInfo, false );
|
|
continue;
|
|
}
|
|
|
|
// If the entity is marked "check PVS" but it's in hierarchy, walk up the hierarchy looking for the
|
|
// for any parent which is also in the PVS. If none are found, then we don't need to worry about sending ourself
|
|
CBaseEntity *orig = pEnt;
|
|
CServerNetworkProperty *check = netProp->GetNetworkParent();
|
|
|
|
// BUG BUG: I think it might be better to build up a list of edict indices which "depend" on other answers and then
|
|
// resolve them in a second pass. Not sure what happens if an entity has two parents who both request PVS check?
|
|
while ( check )
|
|
{
|
|
int checkIndex = check->entindex();
|
|
|
|
// Parent already being sent
|
|
if ( pInfo->m_pTransmitEdict->Get( checkIndex ) )
|
|
{
|
|
orig->SetTransmit( pInfo, true );
|
|
break;
|
|
}
|
|
|
|
edict_t *checkEdict = check->edict();
|
|
int checkFlags = checkEdict->m_fStateFlags & (FL_EDICT_DONTSEND|FL_EDICT_ALWAYS|FL_EDICT_PVSCHECK|FL_EDICT_FULLCHECK);
|
|
if ( checkFlags & FL_EDICT_DONTSEND )
|
|
break;
|
|
|
|
if ( checkFlags & FL_EDICT_ALWAYS )
|
|
{
|
|
orig->SetTransmit( pInfo, true );
|
|
break;
|
|
}
|
|
|
|
if ( checkFlags == FL_EDICT_FULLCHECK )
|
|
{
|
|
// do a full ShouldTransmit() check, may return FL_EDICT_CHECKPVS
|
|
CBaseEntity *pCheckEntity = check->GetBaseEntity();
|
|
nFlags = pCheckEntity->ShouldTransmit( pInfo );
|
|
Assert( !(nFlags & FL_EDICT_FULLCHECK) );
|
|
if ( nFlags & FL_EDICT_ALWAYS )
|
|
{
|
|
pCheckEntity->SetTransmit( pInfo, true );
|
|
orig->SetTransmit( pInfo, true );
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( checkFlags & FL_EDICT_PVSCHECK )
|
|
{
|
|
// Check pvs
|
|
check->RecomputePVSInformation();
|
|
bool bMoveParentInPVS = check->IsInPVS( pInfo );
|
|
if ( bMoveParentInPVS )
|
|
{
|
|
orig->SetTransmit( pInfo, true );
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Continue up chain just in case the parent itself has a parent that's in the PVS...
|
|
check = check->GetNetworkParent();
|
|
}
|
|
}
|
|
|
|
// Msg("A:%i, N:%i, F: %i, P: %i\n", always, dontSend, fullCheck, PVS );
|
|
}
|
|
|
|
|
|
CServerGameClients g_ServerGameClients;
|
|
// INTERFACEVERSION_SERVERGAMECLIENTS_VERSION_3 is compatible with the latest since we're only adding things to the end, so expose that as well.
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CServerGameClients, IServerGameClients003, INTERFACEVERSION_SERVERGAMECLIENTS_VERSION_3, g_ServerGameClients );
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CServerGameClients, IServerGameClients, INTERFACEVERSION_SERVERGAMECLIENTS, g_ServerGameClients );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: called when a player tries to connect to the server
|
|
// Input : *pEdict - the new player
|
|
// char *pszName - the players name
|
|
// char *pszAddress - the IP address of the player
|
|
// reject - output - fill in with the reason why
|
|
// maxrejectlen -- sizeof output buffer
|
|
// the player was not allowed to connect.
|
|
// Output : Returns TRUE if player is allowed to join, FALSE if connection is denied.
|
|
//-----------------------------------------------------------------------------
|
|
bool CServerGameClients::ClientConnect( edict_t *pEdict, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen )
|
|
{
|
|
if ( !g_pGameRules )
|
|
return false;
|
|
|
|
return g_pGameRules->ClientConnected( pEdict, pszName, pszAddress, reject, maxrejectlen );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when a player is fully active (i.e. ready to receive messages)
|
|
// Input : *pEntity - the player
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::ClientActive( edict_t *pEdict, bool bLoadGame )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
|
|
::ClientActive( pEdict, bLoadGame );
|
|
|
|
// If we just loaded from a save file, call OnRestore on valid entities
|
|
EndRestoreEntities();
|
|
|
|
if ( gpGlobals->eLoadType != MapLoad_LoadGame )
|
|
{
|
|
// notify all entities that the player is now in the game
|
|
for ( CBaseEntity *pEntity = gEntList.FirstEnt(); pEntity != NULL; pEntity = gEntList.NextEnt(pEntity) )
|
|
{
|
|
pEntity->PostClientActive();
|
|
}
|
|
}
|
|
|
|
// Tell the sound controller to check looping sounds
|
|
CBasePlayer *pPlayer = ( CBasePlayer * )CBaseEntity::Instance( pEdict );
|
|
CSoundEnvelopeController::GetController().CheckLoopingSoundsForPlayer( pPlayer );
|
|
SceneManager_ClientActive( pPlayer );
|
|
|
|
#if defined( TF_DLL )
|
|
Assert( pPlayer );
|
|
if ( pPlayer && !pPlayer->IsFakeClient() && !pPlayer->IsHLTV() && !pPlayer->IsReplay() )
|
|
{
|
|
CSteamID steamID;
|
|
if ( pPlayer->GetSteamID( &steamID ) )
|
|
{
|
|
GTFGCClientSystem()->ClientActive( steamID );
|
|
}
|
|
else
|
|
{
|
|
if ( !pPlayer->IsReplay() && !pPlayer->IsHLTV() )
|
|
{
|
|
Log("WARNING: ClientActive, but we don't know his SteamID?\n");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pPlayer - the player
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::ClientSpawned( edict_t *pPlayer )
|
|
{
|
|
if ( g_pGameRules )
|
|
{
|
|
g_pGameRules->ClientSpawned( pPlayer );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: called when a player disconnects from a server
|
|
// Input : *pEdict - the player
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::ClientDisconnect( edict_t *pEdict )
|
|
{
|
|
extern bool g_fGameOver;
|
|
|
|
CBasePlayer *player = ( CBasePlayer * )CBaseEntity::Instance( pEdict );
|
|
if ( player )
|
|
{
|
|
if ( !g_fGameOver )
|
|
{
|
|
player->SetMaxSpeed( 0.0f );
|
|
|
|
CSound *pSound;
|
|
pSound = CSoundEnt::SoundPointerForIndex( CSoundEnt::ClientSoundIndex( pEdict ) );
|
|
{
|
|
// since this client isn't around to think anymore, reset their sound.
|
|
if ( pSound )
|
|
{
|
|
pSound->Reset();
|
|
}
|
|
}
|
|
|
|
// since the edict doesn't get deleted, fix it so it doesn't interfere.
|
|
player->RemoveFlag( FL_AIMTARGET ); // don't attract autoaim
|
|
player->AddFlag( FL_DONTTOUCH ); // stop it touching anything
|
|
player->AddFlag( FL_NOTARGET ); // stop NPCs noticing it
|
|
player->AddSolidFlags( FSOLID_NOT_SOLID ); // nonsolid
|
|
|
|
if ( g_pGameRules )
|
|
{
|
|
g_pGameRules->ClientDisconnected( pEdict );
|
|
gamestats->Event_PlayerDisconnected( player );
|
|
}
|
|
}
|
|
|
|
// Make sure all Untouch()'s are called for this client leaving
|
|
CBaseEntity::PhysicsRemoveTouchedList( player );
|
|
CBaseEntity::PhysicsRemoveGroundList( player );
|
|
|
|
#if !defined( NO_ENTITY_PREDICTION )
|
|
// Make sure anything we "own" is simulated by the server from now on
|
|
player->ClearPlayerSimulationList();
|
|
#endif
|
|
#if defined( TF_DLL )
|
|
if ( !player->IsFakeClient() )
|
|
{
|
|
CSteamID steamID;
|
|
if ( player->GetSteamID( &steamID ) )
|
|
{
|
|
GTFGCClientSystem()->ClientDisconnected( steamID );
|
|
}
|
|
else
|
|
{
|
|
if ( !player->IsReplay() && !player->IsHLTV() )
|
|
{
|
|
Log("WARNING: ClientDisconnected, but we don't know his SteamID?\n");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void CServerGameClients::ClientPutInServer( edict_t *pEntity, const char *playername )
|
|
{
|
|
if ( g_pClientPutInServerOverride )
|
|
g_pClientPutInServerOverride( pEntity, playername );
|
|
else
|
|
::ClientPutInServer( pEntity, playername );
|
|
}
|
|
|
|
void CServerGameClients::ClientCommand( edict_t *pEntity, const CCommand &args )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetContainingEntity( pEntity ) );
|
|
::ClientCommand( pPlayer, args );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: called after the player changes userinfo - gives dll a chance to modify
|
|
// it before it gets sent into the rest of the engine->
|
|
// Input : *pEdict - the player
|
|
// *infobuffer - their infobuffer
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::ClientSettingsChanged( edict_t *pEdict )
|
|
{
|
|
// Is the client spawned yet?
|
|
if ( !pEdict->GetUnknown() )
|
|
return;
|
|
|
|
CBasePlayer *player = ( CBasePlayer * )CBaseEntity::Instance( pEdict );
|
|
|
|
if ( !player )
|
|
return;
|
|
|
|
bool bAllowNetworkingClientSettingsChange = g_pGameRules->IsConnectedUserInfoChangeAllowed( player );
|
|
if ( bAllowNetworkingClientSettingsChange )
|
|
{
|
|
|
|
#define QUICKGETCVARVALUE(v) (engine->GetClientConVarValue( player->entindex(), v ))
|
|
|
|
// get network setting for prediction & lag compensation
|
|
|
|
// Unfortunately, we have to duplicate the code in cdll_bounded_cvars.cpp here because the client
|
|
// doesn't send the virtualized value up (because it has no way to know when the virtualized value
|
|
// changes). Possible todo: put the responsibility on the bounded cvar to notify the engine when
|
|
// its virtualized value has changed.
|
|
|
|
player->m_nUpdateRate = Q_atoi( QUICKGETCVARVALUE("cl_updaterate") );
|
|
static const ConVar *pMinUpdateRate = g_pCVar->FindVar( "sv_minupdaterate" );
|
|
static const ConVar *pMaxUpdateRate = g_pCVar->FindVar( "sv_maxupdaterate" );
|
|
if ( pMinUpdateRate && pMaxUpdateRate )
|
|
player->m_nUpdateRate = clamp( player->m_nUpdateRate, (int) pMinUpdateRate->GetFloat(), (int) pMaxUpdateRate->GetFloat() );
|
|
|
|
bool useInterpolation = Q_atoi( QUICKGETCVARVALUE("cl_interpolate") ) != 0;
|
|
if ( useInterpolation )
|
|
{
|
|
float flLerpRatio = Q_atof( QUICKGETCVARVALUE("cl_interp_ratio") );
|
|
if ( flLerpRatio == 0 )
|
|
flLerpRatio = 1.0f;
|
|
float flLerpAmount = Q_atof( QUICKGETCVARVALUE("cl_interp") );
|
|
|
|
static const ConVar *pMin = g_pCVar->FindVar( "sv_client_min_interp_ratio" );
|
|
static const ConVar *pMax = g_pCVar->FindVar( "sv_client_max_interp_ratio" );
|
|
if ( pMin && pMax && pMin->GetFloat() != -1 )
|
|
{
|
|
flLerpRatio = clamp( flLerpRatio, pMin->GetFloat(), pMax->GetFloat() );
|
|
}
|
|
else
|
|
{
|
|
if ( flLerpRatio == 0 )
|
|
flLerpRatio = 1.0f;
|
|
}
|
|
// #define FIXME_INTERP_RATIO
|
|
player->m_fLerpTime = MAX( flLerpAmount, flLerpRatio / player->m_nUpdateRate );
|
|
}
|
|
else
|
|
{
|
|
player->m_fLerpTime = 0.0f;
|
|
}
|
|
|
|
#if !defined( NO_ENTITY_PREDICTION )
|
|
bool usePrediction = Q_atoi( QUICKGETCVARVALUE("cl_predict")) != 0;
|
|
|
|
if ( usePrediction )
|
|
{
|
|
player->m_bPredictWeapons = Q_atoi( QUICKGETCVARVALUE("cl_predictweapons")) != 0;
|
|
player->m_bLagCompensation = Q_atoi( QUICKGETCVARVALUE("cl_lagcompensation")) != 0;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
player->m_bPredictWeapons = false;
|
|
player->m_bLagCompensation = false;
|
|
}
|
|
|
|
|
|
#undef QUICKGETCVARVALUE
|
|
}
|
|
|
|
g_pGameRules->ClientSettingsChanged( player );
|
|
}
|
|
|
|
|
|
#ifdef PORTAL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Runs CFuncAreaPortalBase::UpdateVisibility on each portal
|
|
// Input : pAreaPortal - The Area portal to test for visibility from portals
|
|
// Output : int - 1 if any portal needs this area portal open, 0 otherwise.
|
|
//-----------------------------------------------------------------------------
|
|
int TestAreaPortalVisibilityThroughPortals ( CFuncAreaPortalBase* pAreaPortal, edict_t *pViewEntity, unsigned char *pvs, int pvssize )
|
|
{
|
|
int iPortalCount = CProp_Portal_Shared::AllPortals.Count();
|
|
if( iPortalCount == 0 )
|
|
return 0;
|
|
|
|
CProp_Portal **pPortals = CProp_Portal_Shared::AllPortals.Base();
|
|
|
|
for ( int i = 0; i != iPortalCount; ++i )
|
|
{
|
|
CProp_Portal* pLocalPortal = pPortals[ i ];
|
|
if ( pLocalPortal && pLocalPortal->m_bActivated )
|
|
{
|
|
CProp_Portal* pRemotePortal = pLocalPortal->m_hLinkedPortal.Get();
|
|
|
|
// Make sure this portal's linked portal is in the PVS before we add what it can see
|
|
if ( pRemotePortal && pRemotePortal->m_bActivated && pRemotePortal->NetworkProp() &&
|
|
pRemotePortal->NetworkProp()->IsInPVS( pViewEntity, pvs, pvssize ) )
|
|
{
|
|
bool bIsOpenOnClient = true;
|
|
float fovDistanceAdjustFactor = 1.0f;
|
|
Vector portalOrg = pLocalPortal->GetAbsOrigin();
|
|
int iPortalNeedsThisPortalOpen = pAreaPortal->UpdateVisibility( portalOrg, fovDistanceAdjustFactor, bIsOpenOnClient );
|
|
|
|
// Stop checking on success, this portal needs to be open
|
|
if ( iPortalNeedsThisPortalOpen )
|
|
{
|
|
return iPortalNeedsThisPortalOpen;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A client can have a separate "view entity" indicating that his/her view should depend on the origin of that
|
|
// view entity. If that's the case, then pViewEntity will be non-NULL and will be used. Otherwise, the current
|
|
// entity's origin is used. Either is offset by the m_vecViewOffset to get the eye position.
|
|
// From the eye position, we set up the PAS and PVS to use for filtering network messages to the client. At this point, we could
|
|
// override the actual PAS or PVS values, or use a different origin.
|
|
// NOTE: Do not cache the values of pas and pvs, as they depend on reusable memory in the engine, they are only good for this one frame
|
|
// Input : *pViewEntity -
|
|
// *pClient -
|
|
// **pvs -
|
|
// **pas -
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::ClientSetupVisibility( edict_t *pViewEntity, edict_t *pClient, unsigned char *pvs, int pvssize )
|
|
{
|
|
Vector org;
|
|
|
|
// Reset the PVS!!!
|
|
engine->ResetPVS( pvs, pvssize );
|
|
|
|
g_pToolFrameworkServer->PreSetupVisibility();
|
|
|
|
// Find the client's PVS
|
|
CBaseEntity *pVE = NULL;
|
|
if ( pViewEntity )
|
|
{
|
|
pVE = GetContainingEntity( pViewEntity );
|
|
// If we have a viewentity, it overrides the player's origin
|
|
if ( pVE )
|
|
{
|
|
org = pVE->EyePosition();
|
|
engine->AddOriginToPVS( org );
|
|
}
|
|
}
|
|
|
|
float fovDistanceAdjustFactor = 1;
|
|
|
|
CBasePlayer *pPlayer = ( CBasePlayer * )GetContainingEntity( pClient );
|
|
if ( pPlayer )
|
|
{
|
|
org = pPlayer->EyePosition();
|
|
pPlayer->SetupVisibility( pVE, pvs, pvssize );
|
|
UTIL_SetClientVisibilityPVS( pClient, pvs, pvssize );
|
|
fovDistanceAdjustFactor = pPlayer->GetFOVDistanceAdjustFactorForNetworking();
|
|
}
|
|
|
|
unsigned char portalBits[MAX_AREA_PORTAL_STATE_BYTES];
|
|
memset( portalBits, 0, sizeof( portalBits ) );
|
|
|
|
int portalNums[512];
|
|
int isOpen[512];
|
|
int iOutPortal = 0;
|
|
|
|
for( unsigned short i = g_AreaPortals.Head(); i != g_AreaPortals.InvalidIndex(); i = g_AreaPortals.Next(i) )
|
|
{
|
|
CFuncAreaPortalBase *pCur = g_AreaPortals[i];
|
|
|
|
bool bIsOpenOnClient = true;
|
|
|
|
// Update our array of which portals are open and flush it if necessary.
|
|
portalNums[iOutPortal] = pCur->m_portalNumber;
|
|
isOpen[iOutPortal] = pCur->UpdateVisibility( org, fovDistanceAdjustFactor, bIsOpenOnClient );
|
|
|
|
#ifdef PORTAL
|
|
// If the client doesn't need this open, test if portals might need this area portal open
|
|
if ( isOpen[iOutPortal] == 0 )
|
|
{
|
|
isOpen[iOutPortal] = TestAreaPortalVisibilityThroughPortals( pCur, pViewEntity, pvs, pvssize );
|
|
}
|
|
#endif
|
|
|
|
++iOutPortal;
|
|
if ( iOutPortal >= ARRAYSIZE( portalNums ) )
|
|
{
|
|
engine->SetAreaPortalStates( portalNums, isOpen, iOutPortal );
|
|
iOutPortal = 0;
|
|
}
|
|
|
|
// Version 0 portals (ie: shipping Half-Life 2 era) are always treated as open
|
|
// for purposes of the m_chAreaPortalBits array on the client.
|
|
if ( pCur->m_iPortalVersion == 0 )
|
|
bIsOpenOnClient = true;
|
|
|
|
if ( bIsOpenOnClient )
|
|
{
|
|
if ( pCur->m_portalNumber < 0 )
|
|
continue;
|
|
else if ( pCur->m_portalNumber >= sizeof( portalBits ) * 8 )
|
|
Error( "ClientSetupVisibility: portal number (%d) too large", pCur->m_portalNumber );
|
|
else
|
|
portalBits[pCur->m_portalNumber >> 3] |= (1 << (pCur->m_portalNumber & 7));
|
|
}
|
|
}
|
|
|
|
// Flush the remaining areaportal states.
|
|
engine->SetAreaPortalStates( portalNums, isOpen, iOutPortal );
|
|
|
|
if ( pPlayer )
|
|
{
|
|
// Update the area bits that get sent to the client.
|
|
pPlayer->m_Local.UpdateAreaBits( pPlayer, portalBits );
|
|
|
|
#ifdef PORTAL
|
|
// *After* the player's view has updated its area bits, add on any other areas seen by portals
|
|
CPortal_Player* pPortalPlayer = dynamic_cast<CPortal_Player*>( pPlayer );
|
|
if ( pPortalPlayer )
|
|
{
|
|
pPortalPlayer->UpdatePortalViewAreaBits( pvs, pvssize );
|
|
}
|
|
#endif //PORTAL
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *player -
|
|
// *buf -
|
|
// numcmds -
|
|
// totalcmds -
|
|
// dropped_packets -
|
|
// ignore -
|
|
// paused -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
#define CMD_MAXBACKUP 64
|
|
|
|
float CServerGameClients::ProcessUsercmds( edict_t *player, bf_read *buf, int numcmds, int totalcmds,
|
|
int dropped_packets, bool ignore, bool paused )
|
|
{
|
|
int i;
|
|
CUserCmd *from, *to;
|
|
|
|
// We track last three command in case we drop some
|
|
// packets but get them back.
|
|
CUserCmd cmds[ CMD_MAXBACKUP ];
|
|
|
|
CUserCmd cmdNull; // For delta compression
|
|
|
|
Assert( numcmds >= 0 );
|
|
Assert( ( totalcmds - numcmds ) >= 0 );
|
|
|
|
CBasePlayer *pPlayer = NULL;
|
|
CBaseEntity *pEnt = CBaseEntity::Instance(player);
|
|
if ( pEnt && pEnt->IsPlayer() )
|
|
{
|
|
pPlayer = static_cast< CBasePlayer * >( pEnt );
|
|
}
|
|
// Too many commands?
|
|
if ( totalcmds < 0 || totalcmds >= ( CMD_MAXBACKUP - 1 ) )
|
|
{
|
|
const char *name = "unknown";
|
|
if ( pPlayer )
|
|
{
|
|
name = pPlayer->GetPlayerName();
|
|
}
|
|
|
|
Msg("CBasePlayer::ProcessUsercmds: too many cmds %i sent for player %s\n", totalcmds, name );
|
|
// FIXME: Need a way to drop the client from here
|
|
//SV_DropClient ( host_client, false, "CMD_MAXBACKUP hit" );
|
|
buf->SetOverflowFlag();
|
|
return 0.0f;
|
|
}
|
|
|
|
// Initialize for reading delta compressed usercmds
|
|
cmdNull.Reset();
|
|
from = &cmdNull;
|
|
for ( i = totalcmds - 1; i >= 0; i-- )
|
|
{
|
|
to = &cmds[ i ];
|
|
ReadUsercmd( buf, to, from );
|
|
from = to;
|
|
}
|
|
|
|
// Client not fully connected or server has gone inactive or is paused, just ignore
|
|
if ( ignore || !pPlayer )
|
|
{
|
|
return 0.0f;
|
|
}
|
|
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
pPlayer->ProcessUsercmds( cmds, numcmds, totalcmds, dropped_packets, paused );
|
|
|
|
return TICK_INTERVAL;
|
|
}
|
|
|
|
|
|
void CServerGameClients::PostClientMessagesSent_DEPRECIATED( void )
|
|
{
|
|
}
|
|
|
|
// Sets the client index for the client who typed the command into his/her console
|
|
void CServerGameClients::SetCommandClient( int index )
|
|
{
|
|
g_nCommandClientIndex = index;
|
|
}
|
|
|
|
int CServerGameClients::GetReplayDelay( edict_t *pEdict, int &entity )
|
|
{
|
|
CBasePlayer *pPlayer = ( CBasePlayer * )CBaseEntity::Instance( pEdict );
|
|
|
|
if ( !pPlayer )
|
|
return 0;
|
|
|
|
entity = pPlayer->GetReplayEntity();
|
|
|
|
return pPlayer->GetDelayTicks();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The client's userinfo data lump has changed
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::ClientEarPosition( edict_t *pEdict, Vector *pEarOrigin )
|
|
{
|
|
CBasePlayer *pPlayer = ( CBasePlayer * )CBaseEntity::Instance( pEdict );
|
|
if (pPlayer)
|
|
{
|
|
*pEarOrigin = pPlayer->EarPosition();
|
|
}
|
|
else
|
|
{
|
|
// Shouldn't happen
|
|
Assert(0);
|
|
*pEarOrigin = vec3_origin;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *player -
|
|
// Output : CPlayerState
|
|
//-----------------------------------------------------------------------------
|
|
CPlayerState *CServerGameClients::GetPlayerState( edict_t *player )
|
|
{
|
|
// Is the client spawned yet?
|
|
if ( !player || !player->GetUnknown() )
|
|
return NULL;
|
|
|
|
CBasePlayer *pBasePlayer = ( CBasePlayer * )CBaseEntity::Instance( player );
|
|
if ( !pBasePlayer )
|
|
return NULL;
|
|
|
|
return &pBasePlayer->pl;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: 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
|
|
// Input : *buf -
|
|
// buflen -
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::GetBugReportInfo( char *buf, int buflen )
|
|
{
|
|
recentNPCSpeech_t speech[ SPEECH_LIST_MAX_SOUNDS ];
|
|
int num;
|
|
int i;
|
|
|
|
buf[ 0 ] = 0;
|
|
|
|
if ( gpGlobals->maxClients == 1 )
|
|
{
|
|
CBaseEntity *ent = FindPickerEntity( UTIL_PlayerByIndex(1) );
|
|
if ( ent )
|
|
{
|
|
Q_snprintf( buf, buflen, "Picker %i/%s - ent %s model %s\n",
|
|
ent->entindex(),
|
|
ent->GetClassname(),
|
|
STRING( ent->GetEntityName() ),
|
|
STRING( ent->GetModelName() ) );
|
|
}
|
|
|
|
// get any sounds that were spoken by NPCs recently
|
|
num = GetRecentNPCSpeech( speech );
|
|
if ( num > 0 )
|
|
{
|
|
Q_snprintf( buf, buflen, "%sRecent NPC speech:\n", buf );
|
|
for( i = 0; i < num; i++ )
|
|
{
|
|
Q_snprintf( buf, buflen, "%s time: %6.3f sound name: %s scene: %s\n", buf, speech[ i ].time, speech[ i ].name, speech[ i ].sceneName );
|
|
}
|
|
Q_snprintf( buf, buflen, "%sCurrent time: %6.3f\n", buf, gpGlobals->curtime );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A user has had their network id setup and validated
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameClients::NetworkIDValidated( const char *pszUserName, const char *pszNetworkID )
|
|
{
|
|
}
|
|
|
|
// The client has submitted a keyvalues command
|
|
void CServerGameClients::ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues )
|
|
{
|
|
if ( !pKeyValues )
|
|
return;
|
|
|
|
if ( g_pGameRules )
|
|
{
|
|
g_pGameRules->ClientCommandKeyValues( pEntity, pKeyValues );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static bf_write *g_pMsgBuffer = NULL;
|
|
|
|
void EntityMessageBegin( CBaseEntity * entity, bool reliable /*= false*/ )
|
|
{
|
|
Assert( !g_pMsgBuffer );
|
|
|
|
Assert ( entity );
|
|
|
|
g_pMsgBuffer = engine->EntityMessageBegin( entity->entindex(), entity->GetServerClass(), reliable );
|
|
}
|
|
|
|
void UserMessageBegin( IRecipientFilter& filter, const char *messagename )
|
|
{
|
|
Assert( !g_pMsgBuffer );
|
|
|
|
Assert( messagename );
|
|
|
|
int msg_type = usermessages->LookupUserMessage( messagename );
|
|
|
|
if ( msg_type == -1 )
|
|
{
|
|
Error( "UserMessageBegin: Unregistered message '%s'\n", messagename );
|
|
}
|
|
|
|
g_pMsgBuffer = engine->UserMessageBegin( &filter, msg_type );
|
|
}
|
|
|
|
void MessageEnd( void )
|
|
{
|
|
Assert( g_pMsgBuffer );
|
|
|
|
engine->MessageEnd();
|
|
|
|
g_pMsgBuffer = NULL;
|
|
}
|
|
|
|
void MessageWriteByte( int iValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WRITE_BYTE called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteByte( iValue );
|
|
}
|
|
|
|
void MessageWriteChar( int iValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WRITE_CHAR called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteChar( iValue );
|
|
}
|
|
|
|
void MessageWriteShort( int iValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WRITE_SHORT called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteShort( iValue );
|
|
}
|
|
|
|
void MessageWriteWord( int iValue )
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WRITE_WORD called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteWord( iValue );
|
|
}
|
|
|
|
void MessageWriteLong( int iValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteLong called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteLong( iValue );
|
|
}
|
|
|
|
void MessageWriteFloat( float flValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteFloat called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteFloat( flValue );
|
|
}
|
|
|
|
void MessageWriteAngle( float flValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteAngle called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteBitAngle( flValue, 8 );
|
|
}
|
|
|
|
void MessageWriteCoord( float flValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteCoord called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteBitCoord( flValue );
|
|
}
|
|
|
|
void MessageWriteVec3Coord( const Vector& rgflValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteVec3Coord called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteBitVec3Coord( rgflValue );
|
|
}
|
|
|
|
void MessageWriteVec3Normal( const Vector& rgflValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteVec3Normal called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteBitVec3Normal( rgflValue );
|
|
}
|
|
|
|
void MessageWriteAngles( const QAngle& rgflValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteVec3Normal called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteBitAngles( rgflValue );
|
|
}
|
|
|
|
void MessageWriteString( const char *sz )
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteString called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteString( sz );
|
|
}
|
|
|
|
void MessageWriteEntity( int iValue)
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteEntity called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteShort( iValue );
|
|
}
|
|
|
|
void MessageWriteEHandle( CBaseEntity *pEntity )
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteEHandle called with no active message\n" );
|
|
|
|
long iEncodedEHandle;
|
|
|
|
if( pEntity )
|
|
{
|
|
EHANDLE hEnt = pEntity;
|
|
|
|
int iSerialNum = hEnt.GetSerialNumber() & ( (1 << NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS) - 1 );
|
|
iEncodedEHandle = hEnt.GetEntryIndex() | (iSerialNum << MAX_EDICT_BITS);
|
|
}
|
|
else
|
|
{
|
|
iEncodedEHandle = INVALID_NETWORKED_EHANDLE_VALUE;
|
|
}
|
|
|
|
g_pMsgBuffer->WriteLong( iEncodedEHandle );
|
|
}
|
|
|
|
// bitwise
|
|
void MessageWriteBool( bool bValue )
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteBool called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteOneBit( bValue ? 1 : 0 );
|
|
}
|
|
|
|
void MessageWriteUBitLong( unsigned int data, int numbits )
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteUBitLong called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteUBitLong( data, numbits );
|
|
}
|
|
|
|
void MessageWriteSBitLong( int data, int numbits )
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteSBitLong called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteSBitLong( data, numbits );
|
|
}
|
|
|
|
void MessageWriteBits( const void *pIn, int nBits )
|
|
{
|
|
if (!g_pMsgBuffer)
|
|
Error( "WriteBits called with no active message\n" );
|
|
|
|
g_pMsgBuffer->WriteBits( pIn, nBits );
|
|
}
|
|
|
|
class CServerDLLSharedAppSystems : public IServerDLLSharedAppSystems
|
|
{
|
|
public:
|
|
CServerDLLSharedAppSystems()
|
|
{
|
|
AddAppSystem( "soundemittersystem" DLL_EXT_STRING, SOUNDEMITTERSYSTEM_INTERFACE_VERSION );
|
|
AddAppSystem( "scenefilecache" DLL_EXT_STRING, SCENE_FILE_CACHE_INTERFACE_VERSION );
|
|
}
|
|
|
|
virtual int Count()
|
|
{
|
|
return m_Systems.Count();
|
|
}
|
|
virtual char const *GetDllName( int idx )
|
|
{
|
|
return m_Systems[ idx ].m_pModuleName;
|
|
}
|
|
virtual char const *GetInterfaceName( int idx )
|
|
{
|
|
return m_Systems[ idx ].m_pInterfaceName;
|
|
}
|
|
private:
|
|
void AddAppSystem( char const *moduleName, char const *interfaceName )
|
|
{
|
|
AppSystemInfo_t sys;
|
|
sys.m_pModuleName = moduleName;
|
|
sys.m_pInterfaceName = interfaceName;
|
|
m_Systems.AddToTail( sys );
|
|
}
|
|
|
|
CUtlVector< AppSystemInfo_t > m_Systems;
|
|
};
|
|
|
|
EXPOSE_SINGLE_INTERFACE( CServerDLLSharedAppSystems, IServerDLLSharedAppSystems, SERVER_DLL_SHARED_APPSYSTEMS );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void CServerGameTags::GetTaggedConVarList( KeyValues *pCvarTagList )
|
|
{
|
|
if ( pCvarTagList && g_pGameRules )
|
|
{
|
|
g_pGameRules->GetTaggedConVarList( pCvarTagList );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#ifndef NO_STEAM
|
|
|
|
CSteamID GetSteamIDForPlayerIndex( int iPlayerIndex )
|
|
{
|
|
const CSteamID *pResult = engine->GetClientSteamIDByPlayerIndex( iPlayerIndex );
|
|
if ( pResult )
|
|
return *pResult;
|
|
|
|
// Return a bogus steam ID
|
|
return CSteamID();
|
|
}
|
|
|
|
#endif
|