Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
csgo-2018-source/engine/host_cmd.cpp
KittenPopo c2130ba4e9 uid issue
2021-07-24 21:11:47 -07:00

3054 lines
80 KiB
C++
Raw Permalink Blame History

//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
// HACKHACK fix this include
#if defined( _WIN32 ) && !defined( _X360 )
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
#include "tier0/vprof.h"
#include "server.h"
#include "host_cmd.h"
#include "keys.h"
#include "screen.h"
#include "vengineserver_impl.h"
#include "host_saverestore.h"
#include "sv_filter.h"
#include "gl_matsysiface.h"
#include "pr_edict.h"
#include "world.h"
#include "checksum_engine.h"
#include "const.h"
#include "sv_main.h"
#include "host.h"
#include "demo.h"
#include "cdll_int.h"
#include "networkstringtableserver.h"
#include "networkstringtableclient.h"
#include "host_state.h"
#include "string_t.h"
#include "tier0/dbg.h"
#include "testscriptmgr.h"
#include "r_local.h"
#include "PlayerState.h"
#include "enginesingleuserfilter.h"
#include "profile.h"
#include "protocol.h"
#include "cl_main.h"
#include "sv_steamauth.h"
#include "zone.h"
#include "GameEventManager.h"
#include "datacache/idatacache.h"
#include "sys_dll.h"
#include "cmd.h"
#include "tier0/icommandline.h"
#include "filesystem.h"
#include "filesystem_engine.h"
#include "icliententitylist.h"
#include "icliententity.h"
#include "hltvserver.h"
#if defined( REPLAY_ENABLED )
#include "replayserver.h"
#endif
#include "cdll_engine_int.h"
#include "cl_steamauth.h"
#include "cl_splitscreen.h"
#ifndef DEDICATED
#include "vgui_baseui_interface.h"
#endif
#include "sound.h"
#include "voice.h"
#include "sv_rcon.h"
#if defined( _X360 )
#include "xbox/xbox_console.h"
#include "xbox/xbox_launch.h"
#elif defined( _PS3 )
#include "ps3/ps3_console.h"
#include "tls_ps3.h"
#endif
#include "filesystem/IQueuedLoader.h"
#include "filesystem/IXboxInstaller.h"
#include "toolframework/itoolframework.h"
#include "fmtstr.h"
#include "tier3/tier3.h"
#include "matchmaking/imatchframework.h"
#include "tier2/tier2.h"
#include "shaderapi/gpumemorystats.h"
#include "snd_audio_source.h"
#include "netconsole.h"
#include "tier2/fileutils.h"
#if POSIX
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <fcntl.h>
#endif
#include "ixboxsystem.h"
extern IXboxSystem *g_pXboxSystem;
extern IVEngineClient *engineClient;
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define STEAM_PREFIX "STEAM_"
#ifndef DEDICATED
bool g_bInEditMode = false;
bool g_bInCommentaryMode = false;
#endif
KeyValues *g_pLaunchOptions = NULL;
void PerformKick( cmd_source_t commandSource, int iSearchIndex, char* szSearchString, bool bForceKick, const char* pszMessage );
ConVar host_name_store( "host_name_store", "1", FCVAR_RELEASE, "Whether hostname is recorded in game events and GOTV." );
ConVar host_players_show( "host_players_show", "1", FCVAR_RELEASE, "How players are disclosed in server queries: 0 - query disabled, 1 - show only max players count, 2 - show all players" );
ConVar host_info_show( "host_info_show", "1", FCVAR_RELEASE, "How server info gets disclosed in server queries: 0 - query disabled, 1 - show only general info, 2 - show full info" );
ConVar host_rules_show( "host_rules_show", "1", FCVAR_RELEASE, "How server rules get disclosed in server queries: 0 - query disabled, 1 - query enabled" );
static void HostnameChanged( IConVar *pConVar, const char *pOldValue, float flOldValue )
{
Steam3Server().NotifyOfServerNameChange();
if ( sv.IsActive() && host_name_store.GetBool() )
{
// look up the descriptor first to avoid a DevMsg for HL2 and mods that don't define a
// hostname_change event
CGameEventDescriptor *descriptor = g_GameEventManager.GetEventDescriptor( "hostname_changed" );
if ( descriptor )
{
IGameEvent *event = g_GameEventManager.CreateEvent( "hostname_changed" );
if ( event )
{
ConVarRef var( pConVar );
event->SetString( "hostname", var.GetString() );
g_GameEventManager.FireEvent( event );
}
}
}
}
ConVar host_name( "hostname", "", FCVAR_RELEASE, "Hostname for server.", false, 0.0f, false, 0.0f, HostnameChanged );
ConVar host_map( "host_map", "", FCVAR_RELEASE, "Current map name." );
bool CanShowHostTvStatus()
{
if ( !serverGameDLL )
return true;
if ( serverGameDLL->IsValveDS() )
{
// By default OFFICIAL server will NOT print TV information in "status" output
// Running with -display_tv_status will reveal GOTV information
static bool s_bCanShowHostTvStatusOFFICIAL = !!CommandLine()->FindParm( "-display_tv_status" );
return s_bCanShowHostTvStatusOFFICIAL;
}
else
{
// By default COMMUNITY server will print TV information in "status" output
// Running with -disable_tv_status will conceal GOTV information
static bool s_bCanShowHostTvStatusCOMMUNITY = !CommandLine()->FindParm( "-disable_tv_status" );
return s_bCanShowHostTvStatusCOMMUNITY;
}
}
#ifdef _PS3
ConVar ps3_host_quit_graceperiod( "ps3_host_quit_graceperiod", "7", FCVAR_DEVELOPMENTONLY, "Time granted for save operations to finish" );
ConVar ps3_host_quit_debugpause( "ps3_host_quit_debugpause", "0", FCVAR_DEVELOPMENTONLY, "Time to stall quit for debug purposes" );
#endif
ConVar voice_recordtofile("voice_recordtofile", "0", FCVAR_RELEASE, "Record mic data and decompressed voice data into 'voice_micdata.wav' and 'voice_decompressed.wav'");
ConVar voice_inputfromfile("voice_inputfromfile", "0",FCVAR_RELEASE, "Get voice input from 'voice_input.wav' rather than from the microphone.");
uint GetSteamAppID()
{
#ifndef DEDICATED
if ( Steam3Client().SteamUtils() )
return Steam3Client().SteamUtils()->GetAppID();
#endif
if ( Steam3Server().SteamGameServerUtils() )
return Steam3Server().SteamGameServerUtils()->GetAppID();
return 215; // defaults to Source SDK Base (215) if no steam.inf can be found.
}
EUniverse GetSteamUniverse()
{
#ifndef DEDICATED
if ( Steam3Client().SteamUtils() )
return Steam3Client().SteamUtils()->GetConnectedUniverse();
#endif
if ( Steam3Server().SteamGameServerUtils() )
return Steam3Server().SteamGameServerUtils()->GetConnectedUniverse();
return k_EUniverseInvalid;
}
// Globals
int gHostSpawnCount = 0;
// If any quit handlers balk, then aborts quit sequence
bool EngineTool_CheckQuitHandlers();
#if defined( _GAMECONSOLE )
void Host_Quit_f (void);
void PS3_sysutil_callback_forwarder( uint64 uiStatus, uint64 uiParam );
void Quit_gameconsole_f( bool bWarmRestart, bool bUnused )
{
#if defined( _DEMO )
if ( Host_IsDemoExiting() )
{
// for safety, only want to play this under demo exit conditions
// which guaranteed us a safe exiting context
game->PlayVideoListAndWait( "media/DemoUpsellVids.txt" );
}
#endif
#if defined( _X360 ) && defined( _DEMO )
// demo version has to support variants of the launch structures
// demo version must reply with exact demo launch structure if provided
unsigned int launchID;
int launchSize;
void *pLaunchData;
bool bValid = XboxLaunch()->GetLaunchData( &launchID, &pLaunchData, &launchSize );
if ( bValid && Host_IsDemoHostedFromShell() )
{
XboxLaunch()->SetLaunchData( pLaunchData, launchSize, LF_UNKNOWNDATA );
g_pMaterialSystem->PersistDisplay();
XBX_DisconnectConsoleMonitor();
const char *pImageName = XLAUNCH_KEYWORD_DEFAULT_APP;
if ( launchID == LAUNCH_DATA_DEMO_ID )
{
pImageName = ((LD_DEMO*)pLaunchData)->szLauncherXEX;
}
XboxLaunch()->Launch( pImageName );
return;
}
#endif
#ifdef _X360
// must be first, will cause a reset of the launch if we have never been re-launched
// all further XboxLaunch() operations MUST be writes, otherwise reset
int launchFlags = LF_EXITFROMGAME;
// block until the installer stops
g_pXboxInstaller->IsStopped( true );
if ( g_pXboxInstaller->IsFullyInstalled() )
{
launchFlags |= LF_INSTALLEDTOCACHE;
}
// allocate the full payload
int nPayloadSize = XboxLaunch()->MaxPayloadSize();
byte *pPayload = (byte *)stackalloc( nPayloadSize );
V_memset( pPayload, 0, sizeof( nPayloadSize ) );
// payload is at least the command line
// any user data needed must be placed AFTER the command line
const char *pCmdLine = CommandLine()->GetCmdLine();
int nCmdLineLength = (int)strlen( pCmdLine ) + 1;
V_memcpy( pPayload, pCmdLine, min( nPayloadSize, nCmdLineLength ) );
// add any other data here to payload, after the command line
// ...
// Collect settings to preserve across restarts
int numGameUsers = XBX_GetNumGameUsers();
char slot2ctrlr[4];
char slot2guest[4];
int ctrlr2storage[4];
for ( int k = 0; k < 4; ++ k )
{
slot2ctrlr[k] = (char) XBX_GetUserId( k );
slot2guest[k] = (char) XBX_GetUserIsGuest( k );
ctrlr2storage[k] = XBX_GetStorageDeviceId( k );
}
// storage device may have changed since previous launch
XboxLaunch()->SetStorageID( ctrlr2storage );
// Close the storage devices
g_pXboxSystem->CloseAllContainers();
DWORD nUserID = XBX_GetPrimaryUserId();
XboxLaunch()->SetUserID( nUserID );
XboxLaunch()->SetSlotUsers( numGameUsers, slot2ctrlr, slot2guest );
if ( bWarmRestart )
{
// a restart is an attempt at a hidden reboot-in-place
launchFlags |= LF_WARMRESTART;
}
// set our own data and relaunch self
bool bLaunch = XboxLaunch()->SetLaunchData( pPayload, nPayloadSize, launchFlags );
#if defined( _DEMO )
bLaunch = true;
#endif
if ( bLaunch )
{
// Can't send anything to VXConsole; about to abandon connection
// VXConsole tries to respond but can't and throws the timeout crash
// COM_TimestampedLog( "Launching: \"%s\" Flags: 0x%8.8x", pCmdLine, XboxLaunch()->GetLaunchFlags() );
g_pMaterialSystem->PersistDisplay();
XBX_DisconnectConsoleMonitor();
#if defined( CSTRIKE15 )
XboxLaunch()->SetLaunchData( NULL, 0, 0 );
XboxLaunch()->Launch( XLAUNCH_KEYWORD_DASH_ARCADE );
#else
XboxLaunch()->Launch();
#endif // defined( CSTRIKE15 )
}
#elif defined( _PS3 )
// TODO: preserve when a "restart" is requested!
Assert( !bWarmRestart );
Assert( !bUnused );
if ( bWarmRestart )
{
DevWarning( "TODO: PS3 quit_x360 restart is not implemented yet!\n" );
}
// Prevent re-entry
static bool s_bQuitPreventReentry = false;
if ( s_bQuitPreventReentry )
return;
s_bQuitPreventReentry = true;
// We must go into single-threaded rendering
Host_AllowQueuedMaterialSystem( false );
// Make sure everybody received the EXITGAME callback, might happen multiple times now
float const flTimeStampStart = Plat_FloatTime();
float flGracePeriod = ps3_host_quit_graceperiod.GetFloat();
flGracePeriod = MIN( 7, flGracePeriod );
flGracePeriod = MAX( 0, flGracePeriod );
float const flTimeStampForceShutdown = flTimeStampStart + flGracePeriod;
uint64 uiLastCountdownNotificationSent = 0;
for ( ; ; )
{
enum ShutdownSystemsWait_t
{
kSysSaveRestore,
kSysSaveUtilV2,
kSysSteamClient,
kSysDebugPause,
kSysShutdownSystemsCount
};
char const *szSystems[kSysShutdownSystemsCount] = {0};
char const *szSystemsRequiredState[kSysShutdownSystemsCount] = {0};
// Poll systems whether they are ready to shutdown
if ( saverestore && saverestore->IsSaveInProgress() )
szSystems[kSysSaveRestore] = "saverestore";
extern bool SaveUtilV2_CanShutdown();
if ( !SaveUtilV2_CanShutdown() )
szSystems[kSysSaveUtilV2] = "SaveUtilV2";
if ( Steam3Client().SteamUtils() && !Steam3Client().SteamUtils()->BIsReadyToShutdown() )
szSystems[kSysSteamClient] = "steamclient";
if ( ( ps3_host_quit_debugpause.GetFloat() > 0 ) && ( Plat_FloatTime() < flTimeStampStart + ps3_host_quit_debugpause.GetFloat() ) )
szSystems[kSysDebugPause] = "debugpause";
if ( !Q_memcmp( szSystemsRequiredState, szSystems, sizeof( szSystemsRequiredState ) ) )
{
DevMsg( "PS3 shutdown procedure: all systems ready (%.2f sec elapsed)\n", ( Plat_FloatTime() - flTimeStampStart ) );
break;
}
uint64 uiCountdownNotification = 1 + ( flTimeStampForceShutdown - Plat_FloatTime() );
if ( uiCountdownNotification != uiLastCountdownNotificationSent )
{
uiLastCountdownNotificationSent = uiCountdownNotification;
PS3_sysutil_callback_forwarder( CELL_SYSUTIL_REQUEST_EXITGAME, uiCountdownNotification );
DevWarning( "PS3 shutdown procedure: %.2f sec elapsed...\n", ( Plat_FloatTime() - flTimeStampStart ) );
int nNotReadySystemsCount = 0;
for ( int jj = 0; jj < ARRAYSIZE( szSystems ); ++ jj )
{
if ( szSystems[jj] )
{
DevWarning( " system not ready : %s\n", szSystems[jj] );
++ nNotReadySystemsCount;
}
}
DevWarning( "PS3 shutdown procedure: waiting for %d systems to be ready for shutdown (%.2f sec remaining)...\n", nNotReadySystemsCount, ( flTimeStampForceShutdown - Plat_FloatTime() ) );
}
if ( Plat_FloatTime() >= flTimeStampForceShutdown )
{
DevWarning( "FORCING PS3 SHUTDOWN PROCEDURE: NOT ALL SYSTEMS READY (%.2f sec elapsed)...\n", ( Plat_FloatTime() - flTimeStampStart ) );
break;
}
// Perform blank vsync'ed flips
static ConVarRef mat_vsync( "mat_vsync" );
mat_vsync.SetValue( true );
g_pMaterialSystem->SetFlipPresentFrequency( 1 ); // let it flip every VSYNC, we let interrupt handler throttle this loop to conform with TCR#R092 [no more than 60 fps]
// Dummy frame
g_pMaterialSystem->BeginFrame( 1.0f/60.0f );
CMatRenderContextPtr pRenderContext;
pRenderContext.GetFrom( g_pMaterialSystem );
pRenderContext->ClearColor4ub( 0, 0, 0, 255 );
pRenderContext->ClearBuffers( true, true, true );
pRenderContext.SafeRelease();
g_pMaterialSystem->EndFrame();
g_pMaterialSystem->SwapBuffers();
// Pump system event queue
XBX_ProcessEvents();
XBX_DispatchEventsQueue();
}
// QUIT
Warning( "[PS3 SYSTEM] REQUEST EXITGAME INITIATING QUIT @ %.3f\n", Plat_FloatTime() );
Host_Quit_f();
#else
Assert( 0 );
#error
#endif
}
CON_COMMAND( quit_gameconsole, "" )
{
Quit_gameconsole_f(
args.FindArg( "restart" ) != NULL,
args.FindArg( "invite" ) != NULL );
}
#endif
// store arbitrary launch arguments in KeyValues to avoid having to add code for every new
// launch parameter (like edit mode, commentary mode, background, etc. do)
void SetLaunchOptions( const CCommand &args )
{
if ( g_pLaunchOptions )
{
g_pLaunchOptions->deleteThis();
}
g_pLaunchOptions = new KeyValues( "LaunchOptions" );
for ( int i = 0 ; i < args.ArgC() ; i++ )
{
g_pLaunchOptions->SetString( va("Arg%d", i), args[i] );
}
}
/*
==================
Host_Quit_f
==================
*/
void Host_Quit_f (void)
{
#if !defined(DEDICATED)
if ( !EngineTool_CheckQuitHandlers() )
{
return;
}
#endif
HostState_Shutdown();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CON_COMMAND( _restart, "Shutdown and restart the engine." )
{
/*
// FIXME: How to handle restarts?
#ifndef DEDICATED
if ( !EngineTool_CheckQuitHandlers() )
{
return;
}
#endif
*/
HostState_Restart();
}
#ifndef DEDICATED
//-----------------------------------------------------------------------------
// A console command to spew out driver information
//-----------------------------------------------------------------------------
void Host_LightCrosshair (void);
static ConCommand light_crosshair( "light_crosshair", Host_LightCrosshair, "Show texture color at crosshair", FCVAR_CHEAT );
void Host_LightCrosshair (void)
{
Vector endPoint;
Vector lightmapColor;
// max_range * sqrt(3)
VectorMA( MainViewOrigin(), COORD_EXTENT * 1.74f, MainViewForward(), endPoint );
R_LightVec( MainViewOrigin(), endPoint, true, lightmapColor );
int r = LinearToTexture( lightmapColor.x );
int g = LinearToTexture( lightmapColor.y );
int b = LinearToTexture( lightmapColor.z );
ConMsg( "Luxel Value: %d %d %d\n", r, g, b );
}
#endif
/*
==================
Host_Status_PrintClient
Print client info to console
==================
*/
void Host_Status_PrintClient( IClient *client, bool bShowAddress, void (*print) (const char *fmt, ...) )
{
INetChannelInfo *nci = client->GetNetChannel();
const char *state = "challenging";
if ( client->IsActive() )
state = "active";
else if ( client->IsSpawned() )
state = "spawning";
else if ( client->IsConnected() )
state = "connecting";
if ( nci != NULL )
{
print( "# %2i %i \"%s\" %s %s %i %i %s %d",
client->GetUserID(), client->GetPlayerSlot() + 1, client->GetClientName(), client->GetNetworkIDString(), COM_FormatSeconds( nci->GetTimeConnected() ),
(int)(1000.0f*nci->GetAvgLatency( FLOW_OUTGOING )), (int)(100.0f*nci->GetAvgLoss(FLOW_INCOMING)), state, (int)nci->GetDataRate() );
if ( bShowAddress )
{
print( " %s", nci->GetAddress() );
}
}
else
{
print( "#%2i \"%s\" %s %s %.0f",
client->GetUserID(), client->GetClientName(), client->GetNetworkIDString(), state, client->GetUpdateRate() );
}
print( "\n" );
}
typedef void ( *FnPrintf_t )(const char *fmt, ...);
void Host_Client_Printf(const char *fmt, ...)
{
va_list argptr;
char string[1024];
va_start (argptr,fmt);
Q_vsnprintf (string, sizeof( string ), fmt,argptr);
va_end (argptr);
host_client->ClientPrintf( "%s", string );
}
static void Host_Client_PrintfStub(const char *fmt, ...)
{
}
void Host_PrintStatus( cmd_source_t commandSource, void ( *print )(const char *fmt, ...), bool bShort )
{
bool bWithAddresses = ( ( commandSource != kCommandSrcNetClient ) && ( commandSource != kCommandSrcNetServer ) && ( print == ConMsg ) ); // guarantee to never print for remote
IClient *client;
int j;
if ( !print ) { return; }
// ============================================================
// Server status information.
print( "hostname: %s\n", host_name.GetString() );
const char *pchSecureReasonString = "";
const char *pchUniverse = "";
bool bGSSecure = Steam3Server().BSecure();
if ( !bGSSecure && Steam3Server().BWantsSecure() )
{
if ( Steam3Server().BLoggedOn() )
{
pchSecureReasonString = "(secure mode enabled, connected to Steam3)";
}
else
{
pchSecureReasonString = "(secure mode enabled, disconnected from Steam3)";
}
}
switch ( GetSteamUniverse() )
{
case k_EUniversePublic:
pchUniverse = "";
break;
case k_EUniverseBeta:
pchUniverse = "(beta)";
break;
case k_EUniverseInternal:
pchUniverse = "(internal)";
break;
case k_EUniverseDev:
pchUniverse = "(dev)";
break;
/* no such universe anymore
case k_EUniverseRC:
pchUniverse = "(rc)";
break;
*/
default:
pchUniverse = "(unknown)";
break;
}
if ( bWithAddresses )
{
print( "version : %s/%d %d/%d %s %s %s %s\n",
Sys_GetVersionString(), GetHostVersion(),
GetServerVersion(), build_number(),
bGSSecure ? "secure" : "insecure", pchSecureReasonString,
Steam3Server().GetGSSteamID().IsValid() ? Steam3Server().GetGSSteamID().Render() : "[INVALID_STEAMID]", pchUniverse );
}
else
{
print( "version : %s %s\n",
Sys_GetVersionString(),
bGSSecure ? "secure" : "insecure" );
}
if ( NET_IsMultiplayer() )
{
CUtlString sPublicIPInfo;
if ( !Steam3Server().BLanOnly() )
{
uint32 unPublicIP = Steam3Server().GetPublicIP();
if ( ( unPublicIP != 0 ) && bWithAddresses && sv.IsDedicated() )
{
netadr_t addr;
addr.SetIP( unPublicIP );
sPublicIPInfo.Format(" (public ip: %s)", addr.ToString( true ) );
}
}
print( "udp/ip : %s:%i%s\n", net_local_adr.ToString(true), sv.GetUDPPort(), sPublicIPInfo.String() );
static ConVarRef sv_steamdatagramtransport_port( "sv_steamdatagramtransport_port" );
if ( bWithAddresses && sv_steamdatagramtransport_port.GetInt() > 0 )
{
print( "sdt : =%s on port %d\n", Steam3Server().GetGSSteamID().Render(), sv_steamdatagramtransport_port.GetInt() );
}
const char *osType =
#if defined( WIN32 )
"Windows";
#elif defined( _LINUX )
"Linux";
#elif defined( PLATFORM_OSX )
"OSX";
#else
"Unknown";
#endif
print( "os : %s\n", osType );
char const *serverType = sv.IsHLTV() ? "hltv" : ( sv.IsDedicated() ? ( serverGameDLL->IsValveDS() ? "official dedicated" : "community dedicated" ) : "listen" );
print( "type : %s\n", serverType );
}
#ifndef DEDICATED // no client on dedicated server
if ( !sv.IsDedicated() && GetBaseLocalClient().IsConnected() )
{
print( "map : %s at: %d x, %d y, %d z\n", sv.GetMapName(), (int)MainViewOrigin()[0], (int)MainViewOrigin()[1], (int)MainViewOrigin()[2]);
}
#else
{
print( "map : %s\n", sv.GetMapName() );
}
#endif
if ( CanShowHostTvStatus() )
{
for ( CActiveHltvServerIterator hltv; hltv; hltv.Next() )
{
print( "gotv[%i]: port %i, delay %.1fs, rate %.1f\n", hltv.GetIndex(), hltv->GetUDPPort(), hltv->GetDirector() ? hltv->GetDirector()->GetDelay() : 0.0f, hltv->GetSnapshotRate() );
}
}
#if defined( REPLAY_ENABLED )
if ( replay && replay->IsActive() )
{
print( "replay: port %i, delay %.1fs\n", replay->GetUDPPort(), replay->GetDirector()->GetDelay() );
}
#endif
int nHumans;
int nMaxHumans;
int nBots;
sv.GetMasterServerPlayerCounts( nHumans, nMaxHumans, nBots );
print( "players : %i humans, %i bots (%i/%i max) (%s)\n\n",
nHumans, nBots, nMaxHumans, sv.GetNumGameSlots(), sv.IsHibernating() ? "hibernating" : "not hibernating" );
// ============================================================
#if SUPPORT_NET_CONSOLE
if ( g_pNetConsoleMgr && g_pNetConsoleMgr->IsActive() && bWithAddresses )
{
print( "netcon : %s:%i\n", net_local_adr.ToString( true), g_pNetConsoleMgr->GetAddress().GetPort() );
}
#endif
// Early exit for this server.
if ( bShort )
{
for ( j=0 ; j < sv.GetClientCount() ; j++ )
{
client = sv.GetClient( j );
if ( !client->IsActive() )
continue;
if ( !bWithAddresses && !CanShowHostTvStatus() && client->IsHLTV() )
continue;
print( "#%i - %s\n" , j + 1, client->GetClientName() );
}
return;
}
// the header for the status rows
print( "# userid name uniqueid connected ping loss state rate" );
if ( bWithAddresses )
{
print( " adr" );
}
print( "\n" );
for ( j=0 ; j < sv.GetClientCount() ; j++ )
{
client = sv.GetClient( j );
if ( !client->IsConnected() )
continue; // not connected yet, maybe challenging
if ( !CanShowHostTvStatus() && client->IsHLTV() )
continue;
Host_Status_PrintClient( client, bWithAddresses, print );
}
print( "#end\n" );
}
//-----------------------------------------------------------------------------
// Host_Status_f
//-----------------------------------------------------------------------------
CON_COMMAND( status, "Display map and connection status." )
{
void (*print) (const char *fmt, ...) = Host_Client_PrintfStub;
if ( args.Source() != kCommandSrcNetClient )
{
if ( !sv.IsActive() )
{
Cmd_ForwardToServer( args );
return;
}
#ifndef DBGFLAG_STRINGS_STRIP
print = ConMsg;
#endif
}
else
{
print = Host_Client_Printf;
}
bool bShort = false;
if ( args.ArgC() == 2 )
{
if ( !Q_stricmp( args[1], "short" ) )
{
bShort = true;
}
}
Host_PrintStatus( args.Source(), print, bShort );
}
CON_COMMAND( hltv_replay_status, "Show Killer Replay status and some statistics, works on listen or dedicated server." )
{
HltvReplayStats_t hltvStats;
for ( int j = 0; j < sv.GetClientCount(); j++ )
{
IClient *client = sv.GetClient( j );
if ( !client->IsConnected() )
continue; // not connected yet, maybe challenging
if ( !CanShowHostTvStatus() && client->IsHLTV() )
continue;
INetChannelInfo *nci = client->GetNetChannel();
const char *state = "challenging";
if ( client->IsActive() )
state = "active";
else if ( client->IsSpawned() )
state = "spawning";
else if ( client->IsConnected() )
state = "connecting";
if ( nci != NULL )
{
ConMsg( "# %2i %i \"%s\" %s %s %s %s",
client->GetUserID(), client->GetPlayerSlot() + 1, client->GetClientName(), client->GetNetworkIDString(), COM_FormatSeconds( nci->GetTimeConnected() ),
state, client->GetHltvReplayStatus() );
if ( client->GetHltvReplayDelay() )
ConMsg( ", in replay NOW" );
}
else
{
ConMsg( "#%2i \"%s\" %s %s %s",
client->GetUserID(), client->GetClientName(), client->GetNetworkIDString(), state, client->GetHltvReplayStatus() );
}
if ( CGameClient *pClient = dynamic_cast< CGameClient * >( client ) )
{
if ( pClient->m_HltvReplayStats.nStartRequests )
hltvStats += pClient->m_HltvReplayStats;
if ( pClient->m_nForceWaitForTick > 0 )
{
ConMsg( ", force-waiting for tick %d - server tick %d, current frame %d", pClient->m_nForceWaitForTick, sv.GetTick(), pClient->m_pCurrentFrame ? pClient->m_pCurrentFrame->tick_count : 0 );
}
}
ConMsg( "\n" );
}
extern HltvReplayStats_t m_DisconnectedClientsHltvReplayStats;
if ( m_DisconnectedClientsHltvReplayStats.nClients > 1 )
ConMsg( "%u disconnected clients: %s\n", m_DisconnectedClientsHltvReplayStats.nClients - 1, m_DisconnectedClientsHltvReplayStats.AsString() );
if ( hltvStats.nClients > 0 )
{
ConMsg( "%u current clients: %s\n", hltvStats.nClients, hltvStats.AsString() );
}
}
#if defined( _X360 )
CON_COMMAND( vx_mapinfo, "" )
{
Vector org;
QAngle ang;
const char *pName;
if ( GetBaseLocalClient().IsActive() )
{
pName = GetBaseLocalClient().m_szLevelNameShort;
org = MainViewOrigin();
VectorAngles( MainViewForward(), ang );
IClientEntity *localPlayer = entitylist->GetClientEntity( GetBaseLocalClient().m_nPlayerSlot + 1 );
if ( localPlayer )
{
org = localPlayer->GetAbsOrigin();
}
}
else
{
pName = "";
org.Init();
ang.Init();
}
// HACK: This is only relevant for portal2.
Msg( "BUG REPORT PORTAL POSITIONS:\n" );
Cbuf_AddText( Cbuf_GetCurrentPlayer(), "portal_report\n" );
// send to vxconsole
xMapInfo_t mapInfo;
mapInfo.position[0] = org[0];
mapInfo.position[1] = org[1];
mapInfo.position[2] = org[2];
mapInfo.angle[0] = ang[0];
mapInfo.angle[1] = ang[1];
mapInfo.angle[2] = ang[2];
mapInfo.build = build_number();
mapInfo.skill = skill.GetInt();
// generate the qualified path where .sav files are expected to be written
char savePath[MAX_PATH];
V_snprintf( savePath, sizeof( savePath ), "%s", saverestore->GetSaveDir() );
V_StripTrailingSlash( savePath );
g_pFileSystem->RelativePathToFullPath( savePath, "MOD", mapInfo.savePath, sizeof( mapInfo.savePath ) );
V_FixSlashes( mapInfo.savePath );
if ( pName[0] )
{
// generate the qualified path from where the map was loaded
char mapPath[MAX_PATH];
V_snprintf( mapPath, sizeof( mapPath ), "maps/%s" PLATFORM_EXT ".bsp", pName );
g_pFileSystem->GetLocalPath( mapPath, mapInfo.mapPath, sizeof( mapInfo.mapPath ) );
V_FixSlashes( mapInfo.mapPath );
}
else
{
mapInfo.mapPath[0] = '\0';
}
mapInfo.details[0] = '\0';
ConVarRef host_thread_mode( "host_thread_mode" );
ConVarRef mat_queue_mode( "mat_queue_mode" );
ConVarRef snd_surround_speakers( "snd_surround_speakers" );
V_strncat(
mapInfo.details,
CFmtStr( "Build: %d\n", build_number() ),
sizeof( mapInfo.details ) );
XVIDEO_MODE videoMode;
XGetVideoMode( &videoMode );
V_strncat(
mapInfo.details,
CFmtStr( "Display: %dx%d (%s)\n", videoMode.dwDisplayWidth, videoMode.dwDisplayHeight, videoMode.fIsWideScreen ? "widescreen" : "normal" ),
sizeof( mapInfo.details ) );
int backbufferWidth, backbufferHeight;
materials->GetBackBufferDimensions( backbufferWidth, backbufferHeight );
V_strncat(
mapInfo.details,
CFmtStr( "BackBuffer: %dx%d\n", backbufferWidth, backbufferHeight ),
sizeof( mapInfo.details ) );
// audio info
const char *pAudioInfo = "Unknown";
switch ( snd_surround_speakers.GetInt() )
{
case 2:
pAudioInfo = "Stereo";
break;
case 5:
pAudioInfo = "5.1 Digital Surround";
break;
}
V_strncat(
mapInfo.details,
CFmtStr( "Audio: %s\n", pAudioInfo ),
sizeof( mapInfo.details ) );
// ui language
V_strncat(
mapInfo.details,
CFmtStr( "UI: %s\n", cl_language.GetString() ),
sizeof( mapInfo.details ) );
// cvars
V_strncat(
mapInfo.details,
CFmtStr( "host_thread_mode: %d\n", host_thread_mode.GetInt() ),
sizeof( mapInfo.details ) );
V_strncat(
mapInfo.details,
CFmtStr( "mat_queue_mode: %d\n", mat_queue_mode.GetInt() ),
sizeof( mapInfo.details ) );
XBX_rMapInfo( &mapInfo );
}
#elif defined( _PS3 )
#include "ps3/ps3_sn.h"
CON_COMMAND( vx_mapinfo, "" )
{
Vector org;
QAngle ang;
const char *pName;
if ( GetBaseLocalClient().IsActive() )
{
pName = GetBaseLocalClient().m_szLevelNameShort;
org = MainViewOrigin();
VectorAngles( MainViewForward(), ang );
IClientEntity *localPlayer = entitylist->GetClientEntity( GetBaseLocalClient().m_nPlayerSlot + 1 );
if ( localPlayer )
{
org = localPlayer->GetAbsOrigin();
}
}
else
{
pName = "";
org.Init();
ang.Init();
}
// HACK: This is only relevant for portal2.
Msg( "BUG REPORT PORTAL POSITIONS:\n" );
Cbuf_AddText( Cbuf_GetCurrentPlayer(), "portal_report\n" );
// send to vxconsole
xMapInfo_t mapInfo;
mapInfo.position[0] = org[0];
mapInfo.position[1] = org[1];
mapInfo.position[2] = org[2];
mapInfo.angle[0] = ang[0];
mapInfo.angle[1] = ang[1];
mapInfo.angle[2] = ang[2];
mapInfo.build = build_number();
mapInfo.skill = skill.GetInt();
// generate the qualified path where .sav files are expected to be written
char savePath[MAX_PATH];
V_snprintf( savePath, sizeof( savePath ), "%s", saverestore->GetSaveDir() );
V_StripTrailingSlash( savePath );
g_pFileSystem->RelativePathToFullPath( savePath, "MOD", mapInfo.savePath, sizeof( mapInfo.savePath ) );
V_FixSlashes( mapInfo.savePath );
if ( pName[0] )
{
// generate the qualified path from where the map was loaded
char mapPath[MAX_PATH];
V_snprintf( mapPath, sizeof( mapPath ), "maps/%s" PLATFORM_EXT ".bsp", pName );
g_pFileSystem->GetLocalPath( mapPath, mapInfo.mapPath, sizeof( mapInfo.mapPath ) );
V_FixSlashes( mapInfo.mapPath );
}
else
{
mapInfo.mapPath[0] = '\0';
}
mapInfo.details[0] = '\0';
ConVarRef host_thread_mode( "host_thread_mode" );
ConVarRef mat_queue_mode( "mat_queue_mode" );
ConVarRef snd_surround_speakers( "snd_surround_speakers" );
V_strncat(
mapInfo.details,
CFmtStr( "Build: %d\n", build_number() ),
sizeof( mapInfo.details ) );
/*
XVIDEO_MODE videoMode;
XGetVideoMode( &videoMode );
V_strncat(
mapInfo.details,
CFmtStr( "Display: %dx%d (%s)\n", videoMode.dwDisplayWidth, videoMode.dwDisplayHeight, videoMode.fIsWideScreen ? "widescreen" : "normal" ),
sizeof( mapInfo.details ) );
int backbufferWidth, backbufferHeight;
materials->GetBackBufferDimensions( backbufferWidth, backbufferHeight );
V_strncat(
mapInfo.details,
CFmtStr( "BackBuffer: %dx%d\n", backbufferWidth, backbufferHeight ),
sizeof( mapInfo.details ) );
*/
// audio info
const char *pAudioInfo = "Unknown";
switch ( snd_surround_speakers.GetInt() )
{
case 2:
pAudioInfo = "Stereo";
break;
case 5:
pAudioInfo = "5.1 Digital Surround";
break;
}
V_strncat(
mapInfo.details,
CFmtStr( "Audio: %s\n", pAudioInfo ),
sizeof( mapInfo.details ) );
// ui language
V_strncat(
mapInfo.details,
CFmtStr( "UI: %s\n", cl_language.GetString() ),
sizeof( mapInfo.details ) );
// cvars
V_strncat(
mapInfo.details,
CFmtStr( "host_thread_mode: %d\n", host_thread_mode.GetInt() ),
sizeof( mapInfo.details ) );
V_strncat(
mapInfo.details,
CFmtStr( "mat_queue_mode: %d\n", mat_queue_mode.GetInt() ),
sizeof( mapInfo.details ) );
XBX_rMapInfo( &mapInfo );
}
CON_COMMAND( vx_screenshot, "" )
{
#if 1
g_pMaterialSystem->TransmitScreenshotToVX( );
#else
// COMPILE_TIME_ASSERT( sizeof(g_pfnSwapBufferMarker) == 8);
union FunctionPointerIsReallyADescriptor
{
void (*pFunc_t)();
struct
{
uint32 funcaddress;
int32 iToc;
} fn8;
};
FunctionPointerIsReallyADescriptor *pBreakpoint = (FunctionPointerIsReallyADescriptor *)g_pfnSwapBufferMarker;
// breakpoint.pFunc_t = g_pfnSwapBufferMarker;
uint64 uBPAddress;
/// Address of a pointer that points to the image in memory
char * pFrameBuffer;
/// Width of image
uint32 uWidth;
/// Height of image
uint32 uHeight;
/// Image pitch (as described in CellGCMSurface) - in bytes
uint32 uPitch;
/// Image colour settings (0 = X8R8G8B8, 1 = X8B8G8R8, 2 = R16G16B16X16)
IMaterialSystem::VRAMScreenShotInfoColor_t colour ;
// get one of the screen buffers. Since we breakpoint the game anyway I don't think
// it really matters if we're two out of date. (For this test, anyway.)
g_pMaterialSystem->GetVRAMScreenShotInfo( &pFrameBuffer, &uWidth, &uHeight, &uPitch, &colour );
g_pValvePS3Console->VRAMDumpingInfo( (uint64)pBreakpoint->fn8.funcaddress,
(uint64)pFrameBuffer, uWidth, uHeight, uPitch, colour );
#endif
}
#endif
//-----------------------------------------------------------------------------
// Host_Ping_f
//-----------------------------------------------------------------------------
CON_COMMAND( ping, "Display ping to server." )
{
if ( args.Source() != kCommandSrcNetClient )
{
Cmd_ForwardToServer( args );
return;
}
host_client->ClientPrintf( "Client ping times:\n" );
for ( int i=0; i< sv.GetClientCount(); i++ )
{
IClient *client = sv.GetClient(i);
if ( !client->IsConnected() || client->IsFakeClient() )
continue;
host_client->ClientPrintf ("%4.0f ms : %s\n",
1000.0f * client->GetNetChannel()->GetAvgLatency( FLOW_OUTGOING ), client->GetClientName() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : editmode -
//-----------------------------------------------------------------------------
extern void GetPlatformMapPath( const char *pMapPath, char *pPlatformMapPath, int maxLength );
bool CL_HL2Demo_MapCheck( const char *name )
{
if ( IsPC() && CL_IsHL2Demo() && !sv.IsDedicated() )
{
if ( !Q_stricmp( name, "d1_trainstation_01" ) ||
!Q_stricmp( name, "d1_trainstation_02" ) ||
!Q_stricmp( name, "d1_town_01" ) ||
!Q_stricmp( name, "d1_town_01a" ) ||
!Q_stricmp( name, "d1_town_02" ) ||
!Q_stricmp( name, "d1_town_03" ) ||
!Q_stricmp( name, "background01" ) ||
!Q_stricmp( name, "background03" )
)
{
return true;
}
return false;
}
return true;
}
bool CL_PortalDemo_MapCheck( const char *name )
{
if ( IsPC() && CL_IsPortalDemo() && !sv.IsDedicated() )
{
if ( !Q_stricmp( name, "testchmb_a_00" ) ||
!Q_stricmp( name, "testchmb_a_01" ) ||
!Q_stricmp( name, "testchmb_a_02" ) ||
!Q_stricmp( name, "testchmb_a_03" ) ||
!Q_stricmp( name, "testchmb_a_04" ) ||
!Q_stricmp( name, "testchmb_a_05" ) ||
!Q_stricmp( name, "testchmb_a_06" ) ||
!Q_stricmp( name, "background1" )
)
{
return true;
}
return false;
}
return true;
}
enum EMapFlags
{
EMAP_NONE = 0,
EMAP_EDIT_MODE = (1<<0),
EMAP_BACKGROUND = (1<<1),
EMAP_COMMENTARY = (1<<2),
EMAP_SPLITSCREEN = (1<<3)
};
int _Host_Map_f_CompletionFunc( char const *cmdname, char const *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] );
// Note, leaves name alone if no match possible
static bool Host_Map_Helper_FuzzyName( const CCommand &args, char *name, size_t bufsize )
{
char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ];
CUtlString argv0;
argv0 = args.Arg( 0 );
argv0 += " ";
if ( _Host_Map_f_CompletionFunc( argv0, args[1], commands ) > 0 )
{
Q_strncpy( name, &commands[ 0 ][ argv0.Length() ], bufsize );
return true;
}
return false;
}
void Host_Changelevel_f( const CCommand &args );
void Host_Map_Helper( const CCommand &args, EMapFlags flags )
{
char name[MAX_QPATH];
if (args.ArgC() < 2)
{
Warning("No map specified\n");
return;
}
if ( ( sv.IsActive() && !sv.IsSinglePlayerGame() && !sv.IsLevelMainMenuBackground() ) ||
( sv.IsActive() && sv.IsDedicated() ) )
{
// Using the 'map' command while in a map disconnects all players.
// Ease the pain of this common error by forwarding to the correct command.
Host_Changelevel_f( args );
return;
}
bool bBackground = ( flags & EMAP_BACKGROUND ) != 0;
bool bSplitScreenConnect = ( flags & EMAP_SPLITSCREEN ) != 0;
char ppath[ MAX_QPATH ];
// If there is a .bsp on the end, strip it off!
Q_StripExtension( args[ 1 ], ppath, sizeof( ppath ) );
// Call with quiet flag for initial search
if ( !modelloader->Map_IsValid( ppath, true ) )
{
Host_Map_Helper_FuzzyName( args, ppath, sizeof( ppath ) );
if ( !modelloader->Map_IsValid( ppath ) )
{
Warning( "map load failed: %s not found or invalid\n", ppath );
return;
}
}
GetPlatformMapPath( ppath, name, sizeof( name ) );
// If I was in edit mode reload config file
// to overwrite WC edit key bindings
#if !defined(DEDICATED)
bool bCommentary = ( flags & EMAP_COMMENTARY ) != 0;
bool bEditmode = ( flags & EMAP_EDIT_MODE ) != 0;
if ( !bEditmode )
{
if ( g_bInEditMode )
{
// Re-read config from disk
Host_ReadConfiguration( -1, false );
g_bInEditMode = false;
}
}
else
{
g_bInEditMode = true;
}
g_bInCommentaryMode = bCommentary;
#endif
SetLaunchOptions( args );
if ( !CL_HL2Demo_MapCheck( name ) )
{
Warning( "map load failed: %s not found or invalid\n", name );
return;
}
if ( !CL_PortalDemo_MapCheck( name ) )
{
Warning( "map load failed: %s not found or invalid\n", name );
return;
}
#ifdef DEDICATED
if ( sv.IsDedicated() )
#else
// Stop demo loop
GetBaseLocalClient().demonum = -1;
if ( GetBaseLocalClient().m_nMaxClients == 0 || sv.IsDedicated() )
#endif
{
Host_Disconnect( false ); // stop old game
HostState_NewGame( name, false, bBackground, bSplitScreenConnect );
}
if (args.ArgC() == 10)
{
if (Q_stricmp(args[2], "setpos") == 0
&& Q_stricmp(args[6], "setang") == 0)
{
Vector newpos;
newpos.x = atof( args[3] );
newpos.y = atof( args[4] );
newpos.z = atof( args[5] );
QAngle newangle;
newangle.x = atof( args[7] );
newangle.y = atof( args[8] );
newangle.z = atof( args[9] );
HostState_SetSpawnPoint(newpos, newangle);
}
}
}
// Handle a map command from the console. Active clients are kicked off.
void Host_Map_f( const CCommand &args )
{
Host_Map_Helper( args, (EMapFlags)0 );
}
// Handle a map group command from the console
void Host_MapGroup_f( const CCommand &args )
{
if ( args.ArgC() < 2 )
{
Warning( "Host_MapGroup_f: No mapgroup specified\n" );
return;
}
Msg( "Setting mapgroup to '%s'\n", args[1] );
HostState_SetMapGroupName( args[1] );
}
// Handle smap command to connect multiple splitscreen users at once
void Host_SplitScreen_Map_f( const CCommand &args )
{
#ifndef _DEMO
Host_Map_Helper( args, EMAP_SPLITSCREEN );
#endif
}
//-----------------------------------------------------------------------------
// handle a map_edit <servername> command from the console.
// Active clients are kicked off.
// UNDONE: protect this from use if not in dev. mode
//-----------------------------------------------------------------------------
#ifndef DEDICATED
CON_COMMAND( map_edit, "" )
{
Host_Map_Helper( args, EMAP_EDIT_MODE );
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Runs a map as the background
//-----------------------------------------------------------------------------
void Host_Map_Background_f( const CCommand &args )
{
Host_Map_Helper( args, EMAP_BACKGROUND );
}
//-----------------------------------------------------------------------------
// Purpose: Runs a map in commentary mode
//-----------------------------------------------------------------------------
void Host_Map_Commentary_f( const CCommand &args )
{
Host_Map_Helper( args, EMAP_COMMENTARY );
}
//-----------------------------------------------------------------------------
// Restarts the current server for a dead player
//-----------------------------------------------------------------------------
CON_COMMAND( restart, "Restart the game on the same level (add setpos to jump to current view position on restart)." )
{
if (
#if !defined(DEDICATED)
demoplayer->IsPlayingBack() ||
#endif
!sv.IsActive() )
return;
if ( sv.IsMultiplayer() )
return;
bool bRememberLocation = ( args.ArgC() == 2 && !Q_stricmp( args[1], "setpos" ) );
bool bSplitScreenConnect = GET_NUM_SPLIT_SCREEN_PLAYERS() == 2 ;
Host_Disconnect(false); // stop old game
if ( !CL_HL2Demo_MapCheck( sv.GetMapName() ) )
{
Warning( "map load failed: %s not found or invalid\n", sv.GetMapName() );
return;
}
if ( !CL_PortalDemo_MapCheck( sv.GetMapName() ) )
{
Warning( "map load failed: %s not found or invalid\n", sv.GetMapName() );
return;
}
HostState_NewGame( sv.GetMapName(), bRememberLocation, false, bSplitScreenConnect );
}
//-----------------------------------------------------------------------------
// Restarts the current server for a dead player
//-----------------------------------------------------------------------------
CON_COMMAND( reload, "Reload the most recent saved game (add setpos to jump to current view position on reload).")
{
#ifndef DEDICATED
const char *pSaveName;
char name[MAX_OSPATH];
#endif
if (
#if !defined(DEDICATED)
demoplayer->IsPlayingBack() ||
#endif
!sv.IsActive() )
return;
if ( sv.IsMultiplayer() )
return;
if ( !serverGameDLL->SupportsSaveRestore() )
return;
bool remember_location = false;
if ( args.ArgC() == 2 &&
!Q_stricmp( args[1], "setpos" ) )
{
remember_location = true;
}
// See if there is a most recently saved game
// Restart that game if there is
// Otherwise, restart the starting game map
#ifndef DEDICATED
pSaveName = saverestore->FindRecentSave( name, sizeof( name ) );
// Put up loading plaque
SCR_BeginLoadingPlaque();
{
// Prepare the offline session for server reload
KeyValues *pEvent = new KeyValues( "OnEngineClientSignonStatePrepareChange" );
pEvent->SetString( "reason", "reload" );
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( pEvent );
}
Host_Disconnect( false ); // stop old game
if ( pSaveName && saverestore->SaveFileExists( pSaveName ) )
{
HostState_LoadGame( pSaveName, remember_location, false );
}
else
#endif
{
if ( !CL_HL2Demo_MapCheck( host_map.GetString() ) )
{
Warning( "map load failed: %s not found or invalid\n", host_map.GetString() );
return;
}
if ( !CL_PortalDemo_MapCheck( host_map.GetString() ) )
{
Warning( "map load failed: %s not found or invalid\n", host_map.GetString() );
return;
}
#if !defined( DEDICATED )
if ( pSaveName && pSaveName[0] )
{
Warning( "SAVERESTORE PROBLEM: %s not found! Starting new game in %s\n", pSaveName, host_map.GetString() );
}
#endif
HostState_NewGame( host_map.GetString(), remember_location, false, false );
}
}
//-----------------------------------------------------------------------------
// Purpose: Goes to a new map, taking all clients along
// Output : void Host_Changelevel_f
//-----------------------------------------------------------------------------
void Host_Changelevel_f( const CCommand &args )
{
if ( args.ArgC() < 2 )
{
ConMsg( "changelevel <levelname> : continue game on a new level\n" );
return;
}
if ( !sv.IsActive() )
{
ConMsg( "Can't changelevel, not running server\n" );
return;
}
char mapname[MAX_PATH];
Q_StripExtension( args[ 1 ], mapname, sizeof( mapname ) );
bool bMapMustExist = true;
static ConVarRef sv_workshop_allow_other_maps( "sv_workshop_allow_other_maps" );
if ( StringHasPrefix( mapname, "workshop" ) && ( ( mapname[8] == '/' ) || ( mapname[8] == '\\' ) ) &&
sv_workshop_allow_other_maps.GetBool() )
bMapMustExist = false;
if ( bMapMustExist && !modelloader->Map_IsValid( mapname, true ) )
{
Host_Map_Helper_FuzzyName( args, mapname, sizeof( mapname ) );
if ( !modelloader->Map_IsValid( mapname ) )
{
Warning( "changelevel failed: %s not found\n", mapname );
return;
}
}
if ( !CL_HL2Demo_MapCheck( mapname ) )
{
Warning( "changelevel failed: %s not found\n", mapname );
return;
}
if ( !CL_PortalDemo_MapCheck( mapname ) )
{
Warning( "changelevel failed: %s not found\n", mapname );
return;
}
SetLaunchOptions( args );
HostState_ChangeLevelMP( mapname, args[2] );
}
//-----------------------------------------------------------------------------
// Purpose: Changing levels within a unit, uses save/restore
//-----------------------------------------------------------------------------
void Host_Changelevel2_f( const CCommand &args )
{
if ( args.ArgC() < 2 )
{
ConMsg ("changelevel2 <levelname> : continue game on a new level in the unit\n");
return;
}
if ( !sv.IsActive() )
{
ConMsg( "Can't changelevel2, not in a map\n" );
return;
}
if ( !g_pVEngineServer->IsMapValid( args[1] ) )
{
if ( !CL_IsHL2Demo() || (CL_IsHL2Demo() && !(!Q_stricmp( args[1], "d1_trainstation_03" ) || !Q_stricmp( args[1], "d1_town_02a" ))) )
{
Warning( "changelevel2 failed: %s not found\n", args[1] );
return;
}
}
#if !defined(DEDICATED)
// needs to be before CL_HL2Demo_MapCheck() check as d1_trainstation_03 isn't a valid map
if ( IsPC() && CL_IsHL2Demo() && !sv.IsDedicated() && !Q_stricmp( args[1], "d1_trainstation_03" ) )
{
void CL_DemoTransitionFromTrainstation();
CL_DemoTransitionFromTrainstation();
return;
}
// needs to be before CL_HL2Demo_MapCheck() check as d1_trainstation_03 isn't a valid map
if ( IsPC() && CL_IsHL2Demo() && !sv.IsDedicated() && !Q_stricmp( args[1], "d1_town_02a" ) && !Q_stricmp( args[2], "d1_town_02_02a" ))
{
void CL_DemoTransitionFromRavenholm();
CL_DemoTransitionFromRavenholm();
return;
}
if ( IsPC() && CL_IsPortalDemo() && !sv.IsDedicated() && !Q_stricmp( args[1], "testchmb_a_07" ) )
{
void CL_DemoTransitionFromTestChmb();
CL_DemoTransitionFromTestChmb();
return;
}
#endif
// allow a level transition to d1_trainstation_03 so the Host_Changelevel() can act on it
if ( !CL_HL2Demo_MapCheck( args[1] ) )
{
Warning( "changelevel failed: %s not found\n", args[1] );
return;
}
SetLaunchOptions( args );
HostState_ChangeLevelSP( args[1], args[2] );
}
// On PS/3, due to Matchmaking framework event architecture, Host_Disconnect is called recursively on quit.
// Bad things happen. Since it's not really necessary to disconnect recursively, we'll track and prevent it on PS/3 during shutdown.
int g_nHostDisconnectReentrancyCounter = 0;
class CDisconnectReentrancyCounter
{
public:
CDisconnectReentrancyCounter() { g_nHostDisconnectReentrancyCounter++ ;}
~CDisconnectReentrancyCounter() { g_nHostDisconnectReentrancyCounter-- ;}
};
//-----------------------------------------------------------------------------
// Purpose: Shut down client connection and any server
//-----------------------------------------------------------------------------
void Host_Disconnect( bool bShowMainMenu )
{
#ifdef _PS3
if ( GetTLSGlobals()->bNormalQuitRequested )
{
if ( g_nHostDisconnectReentrancyCounter != 0 )
{
return; // do not disconnect recursively on QUIT
}
}
#endif
IGameEvent *disconnectEvent = g_GameEventManager.CreateEvent( "cs_game_disconnected" );
if ( disconnectEvent )
g_GameEventManager.FireEventClientSide( disconnectEvent );
CDisconnectReentrancyCounter autoReentrancyCounter;
#if !defined( DEDICATED )
if ( bShowMainMenu )
{
// exiting game
// ensure commentary state gets cleared
g_bInCommentaryMode = false;
}
#endif
if ( IsGameConsole() )
{
g_pQueuedLoader->EndMapLoading( false );
}
// Switch to single-threaded rendering during shutdown to
// avoid synchronization issues between destructed objects
// and the renderer
Host_AllowQueuedMaterialSystem( false );
#ifndef DEDICATED
if ( !sv.IsDedicated() )
{
FOR_EACH_VALID_SPLITSCREEN_PLAYER( hh )
{
ACTIVE_SPLITSCREEN_PLAYER_GUARD( hh );
GetLocalClient().Disconnect( bShowMainMenu );
}
}
#endif
#if !defined( DEDICATED )
if ( g_ClientDLL && bShowMainMenu )
{
// forcefully stop any of the full screen video panels used for loading or whatever
// this is a safety precaution to ensure we don't orpan any of the hacky global video panels
g_ClientDLL->ShutdownMovies();
}
#endif
HostState_GameShutdown();
#ifndef DEDICATED
if ( !sv.IsDedicated() )
{
if ( bShowMainMenu && !engineClient->IsDrawingLoadingImage() && ( GetBaseLocalClient().demonum == -1 ) )
{
if ( IsGameConsole() )
{
// Reset larger configuration material system memory (for map) back down for ui work
// This must be BEFORE ui gets-rectivated below
materials->ResetTempHWMemory( true );
}
#ifdef _PS3
if ( GetTLSGlobals()->bNormalQuitRequested )
{
return; // do not disconnect recursively on QUIT
}
#endif
EngineVGui()->ActivateGameUI();
}
}
#endif
}
//-----------------------------------------------------------------------------
// Kill the client and any local server.
//-----------------------------------------------------------------------------
CON_COMMAND_F( disconnect, "Disconnect game from server.", FCVAR_SERVER_CAN_EXECUTE )
{
#ifndef DEDICATED
GetBaseLocalClient().demonum = -1;
#endif
if ( args.ArgC() > 1 )
{
COM_ExplainDisconnection( false, "%s", args[ 1 ] );
}
Host_Disconnect(true);
}
CON_COMMAND( version, "Print version info string." )
{
ConMsg( "Protocol version %i [%i/%i]\nExe version %s (%s)\n", GetHostVersion(), GetServerVersion(), GetClientVersion(), Sys_GetVersionString(), Sys_GetProductString() );
ConMsg( "Exe build: " __TIME__ " " __DATE__ " (%i) (%i)\n", build_number(), GetSteamAppID() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CON_COMMAND( pause, "Toggle the server pause state." )
{
#if !defined( CLIENT_DLL )
#ifndef DEDICATED
if ( !sv.IsDedicated() )
{
if ( !GetBaseLocalClient().m_szLevelName[ 0 ] )
return;
}
#endif
if ( !sv.IsPausable() )
return;
// toggle paused state
sv.SetPaused( !sv.IsPaused() );
// send text message who paused the game
if ( host_client )
sv.BroadcastPrintf( "%s %s the game\n", host_client->GetClientName(), sv.IsPaused() ? "paused" : "unpaused" );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CON_COMMAND( setpause, "Set the pause state of the server." )
{
#if !defined( CLIENT_DLL )
#ifndef DEDICATED
if ( !sv.IsDedicated() )
{
if ( !GetBaseLocalClient().m_szLevelName[ 0 ] )
return;
}
#endif
if ( !sv.IsPausable() )
return;
sv.SetPaused( true );
if ( !args.FindArg( "nomsg" ) )
{
// send text message who paused the game
if ( host_client )
sv.BroadcastPrintf( "%s paused the game\n", host_client->GetClientName() );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CON_COMMAND( unpause, "Unpause the game." )
{
#if !defined( CLIENT_DLL )
#ifndef DEDICATED
if ( !sv.IsDedicated() )
{
if ( !GetBaseLocalClient().m_szLevelName[ 0 ] )
return;
}
#endif
if ( !sv.IsPaused() )
return;
sv.SetPaused( false );
if ( !args.FindArg( "nomsg" ) )
{
// send text messaage who unpaused the game
if ( host_client )
sv.BroadcastPrintf( "%s unpaused the game\n", host_client->GetClientName() );
}
#endif
}
//-----------------------------------------------------------------------------
// Kicks a user off of the server using their userid or uniqueid
//-----------------------------------------------------------------------------
CON_COMMAND( kickid_ex, "Kick a player by userid or uniqueid, provide a force-the-kick flag and also assign a message." )
{
const char *pszArg1 = NULL, *pszMessage = NULL;
int iSearchIndex = -1;
char szSearchString[128];
int argsStartNum = 1;
bool bSteamID = false;
bool bForce = false;
if ( args.ArgC() <= 1 )
{
ConMsg( "Usage: kickid_ex < userid | uniqueid > < force ( 0 / 1 ) > { message }\n" );
return;
}
// get the first argument
pszArg1 = args[1];
// if the first letter is a charcter then
// we're searching for a uniqueid ( e.g. STEAM_ )
if ( *pszArg1 < '0' || *pszArg1 > '9' )
{
// SteamID (need to reassemble it)
if ( StringHasPrefix( pszArg1, STEAM_PREFIX ) && Q_strstr( args[2], ":" ) )
{
Q_snprintf( szSearchString, sizeof( szSearchString ), "%s:%s:%s", pszArg1, args[3], args[5] );
argsStartNum = 5;
bSteamID = true;
}
// some other ID (e.g. "UNKNOWN", "STEAM_ID_PENDING", "STEAM_ID_LAN")
// NOTE: assumed to be one argument
else
{
Q_snprintf( szSearchString, sizeof( szSearchString ), "%s", pszArg1 );
}
}
// this is a userid
else
{
iSearchIndex = Q_atoi( pszArg1 );
}
// check for game type and game mode
if ( args.ArgC() > argsStartNum )
{
if ( atoi( args[ argsStartNum + 1 ] ) == 1 )
{
bForce = true;
}
argsStartNum++;
}
// check for a message
if ( args.ArgC() > argsStartNum )
{
int j;
int dataLen = 0;
pszMessage = args.ArgS();
for ( j = 1; j <= argsStartNum; j++ )
{
dataLen += Q_strlen( args[j] ) + 1; // +1 for the space between args
}
if ( bSteamID )
{
dataLen -= 5; // SteamIDs don't have spaces between the args[) values
}
if ( dataLen > Q_strlen( pszMessage ) ) // saftey check
{
pszMessage = NULL;
}
else
{
pszMessage += dataLen;
}
}
PerformKick( args.Source(), iSearchIndex, szSearchString, bForce, pszMessage );
}
//-----------------------------------------------------------------------------
// Kicks a user off of the server using their userid or uniqueid
//-----------------------------------------------------------------------------
CON_COMMAND( kickid, "Kick a player by userid or uniqueid, with a message." )
{
const char *pszArg1 = NULL, *pszMessage = NULL;
int iSearchIndex = -1;
char szSearchString[128];
int argsStartNum = 1;
bool bSteamID = false;
if ( args.ArgC() <= 1 )
{
ConMsg( "Usage: kickid < userid | uniqueid > { message }\n" );
return;
}
// get the first argument
pszArg1 = args[1];
// if the first letter is a charcter then
// we're searching for a uniqueid ( e.g. STEAM_ )
if ( *pszArg1 < '0' || *pszArg1 > '9' )
{
// SteamID (need to reassemble it)
if ( StringHasPrefix( pszArg1, STEAM_PREFIX ) && Q_strstr( args[2], ":" ) )
{
Q_snprintf( szSearchString, sizeof( szSearchString ), "%s:%s:%s", pszArg1, args[3], args[5] );
argsStartNum = 5;
bSteamID = true;
}
// some other ID (e.g. "UNKNOWN", "STEAM_ID_PENDING", "STEAM_ID_LAN")
// NOTE: assumed to be one argument
else
{
Q_snprintf( szSearchString, sizeof( szSearchString ), "%s", pszArg1 );
}
}
// this is a userid
else
{
iSearchIndex = Q_atoi( pszArg1 );
}
// check for a message
if ( args.ArgC() > argsStartNum )
{
int j;
int dataLen = 0;
pszMessage = args.ArgS();
for ( j = 1; j <= argsStartNum; j++ )
{
dataLen += Q_strlen( args[j] ) + 1; // +1 for the space between args
}
if ( bSteamID )
{
dataLen -= 5; // SteamIDs don't have spaces between the args[) values
}
if ( dataLen > Q_strlen( pszMessage ) ) // saftey check
{
pszMessage = NULL;
}
else
{
pszMessage += dataLen;
}
}
PerformKick( args.Source(), iSearchIndex, szSearchString, false, pszMessage );
}
void PerformKick( cmd_source_t commandSource, int iSearchIndex, char* szSearchString, bool bForceKick, const char* pszMessage )
{
IClient *client = NULL;
char *who = "Console";
// find this client
int i;
for ( i = 0; i < sv.GetClientCount(); i++ )
{
client = sv.GetClient( i );
if ( !client->IsConnected() )
{
continue;
}
// searching by UserID
if ( iSearchIndex != -1 )
{
if ( client->GetUserID() == iSearchIndex )
{
// found!
break;
}
}
// searching by UniqueID
else
{
if ( Q_stricmp( client->GetNetworkIDString(), szSearchString ) == 0 )
{
// found!
break;
}
}
}
// now kick them
if ( i < sv.GetClientCount() )
{
if ( client->IsSplitScreenUser() && client->GetSplitScreenOwner() )
{
client = client->GetSplitScreenOwner();
}
if ( commandSource == kCommandSrcNetClient )
{
who = host_client->m_Name;
}
if ( host_client == client && !sv.IsDedicated() && !bForceKick )
{
// can't kick yourself!
return;
}
if ( iSearchIndex != -1 || !client->IsFakeClient() )
{
if ( pszMessage )
{
client->Disconnect( CFmtStr( "Kicked by %s : %s", who, pszMessage ) );
}
else
{
client->Disconnect( CFmtStr( "Kicked by %s", who ) );
}
}
}
else
{
if ( iSearchIndex != -1 )
{
ConMsg( "userid \"%d\" not found\n", iSearchIndex );
}
else
{
ConMsg( "uniqueid \"%s\" not found\n", szSearchString );
}
}
}
/*
==================
Host_Kick_f
Kicks a user off of the server using their name
==================
*/
CON_COMMAND( kick, "Kick a player by name." )
{
char *who = "Console";
char *pszName = NULL;
IClient *client = NULL;
int i = 0;
char name[64];
if ( args.ArgC() <= 1 )
{
ConMsg( "Usage: kick < name >\n" );
return;
}
// copy the name to a local buffer
memset( name, 0, sizeof(name) );
Q_strncpy( name, args.ArgS(), sizeof(name) );
pszName = name;
// safety check
if ( pszName && pszName[0] != 0 )
{
//HACK-HACK
// check for the name surrounded by quotes (comes in this way from rcon)
int len = Q_strlen( pszName ) - 1; // (minus one since we start at 0)
if ( pszName[0] == '"' && pszName[len] == '"' )
{
// get rid of the quotes at the beginning and end
pszName[len] = 0;
pszName++;
}
for ( i = 0; i < sv.GetClientCount(); i++ )
{
client = sv.GetClient(i);
if ( !client->IsConnected() )
continue;
// found!
if ( Q_strcasecmp( client->GetClientName(), pszName ) == 0 )
break;
}
// now kick them
if ( i < sv.GetClientCount() )
{
if ( client->IsSplitScreenUser() && client->GetSplitScreenOwner() )
{
client = client->GetSplitScreenOwner();
}
if ( args.Source() == kCommandSrcNetClient )
{
who = host_client->m_Name;
}
// can't kick yourself!
if ( host_client == client && !sv.IsDedicated() )
return;
client->Disconnect( CFmtStr( "Kicked by %s", who ) );
}
else
{
ConMsg( "Can't kick \"%s\", name not found\n", pszName );
}
}
}
/*
===============================================================================
DEBUGGING TOOLS
===============================================================================
*/
void Host_PrintMemoryStatus( const char *mapname )
{
const float MB = 1.0f / ( 1024*1024 );
Assert( mapname );
#ifdef PLATFORM_LINUX
struct mallinfo memstats = mallinfo( );
Msg( "[MEMORYSTATUS] [%s] Operating system reports sbrk size: %.2f MB, Used: %.2f MB, #mallocs = %d\n",
mapname, MB*memstats.arena, MB*memstats.uordblks, memstats.hblks );
#elif defined(PLATFORM_OSX)
struct mstats stats = mstats();
Msg( "[MEMORYSTATUS] [%s] Operating system reports Used: %.2f MB, Free: %.2f Total: %.2f\n",
mapname, MB*stats.bytes_used, MB*stats.bytes_free, MB*stats.bytes_total );
#elif defined( _PS3 )
// NOTE: for PS3 nFreeMemory can be negative (on a devkit, we can use more memory than a retail kit has)
int nUsedMemory, nFreeMemory, nAvailable;
g_pMemAlloc->GlobalMemoryStatus( (size_t *)&nUsedMemory, (size_t *)&nFreeMemory );
nAvailable = nUsedMemory + nFreeMemory;
Msg( "[MEMORYSTATUS] [%s] Operating system reports Available: %.2f MB, Used: %.2f MB, Free: %.2f MB\n",
mapname, MB*nAvailable, MB*nUsedMemory, MB*nFreeMemory );
#elif defined(PLATFORM_WINDOWS)
MEMORYSTATUSEX statex;
statex.dwLength = sizeof(statex);
GlobalMemoryStatusEx( &statex );
Msg( "[MEMORYSTATUSEX] [%s] Operating system reports Physical Available: %.2f MB, Physical Used: %.2f MB, Physical Free: %.2f MB\n Virtual Size: %.2f, Virtual Free: %.2f MB, PageFile Size: %.2f, PageFile Free: %.2f MB\n",
mapname, MB*statex.ullTotalPhys, MB*( statex.ullTotalPhys - statex.ullAvailPhys ), MB*statex.ullAvailPhys, MB*statex.ullTotalVirtual, MB*statex.ullAvailVirtual, MB*statex.ullTotalPageFile, MB*statex.ullAvailPageFile );
#endif
if ( IsPS3() )
{
// Include stats on GPU memory usage
GPUMemoryStats stats;
materials->GetGPUMemoryStats( stats );
g_pMemAlloc->SetStatsExtraInfo( mapname, CFmtStr( "%d %d %d %d %d %d %d",
stats.nGPUMemSize, stats.nGPUMemFree, stats.nTextureSize, stats.nRTSize, stats.nVBSize, stats.nIBSize, stats.nUnknown ) );
Msg( "[MEMORYSTATUS] [%s] RSX memory: total %.1fkb, free %.1fkb, textures %.1fkb, render targets %.1fkb, vertex buffers %.1fkb, index buffers %.1fkb, unknown %.1fkb\n",
mapname, stats.nGPUMemSize/1024.0f, stats.nGPUMemFree/1024.0f, stats.nTextureSize/1024.0f, stats.nRTSize/1024.0f, stats.nVBSize/1024.0f, stats.nIBSize/1024.0f, stats.nUnknown/1024.0f );
}
else
{
g_pMemAlloc->SetStatsExtraInfo( mapname, "" );
}
int nTotal = g_pMemAlloc->GetSize( 0 );
if (nTotal == -1)
{
Msg( "Internal heap corrupted!\n" );
}
else
{
Msg( "Internal heap reports: %5.2f MB (%d bytes)\n", nTotal/(1024.0f*1024.0f), nTotal );
}
Msg( "\nHunk Memory Used:\n" );
Hunk_Print();
Msg( "\nDatacache reports:\n" );
g_pDataCache->OutputReport( DC_SUMMARY_REPORT, NULL );
}
//-----------------------------------------------------------------------------
// Dump memory stats
//-----------------------------------------------------------------------------
CON_COMMAND( memory, "Print memory stats." )
{
ConMsg( "Heap Used:\n" );
int nTotal = g_pMemAlloc->GetSize( 0 );
if (nTotal == -1)
{
ConMsg( "Corrupted!\n" );
}
else
{
ConMsg( "%5.2f MB (%d bytes)\n", nTotal/(1024.0f*1024.0f), nTotal );
}
#ifdef VPROF_ENABLED
ConMsg("\nVideo Memory Used:\n");
CVProfile *pProf = &g_VProfCurrentProfile;
int prefixLen = V_strlen( "TexGroup_Global_" );
float total = 0.0f;
for ( int i=0; i < pProf->GetNumCounters(); i++ )
{
if ( pProf->GetCounterGroup( i ) == COUNTER_GROUP_TEXTURE_GLOBAL )
{
float value = pProf->GetCounterValue( i ) * (1.0f/(1024.0f*1024.0f) );
total += value;
const char *pName = pProf->GetCounterName( i );
if ( StringHasPrefix( pName, "TexGroup_Global_" ) )
{
pName += prefixLen;
}
ConMsg( "%5.2f MB: %s\n", value, pName );
}
}
ConMsg("------------------\n");
ConMsg( "%5.2f MB: total\n", total );
#endif
ConMsg( "\nHunk Memory Used:\n" );
Hunk_Print();
}
/*
===============================================================================
DEMO LOOP CONTROL
===============================================================================
*/
#ifndef DEDICATED
//MOTODO move all demo commands to demoplayer
//-----------------------------------------------------------------------------
// Purpose: Gets number of valid demo names
// Output : int
//-----------------------------------------------------------------------------
int Host_GetNumDemos()
{
int c = 0;
#ifndef DEDICATED
for ( int i = 0; i < MAX_DEMOS; ++i )
{
const char *demoname = GetBaseLocalClient().demos[ i ];
if ( !demoname[ 0 ] )
break;
++c;
}
#endif
return c;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Host_PrintDemoList()
{
int count = Host_GetNumDemos();
#ifndef DEDICATED
int next = GetBaseLocalClient().demonum;
if ( next >= count || next < 0 )
{
next = 0;
}
for ( int i = 0; i < MAX_DEMOS; ++i )
{
const char *demoname = GetBaseLocalClient().demos[ i ];
if ( !demoname[ 0 ] )
break;
bool isnextdemo = next == i ? true : false;
DevMsg( "%3s % 2i : %20s\n", isnextdemo ? "-->" : " ", i, GetBaseLocalClient().demos[ i ] );
}
#endif
if ( !count )
{
DevMsg( "No demos in list, use startdemos <demoname> <demoname2> to specify\n" );
}
}
#ifndef DEDICATED
//-----------------------------------------------------------------------------
//
// Con commands related to demos, not available on dedicated servers
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Purpose: Specify list of demos for the "demos" command
//-----------------------------------------------------------------------------
CON_COMMAND( startdemos, "Play demos in demo sequence." )
{
int c = args.ArgC() - 1;
if (c > MAX_DEMOS)
{
Msg ("Max %i demos in demoloop\n", MAX_DEMOS);
c = MAX_DEMOS;
}
Msg ("%i demo(s) in loop\n", c);
for ( int i=1 ; i<c+1 ; i++ )
{
Q_strncpy( GetBaseLocalClient().demos[i-1], args[i], sizeof(GetBaseLocalClient().demos[0]) );
}
GetBaseLocalClient().demonum = 0;
Host_PrintDemoList();
if ( !sv.IsActive() && !demoplayer->IsPlayingBack() )
{
CL_NextDemo ();
}
else
{
GetBaseLocalClient().demonum = -1;
}
}
//-----------------------------------------------------------------------------
// Purpose: Return to looping demos, optional resume demo index
//-----------------------------------------------------------------------------
CON_COMMAND( demos, "Demo demo file sequence." )
{
CClientState &cl = GetBaseLocalClient();
int oldn = cl.demonum;
cl.demonum = -1;
Host_Disconnect(false);
cl.demonum = oldn;
if (cl.demonum == -1)
cl.demonum = 0;
if ( args.ArgC() == 2 )
{
int numdemos = Host_GetNumDemos();
if ( numdemos >= 1 )
{
cl.demonum = clamp( Q_atoi( args[1] ), 0, numdemos - 1 );
DevMsg( "Jumping to %s\n", cl.demos[ cl.demonum ] );
}
}
Host_PrintDemoList();
CL_NextDemo ();
}
//-----------------------------------------------------------------------------
// Purpose: Stop current demo
//-----------------------------------------------------------------------------
CON_COMMAND_F( stopdemo, "Stop playing back a demo.", FCVAR_DONTRECORD )
{
if ( !demoplayer->IsPlayingBack() )
return;
Host_Disconnect (true);
}
//-----------------------------------------------------------------------------
// Purpose: Skip to next demo
//-----------------------------------------------------------------------------
CON_COMMAND( nextdemo, "Play next demo in sequence." )
{
if ( args.ArgC() == 2 )
{
int numdemos = Host_GetNumDemos();
if ( numdemos >= 1 )
{
GetBaseLocalClient().demonum = clamp( Q_atoi( args[1] ), 0, numdemos - 1 );
DevMsg( "Jumping to %s\n", GetBaseLocalClient().demos[ GetBaseLocalClient().demonum ] );
}
}
Host_EndGame( false, "Moving to next demo..." );
}
//-----------------------------------------------------------------------------
// Purpose: Print out the current demo play order
//-----------------------------------------------------------------------------
CON_COMMAND( demolist, "Print demo sequence list." )
{
Host_PrintDemoList();
}
//-----------------------------------------------------------------------------
// Purpose: Host_Soundfade_f
//-----------------------------------------------------------------------------
CON_COMMAND_F( soundfade, "Fade client volume.", FCVAR_SERVER_CAN_EXECUTE )
{
float percent;
float inTime, holdTime, outTime;
if (args.ArgC() != 3 && args.ArgC() != 5)
{
Msg("soundfade <percent> <hold> [<out> <int>]\n");
return;
}
percent = clamp( atof(args[1]), 0.0f, 100.0f );
holdTime = MAX( 0.0f, atof(args[2]) );
inTime = 0.0f;
outTime = 0.0f;
if (args.ArgC() == 5)
{
outTime = MAX( 0.0f, atof(args[3]) );
inTime = MAX( 0.0f, atof( args[4]) );
}
S_SoundFade( percent, holdTime, outTime, inTime );
}
#endif // !DEDICATED
#endif
//-----------------------------------------------------------------------------
// Shutdown the server
//-----------------------------------------------------------------------------
CON_COMMAND( killserver, "Shutdown the server." )
{
Host_Disconnect(true);
if ( !sv.IsDedicated() )
{
// close network sockets and reopen if multiplayer game
NET_SetMultiplayer( false );
NET_SetMultiplayer( !!( g_pMatchFramework->GetMatchTitle()->GetTitleSettingsFlags() & MATCHTITLE_SETTING_MULTIPLAYER ) );
}
}
// [hpe:jason] Enable ENGINE_VOICE for Cstrike 1.5, all platforms
#if defined( CSTRIKE15 )
ConVar voice_vox( "voice_vox", "false", FCVAR_DEVELOPMENTONLY ); // Controls open microphone (no push to talk) settings
#undef NO_ENGINE_VOICE
#else
#define NO_ENGINE_VOICE
#endif
#ifdef NO_ENGINE_VOICE
ConVar voice_ptt( "voice_ptt", "-1.0", FCVAR_DEVELOPMENTONLY ); // Time when ptt key was released, 0 means to keep transmitting voice
#endif
#if !defined(DEDICATED)
void Host_VoiceRecordStart_f(void)
{
#ifdef NO_ENGINE_VOICE
voice_ptt.SetValue( 0 );
#else
ConVarRef voice_vox( "voice_vox" );
if ( voice_vox.GetBool() == true )
return;
int iSsSlot = GET_ACTIVE_SPLITSCREEN_SLOT();
if ( GetLocalClient( iSsSlot ).IsActive() )
{
const char *pUncompressedFile = NULL;
const char *pDecompressedFile = NULL;
const char *pInputFile = NULL;
if (voice_recordtofile.GetInt())
{
pUncompressedFile = "voice_micdata.wav";
pDecompressedFile = "voice_decompressed.wav";
}
if (voice_inputfromfile.GetInt())
{
pInputFile = "voice_input.wav";
}
#if !defined( NO_VOICE )
if (Voice_RecordStart(pUncompressedFile, pDecompressedFile, pInputFile))
{
}
#endif
}
#endif // #ifndef NO_ENGINE_VOICE
}
void Host_VoiceRecordStop_f( const CCommand &args )
{
#ifdef NO_ENGINE_VOICE
voice_ptt.SetValue( (float) Plat_FloatTime() );
#else
ConVarRef voice_vox( "voice_vox" );
if ( voice_vox.GetBool() == true )
return;
int iSsSlot = GET_ACTIVE_SPLITSCREEN_SLOT();
if ( GetLocalClient( iSsSlot ).IsActive() )
{
#if !defined( NO_VOICE )
if (Voice_IsRecording())
{
CL_SendVoicePacket(true);
Voice_RecordStop();
}
if ( args.ArgC() == 2 && V_strcasecmp( args[1], "force" ) == 0 )
{
// do nothing
}
else
{
voice_vox.SetValue( 0 );
}
#endif
}
#endif // #ifndef NO_ENGINE_VOICE
}
#endif
// TERROR: adding a toggle for voice
void Host_VoiceToggle_f( const CCommand &args )
{
#ifdef NO_ENGINE_VOICE
voice_ptt.SetValue( (float) ( voice_ptt.GetFloat() ? 0.0f : Plat_FloatTime() ) );
#endif
#if !defined( DEDICATED ) && !defined( NO_ENGINE_VOICE )
#if !defined( NO_VOICE )
if ( GetBaseLocalClient().IsActive() )
{
bool bToggle = false;
if ( args.ArgC() == 2 && V_strcasecmp( args[1], "on" ) == 0 )
{
bToggle = true;
}
if ( Voice_IsRecording() && bToggle == false )
{
CL_SendVoicePacket(true);
Voice_RecordStop();
}
else if ( bToggle == true && Voice_IsRecording() == false )
{
const char *pUncompressedFile = NULL;
const char *pDecompressedFile = NULL;
const char *pInputFile = NULL;
if (voice_recordtofile.GetInt())
{
pUncompressedFile = "voice_micdata.wav";
pDecompressedFile = "voice_decompressed.wav";
}
if (voice_inputfromfile.GetInt())
{
pInputFile = "voice_input.wav";
}
Voice_RecordStart( pUncompressedFile, pDecompressedFile, pInputFile );
}
}
#endif
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Wrapper for modelloader->Print() function call
//-----------------------------------------------------------------------------
CON_COMMAND( listmodels, "List loaded models." )
{
modelloader->Print();
}
/*
==================
Host_IncrementCVar
==================
*/
CON_COMMAND_F( incrementvar, "Increment specified convar value.", FCVAR_DONTRECORD )
{
if( args.ArgC() != 5 )
{
Warning( "Usage: incrementvar varName minValue maxValue delta\n" );
return;
}
const char *varName = args[ 1 ];
if( !varName )
{
ConDMsg( "Host_IncrementCVar_f without a varname\n" );
return;
}
ConVar *var = ( ConVar * )g_pCVar->FindVar( varName );
if( !var )
{
ConDMsg( "cvar \"%s\" not found\n", varName );
return;
}
float currentValue = var->GetFloat();
float startValue = atof( args[ 2 ] );
float endValue = atof( args[ 3 ] );
float delta = atof( args[ 4 ] );
float newValue = currentValue + delta;
if( newValue > endValue )
{
newValue = startValue;
}
else if ( newValue < startValue )
{
newValue = endValue;
}
// Conver incrementvar command to direct sets to avoid any problems with state in a demo loop.
Cbuf_AddText( Cbuf_GetCurrentPlayer(), va("%s %f", varName, newValue) );
ConDMsg( "%s = %f\n", var->GetName(), newValue );
}
//-----------------------------------------------------------------------------
// Host_MultiplyCVar_f
//-----------------------------------------------------------------------------
CON_COMMAND_F( multvar, "Multiply specified convar value.", FCVAR_DONTRECORD )
{
if (( args.ArgC() != 5 ))
{
Warning( "Usage: multvar varName minValue maxValue factor\n" );
return;
}
const char *varName = args[ 1 ];
if( !varName )
{
ConDMsg( "multvar without a varname\n" );
return;
}
ConVar *var = ( ConVar * )g_pCVar->FindVar( varName );
if( !var )
{
ConDMsg( "cvar \"%s\" not found\n", varName );
return;
}
float currentValue = var->GetFloat();
float startValue = atof( args[ 2 ] );
float endValue = atof( args[ 3 ] );
float factor = atof( args[ 4 ] );
float newValue = currentValue * factor;
if( newValue > endValue )
{
newValue = endValue;
}
else if ( newValue < startValue )
{
newValue = startValue;
}
// Conver incrementvar command to direct sets to avoid any problems with state in a demo loop.
Cbuf_AddText( Cbuf_GetCurrentPlayer(), va("%s %f", varName, newValue) );
ConDMsg( "%s = %f\n", var->GetName(), newValue );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CON_COMMAND( dumpstringtables, "Print string tables to console." )
{
SV_PrintStringTables();
#ifndef DEDICATED
CL_PrintStringTables();
#endif
}
CON_COMMAND( stringtabledictionary, "Create dictionary for current strings." )
{
if ( !sv.IsActive() )
{
Warning( "stringtabledictionary: only valid when running a map\n" );
return;
}
SV_CreateDictionary( sv.GetMapName() );
}
// Register shared commands
CON_COMMAND_F( quit, "Exit the engine.", FCVAR_NONE )
{
if ( args.ArgC() > 1 && V_strcmp( args[ 1 ], "prompt" ) == 0 )
{
Cbuf_AddText( Cbuf_GetCurrentPlayer(), "quit_prompt" );
return;
}
Host_Quit_f();
}
static ConCommand cmd_exit("exit", Host_Quit_f, "Exit the engine.");
#ifndef DEDICATED
#ifdef VOICE_OVER_IP
static ConCommand startvoicerecord("+voicerecord", Host_VoiceRecordStart_f);
static ConCommand endvoicerecord("-voicerecord", Host_VoiceRecordStop_f);
static ConCommand togglevoicerecord("voicerecord_toggle", Host_VoiceToggle_f);
#endif // VOICE_OVER_IP
#endif
//-----------------------------------------------------------------------------
// Purpose: Force a null pointer crash. useful for testing minidumps
//-----------------------------------------------------------------------------
CON_COMMAND_F( crash, "Cause the engine to crash (Debug!!)", FCVAR_CHEAT )
{
Msg( "forcing crash\n" );
#if defined( _X360 )
DmCrashDump( FALSE );
#else
char *p = 0;
*p = 0;
#endif
}
CON_COMMAND_F( spincycle, "Cause the engine to spincycle (Debug!!)", FCVAR_CHEAT )
{
if ( args.ArgC() > 1 )
{
const char *pParam = args.Arg( 1 );
if ( pParam && *pParam && pParam[ V_strlen( pParam ) - 1 ] == 's' )
{
float flSeconds = V_atof( pParam );
if ( flSeconds > 0 )
{
Msg( "Sleeping for %.3f seconds\n", flSeconds );
ThreadSleep( flSeconds * 1000 );
return;
}
}
}
int numCycles = ( args.ArgC() > 1 ) ? Q_atoi( args.Arg(1) ) : 10;
Msg( "forcing spincycle for %d cycles\n", numCycles );
for( int k = 0; k < numCycles; ++ k )
{
( void ) RandomInt( 0, numCycles );
}
}
#if POSIX
CON_COMMAND_F( forktest, "Cause the engine to fork and wait for child PID, parameter can be passed for requested exit code (Debug!!)", FCVAR_CHEAT )
{
EndWatchdogTimer(); // End the watchdog in case child takes too long
int nExitCodeRequested = ( args.ArgC() > 1 ) ? Q_atoi( args.Arg(1) ) : 0;
pid_t pID = fork();
Msg( "forktest: Forked, pID = %d\n", (int) pID );
if ( pID == 0 ) // are we the forked child?
{
//
// Enumerate all open file descriptors that are not #0 (stdin), #1 (stdout), #2 (stderr)
// and close them all.
// This will close all sockets and file handles that can result in process hanging
// when network events occur on the machine and make NFS handles go bad.
//
if ( !CommandLine()->FindParm( "-forkfdskeepall" ) )
{
FileFindHandle_t hFind = NULL;
CUtlVector< int > arrHandlesToClose;
for ( char const *szFileName = g_pFullFileSystem->FindFirst( "/proc/self/fd/*", &hFind );
szFileName && *szFileName; szFileName = g_pFullFileSystem->FindNext( hFind ) )
{
int iFdHandle = Q_atoi( szFileName );
if ( ( iFdHandle > 2 ) && ( arrHandlesToClose.Find( iFdHandle ) == arrHandlesToClose.InvalidIndex() ) )
arrHandlesToClose.AddToTail( iFdHandle );
}
g_pFullFileSystem->FindClose( hFind );
FOR_EACH_VEC( arrHandlesToClose, idxFd )
{
::close( arrHandlesToClose[idxFd] );
}
if ( !CommandLine()->FindParm( "-forkfdskeepstd" ) )
{
// Explicitly close #0 (stdin), #1 (stdout), #2 (stderr) and reopen them to /dev/null to consume 0-1-2 FDs (Posix spec requires to return lowest FDs first)
::close( 0 );
::close( 1 );
::close( 2 );
::open("/dev/null", O_RDONLY);
::open("/dev/null", O_RDWR);
::open("/dev/null", O_RDWR);
}
}
Msg( "Child finished successfully!\n" );
syscall( SYS_exit, nExitCodeRequested ); // don't do a normal c++ exit, don't want to call destructors, etc.
Warning( "Forked child just called SYS_exit.\n" );
}
else
{
int nRet = -1;
int nWait = waitpid( pID, &nRet, 0 );
Msg( "Parent finished wait: %d, ret: %d, exit: %d, code: %d\n", nWait, nRet, WIFEXITED( nRet ), WEXITSTATUS( nRet ) );
}
}
#endif
CON_COMMAND_F( flush, "Flush unlocked cache memory.", FCVAR_CHEAT )
{
#if !defined( DEDICATED )
g_ClientDLL->InvalidateMdlCache();
#endif // DEDICATED
serverGameDLL->InvalidateMdlCache();
g_pDataCache->Flush( true );
#if !defined( DEDICATED )
wavedatacache->Flush();
#endif
}
CON_COMMAND_F( flush_locked, "Flush unlocked and locked cache memory.", FCVAR_CHEAT )
{
#if !defined( DEDICATED )
g_ClientDLL->InvalidateMdlCache();
#endif // DEDICATED
serverGameDLL->InvalidateMdlCache();
g_pDataCache->Flush( false );
#if !defined( DEDICATED )
wavedatacache->Flush();
#endif
}
CON_COMMAND( cache_print, "cache_print [section]\nPrint out contents of cache memory." )
{
const char *pszSection = NULL;
if ( args.ArgC() == 2 )
{
pszSection = args[ 1 ];
}
g_pDataCache->OutputReport( DC_DETAIL_REPORT, pszSection );
}
CON_COMMAND( cache_print_lru, "cache_print_lru [section]\nPrint out contents of cache memory." )
{
const char *pszSection = NULL;
if ( args.ArgC() == 2 )
{
pszSection = args[ 1 ];
}
g_pDataCache->OutputReport( DC_DETAIL_REPORT_LRU, pszSection );
}
CON_COMMAND( cache_print_summary, "cache_print_summary [section]\nPrint out a summary contents of cache memory." )
{
const char *pszSection = NULL;
if ( args.ArgC() == 2 )
{
pszSection = args[ 1 ];
}
g_pDataCache->OutputReport( DC_SUMMARY_REPORT, pszSection );
}
#if defined( _X360 )
CON_COMMAND( vx_datacache_list, "vx_datacache_list" )
{
g_pDataCache->OutputReport( DC_DETAIL_REPORT_VXCONSOLE, NULL );
}
#endif
#ifndef _DEMO
#ifndef DEDICATED
// NOTE: As of shipping the 360 version of L4D, this command will not work correctly. See changelist 612757 (terror src) for why.
CON_COMMAND_F( ss_connect, "If connected with available split screen slots, connects a split screen player to this machine.", FCVAR_DEVELOPMENTONLY )
{
if ( host_state.max_splitscreen_players == 1 )
{
if ( toolframework->InToolMode() )
{
Msg( "Can't ss_connect, split screen not supported when running -tools mode.\n" );
}
else
{
Msg( "Can't ss_connect, game does not support split screen.\n" );
}
return;
}
if ( !GetBaseLocalClient().IsConnected() )
{
Msg( "Can't ss_connect, not connected to game.\n" );
return;
}
int nSlot = 1;
#ifndef DEDICATED
while ( splitscreen->IsValidSplitScreenSlot( nSlot ) )
{
++nSlot;
}
#endif
if ( nSlot >= host_state.max_splitscreen_players )
{
Msg( "Can't ss_connect, no more split screen player slots!\n" );
return;
}
// Grab convars for next available slot
CCLCMsg_SplitPlayerConnect_t msg;
Host_BuildUserInfoUpdateMessage( nSlot, msg.mutable_convars(), false );
GetBaseLocalClient().m_NetChannel->SendNetMsg( msg );
}
CON_COMMAND_F( ss_disconnect, "If connected with available split screen slots, connects a split screen player to this machine.", FCVAR_DEVELOPMENTONLY )
{
if ( args.Source() == kCommandSrcNetClient )
{
#ifndef DEDICATED
host_client->SplitScreenDisconnect( args );
#endif
return;
}
// Get the first valid slot
int nSlot = -1;
for ( int i = 1; i < host_state.max_splitscreen_players; ++i )
{
if ( IS_VALID_SPLIT_SCREEN_SLOT( i ) )
{
nSlot = i;
break;
}
}
if ( args.ArgC() > 1 )
{
int cmdslot = Q_atoi( args.Arg( 1 ) );
if ( IS_VALID_SPLIT_SCREEN_SLOT( cmdslot ) )
{
nSlot = cmdslot;
}
else
{
Msg( "Can't ss_disconnect, slot %d not active\n", cmdslot );
return;
}
}
if ( ! IS_VALID_SPLIT_SCREEN_SLOT( nSlot ) )
{
Msg( "Can't ss_disconnect, no split screen users active\n" );
return;
}
char buf[ 256 ];
Q_snprintf( buf, sizeof( buf ), "ss_disconnect %d\n", nSlot );
CCommand argsClient;
argsClient.Tokenize( buf, kCommandSrcCode );
Cmd_ForwardToServer( argsClient );
#ifndef DEDICATED
splitscreen->SetDisconnecting( nSlot, true );
#endif
}
#endif
#endif
#if 0
CON_COMMAND_F( infinite_loop, "Hang server with an infinite loop to test crash recovery.", FCVAR_CHEAT )
{
for(;;)
{
ThreadSleep( 500 );
}
}
CON_COMMAND_F( null_ptr_references, "Produce a null ptr reference.", FCVAR_CHEAT )
{
*((int *) 0 ) = 77;
}
#endif
Reference in New Issue View Git Blame Copy Permalink