//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======// // // Purpose: // // $NoKeywords: $ // //===========================================================================// #include "cvar.h" #include "gl_cvars.h" #include "tier1/convar.h" #include "filesystem.h" #include "filesystem_engine.h" #include "client.h" #include "server.h" #include "GameEventManager.h" #include "netmessages.h" #include "sv_main.h" #include "demo.h" #include #include "vstdlib/vstrtools.h" #ifdef POSIX #include #endif #ifdef _PS3 #include #endif #ifndef DEDICATED #include #include #endif // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" //----------------------------------------------------------------------------- // Singleton CCvarUtilities //----------------------------------------------------------------------------- static CCvarUtilities g_CvarUtilities; CCvarUtilities *ConVarUtilities = &g_CvarUtilities; //----------------------------------------------------------------------------- // Purpose: Update clients/server when FCVAR_REPLICATED etc vars change //----------------------------------------------------------------------------- static void ConVarNetworkChangeCallback( IConVar *pConVar, const char *pOldValue, float flOldValue ) { ConVarRef var( pConVar ); if ( !pOldValue ) { if ( var.GetFloat() == flOldValue ) return; } else { if ( !Q_strcmp( var.GetString(), pOldValue ) ) return; } if ( var.IsFlagSet( FCVAR_USERINFO ) ) { #ifndef DEDICATED ACTIVE_SPLITSCREEN_PLAYER_GUARD( var.GetSplitScreenPlayerSlot() ); // Are we not a server, but a client and have a change? if ( GetLocalClient().IsConnected() ) { // send changed cvar to server CNETMsg_SetConVar_t convar( var.GetBaseName(), var.GetString() ); GetLocalClient().m_NetChannel->SendNetMsg( convar ); } #endif } // Log changes to server variables // Print to clients if ( var.IsFlagSet( FCVAR_NOTIFY ) ) { IGameEvent *event = g_GameEventManager.CreateEvent( "server_cvar" ); if ( event ) { event->SetString( "cvarname", var.GetName() ); if ( var.IsFlagSet( FCVAR_PROTECTED ) ) { event->SetString("cvarvalue", "***PROTECTED***" ); } else { event->SetString("cvarvalue", var.GetString() ); } g_GameEventManager.FireEvent( event ); } } // Force changes down to clients (if running server) if ( var.IsFlagSet( FCVAR_REPLICATED ) && sv.IsActive() ) { SV_ReplicateConVarChange( static_cast< ConVar* >( pConVar ), var.GetString() ); } } //----------------------------------------------------------------------------- // Implementation of the ICvarQuery interface //----------------------------------------------------------------------------- class CCvarQuery : public CBaseAppSystem< ICvarQuery > { public: bool m_bCallbackInstalled; CCvarQuery( void ) { m_bCallbackInstalled = false; } virtual bool Connect( CreateInterfaceFn factory ) { ICvar *pCVar = (ICvar*)factory( CVAR_INTERFACE_VERSION, 0 ); if ( !pCVar ) return false; pCVar->InstallCVarQuery( this ); return true; } virtual InitReturnVal_t Init() { // If the value has changed, notify clients/server based on ConVar flags. // NOTE: this will only happen for non-FCVAR_NEVER_AS_STRING vars. // Also, this happened in SetDirect for older clients that don't have the // callback interface. if (! m_bCallbackInstalled ) { m_bCallbackInstalled = true; g_pCVar->InstallGlobalChangeCallback( ConVarNetworkChangeCallback ); } return INIT_OK; } virtual void Shutdown() { g_pCVar->RemoveGlobalChangeCallback( ConVarNetworkChangeCallback ); m_bCallbackInstalled = false; } virtual void *QueryInterface( const char *pInterfaceName ) { if ( !Q_stricmp( pInterfaceName, CVAR_QUERY_INTERFACE_VERSION ) ) return (ICvarQuery*)this; return NULL; } // Purpose: Returns true if the commands can be aliased to one another // Either game/client .dll shared with engine, // or game and client dll shared and marked FCVAR_REPLICATED virtual bool AreConVarsLinkable( const ConVar *child, const ConVar *parent ) { // Both parent and child must be marked replicated for this to work bool repchild = child->IsFlagSet( FCVAR_REPLICATED ); bool repparent = parent->IsFlagSet( FCVAR_REPLICATED ); if ( repchild && repparent ) { // Never on protected vars if ( child->IsFlagSet( FCVAR_PROTECTED ) || parent->IsFlagSet( FCVAR_PROTECTED ) ) { ConMsg( "FCVAR_REPLICATED can't also be FCVAR_PROTECTED (%s)\n", child->GetName() ); return false; } // Only on ConVars if ( child->IsCommand() || parent->IsCommand() ) { ConMsg( "FCVAR_REPLICATED not valid on ConCommands (%s)\n", child->GetName() ); return false; } // One must be in client .dll and the other in the game .dll, or both in the engine if ( child->IsFlagSet( FCVAR_GAMEDLL ) && !parent->IsFlagSet( FCVAR_CLIENTDLL ) ) { ConMsg( "For FCVAR_REPLICATED, ConVar must be defined in client and game .dlls (%s)\n", child->GetName() ); return false; } if ( child->IsFlagSet( FCVAR_CLIENTDLL ) && !parent->IsFlagSet( FCVAR_GAMEDLL ) ) { ConMsg( "For FCVAR_REPLICATED, ConVar must be defined in client and game .dlls (%s)\n", child->GetName() ); return false; } // Allowable return true; } // Otherwise need both to allow linkage if ( repchild || repparent ) { ConMsg( "Both ConVars must be marked FCVAR_REPLICATED for linkage to work (%s)\n", child->GetName() ); return false; } if ( parent->IsFlagSet( FCVAR_CLIENTDLL ) ) { ConMsg( "Parent cvar in client.dll not allowed (%s)\n", child->GetName() ); return false; } if ( parent->IsFlagSet( FCVAR_GAMEDLL ) ) { ConMsg( "Parent cvar in server.dll not allowed (%s)\n", child->GetName() ); return false; } return true; } }; //----------------------------------------------------------------------------- // Singleton //----------------------------------------------------------------------------- static CCvarQuery s_CvarQuery; EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CCvarQuery, ICvarQuery, CVAR_QUERY_INTERFACE_VERSION, s_CvarQuery ); void InstallConVarHook( void ) { s_CvarQuery.Init(); } //----------------------------------------------------------------------------- // // CVar utilities begins here // //----------------------------------------------------------------------------- static bool IsAllSpaces( const wchar_t *str ) { const wchar_t *p = str; while ( p && *p ) { if ( !iswspace( *p ) ) return false; ++p; } return true; } //----------------------------------------------------------------------------- // Purpose: // Input : *var - // *value - //----------------------------------------------------------------------------- void CCvarUtilities::SetDirect( ConVar *var, const char *value ) { const char *pszValue; char szNew[ 1024 ]; // Bail early if we're trying to set a FCVAR_USERINFO cvar on a dedicated server if ( var->IsFlagSet( FCVAR_USERINFO ) ) { if ( sv.IsDedicated() ) { return; } } pszValue = value; // This cvar's string must only contain printable characters. // Strip out any other crap. // We'll fill in "empty" if nothing is left if ( var->IsFlagSet( FCVAR_PRINTABLEONLY ) ) { wchar_t unicode[ 512 ]; #ifndef DEDICATED if ( sv.IsDedicated() ) { // Dedicated servers don't have g_pVGuiLocalize, so fall back V_UTF8ToUnicode( pszValue, unicode, sizeof( unicode ) ); } else { g_pVGuiLocalize->ConvertANSIToUnicode( pszValue, unicode, sizeof( unicode ) ); } #else V_UTF8ToUnicode( pszValue, unicode, sizeof( unicode ) ); #endif wchar_t newUnicode[ 512 ]; const wchar_t *pS; wchar_t *pD; // Clear out new string newUnicode[0] = L'\0'; pS = unicode; pD = newUnicode; // Step through the string, only copying back in characters that are printable while ( *pS ) { if ( iswcntrl( *pS ) || *pS == '~' ) { pS++; continue; } *pD++ = *pS++; } // Terminate the new string *pD = L'\0'; // If it's empty or all spaces, then insert a marker string if ( !wcslen( newUnicode ) || IsAllSpaces( newUnicode ) ) { wcsncpy( newUnicode, L"#empty", ( sizeof( newUnicode ) / sizeof( wchar_t ) ) - 1 ); newUnicode[ ( sizeof( newUnicode ) / sizeof( wchar_t ) ) - 1 ] = L'\0'; } #ifndef DEDICATED if ( sv.IsDedicated() ) { V_UnicodeToUTF8( newUnicode, szNew, sizeof( szNew ) ); } else { g_pVGuiLocalize->ConvertUnicodeToANSI( newUnicode, szNew, sizeof( szNew ) ); } #else V_UnicodeToUTF8( newUnicode, szNew, sizeof( szNew ) ); #endif // Point the value here. pszValue = szNew; } if ( var->IsFlagSet( FCVAR_NEVER_AS_STRING ) ) { var->SetValue( (float)atof( pszValue ) ); } else { var->SetValue( pszValue ); } } //----------------------------------------------------------------------------- // Purpose: // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- // If you are changing this, please take a look at IsValidToggleCommand() bool CCvarUtilities::IsCommand( const CCommand &args, const int iSplitscreenSlot /*= -1*/ ) { int c = args.ArgC(); if ( c == 0 ) return false; ConVar *v; // check variables v = g_pCVar->FindVar( args[0] ); if ( !v ) return false; // adjust for split screen convars for slots 2, 3, 4 if ( iSplitscreenSlot > 0 && v->IsFlagSet( FCVAR_SS ) ) { char buf[512]; Q_snprintf( buf, sizeof(buf), "%s%d", args[0], iSplitscreenSlot+1 ); v = g_pCVar->FindVar( buf ); } if ( !v ) return false; // NOTE: Not checking for 'HIDDEN' here so we can actually set hidden convars if ( v->IsFlagSet(FCVAR_DEVELOPMENTONLY) ) return false; // perform a variable print or set if ( c == 1 ) { ConVar_PrintDescription( v ); return true; } if ( v->IsFlagSet( FCVAR_SPONLY ) ) { #ifndef DEDICATED // Connected to server? if ( GetBaseLocalClient().IsConnected() ) { // Is it not a single player game? if ( GetBaseLocalClient().m_nMaxClients > 1 ) { ConMsg( "Can't set %s in multiplayer\n", v->GetName() ); return true; } } #endif } if ( v->IsFlagSet( FCVAR_NOT_CONNECTED ) ) { #ifndef DEDICATED // Connected to server? if ( GetBaseLocalClient().IsConnected() ) { extern IBaseClientDLL *g_ClientDLL; if ( v->IsFlagSet( FCVAR_USERINFO ) && g_ClientDLL && g_ClientDLL->IsConnectedUserInfoChangeAllowed( v ) ) { // Client.dll is allowing the convar change } else { ConMsg( "Can't change %s when playing, disconnect from the server or switch team to spectators\n", v->GetName() ); return true; } } #endif } // Allow cheat commands in singleplayer, debug, or multiplayer with sv_cheats on if ( v->IsFlagSet( FCVAR_CHEAT ) ) { if ( !Host_IsSinglePlayerGame() && !CanCheat() #if !defined(DEDICATED) && !GetBaseLocalClient().ishltv #if defined( REPLAY_ENABLED ) && !GetBaseLocalClient().isreplay #endif && !demoplayer->IsPlayingBack() #endif ) { ConMsg( "Can't use cheat cvar %s in multiplayer, unless the server has sv_cheats set to 1.\n", v->GetName() ); return true; } } // Text invoking the command was typed into the console, decide what to do with it // if this is a replicated ConVar, except don't worry about restrictions if playing a .dem file if ( v->IsFlagSet( FCVAR_REPLICATED ) #if !defined(DEDICATED) && !demoplayer->IsPlayingBack() #endif ) { #ifndef DEDICATED // If not running a server but possibly connected as a client, then // if the message came from console, don't process the command if ( !sv.IsActive() && !sv.IsLoading() && GetBaseLocalClient().IsConnected() ) { ConMsg( "Can't change replicated ConVar %s from console of client, only server operator can change its value\n", v->GetName() ); return true; } #endif } // Note that we don't want the tokenized list, send down the entire string // except for surrounding quotes char remaining[1024]; const char *pArgS = args.ArgS(); int nLen = Q_strlen( pArgS ); bool bIsQuoted = pArgS[0] == '\"'; if ( !bIsQuoted ) { Q_strncpy( remaining, args.ArgS(), sizeof(remaining) ); } else { --nLen; Q_strncpy( remaining, &pArgS[1], sizeof(remaining) ); } // Now strip off any trailing spaces char *p = remaining + nLen - 1; while ( p >= remaining ) { if ( *p > ' ' ) break; *p-- = 0; } // Strip off ending quote if ( bIsQuoted && p >= remaining ) { if ( *p == '\"' ) { *p = 0; } } SetDirect( v, remaining ); return true; } // This is a band-aid copied directly from IsCommand(). bool CCvarUtilities::IsValidToggleCommand( const char *cmd ) { ConVar *v; // check variables v = g_pCVar->FindVar ( cmd ); if (!v) { ConMsg( "%s is not a valid cvar\n", cmd ); return false; } if ( v->IsFlagSet(FCVAR_DEVELOPMENTONLY) || v->IsFlagSet(FCVAR_HIDDEN) ) return false; if ( v->IsFlagSet( FCVAR_SPONLY ) ) { #ifndef DEDICATED // Connected to server? if ( GetBaseLocalClient().IsConnected() ) { // Is it not a single player game? if ( GetBaseLocalClient().m_nMaxClients > 1 ) { ConMsg( "Can't set %s in multiplayer\n", v->GetName() ); return false; } } #endif } if ( v->IsFlagSet( FCVAR_NOT_CONNECTED ) ) { #ifndef DEDICATED // Connected to server? if ( GetBaseLocalClient().IsConnected() ) { extern IBaseClientDLL *g_ClientDLL; if ( v->IsFlagSet( FCVAR_USERINFO ) && g_ClientDLL && g_ClientDLL->IsConnectedUserInfoChangeAllowed( v ) ) { // Client.dll is allowing the convar change } else { ConMsg( "Can't change %s when playing, disconnect from the server or switch team to spectators\n", v->GetName() ); return false; } } #endif } // Allow cheat commands in singleplayer, debug, or multiplayer with sv_cheats on if ( v->IsFlagSet( FCVAR_CHEAT ) ) { if ( !Host_IsSinglePlayerGame() && !CanCheat() #if !defined(DEDICATED) && !demoplayer->IsPlayingBack() #endif ) { ConMsg( "Can't use cheat cvar %s in multiplayer, unless the server has sv_cheats set to 1.\n", v->GetName() ); return false; } } // Text invoking the command was typed into the console, decide what to do with it // if this is a replicated ConVar, except don't worry about restrictions if playing a .dem file if ( v->IsFlagSet( FCVAR_REPLICATED ) #if !defined(DEDICATED) && !demoplayer->IsPlayingBack() #endif ) { #ifndef DEDICATED // If not running a server but possibly connected as a client, then // if the message came from console, don't process the command if ( !sv.IsActive() && !sv.IsLoading() && GetBaseLocalClient().IsConnected() ) { ConMsg( "Can't change replicated ConVar %s from console of client, only server operator can change its value\n", v->GetName() ); return false; } #endif } return true; } void CCvarUtilities::ResetConVarsToDefaultValues( const char *pMatchStr ) { ICvar::Iterator iter( g_pCVar ); for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() ) { ConCommandBase *var = iter.Get(); if ( var->IsCommand() ) continue; ConVar *cv = (ConVar *)var; if ( ( ! pMatchStr ) || // null pattern match? ( memcmp( pMatchStr, cv->GetName(), strlen( pMatchStr ) ) == 0 ) // first chars match ) { cv->Revert(); } } } static bool CVarSortFunc( ConVar * const &lhs, ConVar * const &rhs ) { return ( CaselessStringLessThan( lhs->GetName(), rhs->GetName() ) ); } //----------------------------------------------------------------------------- // Purpose: // Input : *f - //----------------------------------------------------------------------------- void CCvarUtilities::WriteVariables( CUtlBuffer *buff, const int iSplitscreenSlot /*= -1*/, bool bSlotRequired /* = false */, void *pConvarsListVoid /*= NULL*/ ) { CUtlRBTree< ConVar *, int > sorted( 0, 0, CVarSortFunc ); CUtlVector< ConVar * > *pConvarsList = (CUtlVector< ConVar * > *)pConvarsListVoid; ICvar::Iterator iter( g_pCVar ); for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() ) { ConCommandBase *var = iter.Get(); if ( var->IsCommand() ) continue; ConVar *cv = (ConVar *)var; bool archive = cv->IsFlagSet( IsGameConsole() ? FCVAR_ARCHIVE_GAMECONSOLE : FCVAR_ARCHIVE ); if ( archive ) { if ( iSplitscreenSlot >= 0 ) { bool bSlotSpecificConvar = false; if ( cv->IsFlagSet( FCVAR_SS ) ) { // only valid for the 0'th player if ( iSplitscreenSlot != 0 ) { continue; } bSlotSpecificConvar = true; } if ( cv->IsFlagSet( FCVAR_SS_ADDED ) ) { // which added player is this relevant to CSplitScreenAddedConVar *pCheck = dynamic_cast< CSplitScreenAddedConVar * >( cv ); if ( pCheck && pCheck->GetSplitScreenPlayerSlot() != iSplitscreenSlot ) { continue; } bSlotSpecificConvar = true; } if ( bSlotRequired != bSlotSpecificConvar ) { continue; } } sorted.Insert( cv ); } } for ( int i = sorted.FirstInorder(); i != sorted.InvalidIndex(); i = sorted.NextInorder( i ) ) { ConVar *var = sorted[ i ]; // If we are saving per-controller, we always want to write the base name ( joy_inverty as opposed to joy_inverty2 ) const char *name = ( iSplitscreenSlot >= 0 ) ? var->GetBaseName() : var->GetName(); DevMsg( 2, "%s \"%s\"\n", name, var->GetString() ); if ( buff ) buff->Printf( "%s \"%s\"\n", name, var->GetString() ); if ( pConvarsList ) pConvarsList->AddToTail( var ); } } static void Cmd_SetPlayer( int slot, const CCommand &args ) { if ( slot >= host_state.max_splitscreen_players ) { DevMsg( 1, "ignore: %d '%s'\n", slot, args.ArgS() ); return; } // Strip the cmdN and pass the rest of the command to the appropriate slot Cbuf_AddText( (ECommandTarget_t)slot, args.ArgS() ); } CON_COMMAND( cmd1, "sets userinfo string for split screen player in slot 1" ) { Cmd_SetPlayer( 0, args ); } CON_COMMAND( cmd2, "sets userinfo string for split screen player in slot 2" ) { Cmd_SetPlayer( 1, args ); } CON_COMMAND( cmd3, "sets userinfo string for split screen player in slot 3" ) { Cmd_SetPlayer( 2, args ); } CON_COMMAND( cmd4, "sets userinfo string for split screen player in slot 4" ) { Cmd_SetPlayer( 3, args ); } static char *StripTabsAndReturns( const char *inbuffer, char *outbuffer, int outbufferSize ) { char *out = outbuffer; const char *i = inbuffer; char *o = out; out[ 0 ] = 0; while ( *i && o - out < outbufferSize - 1 ) { if ( *i == '\n' || *i == '\r' || *i == '\t' ) { *o++ = ' '; i++; continue; } if ( *i == '\"' ) { *o++ = '\''; i++; continue; } *o++ = *i++; } *o = '\0'; return out; } static char *StripQuotes( const char *inbuffer, char *outbuffer, int outbufferSize ) { char *out = outbuffer; const char *i = inbuffer; char *o = out; out[ 0 ] = 0; while ( *i && o - out < outbufferSize - 1 ) { if ( *i == '\"' ) { *o++ = '\''; i++; continue; } *o++ = *i++; } *o = '\0'; return out; } struct ConVarFlags_t { int bit; const char *desc; const char *shortdesc; }; #define CONVARFLAG( x, y ) { FCVAR_##x, #x, #y } static ConVarFlags_t g_ConVarFlags[]= { // CONVARFLAG( UNREGISTERED, "u" ), CONVARFLAG( ARCHIVE, "a" ), CONVARFLAG( SPONLY, "sp" ), CONVARFLAG( GAMEDLL, "sv" ), CONVARFLAG( CHEAT, "cheat" ), CONVARFLAG( USERINFO, "user" ), CONVARFLAG( NOTIFY, "nf" ), CONVARFLAG( PROTECTED, "prot" ), CONVARFLAG( PRINTABLEONLY, "print" ), CONVARFLAG( UNLOGGED, "log" ), CONVARFLAG( NEVER_AS_STRING, "numeric" ), CONVARFLAG( REPLICATED, "rep" ), CONVARFLAG( DEMO, "demo" ), CONVARFLAG( DONTRECORD, "norecord" ), CONVARFLAG( SERVER_CAN_EXECUTE, "server_can_execute" ), CONVARFLAG( CLIENTCMD_CAN_EXECUTE, "clientcmd_can_execute" ), CONVARFLAG( CLIENTDLL, "cl" ), CONVARFLAG( SS, "ss" ), CONVARFLAG( SS_ADDED, "ss_added" ), CONVARFLAG( DEVELOPMENTONLY, "dev_only" ), }; static void PrintListHeader( FileHandle_t& f ) { char csvflagstr[ 1024 ]; csvflagstr[ 0 ] = 0; int c = ARRAYSIZE( g_ConVarFlags ); for ( int i = 0 ; i < c; ++i ) { char csvf[ 64 ]; ConVarFlags_t & entry = g_ConVarFlags[ i ]; Q_snprintf( csvf, sizeof( csvf ), "\"%s\",", entry.desc ); Q_strncat( csvflagstr, csvf, sizeof( csvflagstr ), COPY_ALL_CHARACTERS ); } g_pFileSystem->FPrintf( f,"\"%s\",\"%s\",%s,\"%s\"\n", "Name", "Value", csvflagstr, "Help Text" ); } //----------------------------------------------------------------------------- // Purpose: // Input : *var - // *f - //----------------------------------------------------------------------------- static void PrintCvar( const ConVar *var, bool logging, FileHandle_t& f ) { char flagstr[ 128 ]; char csvflagstr[ 1024 ]; flagstr[ 0 ] = 0; csvflagstr[ 0 ] = 0; int c = ARRAYSIZE( g_ConVarFlags ); for ( int i = 0 ; i < c; ++i ) { char f[ 32 ]; char csvf[ 64 ]; ConVarFlags_t & entry = g_ConVarFlags[ i ]; if ( var->IsFlagSet( entry.bit ) ) { Q_snprintf( f, sizeof( f ), ", %s", entry.shortdesc ); Q_strncat( flagstr, f, sizeof( flagstr ), COPY_ALL_CHARACTERS ); Q_snprintf( csvf, sizeof( csvf ), "\"%s\",", entry.desc ); } else { Q_snprintf( csvf, sizeof( csvf ), "," ); } Q_strncat( csvflagstr, csvf, sizeof( csvflagstr ), COPY_ALL_CHARACTERS ); } char valstr[ 32 ]; char tempbuff[128]; // Clean up integers if ( var->GetInt() == (int)var->GetFloat() ) { Q_snprintf(valstr, sizeof( valstr ), "%-8i", var->GetInt() ); } else { Q_snprintf(valstr, sizeof( valstr ), "%-8.3f", var->GetFloat() ); } // Print to console ConMsg( "%-40s : %-8s : %-16s : %s\n", var->GetName(), valstr, flagstr, StripTabsAndReturns( var->GetHelpText(), tempbuff, sizeof(tempbuff) ) ); if ( logging ) { g_pFileSystem->FPrintf( f,"\"%s\",\"%s\",%s,\"%s\"\n", var->GetName(), valstr, csvflagstr, StripQuotes( var->GetHelpText(), tempbuff, sizeof(tempbuff) ) ); } } static void PrintCommand( const ConCommand *cmd, bool logging, FileHandle_t& f ) { // Print to console char tempbuff[128]; ConMsg ("%-40s : %-8s : %-16s : %s\n",cmd->GetName(), "cmd", "", StripTabsAndReturns( cmd->GetHelpText(), tempbuff, sizeof(tempbuff) ) ); if ( logging ) { char emptyflags[ 256 ]; emptyflags[ 0 ] = 0; int c = ARRAYSIZE( g_ConVarFlags ); for ( int i = 0; i < c; ++i ) { char csvf[ 64 ]; Q_snprintf( csvf, sizeof( csvf ), "," ); Q_strncat( emptyflags, csvf, sizeof( emptyflags ), COPY_ALL_CHARACTERS ); } // Names staring with +/- need to be wrapped in single quotes char name[ 256 ]; Q_snprintf( name, sizeof( name ), "%s", cmd->GetName() ); if ( name[ 0 ] == '+' || name[ 0 ] == '-' ) { Q_snprintf( name, sizeof( name ), "'%s'", cmd->GetName() ); } char tempbuff[128]; g_pFileSystem->FPrintf( f, "\"%s\",\"%s\",%s,\"%s\"\n", name, "cmd", emptyflags, StripQuotes( cmd->GetHelpText(), tempbuff, sizeof(tempbuff) ) ); } } static bool ConCommandBaseLessFunc( const ConCommandBase * const &lhs, const ConCommandBase * const &rhs ) { const char *left = lhs->GetName(); const char *right = rhs->GetName(); if ( *left == '-' || *left == '+' ) left++; if ( *right == '-' || *right == '+' ) right++; return ( Q_stricmp( left, right ) < 0 ); } //----------------------------------------------------------------------------- // Purpose: // Output : void CCvar::CvarList_f //----------------------------------------------------------------------------- void CCvarUtilities::CvarList( const CCommand &args ) { const ConCommandBase *var; // Temporary Pointer to cvars int iArgs; // Argument count const char *partial = NULL; // Partial cvar to search for... // E.eg int ipLen = 0; // Length of the partial cvar FileHandle_t f = FILESYSTEM_INVALID_HANDLE; // FilePointer for logging bool bLogging = false; // Are we logging? iArgs = args.ArgC(); // Get count // Print usage? if ( iArgs == 2 && !Q_strcasecmp( args[1],"?" ) ) { ConMsg( "cvarlist: [log logfile] [ partial ]\n" ); return; } if ( !Q_strcasecmp( args[1],"log" ) && iArgs >= 3 ) { char fn[256]; Q_snprintf( fn, sizeof( fn ), "%s", args[2] ); f = g_pFileSystem->Open( fn,"wb" ); if ( f ) { bLogging = true; } else { ConMsg( "Couldn't open '%s' for writing!\n", fn ); return; } if ( iArgs == 4 ) { partial = args[ 3 ]; ipLen = Q_strlen( partial ); } } else { partial = args[ 1 ]; ipLen = Q_strlen( partial ); } // Banner ConMsg( "cvar list\n--------------\n" ); CUtlRBTree< const ConCommandBase * > sorted( 0, 0, ConCommandBaseLessFunc ); // Loop through cvars... ICvar::Iterator iter( g_pCVar ); for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() ) { ConCommandBase *var = iter.Get(); bool print = false; if ( var->IsFlagSet(FCVAR_DEVELOPMENTONLY) || var->IsFlagSet(FCVAR_HIDDEN) ) continue; if (partial) // Partial string searching? { if ( !Q_strncasecmp( var->GetName(), partial, ipLen ) ) { print = true; } } else { print = true; } if ( !print ) continue; sorted.Insert( var ); } if ( bLogging ) { PrintListHeader( f ); } for ( int i = sorted.FirstInorder(); i != sorted.InvalidIndex(); i = sorted.NextInorder( i ) ) { var = sorted[ i ]; if ( var->IsCommand() ) { PrintCommand( (ConCommand *)var, bLogging, f ); } else { PrintCvar( (ConVar *)var, bLogging, f ); } } // Show total and syntax help... if ( partial && partial[0] ) { ConMsg("--------------\n%3i convars/concommands for [%s]\n", sorted.Count(), partial ); } else { ConMsg("--------------\n%3i total convars/concommands\n", sorted.Count() ); } if ( bLogging ) { g_pFileSystem->Close( f ); } } //----------------------------------------------------------------------------- // Purpose: Removes the FCVAR_DEVELOPMENTONLY flag from all cvars, making them accessible //----------------------------------------------------------------------------- void CCvarUtilities::EnableDevCvars() { // Loop through cvars... ICvar::Iterator iter( g_pCVar ); for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() ) { ConCommandBase *var = iter.Get(); // remove flag from all cvars var->RemoveFlags( FCVAR_DEVELOPMENTONLY ); } } //----------------------------------------------------------------------------- // Purpose: // Input : // Output : int //----------------------------------------------------------------------------- int CCvarUtilities::CountVariablesWithFlags( int flags ) { int c = 0; ICvar::Iterator iter( g_pCVar ); for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() ) { ConCommandBase *var = iter.Get(); if ( var->IsCommand() ) continue; if ( var->IsFlagSet( flags ) ) { ++c; } } return c; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CCvarUtilities::CvarHelp( const CCommand &args ) { const char *search; const ConCommandBase *var; if ( args.ArgC() != 2 ) { ConMsg( "Usage: help \n" ); return; } // Get name of var to find search = args[1]; // Search for it var = g_pCVar->FindCommandBase( search ); if ( !var ) { ConMsg( "help: no cvar or command named %s\n", search ); return; } // Show info ConVar_PrintDescription( var ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CCvarUtilities::CvarDifferences( const CCommand &args ) { ICvar::Iterator iter( g_pCVar ); for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() ) { ConCommandBase *var = iter.Get(); if ( var->IsCommand( ) ) continue; if ( var->IsFlagSet(FCVAR_DEVELOPMENTONLY) || var->IsFlagSet(FCVAR_HIDDEN) ) continue; if ( !Q_stricmp( ((ConVar *)var)->GetDefault(), ((ConVar *)var)->GetString() ) ) continue; ConVar_PrintDescription( (ConVar *)var ); } } //----------------------------------------------------------------------------- // Purpose: Toggles a cvar on/off, or cycles through a set of values //----------------------------------------------------------------------------- void CCvarUtilities::CvarToggle( const CCommand &args ) { int i; int c = args.ArgC(); if ( c < 2 ) { ConMsg( "Usage: toggle [value1] [value2] [value3]...\n" ); return; } ConVar *var = g_pCVar->FindVar( args[1] ); if ( !IsValidToggleCommand( args[1] ) ) { return; } if ( c == 2 ) { // just toggle it on and off var->SetValue( !var->GetBool() ); ConVar_PrintDescription( var ); } else { // look for the current value in the command arguments for( i = 2; i < c; i++ ) { if ( !Q_strcmp( var->GetString(), args[ i ] ) ) break; } // choose the next one i++; // if we didn't find it, or were at the last value in the command arguments, use the 1st argument if ( i >= c ) { i = 2; } var->SetValue( args[ i ] ); ConVar_PrintDescription( var ); } } int CCvarUtilities::CvarFindFlagsCompletionCallback( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] ) { int flagC = ARRAYSIZE( g_ConVarFlags ); char const *pcmd = "findflags "; int len = Q_strlen( partial ); if ( len < Q_strlen( pcmd ) ) { int i = 0; for ( ; i < MIN( flagC, COMMAND_COMPLETION_MAXITEMS ); i++ ) { Q_snprintf( commands[ i ], sizeof( commands[ i ] ), "%s %s", pcmd, g_ConVarFlags[i].desc ); Q_strlower( commands[ i ] ); } return i; } char const *pSub = partial + Q_strlen( pcmd ); int nSubLen = Q_strlen( pSub ); int values = 0; for ( int i=0; i < flagC; ++i ) { if ( Q_strnicmp( g_ConVarFlags[i].desc, pSub, nSubLen ) ) continue; Q_snprintf( commands[ values ], sizeof( commands[ values ] ), "%s %s", pcmd, g_ConVarFlags[i].desc ); Q_strlower( commands[ values ] ); ++values; if ( values >= COMMAND_COMPLETION_MAXITEMS ) break; } return values; } void CCvarUtilities::CvarFindFlags_f( const CCommand &args ) { if ( args.ArgC() < 2 ) { ConMsg( "Usage: findflags \n" ); ConMsg( "Available flags to search for: \n" ); for ( int i=0; i < ARRAYSIZE( g_ConVarFlags ); i++ ) { ConMsg( " - %s\n", g_ConVarFlags[i].desc ); } return; } // Get substring to find const char *search = args[1]; // Loop through vars and print out findings ICvar::Iterator iter( g_pCVar ); for ( iter.SetFirst() ; iter.IsValid() ; iter.Next() ) { ConCommandBase *var = iter.Get(); if ( var->IsFlagSet(FCVAR_DEVELOPMENTONLY) || var->IsFlagSet(FCVAR_HIDDEN) ) continue; for ( int j=0; j < ARRAYSIZE( g_ConVarFlags ); ++j ) { if ( !var->IsFlagSet( g_ConVarFlags[j].bit ) ) continue; if ( Q_stricmp( g_ConVarFlags[j].desc, search ) ) continue; ConVar_PrintDescription( var ); } } } int FindFlagsCompletionCallback( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] ) { return ConVarUtilities->CvarFindFlagsCompletionCallback( partial, commands ); } //----------------------------------------------------------------------------- // Purpose: Hook to command //----------------------------------------------------------------------------- CON_COMMAND_F_COMPLETION( findflags, "Find concommands by flags.", 0, FindFlagsCompletionCallback ) { ConVarUtilities->CvarFindFlags_f( args ); } //----------------------------------------------------------------------------- // Purpose: Hook to command //----------------------------------------------------------------------------- CON_COMMAND( cvarlist, "Show the list of convars/concommands." ) { ConVarUtilities->CvarList( args ); } //----------------------------------------------------------------------------- // Purpose: Print help text for cvar //----------------------------------------------------------------------------- CON_COMMAND( help, "Find help about a convar/concommand." ) { ConVarUtilities->CvarHelp( args ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CON_COMMAND( differences, "Show all convars which are not at their default values." ) { ConVarUtilities->CvarDifferences( args ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CON_COMMAND( toggle, "Toggles a convar on or off, or cycles through a set of values." ) { ConVarUtilities->CvarToggle( args ); } void ResetGameConVarsToDefaults( void ) { #if defined( LEFT4DEAD ) ConVarRef testprocess( "test_progression_loop" ); ConVarUtilities->ResetConVarsToDefaultValues( "z_" ); if ( ! testprocess.GetInt() ) { ConVarUtilities->ResetConVarsToDefaultValues( "sb_" ); } ConVarUtilities->ResetConVarsToDefaultValues( "survivor_" ); ConVarUtilities->ResetConVarsToDefaultValues( "director_" ); ConVarUtilities->ResetConVarsToDefaultValues( "intensity_" ); ConVarUtilities->ResetConVarsToDefaultValues( "rescue_" ); ConVarUtilities->ResetConVarsToDefaultValues( "tongue_" ); ConVarUtilities->ResetConVarsToDefaultValues( "inferno_" ); ConVarUtilities->ResetConVarsToDefaultValues( "boomer_" ); ConVarUtilities->ResetConVarsToDefaultValues( "hunter_" ); ConVarUtilities->ResetConVarsToDefaultValues( "smoker_" ); ConVarUtilities->ResetConVarsToDefaultValues( "tank_" ); ConVarUtilities->ResetConVarsToDefaultValues( "nav_" ); #endif } CON_COMMAND_F( reset_gameconvars, "Reset a bunch of game convars to default values", FCVAR_CHEAT ) { ResetGameConVarsToDefaults(); } //----------------------------------------------------------------------------- // Purpose: Send the cvars to VXConsole //----------------------------------------------------------------------------- #if defined( USE_VXCONSOLE ) CON_COMMAND( getcvars, "" ) { { // avoid noisy requests // outer logic to prevent multiple requests more complicated than doing just this #if defined( _X360 ) bool bConnected = XBX_IsConsoleConnected(); if ( !bConnected ) { return; } #endif static float s_flLastPublishTime = 0; if ( s_flLastPublishTime && Plat_FloatTime() < s_flLastPublishTime + 2.0f ) { return; } s_flLastPublishTime = Plat_FloatTime(); } #if defined( _X360 ) // get the version from the image // regardles of where the image came from (DVD, HDD) this cracks the embedded version info int nVersion = 0; if ( !IsCert() ) { HANDLE hFile = CreateFile( "d:\\version.xtx", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); if ( hFile != INVALID_HANDLE_VALUE ) { DWORD nFileSize = GetFileSize( hFile, NULL ); if ( nFileSize != (DWORD)-1 && nFileSize > 0 ) { char versionData[1024]; DWORD nBufferSize = MIN( nFileSize, sizeof( versionData ) - 1 ); DWORD nBytesRead = 0; BOOL bResult = ReadFile( hFile, versionData, nBufferSize, &nBytesRead, NULL ); if ( bResult ) { versionData[nBytesRead] = '\0'; nVersion = atoi( versionData ); } } CloseHandle( hFile ); } } XBX_rVersion( nVersion ); #endif // Host_Init() will be calling us again, so defer this expensive operation until then if ( host_initialized ) { #ifdef _PS3 if ( g_pValvePS3Console ) { g_pCVar->PublishToVXConsole(); } #else g_pCVar->PublishToVXConsole(); #endif } } #endif