static char *Cvar_BitInfo( int bit ) { static char info[MAX_INFO_STRING]; struct trie_dump_s *dump; unsigned int i; info[0] = 0; assert( cvar_trie ); Trie_DumpIf( cvar_trie, "", TRIE_DUMP_VALUES, Cvar_HasFlags, &bit, &dump ); // make sure versioncvar comes first for( i = dump->size; i > 0; --i ) { cvar_t *const var = dump->key_value_vector[i-1].value; if( var == versioncvar ) { Info_SetValueForKey( info, var->name, var->string ); break; } } // dump other cvars for( i = 0; i < dump->size; ++i ) { cvar_t *const var = dump->key_value_vector[i].value; if( var != versioncvar ) Info_SetValueForKey( info, var->name, var->string ); } Trie_FreeDump( dump ); return info; }
/* * Cvar_WriteVariables * * Appends lines containing "set variable value" for all variables * with the archive flag set to true. */ void Cvar_WriteVariables( int file ) { char buffer[MAX_PRINTMSG]; struct trie_dump_s *dump; unsigned int i; cvar_flag_t cvar_archive = CVAR_ARCHIVE; assert( cvar_trie ); Trie_DumpIf( cvar_trie, "", TRIE_DUMP_VALUES, Cvar_HasFlags, &cvar_archive, &dump ); for( i = 0; i < dump->size; ++i ) { cvar_t *const var = dump->key_value_vector[i].value; const char *cmd; if( Cvar_FlagIsSet( var->flags, CVAR_USERINFO ) ) cmd = "setau"; else if( Cvar_FlagIsSet( var->flags, CVAR_SERVERINFO ) ) cmd = "setas"; else cmd = "seta"; if( Cvar_FlagIsSet( var->flags, CVAR_LATCH ) || Cvar_FlagIsSet( var->flags, CVAR_LATCH_VIDEO ) || Cvar_FlagIsSet( var->flags, CVAR_LATCH_SOUND ) ) { if( var->latched_string ) Q_snprintfz( buffer, sizeof( buffer ), "%s %s \"%s\"\r\n", cmd, var->name, var->latched_string ); else Q_snprintfz( buffer, sizeof( buffer ), "%s %s \"%s\"\r\n", cmd, var->name, var->string ); } else Q_snprintfz( buffer, sizeof( buffer ), "%s %s \"%s\"\r\n", cmd, var->name, var->string ); FS_Printf( file, "%s", buffer ); } Trie_FreeDump( dump ); }
/* * Cvar_GetLatchedVars * * Any variables with CVAR_LATCHED will now be updated */ void Cvar_GetLatchedVars( cvar_flag_t flags ) { unsigned int i; struct trie_dump_s *dump; cvar_flag_t latchFlags; Cvar_FlagsClear( &latchFlags ); Cvar_FlagSet( &latchFlags, CVAR_LATCH ); Cvar_FlagSet( &latchFlags, CVAR_LATCH_VIDEO ); Cvar_FlagSet( &latchFlags, CVAR_LATCH_SOUND ); Cvar_FlagUnset( &flags, ~latchFlags ); if( !flags ) return; assert( cvar_trie ); Trie_DumpIf( cvar_trie, "", TRIE_DUMP_VALUES, Cvar_IsLatched, &flags, &dump ); for( i = 0; i < dump->size; ++i ) { cvar_t *const var = (cvar_t *) dump->key_value_vector[i].value; if( !strcmp( var->name, "fs_game" ) ) { FS_SetGameDirectory( var->latched_string, qfalse ); return; } Mem_ZoneFree( var->string ); var->string = var->latched_string; var->latched_string = NULL; var->value = atof( var->string ); var->integer = Q_rint( var->value ); } Trie_FreeDump( dump ); }
void Dynvar_List_f( void ) { struct trie_dump_s *dump; unsigned int i, size; char *pattern; Trie_GetSize( dynvar_trie, &size ); if( !size ) { Com_Printf( "No dynvars\n" ); return; } if( Cmd_Argc() == 1 ) pattern = NULL; // no wildcard else pattern = Cmd_Args(); Com_Printf( "\nDynvars:\n" ); assert( dynvar_trie ); Trie_DumpIf( dynvar_trie, "", TRIE_DUMP_VALUES, Dynvar_Console, pattern, &dump ); for( i = 0; i < dump->size; ++i ) { dynvar_t *const dynvar = (dynvar_t *) dump->key_value_vector[i].value; Com_Printf( "%s\n", Dynvar_GetName( dynvar ) ); } Trie_FreeDump( dump ); Com_Printf( "%i dynvars\n", i ); }
void Dynvar_Shutdown( void ) { if( dynvar_initialized ) { struct trie_dump_s *dump; unsigned int i; assert( dynvar_trie ); Cmd_RemoveCommand( "dynvarlist" ); Cmd_RemoveCommand( "setdyn" ); Trie_Dump( dynvar_trie, "", TRIE_DUMP_VALUES, &dump ); for( i = 0; i < dump->size; i++ ) { Dynvar_Destroy( (dynvar_t *)dump->key_value_vector[i].value ); } Trie_FreeDump( dump ); dynvar_initialized = qfalse; } if( dynvar_preinitialized ) { assert( dynvar_trie ); Trie_Destroy( dynvar_trie ); dynvar_trie = NULL; dynvar_preinitialized = qfalse; } }
/* * Cvar_List_f */ static void Cvar_List_f( void ) { struct trie_dump_s *dump; unsigned int i; char *pattern; if( Cmd_Argc() == 1 ) pattern = NULL; else pattern = Cmd_Args(); assert( cvar_trie ); Trie_DumpIf( cvar_trie, "", TRIE_DUMP_VALUES, Cvar_PatternMatches, pattern, &dump ); Com_Printf( "\nConsole variables:\n" ); for( i = 0; i < dump->size; ++i ) { cvar_t *const var = dump->key_value_vector[i].value; #ifdef PUBLIC_BUILD if( Cvar_FlagIsSet( var->flags, CVAR_DEVELOPER ) ) continue; #endif if( Cvar_FlagIsSet( var->flags, CVAR_ARCHIVE ) ) Com_Printf( "*" ); else Com_Printf( " " ); if( Cvar_FlagIsSet( var->flags, CVAR_USERINFO ) ) Com_Printf( "U" ); else Com_Printf( " " ); if( Cvar_FlagIsSet( var->flags, CVAR_SERVERINFO ) ) Com_Printf( "S" ); else Com_Printf( " " ); if( Cvar_FlagIsSet( var->flags, CVAR_NOSET ) || Cvar_FlagIsSet( var->flags, CVAR_READONLY ) ) Com_Printf( "-" ); else if( Cvar_FlagIsSet( var->flags, CVAR_LATCH ) || Cvar_FlagIsSet( var->flags, CVAR_LATCH_VIDEO ) || Cvar_FlagIsSet( var->flags, CVAR_LATCH_SOUND ) ) Com_Printf( "L" ); else Com_Printf( " " ); if( Cvar_FlagIsSet( var->flags, CVAR_CHEAT ) ) Com_Printf( "C" ); else Com_Printf( " " ); Com_Printf( " %s \"%s%s\", default: \"%s%s\"\n", var->name, var->string, Q_ColorStringTerminator( var->string, ColorIndex(COLOR_WHITE) ), var->dvalue, Q_ColorStringTerminator( var->dvalue, ColorIndex(COLOR_WHITE) ) ); } Com_Printf( "%i variables\n", i ); Trie_FreeDump( dump ); }
/* * ML_MapListCmd * Handler for console command "maplist" */ static void ML_MapListCmd( void ) { char *pattern; mapinfo_t *map; int argc = Cmd_Argc(); unsigned int i; struct trie_dump_s *dump = NULL; if( argc > 2 ) { Com_Printf( "Usage: %s [rebuild]\n", Cmd_Argv(0) ); return; } pattern = (argc == 2 ? Cmd_Argv( 1 ) : NULL); if( pattern && !*pattern ) pattern = NULL; if( pattern ) { if( !strcmp( pattern, "rebuild" ) ) { Com_Printf( "Rebuilding map list...\n" ); ML_Restart( true ); return; } if( !strcmp( pattern, "update" ) ) { Com_Printf( "Updating map list...\n" ); ML_Update(); return; } } Trie_DumpIf( mlist_filenames_trie, "", TRIE_DUMP_VALUES, ML_PatternMatchesMap, pattern, &dump ); for( i = 0; i < dump->size; i++ ) { map = ( mapinfo_t * )( dump->key_value_vector[i].value ); Com_Printf( "%s: %s\n", map->filename, map->fullname ); } Trie_FreeDump( dump ); Com_Printf( "%d map(s) %s\n", i, pattern ? "matching" : "total" ); }
/* * ML_GetMapByNum * Prints map infostring in "mapname\0fullname" format into "out" string, * returns fullsize (so that out can be reallocated if there's not enough space) */ size_t ML_GetMapByNum( int num, char *out, size_t size ) { static int i = 0; static struct trie_dump_s *dump = NULL; size_t fsize; mapinfo_t *map; if( !ml_initialized ) return 0; if( ml_flush || i > num ) { if( dump ) { Trie_FreeDump( dump ); dump = NULL; } ml_flush = false; } if( !dump ) { i = 0; Trie_Dump( mlist_filenames_trie, "", TRIE_DUMP_VALUES, &dump ); } for( ; i < num && i < (int)dump->size; i++ ) ; if( i == (int)dump->size ) return 0; map = ( mapinfo_t * )( dump->key_value_vector[i].value ); fsize = strlen( map->filename ) + 1 + strlen( map->fullname ) + 1; if( out && (fsize <= size) ) { Q_strncpyz( out, map->filename, size ); Q_strncpyz( out + strlen( out ) + 1, strcmp( map->fullname, MLIST_UNKNOWN_MAPNAME ) ? map->fullname : map->filename, size - (strlen( out ) + 1) ); } return fsize; }
/* * Cvar_ArchiveList_f */ static void Cvar_ArchiveList_f( void ) { struct trie_dump_s *dump; unsigned int i; assert( cvar_trie ); Trie_Dump( cvar_trie, "", TRIE_DUMP_VALUES, &dump ); for( i = 0; i < dump->size; ++i ) { cvar_t *const var = dump->key_value_vector[i].value; if( Cvar_FlagIsSet( var->flags, CVAR_DEVELOPER ) ) continue; if( !Cvar_FlagIsSet( var->flags, CVAR_ARCHIVE ) ) continue; Com_Printf( "set %s \"%s\"\n", var->name, var->dvalue ); } Trie_FreeDump( dump ); }
/* * Cvar_FixCheatVars * * All cheat variables with be reset to default unless cheats are allowed */ void Cvar_FixCheatVars( void ) { struct trie_dump_s *dump; unsigned int i; cvar_flag_t flags = CVAR_CHEAT; if( Cvar_CheatsAllowed() ) return; assert( cvar_trie ); Trie_DumpIf( cvar_trie, "", TRIE_DUMP_VALUES, Cvar_HasFlags, &flags, &dump ); for( i = 0; i < dump->size; ++i ) { cvar_t *const var = (cvar_t *) dump->key_value_vector[i].value; Mem_ZoneFree( var->string ); var->string = ZoneCopyString( var->dvalue ); var->value = atof( var->string ); var->integer = Q_rint( var->value ); } Trie_FreeDump( dump ); }
/* * ML_BuildCache * Write the map data to a cache file */ static void ML_BuildCache( void ) { int filenum; mapinfo_t *map; struct trie_dump_s *dump; if( !ml_initialized ) return; if( FS_FOpenFile( MLIST_CACHE, &filenum, FS_WRITE|FS_CACHE ) != -1 ) { unsigned int i; Trie_Dump( mlist_filenames_trie, "", TRIE_DUMP_VALUES, &dump ); for( i = 0; i < dump->size; ++i ) { map = ( mapinfo_t * )( dump->key_value_vector[i].value ); FS_Printf( filenum, "%s\r\n%s\r\n", map->filename, map->fullname ); } Trie_FreeDump( dump ); FS_FCloseFile( filenum ); } }
/* * Cvar_Shutdown * * Reads in all archived cvars */ void Cvar_Shutdown( void ) { if( cvar_initialized ) { unsigned int i; struct trie_dump_s *dump; extern cvar_t *developer, *developerMemory; #ifndef DEDICATED_ONLY extern cvar_t *con_printText; #endif assert( cvar_trie ); // NULL out some console variables so that we won't try to read from // the memory pointers after the data has already been freed but before we // reset the pointers to NULL developer = NULL; developerMemory = NULL; dedicated = NULL; #ifndef DEDICATED_ONLY con_printText = NULL; #endif Cmd_RemoveCommand( "set" ); Cmd_RemoveCommand( "seta" ); Cmd_RemoveCommand( "setau" ); Cmd_RemoveCommand( "setas" ); Cmd_RemoveCommand( "setu" ); Cmd_RemoveCommand( "sets" ); Cmd_RemoveCommand( "reset" ); Cmd_RemoveCommand( "toggle" ); Cmd_RemoveCommand( "cvarlist" ); #ifndef PUBLIC_BUILD Cmd_RemoveCommand( "cvararchivelist" ); #endif Trie_Dump( cvar_trie, "", TRIE_DUMP_VALUES, &dump ); for( i = 0; i < dump->size; ++i ) { cvar_t *const var = dump->key_value_vector[i].value; if( var->string ) Mem_ZoneFree( var->string ); if( var->dvalue ) Mem_ZoneFree( var->dvalue ); Mem_ZoneFree( var ); } Trie_FreeDump( dump ); cvar_initialized = qfalse; } if( cvar_preinitialized ) { assert( cvar_trie ); Trie_Destroy( cvar_trie ); cvar_trie = NULL; cvar_preinitialized = qfalse; } }