source-engine/engine/sv_main.cpp

//
// Purpose:
//
// $Workfile:     $
// $NoKeywords: $
//===========================================================================//

#include "server_pch.h"
#include "decal.h"
#include "host_cmd.h"
#include "cmodel_engine.h"
#include "sv_log.h"
#include "zone.h"
#include "sound.h"
#include "vox.h"
#include "EngineSoundInternal.h"
#include "checksum_engine.h"
#include "host.h"
#include "keys.h"
#include "vengineserver_impl.h"
#include "sv_filter.h"
#include "pr_edict.h"
#include "screen.h"
#include "sys_dll.h"
#include "world.h"
#include "sv_main.h"
#include "networkstringtableserver.h"
#include "datamap.h"
#include "filesystem_engine.h"
#include "string_t.h"
#include "vstdlib/random.h"
#include "networkstringtable.h"
#include "dt_send_eng.h"
#include "sv_packedentities.h"
#include "testscriptmgr.h"
#include "PlayerState.h"
#include "saverestoretypes.h"
#include "tier0/vprof.h"
#include "proto_oob.h"
#include "staticpropmgr.h"
#include "checksum_crc.h"
#include "console.h"
#include "tier0/icommandline.h"
#include "gl_matsysiface.h"
#include "GameEventManager.h"
#ifndef SWDS
#include "vgui_baseui_interface.h"
#endif
#include "cbenchmark.h"
#include "client.h"
#include "hltvserver.h"
#include "replay_internal.h"
#include "replayserver.h"
#include "KeyValues.h"
#include "sv_logofile.h"
#include "cl_steamauth.h"
#include "sv_steamauth.h"
#include "sv_plugin.h"
#include "DownloadListGenerator.h"
#include "sv_steamauth.h"
#include "LocalNetworkBackdoor.h"
#include "cvar.h"
#include "enginethreads.h"
#include "tier1/functors.h"
#include "vstdlib/jobthread.h"
#include "pure_server.h"
#include "datacache/idatacache.h"
#include "filesystem/IQueuedLoader.h"
#include "vstdlib/jobthread.h"
#include "SourceAppInfo.h"
#include "cl_rcon.h"
#include "host_state.h"
#include "voice.h"
#include "cbenchmark.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#include "tier0/memalloc.h"

extern CNetworkStringTableContainer *networkStringTableContainerServer;
extern CNetworkStringTableContainer *networkStringTableContainerClient;
//void OnHibernateWhenEmptyChanged( IConVar *var, const char *pOldValue, float flOldValue );
//ConVar sv_hibernate_when_empty( "sv_hibernate_when_empty", "1", 0, "Puts the server into extremely low CPU usage mode when no clients connected", OnHibernateWhenEmptyChanged );
//ConVar sv_hibernate_ms( "sv_hibernate_ms", "20", 0, "# of milliseconds to sleep per frame while hibernating" );
//ConVar sv_hibernate_ms_vgui( "sv_hibernate_ms_vgui", "20", 0, "# of milliseconds to sleep per frame while hibernating but running the vgui dedicated server frontend" );
//static ConVar sv_hibernate_postgame_delay( "sv_hibernate_postgame_delay", "5", 0, "# of seconds to wait after final client leaves before hibernating.");
ConVar sv_shutdown_timeout_minutes( "sv_shutdown_timeout_minutes", "360", FCVAR_REPLICATED, "If sv_shutdown is pending, wait at most N minutes for server to drain before forcing shutdown." );

static double s_timeForceShutdown = 0.0;

extern ConVar deathmatch;
extern ConVar sv_sendtables;

// Server default maxplayers value
#define DEFAULT_SERVER_CLIENTS	6
// This many players on a Lan with same key, is ok.
#define MAX_IDENTICAL_CDKEYS	5

CGameServer	sv;

CGlobalVars g_ServerGlobalVariables( false );

static int	current_skill;

static void SV_CheatsChanged_f( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	ConVarRef var( pConVar );
	if ( var.GetInt() == 0 )
	{
		// cheats were disabled, revert all cheat cvars to their default values
		g_pCVar->RevertFlaggedConVars( FCVAR_CHEAT );

		DevMsg( "FCVAR_CHEAT cvars reverted to defaults.\n" );
	}
}

static bool g_sv_pure_waiting_on_reload = false;
static int g_sv_pure_mode = 0;
int GetSvPureMode()
{
	return g_sv_pure_mode;
}

static void SV_Pure_f( const CCommand &args )
{
    int pure_mode = -2;
    if ( args.ArgC() == 2 )
    {
        pure_mode = atoi( args[1] );
    }

    Msg( "--------------------------------------------------------\n" );
    if ( pure_mode >= -1 && pure_mode <= 2 )
    {
        // Not changing?
        if ( pure_mode == GetSvPureMode() )
        {
            Msg( "sv_pure value unchanged (current value is %d).\n", GetSvPureMode() );
        }
        else
        {

			// Set the value.
            g_sv_pure_mode = pure_mode;
            Msg( "sv_pure set to %d.\n", g_sv_pure_mode );

            if ( sv.IsActive() )
            {
				g_sv_pure_waiting_on_reload = true;
            }
        }
    }
    else
    {
        Msg( "sv_pure: Only allow client to use certain files.\n"
			"\n"
            "  -1 - Do not apply any rules or restrict which files the client may load.\n"
            "   0 - Apply rules in cfg/pure_server_minimal.txt only.\n"
            "   1 - Apply rules in cfg/pure_server_full.txt and then cfg/pure_server_whitelist.txt.\n"
            "   2 - Apply rules in cfg/pure_server_full.txt.\n"
            "\n"
            "   See cfg/pure_server_whitelist_example.txt for more details.\n"
		);
    }

    if ( pure_mode == -2 )
    {
        // If we're a client on a server with sv_pure = 1, display the current whitelist.
#ifndef DEDICATED
        if ( cl.IsConnected() )
        {
            Msg( "\n\n" );
            extern void CL_PrintWhitelistInfo(); // from cl_main.cpp
            CL_PrintWhitelistInfo();
        }
        else
#endif
        {
            Msg( "\nCurrent sv_pure value is %d.\n", GetSvPureMode() );
        }
    }
	if ( sv.IsActive() && g_sv_pure_waiting_on_reload )
	{
		Msg( "Note: Waiting for the next changelevel to apply the current value.\n" );
	}
    Msg( "--------------------------------------------------------\n" );
}

static ConCommand sv_pure( "sv_pure", SV_Pure_f, "Show user data." );

ConVar	sv_pure_kick_clients( "sv_pure_kick_clients", "1", 0, "If set to 1, the server will kick clients with mismatching files. Otherwise, it will issue a warning to the client." );
ConVar	sv_pure_trace( "sv_pure_trace", "0", 0, "If set to 1, the server will print a message whenever a client is verifying a CRC for a file." );
ConVar	sv_pure_consensus( "sv_pure_consensus", "5", 0, "Minimum number of file hashes to agree to form a consensus." );
ConVar	sv_pure_retiretime( "sv_pure_retiretime", "900", 0, "Seconds of server idle time to flush the sv_pure file hash cache." );

ConVar  sv_cheats( "sv_cheats", "0", FCVAR_NOTIFY|FCVAR_REPLICATED, "Allow cheats on server", SV_CheatsChanged_f );
ConVar  sv_lan( "sv_lan", "0", 0, "Server is a lan server ( no heartbeat, no authentication, no non-class C addresses )" );



static	ConVar sv_pausable( "sv_pausable","0", FCVAR_NOTIFY, "Is the server pausable." );
static	ConVar sv_contact( "sv_contact", "", FCVAR_NOTIFY, "Contact email for server sysop" );
static	ConVar sv_cacheencodedents("sv_cacheencodedents", "1", 0, "If set to 1, does an optimization to prevent extra SendTable_Encode calls.");
static	ConVar sv_voiceenable( "sv_voiceenable", "1", FCVAR_ARCHIVE|FCVAR_NOTIFY ); // set to 0 to disable all voice forwarding.
		ConVar sv_downloadurl( "sv_downloadurl", "", FCVAR_REPLICATED, "Location from which clients can download missing files" );
		ConVar sv_maxreplay("sv_maxreplay", "0", 0, "Maximum replay time in seconds", true, 0, true, 15 );

static ConVar sv_consistency( "sv_consistency", "1", FCVAR_REPLICATED, "Legacy variable with no effect!  This was deleted and then added as a temporary kludge to prevent players from being banned by servers running old versions of SMAC" );

/// XXX(JohnS): When steam voice gets ugpraded to Opus we will probably default back to steam.  At that time we should
///             note that Steam voice is the highest quality codec below.
static ConVar sv_voicecodec( "sv_voicecodec", "vaudio_opus", 0,
                             "Specifies which voice codec to use. Valid options are:\n"
                             "vaudio_speex - Legacy Speex codec (lowest quality)\n"
                             "vaudio_celt - Newer CELT codec\n"
							 "vaudio_opus - Latest Opus codec (highest quality, comes by default)\n"
                             "steam - Use Steam voice API" );


ConVar  sv_mincmdrate( "sv_mincmdrate", "20", FCVAR_REPLICATED, "This sets the minimum value for cl_cmdrate. 0 == unlimited." );
ConVar  sv_maxcmdrate( "sv_maxcmdrate", "100", FCVAR_REPLICATED, "(If sv_mincmdrate is > 0), this sets the maximum value for cl_cmdrate." );
ConVar  sv_client_cmdrate_difference( "sv_client_cmdrate_difference", "20", FCVAR_REPLICATED, 
	"cl_cmdrate is moved to within sv_client_cmdrate_difference units of cl_updaterate before it "
	"is clamped between sv_mincmdrate and sv_maxcmdrate." );

ConVar  sv_client_min_interp_ratio( "sv_client_min_interp_ratio", "1", FCVAR_REPLICATED, 
								   "This can be used to limit the value of cl_interp_ratio for connected clients "
								   "(only while they are connected).\n"
								   "              -1 = let clients set cl_interp_ratio to anything\n"
								   " any other value = set minimum value for cl_interp_ratio"
								   );
ConVar  sv_client_max_interp_ratio( "sv_client_max_interp_ratio", "5", FCVAR_REPLICATED, 
								   "This can be used to limit the value of cl_interp_ratio for connected clients "
								   "(only while they are connected). If sv_client_min_interp_ratio is -1, "
								   "then this cvar has no effect."
								   );
ConVar  sv_client_predict( "sv_client_predict", "-1", FCVAR_REPLICATED, 
	"This can be used to force the value of cl_predict for connected clients "
	"(only while they are connected).\n"
	"   -1 = let clients set cl_predict to anything\n"
	"    0 = force cl_predict to 0\n"
	"    1 = force cl_predict to 1"
	);

ConVar  sv_restrict_aspect_ratio_fov( "sv_restrict_aspect_ratio_fov", "1", FCVAR_REPLICATED, 
									 "This can be used to limit the effective FOV of users using wide-screen\n"
									 "resolutions with aspect ratios wider than 1.85:1 (slightly wider than 16:9).\n"
									 "    0 = do not cap effective FOV\n"
									 "    1 = limit the effective FOV on windowed mode users using resolutions\n"
									 "        greater than 1.85:1\n"
									 "    2 = limit the effective FOV on both windowed mode and full-screen users\n",
									 true, 0, true, 2);

void OnTVEnablehanged( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	ConVarRef var( pConVar );

/*
	ConVarRef replay_enable( "replay_enable" );
	if ( var.GetBool() && replay_enable.IsValid() && replay_enable.GetBool() )
	{
		var.SetValue( 0 );
		Warning( "Error: Replay is enabled.  Please disable Replay if you wish to enable SourceTV.\n" );
		return;
	}
*/

	//Let's check maxclients and make sure we have room for SourceTV
	if ( var.GetBool() == true )
	{
		sv.InitMaxClients();
	}
}

ConVar tv_enable( "tv_enable", "0", FCVAR_NOTIFY, "Activates SourceTV on server.", OnTVEnablehanged );

extern ConVar *sv_noclipduringpause;

static bool s_bForceSend = false;

void SV_ForceSend()
{
	s_bForceSend = true;
}

bool g_FlushMemoryOnNextServer;
int g_FlushMemoryOnNextServerCounter;

void SV_FlushMemoryOnNextServer()
{
	g_FlushMemoryOnNextServer = true;
	g_FlushMemoryOnNextServerCounter++;
}

// Prints important entity creation/deletion events to console
#if defined( _DEBUG )
ConVar  sv_deltatrace( "sv_deltatrace", "0", 0, "For debugging, print entity creation/deletion info to console." );
#define TRACE_DELTA( text ) if ( sv_deltatrace.GetInt() ) { ConMsg( text ); };
#else
#define TRACE_DELTA( funcs )
#endif


#if defined( DEBUG_NETWORKING )

//-----------------------------------------------------------------------------
// Opens the recording file
//-----------------------------------------------------------------------------

static FILE* OpenRecordingFile()
{
	FILE* fp = 0;
	static bool s_CantOpenFile = false;
	static bool s_NeverOpened = true;
	if (!s_CantOpenFile)
	{
		fp = fopen( "svtrace.txt", s_NeverOpened ? "wt" : "at" );
		if (!fp)
		{
			s_CantOpenFile = true;
		}
		s_NeverOpened = false;
	}
	return fp;
}

//-----------------------------------------------------------------------------
// Records an argument for a command, flushes when the command is done
//-----------------------------------------------------------------------------
/*
void SpewToFile( char const* pFmt, ... )
static void SpewToFile( const char* pFmt, ... )
{
	static CUtlVector<unsigned char> s_RecordingBuffer;

	char temp[2048];
	va_list args;

	va_start( args, pFmt );
	int len = Q_vsnprintf( temp, sizeof( temp ), pFmt, args );
	va_end( args );
	Assert( len < 2048 );

	int idx = s_RecordingBuffer.AddMultipleToTail( len );
	memcpy( &s_RecordingBuffer[idx], temp, len );
	if ( 1 ) //s_RecordingBuffer.Size() > 8192)
	{
		FILE* fp = OpenRecordingFile();
		fwrite( s_RecordingBuffer.Base(), 1, s_RecordingBuffer.Size(), fp );
		fclose( fp );

		s_RecordingBuffer.RemoveAll();
	}
}
*/

#endif // #if defined( DEBUG_NETWORKING )


/*void SV_Init(bool isDedicated)
{
	sv.Init( isDedicated );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void SV_Shutdown( void )
{
	sv.Shutdown();
}*/

void CGameServer::Clear( void )
{
	m_pModelPrecacheTable = NULL;
	m_pGenericPrecacheTable = NULL;
	m_pSoundPrecacheTable = NULL;
	m_pDecalPrecacheTable = NULL;
	m_pDynamicModelsTable = NULL;
	m_bIsLevelMainMenuBackground = false;

	m_bLoadgame = false;
	
	host_state.SetWorldModel( NULL );	

	Q_memset( m_szStartspot, 0, sizeof( m_szStartspot ) );
	
	num_edicts = 0;
	max_edicts = 0;
	free_edicts = 0;
	edicts = NULL;
	
	// Clear the instance baseline indices in the ServerClasses.
	if ( serverGameDLL )
	{
		for( ServerClass *pCur = serverGameDLL->GetAllServerClasses(); pCur; pCur=pCur->m_pNext )
		{
			pCur->m_InstanceBaselineIndex = INVALID_STRING_INDEX;
		}
	}

	for ( int i = 0; i < m_TempEntities.Count(); i++ )
	{
		delete m_TempEntities[i];
	}

	m_TempEntities.Purge();

	CBaseServer::Clear();
}



//-----------------------------------------------------------------------------
// Purpose: Create any client/server string tables needed internally by the engine
//-----------------------------------------------------------------------------
void CGameServer::CreateEngineStringTables( void )
{
	int i,j;

	m_StringTables->SetTick( m_nTickCount ); // set first tick

	bool bUseFilenameTables = false;	

	char szDownloadableFileTablename[255] = DOWNLOADABLE_FILE_TABLENAME;
	char szModelPrecacheTablename[255] = MODEL_PRECACHE_TABLENAME;
	char szGenericPrecacheTablename[255] = GENERIC_PRECACHE_TABLENAME;
	char szSoundPrecacheTablename[255] = SOUND_PRECACHE_TABLENAME;
	char szDecalPrecacheTablename[255] = DECAL_PRECACHE_TABLENAME;

	// This was added into staging at some point and is not enabled in main or rel.
	if ( 0 )
	{
		bUseFilenameTables = true;
		Q_snprintf( szDownloadableFileTablename, 255, ":%s", DOWNLOADABLE_FILE_TABLENAME );
		Q_snprintf( szModelPrecacheTablename, 255, ":%s", MODEL_PRECACHE_TABLENAME );
		Q_snprintf( szGenericPrecacheTablename, 255, ":%s", GENERIC_PRECACHE_TABLENAME );
		Q_snprintf( szSoundPrecacheTablename, 255, ":%s", SOUND_PRECACHE_TABLENAME );
		Q_snprintf( szDecalPrecacheTablename, 255, ":%s", DECAL_PRECACHE_TABLENAME );		
	} 	

	m_pDownloadableFileTable = m_StringTables->CreateStringTableEx( 
		szDownloadableFileTablename, 
		MAX_DOWNLOADABLE_FILES,
		0,
		0,
		bUseFilenameTables );

	m_pModelPrecacheTable = m_StringTables->CreateStringTableEx( 
		szModelPrecacheTablename, 
		MAX_MODELS,
		sizeof ( CPrecacheUserData ),
		PRECACHE_USER_DATA_NUMBITS,
		bUseFilenameTables );

	m_pGenericPrecacheTable = m_StringTables->CreateStringTableEx(
		szGenericPrecacheTablename,
		MAX_GENERIC,
		sizeof ( CPrecacheUserData ),
		PRECACHE_USER_DATA_NUMBITS,
		bUseFilenameTables );

	m_pSoundPrecacheTable = m_StringTables->CreateStringTableEx(
		szSoundPrecacheTablename,
		MAX_SOUNDS,
		sizeof ( CPrecacheUserData ),
		PRECACHE_USER_DATA_NUMBITS,
		bUseFilenameTables );

	m_pDecalPrecacheTable = m_StringTables->CreateStringTableEx(
		szDecalPrecacheTablename,
		MAX_BASE_DECALS,
		sizeof ( CPrecacheUserData ),
		PRECACHE_USER_DATA_NUMBITS,
		bUseFilenameTables );

	m_pInstanceBaselineTable = m_StringTables->CreateStringTable(
		INSTANCE_BASELINE_TABLENAME,
		MAX_DATATABLES );

	m_pLightStyleTable = m_StringTables->CreateStringTable( 
		LIGHT_STYLES_TABLENAME, 
		MAX_LIGHTSTYLES );

	m_pUserInfoTable = m_StringTables->CreateStringTable(
		USER_INFO_TABLENAME,
		1<<ABSOLUTE_PLAYER_LIMIT_DW ); // make it a power of 2

	// Fixed-size user data; bit value of either 0 or 1.
	m_pDynamicModelsTable = m_StringTables->CreateStringTable( "DynamicModels", 2048, true, 1 );

	// Send the query info..
	m_pServerStartupTable = m_StringTables->CreateStringTable( 
		SERVER_STARTUP_DATA_TABLENAME,
		4 );
	SetQueryPortFromSteamServer();
	CopyPureServerWhitelistToStringTable();

	Assert ( m_pModelPrecacheTable && 
			 m_pGenericPrecacheTable &&
			 m_pSoundPrecacheTable &&
			 m_pDecalPrecacheTable &&
			 m_pInstanceBaselineTable &&
			 m_pLightStyleTable &&
			 m_pUserInfoTable &&
			 m_pServerStartupTable &&
			 m_pDownloadableFileTable &&
			 m_pDynamicModelsTable );

	// create an empty lightstyle table with unique index names
	for ( i = 0; i<MAX_LIGHTSTYLES; i++ )
	{
		char name[8]; Q_snprintf( name, 8, "%i", i );
		j = m_pLightStyleTable->AddString( true, name );
		Assert( j==i ); // indices must match 
	}

	for ( i = 0; i<GetMaxClients(); i++ )
	{
		char name[8]; Q_snprintf( name, 8, "%i", i );
		j = m_pUserInfoTable->AddString( true, name );
		Assert( j==i ); // indices must match 
	}

	// set up the downloadable files generator
	DownloadListGenerator().SetStringTable( m_pDownloadableFileTable );
}

void CGameServer::SetQueryPortFromSteamServer()
{
	if ( !m_pServerStartupTable )
		return;
		
	int queryPort = Steam3Server().GetQueryPort();
	m_pServerStartupTable->AddString( true, "QueryPort", sizeof( queryPort ), &queryPort );
}

void CGameServer::CopyPureServerWhitelistToStringTable()
{
	if ( !m_pPureServerWhitelist )
		return;
	
	CUtlBuffer buf;
	m_pPureServerWhitelist->Encode( buf );
	m_pServerStartupTable->AddString( true, "PureServerWhitelist", buf.TellPut(), buf.Base() );
}


void SV_InstallClientStringTableMirrors( void )
{
#ifndef SWDS
#ifndef SHARED_NET_STRING_TABLES

	int numTables = networkStringTableContainerServer->GetNumTables();

	for ( int i =0; i<numTables; i++)
	{
		// iterate through server tables
		CNetworkStringTable *serverTable = 
			(CNetworkStringTable*)networkStringTableContainerServer->GetTable( i );

		if ( !serverTable )
			continue;

		// get mathcing client table
		CNetworkStringTable *clientTable = 
			(CNetworkStringTable*)networkStringTableContainerClient->FindTable( serverTable->GetTableName() );

		if ( !clientTable )
		{
			DevMsg("SV_InstallClientStringTableMirrors! Missing client table \"%s\".\n ", serverTable->GetTableName() );
			continue;
		}

		// link client table to server table
		serverTable->SetMirrorTable( clientTable );
	}
#endif
#endif
}



//-----------------------------------------------------------------------------
// user <name or userid>
//
// Dump userdata / masterdata for a user
//-----------------------------------------------------------------------------
CON_COMMAND( user, "Show user data." )
{
	int		uid;
	int		i;
	
	if ( !sv.IsActive() )
	{
		ConMsg( "Can't 'user', not running a server\n" );
		return;
	}

	if (args.ArgC() != 2)
	{
		ConMsg ("Usage: user <username / userid>\n");
		return;
	}

	uid = atoi(args[1]);

	for (i=0 ; i< sv.GetClientCount() ; i++)
	{
		IClient *pClient = sv.GetClient( i );

		if ( !pClient->IsConnected() )
			continue;

		if ( (pClient->GetPlayerSlot()== uid ) || !Q_strcmp( pClient->GetClientName(), args[1]) )
		{
			ConMsg ("TODO: SV_User_f.\n");
			return;
		}
	}

	ConMsg ("User not in server.\n");
}


//-----------------------------------------------------------------------------
// Dump userids for all current players
//-----------------------------------------------------------------------------
CON_COMMAND( users, "Show user info for players on server." )
{
	if ( !sv.IsActive() )
	{
		ConMsg( "Can't 'users', not running a server\n" );
		return;
	}

	int c = 0;
	ConMsg ("<slot:userid:\"name\">\n");
	for ( int i=0 ; i< sv.GetClientCount() ; i++ )
	{
		IClient *pClient = sv.GetClient( i );

		if ( pClient->IsConnected() )
		{
			ConMsg ("%i:%i:\"%s\"\n", pClient->GetPlayerSlot(), pClient->GetUserID(), pClient->GetClientName() );
			c++;
		}
	}

	ConMsg ( "%i users\n", c );
}

//-----------------------------------------------------------------------------
// Purpose: Determine the value of sv.maxclients
//-----------------------------------------------------------------------------
bool CL_IsHL2Demo(); // from cl_main.cpp
bool CL_IsPortalDemo(); // from cl_main.cpp

extern ConVar tv_enable;

void SetupMaxPlayers( int iDesiredMaxPlayers )
{
	int minmaxplayers = 1;
	int maxmaxplayers = ABSOLUTE_PLAYER_LIMIT;
	int defaultmaxplayers = 1;

	if ( serverGameClients )
	{
		serverGameClients->GetPlayerLimits( minmaxplayers, maxmaxplayers, defaultmaxplayers );

		if ( minmaxplayers < 1 )
		{
			Sys_Error( "GetPlayerLimits:  min maxplayers must be >= 1 (%i)", minmaxplayers );
		}
		else if ( defaultmaxplayers < 1 )
		{
			Sys_Error( "GetPlayerLimits:  default maxplayers must be >= 1 (%i)", minmaxplayers );
		}

		if ( minmaxplayers > maxmaxplayers || defaultmaxplayers > maxmaxplayers )
		{
			Sys_Error( "GetPlayerLimits:  min maxplayers %i > max %i", minmaxplayers, maxmaxplayers );
		}

		if ( maxmaxplayers > ABSOLUTE_PLAYER_LIMIT )
		{
			Sys_Error( "GetPlayerLimits:  max players limited to %i", ABSOLUTE_PLAYER_LIMIT );
		}
	}

	// Determine absolute limit
	sv.m_nMaxClientsLimit = maxmaxplayers;

	// Check for command line override
	int newmaxplayers = iDesiredMaxPlayers;

	if ( newmaxplayers >= 1 )
	{
		// Never go above what the game .dll can handle
		newmaxplayers	= min( newmaxplayers, maxmaxplayers );
		sv.m_nMaxClientsLimit	= newmaxplayers;
	}
	else
	{
		newmaxplayers	= defaultmaxplayers;
	}

#if defined( REPLAY_ENABLED )
	if ( Replay_IsSupportedModAndPlatform() && CommandLine()->CheckParm( "-replay" ) )
	{
		newmaxplayers += 1;
		sv.m_nMaxClientsLimit += 1;
	}
#endif

	if ( tv_enable.GetBool() )
	{
		newmaxplayers += 1;
		sv.m_nMaxClientsLimit += 1;
	}

	newmaxplayers = clamp( newmaxplayers, minmaxplayers, sv.m_nMaxClientsLimit );

	if ( ( CL_IsHL2Demo() || CL_IsPortalDemo() ) && !sv.IsDedicated() )
	{
		newmaxplayers = 1;
		sv.m_nMaxClientsLimit = 1;
	}

	if ( sv.GetMaxClients() < newmaxplayers || !tv_enable.GetBool() )
		sv.SetMaxClients( newmaxplayers );

}

void CGameServer::InitMaxClients( void )
{
	int newmaxplayers = CommandLine()->ParmValue( "-maxplayers", -1 );
	if ( newmaxplayers == -1 )
	{
		newmaxplayers = CommandLine()->ParmValue( "+maxplayers", -1 );
	}

	SetupMaxPlayers( newmaxplayers );
}

//-----------------------------------------------------------------------------
// Purpose: Changes the maximum # of players allowed on the server.
//  Server cannot be running when command is issued.
//-----------------------------------------------------------------------------
CON_COMMAND( maxplayers, "Change the maximum number of players allowed on this server." )
{
	if ( args.ArgC () != 2 )
	{
		ConMsg ("\"maxplayers\" is \"%u\"\n", sv.GetMaxClients() );
		return;
	}

	if ( sv.IsActive() )
	{
		ConMsg( "Cannot change maxplayers while the server is running\n");
		return;
	}

	SetupMaxPlayers( Q_atoi( args[ 1 ] ) );
}

int SV_BuildSendTablesArray( ServerClass *pClasses, SendTable **pTables, int nMaxTables )
{
        int nTables = 0;

        for( ServerClass *pCur=pClasses; pCur; pCur=pCur->m_pNext )
        {
                ErrorIfNot( nTables < nMaxTables, ("SV_BuildSendTablesArray: too many SendTables!") );
                pTables[nTables] = pCur->m_pTable;
                ++nTables;
        }

        return nTables;
}


// Builds an alternate copy of the datatable for any classes that have datatables with props excluded.
void SV_InitSendTables( ServerClass *pClasses )
{
	SendTable *pTables[MAX_DATATABLES];
	int nTables = SV_BuildSendTablesArray( pClasses, pTables, ARRAYSIZE( pTables ) );

	SendTable_Init( pTables, nTables );
}


void SV_TermSendTables( ServerClass *pClasses )
{
	SendTable_Term();
}


//-----------------------------------------------------------------------------
// Purpose: returns which games/mods we're allowed to play
//-----------------------------------------------------------------------------
struct ModDirPermissions_t
{
	int m_iAppID;
	const char *m_pchGameDir;
};

static ModDirPermissions_t g_ModDirPermissions[] =
{
	{ GetAppSteamAppId( k_App_CSS ),        GetAppModName( k_App_CSS ) },
	{ GetAppSteamAppId( k_App_DODS ),       GetAppModName( k_App_DODS ) },
	{ GetAppSteamAppId( k_App_HL2MP ),      GetAppModName( k_App_HL2MP ) },
	{ GetAppSteamAppId( k_App_LOST_COAST ), GetAppModName( k_App_LOST_COAST ) },
	{ GetAppSteamAppId( k_App_HL1DM ),      GetAppModName( k_App_HL1DM ) },
	{ GetAppSteamAppId( k_App_PORTAL ),     GetAppModName( k_App_PORTAL ) },
	{ GetAppSteamAppId( k_App_HL2 ),        GetAppModName( k_App_HL2 ) },
	{ GetAppSteamAppId( k_App_HL2_EP1 ),    GetAppModName( k_App_HL2_EP1 ) },
	{ GetAppSteamAppId( k_App_HL2_EP2 ),    GetAppModName( k_App_HL2_EP2 ) },
	{ GetAppSteamAppId( k_App_TF2 ),        GetAppModName( k_App_TF2 ) },
};

bool ServerDLL_Load( bool bIsServerOnly )
{
	// Load in the game .dll
	LoadEntityDLLs( GetBaseDirectory(), bIsServerOnly );
	return true;
}

void ServerDLL_Unload()
{
	UnloadEntityDLLs();
}

#if !defined(DEDICATED)
#if !defined(_X360)
// Put this function declaration at global scope to avoid the ambiguity of the most vexing parse.
bool CL_IsHL2Demo();
#endif
#endif

//-----------------------------------------------------------------------------
// Purpose: Loads the game .dll
//-----------------------------------------------------------------------------
void SV_InitGameDLL( void )
{
	// Clear out the command buffer.
	Cbuf_Execute();

	// Don't initialize a second time
	if ( sv.dll_initialized )
	{
		return;
	}

#if !defined(SWDS)
#if !defined(_X360)
	if ( CL_IsHL2Demo() && !sv.IsDedicated() && Q_stricmp( COM_GetModDirectory(), "hl2" ) )
	{
		Error( "The HL2 demo is unable to run Mods.\n" );
		return;			
	} 

	if ( CL_IsPortalDemo() && !sv.IsDedicated() && Q_stricmp( COM_GetModDirectory(), "portal" ) )
	{
		Error( "The Portal demo is unable to run Mods.\n" );
		return;			
	} 

	// check permissions
	if ( Steam3Client().SteamApps() && !CL_IsHL2Demo() && !CL_IsPortalDemo() )
	{
		bool bVerifiedMod = false;

        // find the game dir we're running
		for ( int i = 0; i < ARRAYSIZE( g_ModDirPermissions ); i++ )
		{
			if ( !Q_stricmp( COM_GetModDirectory(), g_ModDirPermissions[i].m_pchGameDir ) )
			{
				// we've found the mod, make sure we own the app
				if (  Steam3Client().SteamApps()->BIsSubscribedApp( g_ModDirPermissions[i].m_iAppID ) )
				{
					bVerifiedMod = true;
				}
				else
				{
					Error( "No permissions to run '%s'\n", COM_GetModDirectory() );
					return;			
				}

				break;
			}
		}

		if ( !bVerifiedMod )
		{
			// make sure they can run the Source engine
			if ( ! Steam3Client().SteamApps()->BIsSubscribedApp( 215  ) )
			{
				Error( "A Source engine game is required to run mods\n" );
				return;
			}
		}
	}

#endif // _X360
#endif

	COM_TimestampedLog( "SV_InitGameDLL" );

	if ( !serverGameDLL )
	{
		Warning( "Failed to load server binary\n" );
		return;
	}

	// Flag that we've started the game .dll
	sv.dll_initialized = true;

	COM_TimestampedLog( "serverGameDLL->DLLInit" );

	// Tell the game DLL to start up
	if(!serverGameDLL->DLLInit(g_AppSystemFactory, g_AppSystemFactory, g_AppSystemFactory, &g_ServerGlobalVariables))
	{
		Host_Error("IDLLFunctions::DLLInit returned false.\n");
	}

	if ( CommandLine()->FindParm( "-NoLoadPluginsForClient" ) == 0 )
		g_pServerPluginHandler->LoadPlugins(); // load 3rd party plugins
	

	// let's not have any servers with no name
	if ( host_name.GetString()[0] == 0 )
	{
		host_name.SetValue( serverGameDLL->GetGameDescription() );
	}

	sv_noclipduringpause = ( ConVar * )g_pCVar->FindVar( "sv_noclipduringpause" );

	COM_TimestampedLog( "SV_InitSendTables" );

	// Make extra copies of data tables if they have SendPropExcludes.
	SV_InitSendTables( serverGameDLL->GetAllServerClasses() );

	host_state.interval_per_tick = serverGameDLL->GetTickInterval();
	if ( host_state.interval_per_tick < MINIMUM_TICK_INTERVAL ||
		 host_state.interval_per_tick > MAXIMUM_TICK_INTERVAL )
	{
		Sys_Error( "GetTickInterval returned bogus tick interval (%f)[%f to %f is valid range]", host_state.interval_per_tick,
			MINIMUM_TICK_INTERVAL, MAXIMUM_TICK_INTERVAL );
	}

	// set maxclients limit based on Mod or commandline settings
	sv.InitMaxClients();

	// Execute and server commands the game .dll added at startup
	Cbuf_Execute();

#if defined( REPLAY_ENABLED )
	extern IReplaySystem *g_pReplay;
	if ( Replay_IsSupportedModAndPlatform() && sv.IsDedicated() )
	{
		if ( !serverGameDLL->ReplayInit( g_fnReplayFactory ) )
		{
			Sys_Error( "Server replay init failed" );
		}

		if ( sv.IsDedicated() && !g_pReplay->SV_Init( g_ServerFactory ) )
		{
			Sys_Error( "Replay system server init failed!" ); 
		}
	}
#endif
}

//
// Release resources associated with extension DLLs.
//
void SV_ShutdownGameDLL( void )
{
	if ( !sv.dll_initialized )
	{
		return;
	}

	if ( g_pReplay )
	{
		g_pReplay->SV_Shutdown();
	}

	// Delete any extra SendTable copies we've attached to the game DLL's classes, if any.
	SV_TermSendTables( serverGameDLL->GetAllServerClasses() );
	g_pServerPluginHandler->UnloadPlugins();
	serverGameDLL->DLLShutdown();

	UnloadEntityDLLs();

	sv.dll_initialized = false;
}


ServerClass* SV_FindServerClass( const char *pName )
{
	ServerClass *pCur = serverGameDLL->GetAllServerClasses();
	while ( pCur )
	{
		if ( Q_stricmp( pCur->GetName(), pName ) == 0 )
			return pCur;

		pCur = pCur->m_pNext;
	}
	
	return NULL;
}

ServerClass* SV_FindServerClass( int index )
{
	ServerClass *pCur = serverGameDLL->GetAllServerClasses();
	int count = 0;

	while ( (count < index) && (pCur != NULL) )
	{
		count++;
		pCur = pCur->m_pNext;
	}

	return pCur;
}

//-----------------------------------------------------------------------------
// Purpose: General initialization of the server
//-----------------------------------------------------------------------------
void CGameServer::Init (bool isDedicated)
{
	CBaseServer::Init( isDedicated );

	m_FullSendTables.SetDebugName( "m_FullSendTables" );
	
	dll_initialized = false;
}

bool CGameServer::IsPausable( void ) const
{
	// In single-player, they can always pause it. In multiplayer, check the cvar.
	if ( IsMultiplayer() )
	{
		return sv_pausable.GetBool();
	}
	else
	{
		return true;
	}
}

void CGameServer::Shutdown( void )
{
	m_bIsLevelMainMenuBackground = false;

	CBaseServer::Shutdown();

	// Actually performs a shutdown.
	framesnapshotmanager->LevelChanged();

	IGameEvent *event = g_GameEventManager.CreateEvent( "server_shutdown" );

	if ( event )
	{
		event->SetString( "reason", "quit" );
		g_GameEventManager.FireEvent( event );
	}

	Steam3Server().Shutdown();

	if ( serverGameDLL && g_iServerGameDLLVersion >= 7 )
	{
		serverGameDLL->GameServerSteamAPIShutdown();
	}

	// Log_Printf( "Server shutdown.\n" );
	g_Log.Close();
}


/*
==================
SV_StartSound

Each entity can have eight independant sound sources, like voice,
weapon, feet, etc.

Channel 0 is an auto-allocate channel, the others override anything
allready running on that entity/channel pair.

An attenuation of 0 will play full volume everywhere in the level.
Larger attenuations will drop off.  (max 4 attenuation)

Pitch should be PITCH_NORM (100) for no pitch shift. Values over 100 (up to 255)
shift pitch higher, values lower than 100 lower the pitch.
==================
*/
void SV_StartSound ( IRecipientFilter& filter, edict_t *pSoundEmittingEntity, int iChannel, 
	const char *pSample, float flVolume, soundlevel_t iSoundLevel, int iFlags, 
	int iPitch, int iSpecialDSP, const Vector *pOrigin, float soundtime, int speakerentity, CUtlVector< Vector >* pUtlVecOrigins )
{

	SoundInfo_t sound; 
	sound.SetDefault();

	sound.nEntityIndex = pSoundEmittingEntity ? NUM_FOR_EDICT( pSoundEmittingEntity ) : 0;
	sound.nChannel = iChannel;
	sound.fVolume = flVolume;
	sound.Soundlevel = iSoundLevel;
	sound.nFlags = iFlags;
	sound.nPitch = iPitch;
	sound.nSpecialDSP = iSpecialDSP;
	sound.nSpeakerEntity = speakerentity;

	if ( iFlags & SND_STOP )
	{
		Assert( filter.IsReliable() );
	}

	// Compute the sound origin
	if ( pOrigin )
	{
		VectorCopy( *pOrigin, sound.vOrigin );
	}
	else if ( pSoundEmittingEntity )
	{
		IServerEntity *serverEntity = pSoundEmittingEntity->GetIServerEntity();
		if ( serverEntity )
		{
			CM_WorldSpaceCenter( serverEntity->GetCollideable(), &sound.vOrigin );
		}
	}

	// Add actual sound origin to vector if requested
	if ( pUtlVecOrigins )
	{
		(*pUtlVecOrigins).AddToTail( sound.vOrigin );
	}

	// set sound delay
	if ( soundtime != 0.0f )
	{
		// add one tick since server time ends at the current tick
		// we'd rather delay sounds slightly than skip the beginning samples
		// so add one tick of latency
		soundtime += sv.GetTickInterval();

		sound.fDelay = soundtime - sv.GetFinalTickTime();
		sound.nFlags |= SND_DELAY;
#if 0
		static float lastSoundTime = 0;
		Msg("SV: [%.3f] Play %s at %.3f\n", soundtime - lastSoundTime, pSample, soundtime );
		lastSoundTime = soundtime;
#endif
	}
	
	// find precache number for sound
	
	// if this is a sentence, get sentence number
	if ( pSample && TestSoundChar(pSample, CHAR_SENTENCE) )
	{
		sound.bIsSentence = true;
		sound.nSoundNum = Q_atoi( PSkipSoundChars(pSample) );
		if ( sound.nSoundNum >= VOX_SentenceCount() )
		{
			ConMsg("SV_StartSound: invalid sentence number: %s", PSkipSoundChars(pSample));
			return;
		}
	}
	else
	{
		sound.bIsSentence = false;
		sound.nSoundNum = sv.LookupSoundIndex( pSample );
		if ( !sound.nSoundNum || !sv.GetSound( sound.nSoundNum ) )
		{
			ConMsg ("SV_StartSound: %s not precached (%d)\n", pSample, sound.nSoundNum );
			return;
		}
    }

	// now sound message is complete, send to clients in filter
	sv.BroadcastSound( sound, filter );
}

//-----------------------------------------------------------------------------
// Purpose: Sets bits of playerbits based on valid multicast recipients
// Input  : usepas - 
//			origin - 
//			playerbits - 
//-----------------------------------------------------------------------------
void SV_DetermineMulticastRecipients( bool usepas, const Vector& origin, CBitVec< ABSOLUTE_PLAYER_LIMIT >& playerbits )
{
	// determine cluster for origin
	int cluster = CM_LeafCluster( CM_PointLeafnum( origin ) );
	byte pvs[MAX_MAP_LEAFS/8];
	int visType = usepas ? DVIS_PAS : DVIS_PVS;
	const byte *pMask = CM_Vis( pvs, sizeof(pvs), cluster, visType );

	playerbits.ClearAll();

	// Check for relevent clients
	for (int i = 0; i < sv.GetClientCount(); i++ )
	{
		CGameClient *pClient = sv.Client( i );

		if ( !pClient->IsActive() )
			continue;

		// HACK:  Should above also check pClient->spawned instead of this
		if ( !pClient->edict || pClient->edict->IsFree() || pClient->edict->GetUnknown() == NULL )
			continue;
		
		// Always add the  or Replay client
#if defined( REPLAY_ENABLED )
		if ( pClient->IsHLTV() || pClient->IsReplay() )
#else
		if ( pClient->IsHLTV() )
#endif
		{
			playerbits.Set( i );
			continue;
		}

		Vector vecEarPosition;
		serverGameClients->ClientEarPosition( pClient->edict, &vecEarPosition );

		int iBitNumber = CM_LeafCluster( CM_PointLeafnum( vecEarPosition ) );
		if ( !(pMask[iBitNumber>>3] & (1<<(iBitNumber&7)) ) )
			continue;

		playerbits.Set( i );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Write single ConVar change to all connected clients
// Input  : *var - 
//			*newValue - 
//-----------------------------------------------------------------------------
void SV_ReplicateConVarChange( ConVar const *var, const char *newValue )
{
	Assert( var );
	Assert( var->IsFlagSet( FCVAR_REPLICATED ) );
	Assert( newValue );

	if ( !sv.IsActive() || !sv.IsMultiplayer() )
		return;

	NET_SetConVar cvarMsg( var->GetName(), Host_CleanupConVarStringValue( newValue ) );

	sv.BroadcastMessage( cvarMsg );
}


//-----------------------------------------------------------------------------
// Purpose: Execute a command on all clients or a particular client
// Input  : *var - 
//			*newValue - 
//-----------------------------------------------------------------------------
void SV_ExecuteRemoteCommand( const char *pCommand, int nClientSlot )
{
	if ( !sv.IsActive() || !sv.IsMultiplayer() )
		return;

	NET_StringCmd cmdMsg( pCommand );

	if ( nClientSlot >= 0 )
	{
		CEngineSingleUserFilter filter( nClientSlot + 1, true );
		sv.BroadcastMessage( cmdMsg, filter );
	}
	else
	{
		sv.BroadcastMessage( cmdMsg );
	}
}



/*
==============================================================================

CLIENT SPAWNING

==============================================================================
*/

CGameServer::CGameServer()
{
	m_nMaxClientsLimit = 0;
	m_pPureServerWhitelist = NULL;
	m_bHibernating = false;
	m_bLoadedPlugins = false;
	V_memset( m_szMapname, 0, sizeof( m_szMapname ) );
	V_memset( m_szMapFilename, 0, sizeof( m_szMapFilename ) );
}


CGameServer::~CGameServer()
{
	if ( m_pPureServerWhitelist )
		m_pPureServerWhitelist->Release();
}


//-----------------------------------------------------------------------------
// Purpose: Disconnects the client and cleans out the m_pEnt CBasePlayer container object
// Input  : *clientedict - 
//-----------------------------------------------------------------------------
void CGameServer::RemoveClientFromGame( CBaseClient *client )
{
	CGameClient *pClient = (CGameClient*)client;

	// we must have an active server and a spawned client 
	// If we are a local server and we're disconnecting just return
	if ( !pClient->edict || !pClient->IsSpawned() || !IsActive() || (pClient->GetNetChannel() && pClient->GetNetChannel()->IsLoopback() ) )
		return;

	Assert( g_pServerPluginHandler );

	g_pServerPluginHandler->ClientDisconnect( pClient->edict );
	// release the DLL entity that's attached to this edict, if any
	serverGameEnts->FreeContainingEntity( pClient->edict );

}

static int s_iNetSpikeValue = -1;

int GetNetSpikeValue()
{
	// Read from the command line the first time
	if ( s_iNetSpikeValue < 0 )
		s_iNetSpikeValue = Max( V_atoi( CommandLine()->ParmValue( "-netspike", "0" ) ), 0 );
	return s_iNetSpikeValue;
}

const char szSvNetSpikeUsageText[] = 
	"Write network trace if amount of data sent to client exceeds N bytes.  Use zero to disable tracing.\n"
	"Note that having this enabled, even if never triggered, impacts performance.  Set to zero when not in use.\n"
	"For compatibility reasons, this command can be initialized on the command line with the -netspike option.";

static void sv_netspike_f( const CCommand &args )
{
    if ( args.ArgC() != 2 )
    {
		Msg( "%s\n\n", szSvNetSpikeUsageText );
		Msg( "sv_netspike value is currently %d\n", GetNetSpikeValue() );
		return;
    }

	s_iNetSpikeValue = Max( V_atoi( args.Arg( 1 ) ), 0 );
}

static ConCommand sv_netspike( "sv_netspike", sv_netspike_f, szSvNetSpikeUsageText
);

CBaseClient *CGameServer::CreateNewClient(int slot )
{
	CBaseClient *pClient = new CGameClient( slot, this );
	return pClient;
}



/*
================
SV_FinishCertificateCheck

For LAN connections, make sure we don't have too many people with same cd key hash
For Authenticated net connections, check the certificate and also double check won userid
 from that certificate
================
*/
bool CGameServer::FinishCertificateCheck( netadr_t &adr, int nAuthProtocol, const char *szRawCertificate, int clientChallenge )
{
	// Now check auth information
	switch ( nAuthProtocol )
	{
	default:
	case PROTOCOL_AUTHCERTIFICATE:
		RejectConnection( adr, clientChallenge, "#GameUI_ServerAuthDisabled");
		return false;

	case PROTOCOL_STEAM:
		return true; // the SteamAuthServer() state machine checks this
		break;

	case PROTOCOL_HASHEDCDKEY:
		if ( AllowDebugDedicatedServerOutsideSteam() )
			return true;

/*
		if ( !Host_IsSinglePlayerGame() || sv.IsDedicated()) // PROTOCOL_HASHEDCDKEY isn't allowed for multiplayer servers
		{
			RejectConnection( adr, clientChallenge, "#GameUI_ServerCDKeyAuthInvalid" );
			return false;
		}

		if ( Q_strlen( szRawCertificate ) != 32 )
		{
			RejectConnection( adr, clientChallenge, "#GameUI_ServerInvalidCDKey" );
			return false;
		}*/

		int nHashCount = 0;

		// Now make sure that this hash isn't "overused"
		for ( int i=0; i< GetClientCount(); i++ )
		{
			CBaseClient *pClient = Client(i);

			if ( !pClient->IsConnected() )
				continue;

			if ( Q_strnicmp ( szRawCertificate, pClient->m_GUID, SIGNED_GUID_LEN ) )
				continue;

			nHashCount++;
		}

		if ( nHashCount >= MAX_IDENTICAL_CDKEYS )
		{
			RejectConnection( adr, clientChallenge, "#GameUI_ServerCDKeyInUse" );
			return false;
		}
		break;
	}

	return true;
}

/*
=============================================================================

The PVS must include a small area around the client to allow head bobbing
or other small motion on the client side.  Otherwise, a bob might cause an
entity that should be visible to not show up, especially when the bob
crosses a waterline.

=============================================================================
*/

static int		s_FatBytes;
static byte*	s_pFatPVS = 0;

CUtlVector<int> g_AreasNetworked;

static void SV_AddToFatPVS( const Vector& org )
{
	int		i;
	byte	pvs[MAX_MAP_LEAFS/8];

	CM_Vis( pvs, sizeof(pvs), CM_LeafCluster( CM_PointLeafnum( org ) ), DVIS_PVS );
	for (i=0 ; i<s_FatBytes ; i++)
	{
		s_pFatPVS[i] |= pvs[i];
	}
}

//-----------------------------------------------------------------------------
// Purpose: Zeroes out pvs, this way we can or together multiple pvs's for a player
//-----------------------------------------------------------------------------
void SV_ResetPVS( byte* pvs, int pvssize )
{
	s_pFatPVS = pvs;
	s_FatBytes = Bits2Bytes(CM_NumClusters());

	if ( s_FatBytes > pvssize )
	{
		Sys_Error( "SV_ResetPVS:  Size %i too big for buffer %i\n", s_FatBytes, pvssize );
	}

	Q_memset (s_pFatPVS, 0, s_FatBytes);
	g_AreasNetworked.RemoveAll();
}

/*
=============
Calculates a PVS that is the inclusive or of all leafs within 8 pixels of the
given point.
=============
*/
void SV_AddOriginToPVS( const Vector& origin )
{
	SV_AddToFatPVS( origin );
	int area = CM_LeafArea( CM_PointLeafnum( origin ) );
	int i;
	for( i = 0; i < g_AreasNetworked.Count(); i++ )
	{
		if( g_AreasNetworked[i] == area )
		{
			return;
		}
	}
	g_AreasNetworked.AddToTail( area );
}

void CGameServer::BroadcastSound( SoundInfo_t &sound, IRecipientFilter &filter )
{
	int num = filter.GetRecipientCount();
	
	// don't add sounds while paused, unless we're in developer mode
	if ( IsPaused() && !developer.GetInt() )
		return;

	for ( int i = 0; i < num; i++ )
	{
		int index = filter.GetRecipientIndex( i );

		if ( index < 1 || index > GetClientCount() )
		{
			Msg( "CGameServer::BroadcastSound:  Recipient Filter for sound (reliable: %s, init: %s) with bogus client index (%i) in list of %i clients\n", 
					filter.IsReliable() ? "yes" : "no",
					filter.IsInitMessage() ? "yes" : "no",
					index, num );

			continue;
		}

		CGameClient *pClient = Client( index - 1 );

		// client must be fully connect to hear sounds
		if ( !pClient->IsActive() )
		{
			continue;
		}

		pClient->SendSound( sound, filter.IsReliable() );
	}
}

bool CGameServer::IsInPureServerMode() const
{
	return (m_pPureServerWhitelist != NULL);
}

CPureServerWhitelist * CGameServer::GetPureServerWhitelist() const
{
	return m_pPureServerWhitelist;
}

//void OnHibernateWhenEmptyChanged( IConVar *var, const char *pOldValue, float flOldValue )
//{
//	// We only need to do something special if we were preventing hibernation
//	// with sv_hibernate_when_empty but we would otherwise have been hibernating.
//	// In that case, punt all connected clients.
//	sv.UpdateHibernationState( ); 
//}

static bool s_bExitWhenEmpty = false;
static ConVar sv_memlimit(  "sv_memlimit", "0", 0, 
	"If set, whenever a game ends, if the total memory used by the server is "
	"greater than this # of megabytes, the server will exit."	);
static ConVar sv_minuptimelimit(  "sv_minuptimelimit", "0", 0, 
	"If set, whenever a game ends, if the server uptime is less than "
	"this number of hours, the server will continue running regardless of sv_memlimit."	);
static ConVar sv_maxuptimelimit(  "sv_maxuptimelimit", "0", 0, 
	"If set, whenever a game ends, if the server uptime exceeds "
	"this number of hours, the server will exit."	);

#if 0
static void sv_WasteMemory( void )
{
	uint8 *pWastedRam = new uint8[ 100 * 1024 * 1024 ];
	memset( pWastedRam, 0xff, 100 * 1024 * 1024 );			// make sure it gets committed
	Msg( "waste 100mb. using %dMB with an sv_memory_limit of %dMB\n", ApproximateProcessMemoryUsage() / ( 1024 * 1024 ), sv_memlimit.GetInt() );
}

static ConCommand sv_wastememory( "sv_wastememory", sv_WasteMemory, "Causes the server to allocate 100MB of ram and never free it", FCVAR_CHEAT );
#endif


static void sv_ShutDownCancel( void )
{
	if ( s_bExitWhenEmpty || ( s_timeForceShutdown > 0.0 ) )
	{
		ConMsg( "sv_shutdown canceled.\n" );
	}
	else
	{
		ConMsg( "sv_shutdown not pending.\n" );
	}

	s_bExitWhenEmpty = false;
	s_timeForceShutdown = 0.0;
}

static ConCommand sv_shutdown_cancel( "sv_shutdown_cancel", sv_ShutDownCancel, "Cancels pending sv_shutdown command" );


static void sv_ShutDown( void )
{
	if ( !sv.IsDedicated() )
	{
		Warning( "sv_shutdown only works on dedicated servers.\n" );
		return;
	}

	s_bExitWhenEmpty = true;
	Warning( "sv_shutdown command received.\n" );

	double timeCurrent = Plat_FloatTime();
	if ( sv.IsHibernating() || !sv.IsActive() )
	{
		Warning( "Server is inactive or hibernating. Shutting down right now\n" );
		s_timeForceShutdown = timeCurrent + 5.0; // don't forget!
		HostState_Shutdown();
	}
	else
	{
		// Check if we should update shutdown timeout
		if ( s_timeForceShutdown == 0.0 && sv_shutdown_timeout_minutes.GetInt() > 0 )
			s_timeForceShutdown = timeCurrent + sv_shutdown_timeout_minutes.GetInt() * 60.0;

		// Print appropriate message
		if ( s_timeForceShutdown > 0.0 )
		{
			Warning( "Server will shut down in %d seconds, or when it becomes empty.\n", (int)(s_timeForceShutdown - timeCurrent) );
		}
		else
		{
			Warning( "Server will shut down when it becomes empty.\n" );
		}
	}
}

static ConCommand sv_shutdown( "sv_shutdown", sv_ShutDown, "Sets the server to shutdown next time it's empty" );


bool CGameServer::IsHibernating() const
{
	return m_bHibernating;
}

void CGameServer::SetHibernating( bool bHibernating )
{
	static double s_flPlatFloatTimeBeginUptime = Plat_FloatTime();

	if ( m_bHibernating != bHibernating )
	{
		m_bHibernating = bHibernating;
		Msg( m_bHibernating ? "Server is hibernating\n" : "Server waking up from hibernation\n" );
		if ( m_bHibernating )
		{
			// see if we have any other connected bot clients
			for ( int iClient = 0; iClient < m_Clients.Count(); iClient++ )
			{			
				CBaseClient *pClient = m_Clients[iClient];
				if ( pClient->IsFakeClient() && pClient->IsConnected() && !pClient->IsSplitScreenUser() && !pClient->IsReplay() && !pClient->IsHLTV() )
				{
					pClient->Disconnect( "Punting bot, server is hibernating" );
				}
			}

			// A solo player using the game menu to return to lobby can leave the server paused
			SetPaused( false );

			// if we are hibernating, and we want to quit, quit
			bool bExit = false;
			if ( s_bExitWhenEmpty )
			{
				bExit = true;
				Warning( "Server shutting down because sv_shutdown was requested and a server is empty.\n" );
			}
			else
			{
				if ( sv_memlimit.GetInt() )
				{
					if ( ApproximateProcessMemoryUsage() > 1024 * 1024 * sv_memlimit.GetInt() )
					{
						if ( ( sv_minuptimelimit.GetFloat() > 0 ) &&
							( ( Plat_FloatTime() - s_flPlatFloatTimeBeginUptime ) / 3600.0 < sv_minuptimelimit.GetFloat() ) )
						{
							Warning( "Server is using %dMB with an sv_memory_limit of %dMB, but will not shutdown because sv_minuptimelimit is %.3f hr while current uptime is %.3f\n",
								ApproximateProcessMemoryUsage() / ( 1024 * 1024 ), sv_memlimit.GetInt(),
								sv_minuptimelimit.GetFloat(), ( Plat_FloatTime() - s_flPlatFloatTimeBeginUptime ) / 3600.0 );
						}
						else
						{
							Warning( "Server shutting down because of using %dMB with an sv_memory_limit of %dMB\n", ApproximateProcessMemoryUsage() / ( 1024 * 1024 ), sv_memlimit.GetInt() );
							bExit = true;
						}
					}
				}

				if ( ( sv_maxuptimelimit.GetFloat() > 0 ) &&
					( ( Plat_FloatTime() - s_flPlatFloatTimeBeginUptime ) / 3600.0 > sv_maxuptimelimit.GetFloat() ) )
				{
					Warning( "Server will shutdown because sv_maxuptimelimit is %.3f hr while current uptime is %.3f, using %dMB with an sv_memory_limit of %dMB\n",
						sv_maxuptimelimit.GetFloat(), ( Plat_FloatTime() - s_flPlatFloatTimeBeginUptime ) / 3600.0,
						ApproximateProcessMemoryUsage() / ( 1024 * 1024 ), sv_memlimit.GetInt() );
					bExit = true;
				}
			}
			
//#ifdef _LINUX
//			// if we are a child process running forked, we want to exit now. We want to "really" exit. no destructors, no nothing
//			if ( IsChildProcess() )							// are we a subprocess?
//			{
//				syscall( SYS_exit_group, 0 );	// we are not going to perform a normal c++ exit. We _dont_ want to run destructors, etc.
//			}
//#endif
			if ( bExit )
			{
				HostState_Shutdown();
			}
//			ResetGameConVarsToDefaults();
		}

		if ( g_iServerGameDLLVersion >= 8 )
		{
			serverGameDLL->SetServerHibernation( m_bHibernating );
		}

		// Heartbeat ASAP
		Steam3Server().SendUpdatedServerDetails();
		if ( Steam3Server().SteamGameServer() )
		{
			Steam3Server().SteamGameServer()->ForceHeartbeat();
		}
	}
}

void CGameServer::UpdateHibernationState()
{
	if ( !IsDedicated() || sv.m_State == ss_dead )
		return;

	// is this the last client disconnecting?
	bool bHaveAnyClients = false;

	// see if we have any other connected clients
	for ( int iClient = 0; iClient < m_Clients.Count(); iClient++ )
	{			
		CBaseClient *pClient = m_Clients[iClient];
		// don't consider the client being removed, it still shows as connected but won't be in a moment
		if ( pClient->IsConnected() && ( pClient->IsSplitScreenUser() || !pClient->IsFakeClient() ) )
		{
			bHaveAnyClients = true;
			break;
		}
	}

	bool hibernateFromGCServer = ( g_iServerGameDLLVersion < 8 ) || !serverGameDLL->GetServerGCLobby() || serverGameDLL->GetServerGCLobby()->ShouldHibernate();

	// If a restart was requested and we're supposed to reboot after XX amount of time, reboot the server.
	if ( !bHaveAnyClients && ( sv_maxuptimelimit.GetFloat() > 0.0f ) &&
		 Steam3Server().SteamGameServer() && Steam3Server().SteamGameServer()->WasRestartRequested() )
	{
		hibernateFromGCServer = true;
		s_bExitWhenEmpty = true;
	}

	//SetHibernating( sv_hibernate_when_empty.GetBool() && hibernateFromGCServer && !bHaveAnyClients );
	SetHibernating( hibernateFromGCServer && !bHaveAnyClients );
}

void CGameServer::FinishRestore()
{
#ifndef SWDS
	CSaveRestoreData currentLevelData;
	char			name[MAX_OSPATH];

	if ( !m_bLoadgame )
		return;

	g_ServerGlobalVariables.pSaveData = &currentLevelData;
	// Build the adjacent map list
	serverGameDLL->BuildAdjacentMapList();

	if ( !saverestore->IsXSave() )
	{
		Q_snprintf( name, sizeof( name ), "%s%s.HL2", saverestore->GetSaveDir(), m_szMapname );
	}
	else
	{
		Q_snprintf( name, sizeof( name ), "%s:\\%s.HL2", GetCurrentMod(), m_szMapname );
	}

	Q_FixSlashes( name );

	saverestore->RestoreClientState( name, false );

	if ( g_ServerGlobalVariables.eLoadType == MapLoad_Transition )
	{
		for ( int i = 0; i < currentLevelData.levelInfo.connectionCount; i++ )
		{
			saverestore->RestoreAdjacenClientState( currentLevelData.levelInfo.levelList[i].mapName );
		}
	}

	saverestore->OnFinishedClientRestore();

	g_ServerGlobalVariables.pSaveData = NULL;

	// Reset
	m_bLoadgame = false;
	saverestore->SetIsXSave( IsX360() );
#endif
}

void CGameServer::CopyTempEntities( CFrameSnapshot* pSnapshot )	
{
	Assert( pSnapshot->m_pTempEntities == NULL );

	if ( m_TempEntities.Count() > 0 )
	{
		// copy temp entities if any
		pSnapshot->m_nTempEntities = m_TempEntities.Count();

		pSnapshot->m_pTempEntities = new CEventInfo*[pSnapshot->m_nTempEntities];

		Q_memcpy( pSnapshot->m_pTempEntities, m_TempEntities.Base(), m_TempEntities.Count() * sizeof( CEventInfo * ) );

		// clear server list
		m_TempEntities.RemoveAll();
	}
}

// If enabled, random crashes start to appear in WriteTempEntities, etc. It looks like
// one thread can be in WriteDeltaEntities while another is in WriteTempEntities, and both are
// partying on g_FrameSnapshotManager.m_FrameSnapshots. Bruce sent e-mail from a customer
// that stated these crashes don't occur when parallel_sendsnapshot is disabled. Zoid said:
//
//   Easiest is just turn off parallel snapshots, it's not much of a win on servers where we
//   are running many instances anyway. It's off in Dota and CSGO dedicated servers.
//
// Bruce also had a patch to disable this in //ValveGames/staging/game/tf/cfg/unencrypted/print_instance_config.py
static ConVar sv_parallel_sendsnapshot( "sv_parallel_sendsnapshot", "0" );

static void SV_ParallelSendSnapshot( CGameClient *& pClient )
{
	// HLTV and replay clients must be handled on the main thread
	// because they access and modify global state. Skip them.
	if ( pClient->IsHLTV() )
		return;
#if defined( REPLAY_ENABLED )
	if ( pClient->IsReplay() )
		return;
#endif
	CClientFrame *pFrame = pClient->GetSendFrame();
	if ( pFrame )
	{
		pClient->SendSnapshot( pFrame );
		pClient->UpdateSendState();
	}
	// Replace this parallel processing array entry with NULL so
	// that the calling code knows that this entry was handled.
	pClient = NULL;
}

void CGameServer::SendClientMessages ( bool bSendSnapshots )
{
	VPROF_BUDGET( "SendClientMessages", VPROF_BUDGETGROUP_OTHER_NETWORKING );
	
	// build individual updates
	int receivingClientCount = 0;
	CGameClient*	pReceivingClients[ABSOLUTE_PLAYER_LIMIT];
	for (int i=0; i< GetClientCount(); i++ )
	{
		CGameClient* client = Client(i);
		
		// Update Host client send state...
		if ( !client->ShouldSendMessages() )
			continue;
		
		// Append the unreliable data (player updates and packet entities)
		if ( bSendSnapshots && client->IsActive() )
		{
			// Add this client to the list of clients we're gonna send to.
			pReceivingClients[receivingClientCount] = client;
			++receivingClientCount;
		}
		else
		{
			// Connected, but inactive, just send reliable, sequenced info.
			if ( client->IsFakeClient() )
				continue;
				
			// if client never send a netchannl packet yet, send S2C_CONNECTION 
			// because it could get lost in multiplayer
			if ( NET_IsMultiplayer() && client->m_NetChannel->GetSequenceNr(FLOW_INCOMING) == 0 )
			{
				NET_OutOfBandPrintf ( m_Socket, client->m_NetChannel->GetRemoteAddress(), "%c00000000000000", S2C_CONNECTION );
			}

#ifdef SHARED_NET_STRING_TABLES
			sv.m_StringTables->TriggerCallbacks( client->m_nDeltaTick );
#endif

			client->m_NetChannel->Transmit();
			client->UpdateSendState();
		}
	}

	if ( receivingClientCount )
	{
		// if any client wants an update, take new snapshot now
		CFrameSnapshot* pSnapshot = framesnapshotmanager->TakeTickSnapshot( m_nTickCount );

		// copy temp ents references to pSnapshot
		CopyTempEntities( pSnapshot );

		// Compute the client packs
		SV_ComputeClientPacks( receivingClientCount, pReceivingClients, pSnapshot );

		if ( receivingClientCount > 1 && sv_parallel_sendsnapshot.GetBool() )
		{
			// SV_ParallelSendSnapshot will not process HLTV or Replay clients as they
			// must be run on the main thread due to un-threadsafe global state access.
			// It will replace anything that it does process with a NULL pointer.
			ParallelProcess( "SV_ParallelSendSnapshot", pReceivingClients, receivingClientCount, &SV_ParallelSendSnapshot );
		}
		
		for (int i = 0; i < receivingClientCount; ++i)
		{
			CGameClient *pClient = pReceivingClients[i];
			if ( !pClient )
				continue;
			CClientFrame *pFrame = pClient->GetSendFrame();
			if ( !pFrame )
				continue;
			pClient->SendSnapshot( pFrame );
			pClient->UpdateSendState();
		}
	
		pSnapshot->ReleaseReference();
	}
}

void CGameServer::SetMaxClients( int number )
{
	m_nMaxclients = clamp( number, 1, m_nMaxClientsLimit );

	if ( tv_enable.GetBool() == false )
	{
		ConMsg( "maxplayers set to %i\n", m_nMaxclients );
	}
	else
	{
		ConMsg( "maxplayers set to %i (extra slot was added for SourceTV)\n", m_nMaxclients );
	}

	deathmatch.SetValue( m_nMaxclients > 1 );
}

//-----------------------------------------------------------------------------
// A potential optimization of the client data sending; the optimization
// is based around the fact that we think that we're spending all our time in
// cache misses since we are accessing so much memory
//-----------------------------------------------------------------------------





/*
==============================================================================
SERVER SPAWNING

==============================================================================
*/

void SV_WriteVoiceCodec(bf_write &pBuf)
{
	// Only send in multiplayer. Otherwise, we don't want voice.

	const char *pCodec = sv.IsMultiplayer() ? sv_voicecodec.GetString() : NULL;
	int nSampleRate = pCodec ? Voice_GetDefaultSampleRate( pCodec ) : 0;
	SVC_VoiceInit voiceinit( pCodec, nSampleRate );
	voiceinit.WriteToBuffer( pBuf );
}

// Gets voice data from a client and forwards it to anyone who can hear this client.
ConVar voice_debugfeedbackfrom( "voice_debugfeedbackfrom", "0" );

void SV_BroadcastVoiceData(IClient * pClient, int nBytes, char * data, int64 xuid )
{
	// Disable voice?
	if( !sv_voiceenable.GetInt() )
		return;

	// Build voice message once
	SVC_VoiceData voiceData;
	voiceData.m_nFromClient = pClient->GetPlayerSlot();
	voiceData.m_nLength = nBytes * 8;	// length in bits
	voiceData.m_DataOut = data;
	voiceData.m_xuid = xuid;

	if ( voice_debugfeedbackfrom.GetBool() )
	{
		Msg( "Sending voice from: %s - playerslot: %d\n", pClient->GetClientName(), pClient->GetPlayerSlot() + 1 );
	}

	for(int i=0; i < sv.GetClientCount(); i++)
	{
		IClient *pDestClient = sv.GetClient(i);

		bool bSelf = (pDestClient == pClient);

		// Only send voice to active clients
		if( !pDestClient->IsActive() )
			continue;

		// Does the game code want cl sending to this client?

		bool bHearsPlayer = pDestClient->IsHearingClient( voiceData.m_nFromClient );
		voiceData.m_bProximity = pDestClient->IsProximityHearingClient( voiceData.m_nFromClient );

		if ( IsX360() && bSelf == true )			
			continue;
			
		if ( !bHearsPlayer && !bSelf )
			continue;	

		voiceData.m_nLength = nBytes * 8;

		// Is loopback enabled?
		if( !bHearsPlayer )
		{
			// Still send something, just zero length (this is so the client 
			// can display something that shows knows the server knows it's talking).
			voiceData.m_nLength = 0;	
		}

		pDestClient->SendNetMsg( voiceData );
	}
}


// UNDONE: "player.mdl" ???  This should be set by name in the DLL
/*
================
SV_CreateBaseline

================
*/
void SV_CreateBaseline (void)
{
	SV_WriteVoiceCodec( sv.m_Signon );

	ServerClass *pClasses = serverGameDLL->GetAllServerClasses();

	// Send SendTable info.
	if ( sv_sendtables.GetInt() )
	{
#ifdef _XBOX
		Error( "sv_sendtables not allowed on XBOX." );
#endif
		sv.m_FullSendTablesBuffer.EnsureCapacity( NET_MAX_PAYLOAD );
		sv.m_FullSendTables.StartWriting( sv.m_FullSendTablesBuffer.Base(), sv.m_FullSendTablesBuffer.Count() );
		
		SV_WriteSendTables( pClasses, sv.m_FullSendTables );
		
		if ( sv.m_FullSendTables.IsOverflowed() )
		{
			Host_Error("SV_CreateBaseline: WriteSendTables overflow.\n" );
			return;
		}

		// Send class descriptions.
		SV_WriteClassInfos(pClasses, sv.m_FullSendTables);

		if ( sv.m_FullSendTables.IsOverflowed() )
		{
			Host_Error("SV_CreateBaseline: WriteClassInfos overflow.\n" );
			return;
		}
	}

	// If we're using the local network backdoor, we'll never use the instance baselines.
	if ( !g_pLocalNetworkBackdoor )
	{
		int		count = 0;
		int		bytes = 0;
		
		for ( int entnum = 0; entnum < sv.num_edicts ; entnum++)
		{
			// get the current server version
			edict_t *edict = sv.edicts + entnum;

			if ( edict->IsFree() || !edict->GetUnknown() )
				continue;

			ServerClass *pClass   = edict->GetNetworkable() ? edict->GetNetworkable()->GetServerClass() : 0;

			if ( !pClass )
			{
				Assert( pClass );
				continue;	// no Class ?
			}

			if ( pClass->m_InstanceBaselineIndex != INVALID_STRING_INDEX )
				continue; // we already have a baseline for this class

			SendTable *pSendTable = pClass->m_pTable;

			//
			// create entity baseline
			//
			
			ALIGN4 char packedData[MAX_PACKEDENTITY_DATA] ALIGN4_POST;
			bf_write writeBuf( "SV_CreateBaseline->writeBuf", packedData, sizeof( packedData ) );


			// create basline from zero values
			if ( !SendTable_Encode(
				pSendTable, 
				edict->GetUnknown(), 
				&writeBuf, 
				entnum,
				NULL,
				false
				) )
			{
				Host_Error("SV_CreateBaseline: SendTable_Encode returned false (ent %d).\n", entnum);
			}

			// copy baseline into baseline stringtable
			SV_EnsureInstanceBaseline( pClass, entnum, packedData, writeBuf.GetNumBytesWritten() );

			bytes += writeBuf.GetNumBytesWritten();
			count ++;
		}
		DevMsg("Created class baseline: %i classes, %i bytes.\n", count,bytes); 
	}

	g_GameEventManager.ReloadEventDefinitions();

	SVC_GameEventList gameevents;
	char data[NET_MAX_PAYLOAD];
	gameevents.m_DataOut.StartWriting( data, sizeof(data) );

	g_GameEventManager.WriteEventList( &gameevents );
	gameevents.WriteToBuffer( sv.m_Signon );
}

//-----------------------------------------------------------------------------
// Purpose: Ensure steam context is initialized for multiplayer gameservers. Idempotent.
//-----------------------------------------------------------------------------
void SV_InitGameServerSteam()
{
	if ( sv.IsMultiplayer() )
	{
		Steam3Server().Activate( CSteam3Server::eServerTypeNormal );
		sv.SetQueryPortFromSteamServer();
		if ( serverGameDLL && g_iServerGameDLLVersion >= 6 )
		{
			serverGameDLL->GameServerSteamAPIActivated();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
// Input  : runPhysics -
//-----------------------------------------------------------------------------
bool SV_ActivateServer()
{
	COM_TimestampedLog( "SV_ActivateServer" );
#ifndef SWDS
	EngineVGui()->UpdateProgressBar(PROGRESS_ACTIVATESERVER);
#endif

	COM_TimestampedLog( "serverGameDLL->ServerActivate" );

	host_state.interval_per_tick = serverGameDLL->GetTickInterval();
	if ( host_state.interval_per_tick < MINIMUM_TICK_INTERVAL ||
		host_state.interval_per_tick > MAXIMUM_TICK_INTERVAL )
	{
		Sys_Error( "GetTickInterval returned bogus tick interval (%f)[%f to %f is valid range]", host_state.interval_per_tick,
			MINIMUM_TICK_INTERVAL, MAXIMUM_TICK_INTERVAL );
	}

	Msg( "SV_ActivateServer: setting tickrate to %.1f\n", 1.0f / host_state.interval_per_tick );

	bool bPrevState = networkStringTableContainerServer->Lock( false );
	// Activate the DLL server code
	g_pServerPluginHandler->ServerActivate( sv.edicts, sv.num_edicts, sv.GetMaxClients() );

	// all setup is completed, any further precache statements are errors
	sv.m_State = ss_active;
	
	COM_TimestampedLog( "SV_CreateBaseline" );

	// create a baseline for more efficient communications
	SV_CreateBaseline();

	sv.allowsignonwrites = false;

	// set skybox name
	ConVar const *skyname = g_pCVar->FindVar( "sv_skyname" );

	if ( skyname )
	{
		Q_strncpy( sv.m_szSkyname, skyname->GetString(), sizeof( sv.m_szSkyname ) );
	}
	else
	{
		Q_strncpy( sv.m_szSkyname, "unknown", sizeof( sv.m_szSkyname ) );
	}

	COM_TimestampedLog( "Send Reconnects" );

	// Tell connected clients to reconnect
	sv.ReconnectClients();

	// Tell what kind of server has been started.
	if ( sv.IsMultiplayer() )
	{
		ConDMsg ("%i player server started\n", sv.GetMaxClients() );
	}
	else
	{
		ConDMsg ("Game started\n");
	}

	// Replay setup
#if defined( REPLAY_ENABLED )
	if ( g_pReplay && g_pReplay->IsReplayEnabled() )
	{
		if ( !replay )
		{
			replay = new CReplayServer;
			replay->Init( NET_IsDedicated() );
		}

		if ( replay->IsActive() )
		{
			// replay master already running, just activate client
			replay->m_MasterClient->ActivatePlayer();
			replay->StartMaster( replay->m_MasterClient );
		}
		else
		{
			// create new replay client
			ConVarRef replay_name( "replay_name" );
			CGameClient *pClient = (CGameClient*)sv.CreateFakeClient( replay_name.GetString() );
			replay->StartMaster( pClient );
		}
	}
	else
	{

		// make sure replay is disabled
		if ( replay )
			replay->Shutdown();
	}
#endif	// #if defined( REPLAY_ENABLED )

	// HLTV setup
	if ( tv_enable.GetBool() )
	{
		if ( CommandLine()->FindParm("-nohltv") )
		{
			// let user know that SourceTV will not work
			ConMsg ("SourceTV is disabled on this server.\n");
		}
		else
		{
			// create SourceTV object if not already there
			if ( !hltv )
			{
				hltv = new CHLTVServer;
				hltv->Init( NET_IsDedicated() );
			}

			if ( hltv->IsActive() && hltv->IsMasterProxy() )
			{
				// HLTV master already running, just activate client
				hltv->m_MasterClient->ActivatePlayer();
				hltv->StartMaster( hltv->m_MasterClient );
			}
			else
			{
				// create new HLTV client
				CGameClient *pClient = (CGameClient*)sv.CreateFakeClient( tv_name.GetString() );
				hltv->StartMaster( pClient );
			}
		}
	}
	else
	{

		// make sure HLTV is disabled
		if ( hltv )
			hltv->Shutdown();
	}

	if (sv.IsDedicated())
	{
		// purge unused models and their data hierarchy (materials, shaders, etc)
		modelloader->PurgeUnusedModels();
	}

	SV_InitGameServerSteam();
	networkStringTableContainerServer->Lock( bPrevState );

	// Heartbeat the master server in case we turned SrcTV on or off.
	Steam3Server().SendUpdatedServerDetails();
	if ( Steam3Server().SteamGameServer() )
	{
		Steam3Server().SteamGameServer()->ForceHeartbeat();
	}

	COM_TimestampedLog( "SV_ActivateServer(finished)" );

	return true;
}

#include "tier0/memdbgoff.h"

static void SV_AllocateEdicts()
{
	sv.edicts = (edict_t *)Hunk_AllocName( sv.max_edicts*sizeof(edict_t), "edicts" );

	COMPILE_TIME_ASSERT( MAX_EDICT_BITS+1 <= 8*sizeof(sv.edicts[0].m_EdictIndex) );

	// Invoke the constructor so the vtable is set correctly..
	for (int i = 0; i < sv.max_edicts; ++i)
	{
		new( &sv.edicts[i] ) edict_t;
		sv.edicts[i].m_EdictIndex = i;
		sv.edicts[i].freetime = 0;
	}
	ED_ClearFreeEdictList();

	sv.edictchangeinfo = (IChangeInfoAccessor *)Hunk_AllocName( sv.max_edicts * sizeof( IChangeInfoAccessor ), "edictchangeinfo" );
}

#include "tier0/memdbgon.h"

void CGameServer::ReloadWhitelist( const char *pMapName )
{
	// Always return - until we get the whitelist stuff resolved for TF2.
	if ( m_pPureServerWhitelist )
	{
		m_pPureServerWhitelist->Release();
		m_pPureServerWhitelist = NULL;
	}

	g_sv_pure_waiting_on_reload = false;

	// Don't do sv_pure stuff in SP games.
	if ( GetMaxClients() <= 1 )
		return;

	// Don't use the whitelist if sv_pure is not set.
	if ( GetSvPureMode() < 0 )
		return;

	// There's a magic number we use in the steam.inf in P4 that we don't update.
	// We can use this to detect if they are running out of P4, and if so, don't use the whitelist
	const char *pszVersionInP4 = "2000";
	if ( !Q_strcmp( GetSteamInfIDVersionInfo().szVersionString, pszVersionInP4 ) )
		return;

	m_pPureServerWhitelist = CPureServerWhitelist::Create( g_pFileSystem );

	// Load it
	m_pPureServerWhitelist->Load( GetSvPureMode() );

	// Load user whitelists, if allowed
	if ( GetSvPureMode() == 1 )
	{
		
		// Load the per-map whitelist.
		const char *pMapWhitelistSuffix = "_whitelist.txt";
		char testFilename[MAX_PATH] = "maps";
		V_AppendSlash( testFilename, sizeof( testFilename ) );
		V_strncat( testFilename, pMapName, sizeof( testFilename ) );
		V_strncat( testFilename, pMapWhitelistSuffix, sizeof( testFilename ) );
		
		KeyValues *kv = new KeyValues( "" );
		if ( kv->LoadFromFile( g_pFileSystem, testFilename ) )
			m_pPureServerWhitelist->LoadCommandsFromKeyValues( kv );
		kv->deleteThis();
	}

}


/*
================
SV_SpawnServer

This is called at the start of each level
================
*/
bool CGameServer::SpawnServer( const char *szMapName, const char *szMapFile, const char *startspot )
{
	int		i;

	Assert( serverGameClients );

	if ( CommandLine()->FindParm( "-NoLoadPluginsForClient" ) != 0 )
	{
		if ( !m_bLoadedPlugins )
		{
			// Only load plugins once.
			m_bLoadedPlugins = true;
			g_pServerPluginHandler->LoadPlugins(); // load 3rd party plugins
		}
	}

	// Reset the last used count on all models before beginning the new load -- The nServerCount value on models could
	// be from a client load connecting to a different server, and we know we're at the beginning of a new load now.
	modelloader->ResetModelServerCounts();

	ReloadWhitelist( szMapName );

	COM_TimestampedLog( "SV_SpawnServer(%s)", szMapName );
#ifndef SWDS
	EngineVGui()->UpdateProgressBar(PROGRESS_SPAWNSERVER);
#endif
	COM_SetupLogDir( szMapName );

	g_Log.Open();
	g_Log.Printf( "Loading map \"%s\"\n", szMapName );
	g_Log.PrintServerVars();

#ifndef SWDS
	SCR_CenterStringOff();
#endif

	if ( startspot )
	{
		ConDMsg("Spawn Server: %s: [%s]\n", szMapName, startspot );
	}
	else
	{
		ConDMsg("Spawn Server: %s\n", szMapName );
	}

	// Any partially connected client will be restarted if the spawncount is not matched.
	gHostSpawnCount = ++m_nSpawnCount;

	//
	// make cvars consistant
	//
	deathmatch.SetValue( IsMultiplayer() ? 1 : 0 );
	if ( coop.GetInt() )
	{
		deathmatch.SetValue( 0 );
	}

	current_skill = (int)(skill.GetFloat() + 0.5);
	current_skill = max( current_skill, 0 );
	current_skill = min( current_skill, 3 );

	skill.SetValue( (float)current_skill );

	COM_TimestampedLog( "StaticPropMgr()->LevelShutdown()" );

#if !defined( SWDS )
	g_pShadowMgr->LevelShutdown();
#endif // SWDS
	StaticPropMgr()->LevelShutdown();

	// if we have an hltv relay proxy running, stop it now
	if ( hltv && !hltv->IsMasterProxy() )
	{
		hltv->Shutdown();
	}
	
	// NOTE: Replay system does not deal with relay proxies.

	COM_TimestampedLog( "Host_FreeToLowMark" );

	Host_FreeStateAndWorld( true );
	Host_FreeToLowMark( true );

	// Clear out the mapversion so it's reset when the next level loads. Needed for changelevels.
	g_ServerGlobalVariables.mapversion = 0;

	COM_TimestampedLog( "sv.Clear()" );

	Clear();

	COM_TimestampedLog( "framesnapshotmanager->LevelChanged()" );

	// Clear out the state of the most recently sent packed entities from
	// the snapshot manager
	framesnapshotmanager->LevelChanged();

	// set map name
	Q_strncpy( m_szMapname, szMapName, sizeof( m_szMapname ) );
	Q_strncpy( m_szMapFilename, szMapFile, sizeof( m_szMapFilename ) );

	// set startspot
	if (startspot)
	{
		Q_strncpy(m_szStartspot, startspot, sizeof( m_szStartspot ) );
	}
	else
	{
		m_szStartspot[0] = 0;
	}

	if ( g_FlushMemoryOnNextServer )
	{
		g_FlushMemoryOnNextServer = false;
		if ( IsX360() )
		{
			g_pQueuedLoader->PurgeAll();
		}
		g_pDataCache->Flush();
		g_pMaterialSystem->CompactMemory();
		g_pFileSystem->AsyncFinishAll();
#if !defined( SWDS )
		extern CThreadMutex g_SndMutex;
		g_SndMutex.Lock();
		g_pFileSystem->AsyncSuspend();
		g_pThreadPool->SuspendExecution();
		MemAlloc_CompactHeap();
		g_pThreadPool->ResumeExecution();
		g_pFileSystem->AsyncResume();
		g_SndMutex.Unlock();
#endif // SWDS
	}

	// Preload any necessary data from the xzps:
	g_pFileSystem->SetupPreloadData();
	g_pMDLCache->InitPreloadData( false );

	// Allocate server memory
	max_edicts = MAX_EDICTS;


	g_ServerGlobalVariables.maxEntities = max_edicts;
	g_ServerGlobalVariables.maxClients = GetMaxClients();
#ifndef SWDS
	g_ClientGlobalVariables.network_protocol = PROTOCOL_VERSION;
#endif

	// Assume no entities beyond world and client slots
	num_edicts = GetMaxClients()+1;

	COM_TimestampedLog( "SV_AllocateEdicts" );

	SV_AllocateEdicts();

	serverGameEnts->SetDebugEdictBase( edicts );

	allowsignonwrites = true;

	serverclasses = 0;		// number of unique server classes
	serverclassbits = 0;		// log2 of serverclasses

	// Assign class ids to server classes here so we can encode temp ents into signon
	//  if needed
	AssignClassIds();

	COM_TimestampedLog( "Set up players" );

	// allocate player data, and assign the values into the edicts
	for ( i=0 ; i< GetClientCount() ; i++ )
	{
		CGameClient * pClient = Client(i);

		// edict for a player is slot + 1, world = 0
		pClient->edict = edicts + i + 1;
	
		// Setup up the edict
		InitializeEntityDLLFields( pClient->edict );
	}

	COM_TimestampedLog( "Set up players(done)" );

	m_State = ss_loading;
	
	// Set initial time values.
	m_flTickInterval = host_state.interval_per_tick;
	m_nTickCount = (int)( 1.0 / host_state.interval_per_tick ) + 1; // Start at appropriate 1

	g_ServerGlobalVariables.tickcount = m_nTickCount;
	g_ServerGlobalVariables.curtime = GetTime();

	// Load the world model.
	g_pFileSystem->AddSearchPath( szMapFile, "GAME", PATH_ADD_TO_HEAD );
	g_pFileSystem->BeginMapAccess();

	if ( !CommandLine()->FindParm( "-allowstalezip" ) )
	{
		if ( g_pFileSystem->FileExists( "stale.txt", "GAME" ) )
		{
			Warning( "This map is not final!!  Needs to be rebuilt without -keepstalezip and without -onlyents\n" );
		}
	}

	COM_TimestampedLog( "modelloader->GetModelForName(%s) -- Start", szMapFile );

	host_state.SetWorldModel( modelloader->GetModelForName( szMapFile, IModelLoader::FMODELLOADER_SERVER ) );
	if ( !host_state.worldmodel )
	{
		ConMsg( "Couldn't spawn server %s\n", szMapFile );
		m_State = ss_dead;
		g_pFileSystem->EndMapAccess();
		return false;
	}

	COM_TimestampedLog( "modelloader->GetModelForName(%s) -- Finished", szMapFile );

	if ( IsMultiplayer() && !IsX360() )
	{
#ifndef SWDS
		EngineVGui()->UpdateProgressBar(PROGRESS_CRCMAP);
#endif
		// Server map CRC check.
		V_memset( worldmapMD5.bits, 0, MD5_DIGEST_LENGTH );
		if ( !MD5_MapFile( &worldmapMD5, szMapFile ) )
		{
			ConMsg( "Couldn't CRC server map: %s\n", szMapFile );
			m_State = ss_dead;
			g_pFileSystem->EndMapAccess();
			return false;
		}

#ifndef SWDS
		EngineVGui()->UpdateProgressBar(PROGRESS_CRCCLIENTDLL);
#endif
	}
	else
	{
		V_memset( worldmapMD5.bits, 0, MD5_DIGEST_LENGTH );
	}

	m_StringTables = networkStringTableContainerServer;

	COM_TimestampedLog( "SV_CreateNetworkStringTables" );

#ifndef SWDS
	EngineVGui()->UpdateProgressBar(PROGRESS_CREATENETWORKSTRINGTABLES);
#endif

	// Create network string tables ( including precache tables )
	SV_CreateNetworkStringTables();

	// Leave empty slots for models/sounds/generic (not for decals though)
	PrecacheModel( "", 0 );
	PrecacheGeneric( "", 0 );
	PrecacheSound( "", 0 );

	COM_TimestampedLog( "Precache world model (%s)", szMapFile );

#ifndef SWDS
	EngineVGui()->UpdateProgressBar(PROGRESS_PRECACHEWORLD);
#endif
	// Add in world
	PrecacheModel( szMapFile, RES_FATALIFMISSING | RES_PRELOAD, host_state.worldmodel );

	COM_TimestampedLog( "Precache brush models" );

	// Add world submodels to the model cache
	for ( i = 1 ; i < host_state.worldbrush->numsubmodels ; i++ )
	{
		// Add in world brush models
		char localmodel[5]; // inline model names "*1", "*2" etc
		Q_snprintf( localmodel, sizeof( localmodel ), "*%i", i );

		PrecacheModel( localmodel, RES_FATALIFMISSING | RES_PRELOAD, modelloader->GetModelForName( localmodel, IModelLoader::FMODELLOADER_SERVER ) );
	}

#ifndef SWDS
	EngineVGui()->UpdateProgressBar(PROGRESS_CLEARWORLD);
#endif
	COM_TimestampedLog( "SV_ClearWorld" );

	// Clear world interaction links
	// Loads and inserts static props
	SV_ClearWorld();

	//
	// load the rest of the entities
	//

	COM_TimestampedLog( "InitializeEntityDLLFields" );

	InitializeEntityDLLFields( edicts );

	// Clear the free bit on the world edict (entindex: 0).
	ED_ClearFreeFlag( &edicts[0] );

	if (coop.GetFloat())
	{
		g_ServerGlobalVariables.coop = (coop.GetInt() != 0);
	}
	else
	{
		g_ServerGlobalVariables.deathmatch = (deathmatch.GetInt() != 0);
	}

	g_ServerGlobalVariables.mapname   = MAKE_STRING( m_szMapname );
	g_ServerGlobalVariables.startspot = MAKE_STRING( m_szStartspot );

	GetTestScriptMgr()->CheckPoint( "map_load" );

	// set game event
	IGameEvent *event = g_GameEventManager.CreateEvent( "server_spawn" );
	if ( event )
	{
		event->SetString( "hostname", host_name.GetString() );
		event->SetString( "address", net_local_adr.ToString( false ) );
		event->SetInt(    "port", GetUDPPort() );
		event->SetString( "game", com_gamedir );
		event->SetString( "mapname", GetMapName() );
		event->SetInt(    "maxplayers", GetMaxClients() );
		event->SetInt(	  "password", 0 );				// TODO
#if defined( _WIN32 )
		event->SetString( "os", "WIN32" );
#elif defined ( LINUX )
		event->SetString( "os", "LINUX" );
#elif defined ( OSX )
		event->SetString( "os", "OSX" );
#elif defined(PLATFORM_BSD)
    event->SetString("os",
#    ifdef __FreeBSD__
      "FreeBSD"
#    else
      "BSD"
#    endif
    );
#else
#error
#endif
		event->SetInt( "dedicated", IsDedicated() ? 1 : 0 );

		g_GameEventManager.FireEvent( event );
	}

	COM_TimestampedLog( "SV_SpawnServer -- Finished" );

	g_pFileSystem->EndMapAccess();
	return true;
}


void CGameServer::UpdateMasterServerPlayers()
{
	if ( !Steam3Server().SteamGameServer() )
		return;

	for ( int i=0; i < GetClientCount() ; i++ )
	{
		CGameClient *client = Client(i);
		
		if ( !client->IsConnected() )
			continue;

		CPlayerState *pl = serverGameClients->GetPlayerState( client->edict );
		if ( !pl )
			continue;

		if ( !client->m_SteamID.IsValid() )
			continue;

		Steam3Server().SteamGameServer()->BUpdateUserData( client->m_SteamID, client->GetClientName(), pl->frags );
	}
}


//-----------------------------------------------------------------------------
// SV_IsSimulating
//-----------------------------------------------------------------------------
bool SV_IsSimulating( void )
{
	if ( sv.IsPaused() )
		return false;

#ifndef SWDS
	// Don't simulate in single player if console is down or the bug UI is active and we're in a game 
	if ( !sv.IsMultiplayer() )
	{
		if ( g_LostVideoMemory )
			return false;

		// Don't simulate in single player if console is down or the bug UI is active and we're in a game 
		if ( cl.IsActive() && ( Con_IsVisible() || EngineVGui()->ShouldPause() ) )
			return false;
	}
#endif //SWDS
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool SV_HasPlayers()
{
	/*int i;
	for ( i = 0; i < sv.clients.Count(); i++ )
	{
		if ( sv.clients[ i ]->active )
		{
			return true;
		}
	}

	return false; */

	return sv.GetClientCount() > 0;
}

//-----------------------------------------------------------------------------
// Purpose: Run physics code (simulating == false means we're paused, but we'll still
//  allow player usercmds to be processed
//-----------------------------------------------------------------------------
void SV_Think( bool bIsSimulating )
{
	VPROF( "SV_Physics" );
	tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "SV_Think(%s)", bIsSimulating ? "simulating" : "not simulating" );
	
// @FD The staging branch already did away with "frames" and wakes on tick
// optimally.  Currently the hibernating flag essentially means "is empty
// and available to host a game," which is used for the GC matchmaking.
	sv.UpdateHibernationState();

	if ( s_timeForceShutdown > 0.0 )
	{
		if ( s_timeForceShutdown < Plat_FloatTime() )
		{
			Warning( "Server shutting down because sv_shutdown was requested and timeout has expired.\n" );
			HostState_Shutdown();
		}
	}
//	if ( sv.IsDedicated() )
//	{
//		sv.UpdateReservedState();
//		if ( sv.IsHibernating() )
//		{
//			// if we're hibernating, just sleep for a while and do not call server.dll to run a frame
//			int nMilliseconds = sv_hibernate_ms.GetInt();
//#ifndef DEDICATED // Non-Linux
//			if ( g_bIsVGuiBasedDedicatedServer )
//			{
//				// Keep VGUi happy
//				nMilliseconds = sv_hibernate_ms_vgui.GetInt();
//			}
//#endif
//			g_pNetworkSystem->SleepUntilMessages( NS_SERVER, nMilliseconds );
//			return;
//		}
//	}

	g_ServerGlobalVariables.tickcount   = sv.m_nTickCount;
	g_ServerGlobalVariables.curtime		= sv.GetTime();
	g_ServerGlobalVariables.frametime	= bIsSimulating ? host_state.interval_per_tick : 0;

	// in singleplayer only run think/simulation if localplayer is connected
	bIsSimulating =  bIsSimulating && ( sv.IsMultiplayer() || cl.IsActive() );

	g_pServerPluginHandler->GameFrame( bIsSimulating );

	if( bIsSimulating )
		GetBenchResultsMgr()->Frame();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : simulating - 
//-----------------------------------------------------------------------------
void SV_PreClientUpdate(bool bIsSimulating )
{
	if ( !serverGameDLL )
		return;

	serverGameDLL->PreClientUpdate( bIsSimulating );
}


//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
/*
==================
SV_Frame

==================
*/
CFunctor *g_pDeferredServerWork;

void SV_FrameExecuteThreadDeferred()
{
	if ( g_pDeferredServerWork )
	{
		(*g_pDeferredServerWork)();
		delete g_pDeferredServerWork;
		g_pDeferredServerWork = NULL;
	}
}

void SV_SendClientUpdates( bool bIsSimulating, bool bSendDuringPause )
{
	bool bForcedSend = s_bForceSend;
	s_bForceSend = false;

	// ask game.dll to add any debug graphics
	SV_PreClientUpdate( bIsSimulating );

	// This causes network messages to be sent
	sv.SendClientMessages( bIsSimulating || bForcedSend );

	// tricky, increase stringtable tick at least one tick
	// so changes made after this point are not counted to this server
	// frame since we already send out the client snapshots
	networkStringTableContainerServer->SetTick( sv.m_nTickCount + 1 );
}

void SV_Frame( bool finalTick )
{
	VPROF( "SV_Frame" );

	if ( serverGameDLL && finalTick )
	{
		serverGameDLL->Think( finalTick );
	}

	if ( !sv.IsActive() || !Host_ShouldRun() )
	{
		return;
	}

	g_ServerGlobalVariables.frametime = host_state.interval_per_tick;

	bool bIsSimulating = SV_IsSimulating();
	bool bSendDuringPause = sv_noclipduringpause ? sv_noclipduringpause->GetBool() : false;

	// unlock sting tables to allow changes, helps to find unwanted changes (bebug build only)
	networkStringTableContainerServer->Lock( false );
	

	// Run any commands from client and play client Think functions if it is time.
	sv.RunFrame(); // read network input etc

	bool simulated = false;
	if ( SV_HasPlayers() )
	{	
		bool serverCanSimulate = ( serverGameDLL && !serverGameDLL->IsRestoring() ) ? true : false;

		if ( serverCanSimulate && ( bIsSimulating || bSendDuringPause ) )
		{
			simulated = true;
			sv.m_nTickCount++;

			networkStringTableContainerServer->SetTick( sv.m_nTickCount );
		}

		SV_Think( bIsSimulating );
	}
	else if ( sv.IsMultiplayer() )
	{
		SV_Think( false );	// let the game.dll systems think
	}

	// This value is read on another thread, so this needs to only happen once per frame and be atomic.
	sv.m_bSimulatingTicks = simulated;

	// Send the results of movement and physics to the clients
	if ( finalTick )
	{
		if ( !IsEngineThreaded() || sv.IsMultiplayer() )
			SV_SendClientUpdates( bIsSimulating, bSendDuringPause );
		else
			g_pDeferredServerWork = CreateFunctor( SV_SendClientUpdates, bIsSimulating, bSendDuringPause );

	}

	// lock string tables
	networkStringTableContainerServer->Lock( true );

	// let the steam auth server process new connections
	if ( IsPC() && sv.IsMultiplayer() )
	{
		Steam3Server().RunFrame();
	}
}