DOOM-3-BFG

Common_load.cpp (37142B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #include "../idlib/precompiled.h"
 #pragma hdrstop
 
 #include "Common_local.h"
 #include "../sys/sys_lobby_backend.h"
 
 
 #define LAUNCH_TITLE_DOOM_EXECUTABLE		"doom1.exe"
 #define LAUNCH_TITLE_DOOM2_EXECUTABLE		"doom2.exe"
 
 idCVar com_wipeSeconds( "com_wipeSeconds", "1", CVAR_SYSTEM, "" );
 idCVar com_disableAutoSaves( "com_disableAutoSaves", "0", CVAR_SYSTEM | CVAR_BOOL, "" );
 idCVar com_disableAllSaves( "com_disableAllSaves", "0", CVAR_SYSTEM | CVAR_BOOL, "" );
 
 
 extern idCVar sys_lang;
 
 extern idCVar g_demoMode;
 
 // This is for the dirty hack to get a dialog to show up before we capture the screen for autorender.
 const int NumScreenUpdatesToShowDialog = 25;
 
 /*
 ================
 idCommonLocal::LaunchExternalTitle
 
 Launches an external title  ( Doom 1, or 2 ) based on title index. 
 for PS3, a device number is sent in, for the game to register as a local 
 user by default, when title initializes.
 ================
 */
 void idCommonLocal::LaunchExternalTitle( int titleIndex, int device, const lobbyConnectInfo_t * const connectInfo ) {
 
 	idStr deviceString( device );
 
 	// We want to pass in the current executable, so that the launching title knows which title to return to.
 	// as of right now, this feature is TBD. 
 	const char * currentExecutablePath = "ImNotSureYet";
 	idStr launchingExecutablePath;
 
 	idCmdArgs cmdArgs;
 	cmdArgs.AppendArg( currentExecutablePath );
 	
 	if ( titleIndex == LAUNCH_TITLE_DOOM ) {
 			launchingExecutablePath.Format("%s%s", Sys_DefaultBasePath(), LAUNCH_TITLE_DOOM_EXECUTABLE );
 		cmdArgs.AppendArg( "d1bfg" );
 	} else if ( titleIndex == LAUNCH_TITLE_DOOM2 ) {
 		launchingExecutablePath.Format("%s%s", Sys_DefaultBasePath(), LAUNCH_TITLE_DOOM2_EXECUTABLE );
 		cmdArgs.AppendArg( "d2bfg" );
 
 	} else {
 
 		idLib::Warning("Unhandled Launch Title %d \n", titleIndex );
 	}
 
 	cmdArgs.AppendArg( deviceString.c_str() );
 
 	// Add an argument so that the new process knows whether or not to read exitspawn data.
 	if ( connectInfo != NULL ) {
 		cmdArgs.AppendArg( "exitspawnInvite" );
 	}
 
 	// Add arguments so that the new process will know which command line to invoke to relaunch this process
 	// if necessary.
 
 	const int launchDataSize = ( connectInfo == NULL ) ? 0 : sizeof( *connectInfo );
 
 	Sys_Launch(  launchingExecutablePath.c_str() , cmdArgs, const_cast< lobbyConnectInfo_t * const >( connectInfo ), launchDataSize );
 }
 
 /*
 ================
 idCommonLocal::StartWipe
 
 Draws and captures the current state, then starts a wipe with that image
 ================
 */
 void idCommonLocal::StartWipe( const char *_wipeMaterial, bool hold ) {
 	console->Close();
 
 	Draw();
 
 	renderSystem->CaptureRenderToImage( "_currentRender" );
 
 	wipeMaterial = declManager->FindMaterial( _wipeMaterial, false );
 
 	wipeStartTime = Sys_Milliseconds();
 	wipeStopTime = wipeStartTime + SEC2MS( com_wipeSeconds.GetFloat() );
 	wipeHold = hold;
 }
 
 /*
 ================
 idCommonLocal::CompleteWipe
 ================
 */
 void idCommonLocal::CompleteWipe() {
 	while ( Sys_Milliseconds() < wipeStopTime ) {
 		BusyWait();
 		Sys_Sleep( 10 );
 	}
 
 	// ensure it is completely faded out
 	wipeStopTime = Sys_Milliseconds();
 	BusyWait();
 }
 
 /*
 ================
 idCommonLocal::ClearWipe
 ================
 */
 void idCommonLocal::ClearWipe() {
 	wipeHold = false;
 	wipeStopTime = 0;
 	wipeStartTime = 0;
 	wipeForced = false;
 }
 
 /*
 ===============
 idCommonLocal::StartNewGame
 ===============
 */
 void idCommonLocal::StartNewGame( const char * mapName, bool devmap, int gameMode ) {
 	if ( session->GetSignInManager().GetMasterLocalUser() == NULL ) {
 		// For development make sure a controller is registered
 		// Can't just register the local user because it will be removed because of it's persistent state
 		session->GetSignInManager().SetDesiredLocalUsers( 1, 1 );
 		session->GetSignInManager().Pump();
 	}
 
 	idStr mapNameClean = mapName;
 	mapNameClean.StripFileExtension();
 	mapNameClean.BackSlashesToSlashes();
 
 	idMatchParameters matchParameters;
 	matchParameters.mapName = mapNameClean;
 	if ( gameMode == GAME_MODE_SINGLEPLAYER ) {
 		matchParameters.numSlots = 1;
 		matchParameters.gameMode = GAME_MODE_SINGLEPLAYER;
 		matchParameters.gameMap = GAME_MAP_SINGLEPLAYER;
 	} else {
 		matchParameters.gameMap = mpGameMaps.Num();	// If this map isn't found in mpGameMaps, then set it to some undefined value (this happens when, for example, we load a box map with netmap)
 		matchParameters.gameMode = gameMode;
 		matchParameters.matchFlags = DefaultPartyFlags;
 		for ( int i = 0; i < mpGameMaps.Num(); i++ ) {
 			if ( idStr::Icmp( mpGameMaps[i].mapFile, mapNameClean ) == 0 ) {
 				matchParameters.gameMap = i;
 				break;
 			}
 		}
 		matchParameters.numSlots = session->GetTitleStorageInt("MAX_PLAYERS_ALLOWED", 4 );
 	}
 
 	cvarSystem->MoveCVarsToDict( CVAR_SERVERINFO, matchParameters.serverInfo );
 	if ( devmap ) {
 		matchParameters.serverInfo.Set( "devmap", "1" );
 	} else {
 		matchParameters.serverInfo.Delete( "devmap" );
 	}
 
 	session->QuitMatchToTitle();
 	if ( WaitForSessionState( idSession::IDLE ) ) {
 		session->CreatePartyLobby( matchParameters );
 		if ( WaitForSessionState( idSession::PARTY_LOBBY ) ) {
 			session->CreateMatch( matchParameters );
 			if ( WaitForSessionState( idSession::GAME_LOBBY ) ) {
 				cvarSystem->SetCVarBool( "developer", devmap );
 				session->StartMatch();
 			}
 		}
 	}
 }
 
 /*
 ===============
 idCommonLocal::MoveToNewMap
 Single player transition from one map to another
 ===============
 */
 void idCommonLocal::MoveToNewMap( const char *mapName, bool devmap ) {
 	idMatchParameters matchParameters;
 	matchParameters.numSlots = 1;
 	matchParameters.gameMode = GAME_MODE_SINGLEPLAYER;
 	matchParameters.gameMap = GAME_MAP_SINGLEPLAYER;
 	matchParameters.mapName = mapName;
 	cvarSystem->MoveCVarsToDict( CVAR_SERVERINFO, matchParameters.serverInfo );
 	if ( devmap ) {
 		matchParameters.serverInfo.Set( "devmap", "1" );
 		mapSpawnData.persistentPlayerInfo.Clear();
 	} else {
 		matchParameters.serverInfo.Delete( "devmap" );
 		mapSpawnData.persistentPlayerInfo = game->GetPersistentPlayerInfo( 0 );
 	}
 	session->QuitMatchToTitle();
 	if ( WaitForSessionState( idSession::IDLE ) ) {
 		session->CreatePartyLobby( matchParameters );
 		if ( WaitForSessionState( idSession::PARTY_LOBBY ) ) {
 			session->CreateMatch( matchParameters );
 			if ( WaitForSessionState( idSession::GAME_LOBBY ) ) {
 				session->StartMatch();
 			}
 		}
 	}
 }
 
 /*
 ===============
 idCommonLocal::UnloadMap
 
 Performs cleanup that needs to happen between maps, or when a
 game is exited.
 Exits with mapSpawned = false
 ===============
 */
 void idCommonLocal::UnloadMap() {
 	StopPlayingRenderDemo();
 
 	// end the current map in the game
 	if ( game ) {
 		game->MapShutdown();
 	}
 
 	if ( writeDemo ) {
 		StopRecordingRenderDemo();
 	}
 
 	mapSpawned = false;
 }
 
 /*
 ===============
 idCommonLocal::LoadLoadingGui
 ===============
 */
 void idCommonLocal::LoadLoadingGui( const char *mapName, bool & hellMap ) {
 
 	defaultLoadscreen = false;
 	loadGUI = new idSWF( "loading/default", NULL );	
 	
 	if ( g_demoMode.GetBool() ) {
 		hellMap = false;
 		if ( loadGUI != NULL ) {					
 			const idMaterial * defaultMat = declManager->FindMaterial( "guis/assets/loadscreens/default" );
 			renderSystem->LoadLevelImages();
 			
 			loadGUI->Activate( true );
 			idSWFSpriteInstance * bgImg = loadGUI->GetRootObject().GetSprite( "bgImage" );
 			if ( bgImg != NULL ) {
 				bgImg->SetMaterial( defaultMat );
 			}
 		}
 		defaultLoadscreen = true;
 		return;
 	}
 
 	// load / program a gui to stay up on the screen while loading
 	idStrStatic< MAX_OSPATH > stripped = mapName;
 	stripped.StripFileExtension();
 	stripped.StripPath();
 
 	// use default load screen for demo
 	idStrStatic< MAX_OSPATH > matName = "guis/assets/loadscreens/";
 	matName.Append( stripped );
 	const idMaterial * mat = declManager->FindMaterial( matName );
 
 	renderSystem->LoadLevelImages();
 
 	if ( mat->GetImageWidth() < 32 ) {
 		mat = declManager->FindMaterial( "guis/assets/loadscreens/default" );
 		renderSystem->LoadLevelImages();
 	}
 
 	loadTipList.SetNum( loadTipList.Max() );
 	for ( int i = 0; i < loadTipList.Max(); ++i ) {
 		loadTipList[i] = i;
 	}
 
 	if ( loadGUI != NULL ) {
 		loadGUI->Activate( true );
 		nextLoadTip = Sys_Milliseconds() + LOAD_TIP_CHANGE_INTERVAL;
 
 		idSWFSpriteInstance * bgImg = loadGUI->GetRootObject().GetSprite( "bgImage" );
 		if ( bgImg != NULL ) {
 			bgImg->SetMaterial( mat );
 		}
 
 		idSWFSpriteInstance * overlay = loadGUI->GetRootObject().GetSprite( "overlay" );
 
 		const idDeclEntityDef * mapDef = static_cast<const idDeclEntityDef *>(declManager->FindType( DECL_MAPDEF, mapName, false ));
 		if ( mapDef != NULL ) {
 			isHellMap = mapDef->dict.GetBool( "hellMap", false );
 
 			if ( isHellMap && overlay != NULL ) {
 				overlay->SetVisible( false );
 			}
 
 			idStr desc;	
 			idStr subTitle;
 			idStr displayName;
 			idSWFTextInstance * txtVal = NULL;
 
 			txtVal = loadGUI->GetRootObject().GetNestedText( "txtRegLoad" );
 			displayName = idLocalization::GetString( mapDef->dict.GetString( "name", mapName ) );
 
 			if ( txtVal != NULL ) {
 				txtVal->SetText( "#str_00408" );
 				txtVal->SetStrokeInfo( true, 2.0f, 1.0f );
 			}			
 
 			const idMatchParameters & matchParameters = session->GetActingGameStateLobbyBase().GetMatchParms();
 			if ( matchParameters.gameMode == GAME_MODE_SINGLEPLAYER ) {
 				desc = idLocalization::GetString( mapDef->dict.GetString( "desc", "" ) );
 				subTitle = idLocalization::GetString( mapDef->dict.GetString( "subTitle", "" ) );
 			} else {
 				const idStrList & modes = common->GetModeDisplayList();
 				subTitle = modes[ idMath::ClampInt( 0, modes.Num() - 1, matchParameters.gameMode ) ];
 
 				const char * modeDescs[] = { "#str_swf_deathmatch_desc", "#str_swf_tourney_desc", "#str_swf_team_deathmatch_desc", "#str_swf_lastman_desc", "#str_swf_ctf_desc" };
 				desc = idLocalization::GetString( modeDescs[matchParameters.gameMode] );
 			}
 			
 			if ( !isHellMap ) {
 				txtVal = loadGUI->GetRootObject().GetNestedText( "txtName" );
 			} else {
 				txtVal = loadGUI->GetRootObject().GetNestedText( "txtHellName" );
 			}
 			if ( txtVal != NULL ) {
 				txtVal->SetText( displayName );
 				txtVal->SetStrokeInfo( true, 2.0f, 1.0f );
 			}
 
 			txtVal = loadGUI->GetRootObject().GetNestedText( "txtSub" );
 			if ( txtVal != NULL && !isHellMap ) {
 				txtVal->SetText( subTitle );
 				txtVal->SetStrokeInfo( true, 1.75f, 0.75f );
 			}
 
 			txtVal = loadGUI->GetRootObject().GetNestedText( "txtDesc" );
 			if ( txtVal != NULL ) {
 				if ( isHellMap ) {
 					txtVal->SetText( va( "\n%s", desc.c_str() ) );
 				} else {
 					txtVal->SetText( desc );
 				}
 				txtVal->SetStrokeInfo( true, 1.75f, 0.75f );
 			}
 		}
 	}
 }
 
 /*
 ===============
 idCommonLocal::ExecuteMapChange
 
 Performs the initialization of a game based on session match parameters, used for both single
 player and multiplayer, but not for renderDemos, which don't create a game at all.
 Exits with mapSpawned = true
 ===============
 */
 void idCommonLocal::ExecuteMapChange() {
 	if ( session->GetState() != idSession::LOADING ) {
 		idLib::Warning( "Session state is not LOADING in ExecuteMapChange" );
 		return;
 	}
 
 	// Clear all dialogs before beginning the load
 	common->Dialog().ClearDialogs( true );
 	
 	// Remember the current load ID.
 	// This is so we can tell if we had a new loadmap request from within an existing loadmap call
 	const int cachedLoadingID = session->GetLoadingID();
 
 	const idMatchParameters & matchParameters = session->GetActingGameStateLobbyBase().GetMatchParms();
 
 	if ( matchParameters.numSlots <= 0 ) {
 		idLib::Warning( "numSlots <= 0 in ExecuteMapChange" );
 		return;
 	}
 
 	insideExecuteMapChange = true;
 
 	common->Printf( "--------- Execute Map Change ---------\n" );
 	common->Printf( "Map: %s\n", matchParameters.mapName.c_str() );
 
 	// ensure that r_znear is reset to the default value
 	// this fixes issues with the projection matrix getting messed up when switching maps or loading a saved game
 	// while an in-game cinematic is playing.
 	cvarSystem->SetCVarFloat( "r_znear", 3.0f );
 
 	// reset all cheat cvars for a multiplayer game
 	if ( IsMultiplayer() ) {
 		cvarSystem->ResetFlaggedVariables( CVAR_CHEAT );
 	}
 
 	int start = Sys_Milliseconds();
 
 	for ( int i = 0; i < MAX_INPUT_DEVICES; i++ ) {
 		Sys_SetRumble( i, 0, 0 );
 	}
 
 	// close console and remove any prints from the notify lines
 	console->Close();
 
 	// clear all menu sounds
 	soundWorld->Pause();
 	menuSoundWorld->ClearAllSoundEmitters();
 	soundSystem->SetPlayingSoundWorld( menuSoundWorld );
 	soundSystem->Render();
 
 	// extract the map name from serverinfo
 	currentMapName = matchParameters.mapName;
 	currentMapName.StripFileExtension();
 
 	idStrStatic< MAX_OSPATH > fullMapName = "maps/";
 	fullMapName += currentMapName;
 	fullMapName.SetFileExtension( "map" );
 
 	if ( mapSpawnData.savegameFile ) {
 		fileSystem->BeginLevelLoad( currentMapName, NULL, 0 );
 	} else {
 		fileSystem->BeginLevelLoad( currentMapName, saveFile.GetDataPtr(), saveFile.GetAllocated() );
 	}
 
 	// capture the current screen and start a wipe
 	// immediately complete the wipe to fade out the level transition
 	// run the wipe to completion
 	StartWipe( "wipeMaterial", true );
 	CompleteWipe();
 
 	int sm = Sys_Milliseconds();
 	// shut down the existing game if it is running
 	UnloadMap();
 	int ms = Sys_Milliseconds() - sm;
 	common->Printf( "%6d msec to unload map\n", ms );
 
 	// Free media from previous level and
 	// note which media we are going to need to load
 	sm = Sys_Milliseconds();
 	renderSystem->BeginLevelLoad();
 	soundSystem->BeginLevelLoad();
 	declManager->BeginLevelLoad();
 	uiManager->BeginLevelLoad();
 	ms = Sys_Milliseconds() - sm;
 	common->Printf( "%6d msec to free assets\n", ms );
 
 	//Sys_DumpMemory( true );
 
 	// load / program a gui to stay up on the screen while loading
 	// set the loading gui that we will wipe to
 	bool hellMap = false;
 	LoadLoadingGui( currentMapName, hellMap );
 
 	// Stop rendering the wipe
 	ClearWipe();
 
 
 	if ( fileSystem->UsingResourceFiles() ) {
 		idStrStatic< MAX_OSPATH > manifestName = currentMapName;
 		manifestName.Replace( "game/", "maps/" );
 		manifestName.Replace( "/mp/", "/" );
 		manifestName += ".preload";
 		idPreloadManifest manifest;
 		manifest.LoadManifest( manifestName );
 		renderSystem->Preload( manifest, currentMapName );
 		soundSystem->Preload( manifest );
 		game->Preload( manifest );
 	}
 
 	if ( common->IsMultiplayer() ) {
 		// In multiplayer, make sure the player is either 60Hz or 120Hz
 		// to avoid potential issues.
 		const float mpEngineHz = ( com_engineHz.GetFloat() < 90.0f ) ? 60.0f : 120.0f;
 		com_engineHz_denominator = 100LL * mpEngineHz;
 		com_engineHz_latched = mpEngineHz;
 	} else {
 		// allow com_engineHz to be changed between map loads
 		com_engineHz_denominator = 100LL * com_engineHz.GetFloat();
 		com_engineHz_latched = com_engineHz.GetFloat();
 	}
 
 	// note any warning prints that happen during the load process
 	common->ClearWarnings( currentMapName );
 
 	// release the mouse cursor
 	// before we do this potentially long operation
 	Sys_GrabMouseCursor( false );
 
 	// let the renderSystem load all the geometry
 	if ( !renderWorld->InitFromMap( fullMapName ) ) {
 		common->Error( "couldn't load %s", fullMapName.c_str() );
 	}
 
 	// for the synchronous networking we needed to roll the angles over from
 	// level to level, but now we can just clear everything
 	usercmdGen->InitForNewMap();
 
 	// load and spawn all other entities ( from a savegame possibly )
 	if ( mapSpawnData.savegameFile ) {
 		if ( !game->InitFromSaveGame( fullMapName, renderWorld, soundWorld, mapSpawnData.savegameFile, mapSpawnData.stringTableFile, mapSpawnData.savegameVersion ) ) {
 			// If the loadgame failed, end the session, which will force us to go back to the main menu
 			session->QuitMatchToTitle();
 		}
 	} else {
 		if ( !IsMultiplayer() ) {
 			assert( game->GetLocalClientNum() == 0 );
 			assert( matchParameters.gameMode == GAME_MODE_SINGLEPLAYER );
 			assert( matchParameters.gameMap == GAME_MAP_SINGLEPLAYER );
 			game->SetPersistentPlayerInfo( 0, mapSpawnData.persistentPlayerInfo );
 		}
 		game->SetServerInfo( matchParameters.serverInfo );
 		game->InitFromNewMap( fullMapName, renderWorld, soundWorld, matchParameters.gameMode, Sys_Milliseconds() );
 	}
 
 	game->Shell_CreateMenu( true );
 
 	// Reset some values important to multiplayer
 	ResetNetworkingState();
 
 	// If the session state is not loading here, something went wrong.
 	if ( session->GetState() == idSession::LOADING && session->GetLoadingID() == cachedLoadingID ) {
 		// Notify session we are done loading
 		session->LoadingFinished();
 
 		while ( session->GetState() == idSession::LOADING ) {
 			Sys_GenerateEvents();
 			session->UpdateSignInManager();
 			session->Pump();
 			Sys_Sleep( 10 );
 		}
 	}
 
 	if ( !mapSpawnData.savegameFile ) {
 		// run a single frame to catch any resources that are referenced by events posted in spawn
 		idUserCmdMgr emptyCommandManager;
 		gameReturn_t emptyGameReturn;
 		for ( int playerIndex = 0; playerIndex < MAX_PLAYERS; ++playerIndex ) {
 			emptyCommandManager.PutUserCmdForPlayer( playerIndex, usercmd_t() );
 		}
 		if ( IsClient() ) {
 			game->ClientRunFrame( emptyCommandManager, false, emptyGameReturn );
 		} else {
 			game->RunFrame( emptyCommandManager, emptyGameReturn );
 		}
 	}
 
 	renderSystem->EndLevelLoad();
 	soundSystem->EndLevelLoad();
 	declManager->EndLevelLoad();
 	uiManager->EndLevelLoad( currentMapName );
 	fileSystem->EndLevelLoad();
 
 	if ( !mapSpawnData.savegameFile && !IsMultiplayer() ) {
 		common->Printf( "----- Running initial game frames -----\n" );
 
 		// In single player, run a bunch of frames to make sure ragdolls are settled
 		idUserCmdMgr emptyCommandManager;
 		gameReturn_t emptyGameReturn;
 		for ( int i = 0; i < 100; i++ ) {
 			for ( int playerIndex = 0; playerIndex < MAX_PLAYERS; ++playerIndex ) {
 				emptyCommandManager.PutUserCmdForPlayer( playerIndex, usercmd_t() );
 			}
 			game->RunFrame( emptyCommandManager, emptyGameReturn );
 		}
 
 		// kick off an auto-save of the game (so we can always continue in this map if we die before hitting an autosave)
 		common->Printf( "----- Saving Game -----\n" );
 		SaveGame( "autosave" );
 	}
 
 	common->Printf( "----- Generating Interactions -----\n" );
 
 	// let the renderSystem generate interactions now that everything is spawned
 	renderWorld->GenerateAllInteractions();
 
 	{
 		int vertexMemUsedKB = vertexCache.staticData.vertexMemUsed.GetValue() / 1024;
 		int indexMemUsedKB = vertexCache.staticData.indexMemUsed.GetValue() / 1024;
 		idLib::Printf( "Used %dkb of static vertex memory (%d%%)\n", vertexMemUsedKB, vertexMemUsedKB * 100 / ( STATIC_VERTEX_MEMORY / 1024 ) );
 		idLib::Printf( "Used %dkb of static index memory (%d%%)\n", indexMemUsedKB, indexMemUsedKB * 100 / ( STATIC_INDEX_MEMORY / 1024 ) );
 	}
 
 	if ( common->JapaneseCensorship() ) {
 		if ( currentMapName.Icmp( "game/mp/d3xpdm3" ) == 0 ) {
 			const idMaterial * gizpool2 = declManager->FindMaterial( "textures/hell/gizpool2" );
 			idMaterial * chiglass1bluex = const_cast<idMaterial *>( declManager->FindMaterial( "textures/sfx/chiglass1bluex" ) );
 			idTempArray<char> text( gizpool2->GetTextLength() );
 			gizpool2->GetText( text.Ptr() );
 			chiglass1bluex->Parse( text.Ptr(), text.Num(), false );
 		}
 	}
 
 	common->PrintWarnings();
 
 	session->Pump();
 
 	if ( session->GetState() != idSession::INGAME ) {
 		// Something went wrong, don't process stale reliables that have been queued up.
 		reliableQueue.Clear();
 	}
 
 	usercmdGen->Clear();
 
 	// remove any prints from the notify lines
 	console->ClearNotifyLines();
 
 	Sys_SetPhysicalWorkMemory( -1, -1 );
 
 	// at this point we should be done with the loading gui so we kill it
 	delete loadGUI;
 	loadGUI = NULL;
 
 
 	// capture the current screen and start a wipe
 	StartWipe( "wipe2Material" );
 
 	// we are valid for game draws now
 	insideExecuteMapChange = false;
 	mapSpawned = true;
 	Sys_ClearEvents();
 
 
 	int	msec = Sys_Milliseconds() - start;
 	common->Printf( "%6d msec to load %s\n", msec, currentMapName.c_str() );
 	//Sys_DumpMemory( false );	
 
 	// Issue a render at the very end of the load process to update soundTime before the first frame
 	soundSystem->Render();
 }
 
 /*
 ===============
 idCommonLocal::UpdateLevelLoadPacifier
 
 Pumps the session and if multiplayer, displays dialogs during the loading process.
 ===============
 */
 void idCommonLocal::UpdateLevelLoadPacifier() {	
 	autoRenderIconType_t icon = AUTORENDER_DEFAULTICON;
 	bool autoswapsRunning = renderSystem->AreAutomaticBackgroundSwapsRunning( &icon );
 	if ( !insideExecuteMapChange && !autoswapsRunning ) {
 		return;
 	}
 
 	const int sessionUpdateTime = common->IsMultiplayer() ? 16 : 100;
 
 	const int time = Sys_Milliseconds();
 
 	// Throttle session pumps.
 	if ( time - lastPacifierSessionTime >= sessionUpdateTime ) {
 		lastPacifierSessionTime = time;
 
 		Sys_GenerateEvents();
 
 		session->UpdateSignInManager();
 		session->Pump();
 		session->ProcessSnapAckQueue();
 	}
 
 	if ( autoswapsRunning ) {
 		// If autoswaps are running, only update if a Dialog is shown/dismissed
 		bool dialogState = Dialog().HasAnyActiveDialog();
 		if ( lastPacifierDialogState != dialogState ) {
 			lastPacifierDialogState = dialogState;
 			renderSystem->EndAutomaticBackgroundSwaps();
 			if ( dialogState ) {
 				icon = AUTORENDER_DIALOGICON; // Done this way to handle the rare case of a tip changing at the same time a dialog comes up
 				for ( int i = 0; i < NumScreenUpdatesToShowDialog; ++i ) {
 					UpdateScreen( false );
 				}
 			}
 			renderSystem->BeginAutomaticBackgroundSwaps( icon );
 		}
 	} else {
 		// On the PC just update at a constant rate for the Steam overlay
 		if ( time - lastPacifierGuiTime >= 50 ) {
 			lastPacifierGuiTime = time;
 			UpdateScreen( false );
 		}
 	}
 
 	if ( time >= nextLoadTip && loadGUI != NULL && loadTipList.Num() > 0 && !defaultLoadscreen ) {
 		if ( autoswapsRunning ) {
 			renderSystem->EndAutomaticBackgroundSwaps();
 		}
 		nextLoadTip = time + LOAD_TIP_CHANGE_INTERVAL;
 		const int rnd = time % loadTipList.Num();
 		idStrStatic<20> tipId;
 		tipId.Format( "#str_loadtip_%d", loadTipList[ rnd ] );
 		loadTipList.RemoveIndex( rnd );
 
 		idSWFTextInstance * txtVal = loadGUI->GetRootObject().GetNestedText( "txtDesc" );
 		if ( txtVal != NULL ) {
 			if ( isHellMap ) {
 				txtVal->SetText( va( "\n%s", idLocalization::GetString( tipId ) ) );
 			} else {
 				txtVal->SetText( idLocalization::GetString( tipId ) );
 			}
 			txtVal->SetStrokeInfo( true, 1.75f, 0.75f );
 		}
 		UpdateScreen( false );
 		if ( autoswapsRunning ) {
 			renderSystem->BeginAutomaticBackgroundSwaps( icon );
 		}
 	}
 }
 
 /*
 ===============
 idCommonLocal::ScrubSaveGameFileName
 
 Turns a bad file name into a good one or your money back
 ===============
 */
 void idCommonLocal::ScrubSaveGameFileName( idStr &saveFileName ) const {
 	int i;
 	idStr inFileName;
 
 	inFileName = saveFileName;
 	inFileName.RemoveColors();
 	inFileName.StripFileExtension();
 
 	saveFileName.Clear();
 
 	int len = inFileName.Length();
 	for ( i = 0; i < len; i++ ) {
 		if ( strchr( "',.~!@#$%^&*()[]{}<>\\|/=?+;:-\'\"", inFileName[i] ) ) {
 			// random junk
 			saveFileName += '_';
 		} else if ( (const unsigned char)inFileName[i] >= 128 ) {
 			// high ascii chars
 			saveFileName += '_';
 		} else if ( inFileName[i] == ' ' ) {
 			saveFileName += '_';
 		} else {
 			saveFileName += inFileName[i];
 		}
 	}
 }
 
 /*
 ===============
 idCommonLocal::SaveGame
 ===============
 */
 bool idCommonLocal::SaveGame( const char * saveName ) {
 	if ( pipelineFile != NULL ) {
 		// We're already in the middle of a save. Leave us alone.
 		return false;
 	}
 
 	if ( com_disableAllSaves.GetBool() || ( com_disableAutoSaves.GetBool() && ( idStr::Icmp( saveName, "autosave" ) == 0 ) ) ) {
 		return false;
 	}
 
 	if ( IsMultiplayer() ) {
 		common->Printf( "Can't save during net play.\n" );
 		return false;
 	}
 
 	if (mapSpawnData.savegameFile != NULL ) {
 		return false;
 	}
 
 	const idDict & persistentPlayerInfo = game->GetPersistentPlayerInfo( 0 );
 	if ( persistentPlayerInfo.GetInt( "health" ) <= 0 ) {
 		common->Printf( "You must be alive to save the game\n" );
 		return false;
 	}
 
 	soundWorld->Pause();
 	soundSystem->SetPlayingSoundWorld( menuSoundWorld );
 	soundSystem->Render();
 
 	Dialog().ShowSaveIndicator( true );
 	if ( insideExecuteMapChange ) {
 		UpdateLevelLoadPacifier();
 	} else {
 		// Heremake sure we pump the gui enough times to show the 'saving' dialog
 		const bool captureToImage = false;
 		for ( int i = 0; i < NumScreenUpdatesToShowDialog; ++i ) {
 			UpdateScreen( captureToImage );
 		}
 		renderSystem->BeginAutomaticBackgroundSwaps( AUTORENDER_DIALOGICON );
 	}
 
 	// Make sure the file is writable and the contents are cleared out (Set to write from the start of file)
 	saveFile.MakeWritable();
 	saveFile.Clear( false );
 	stringsFile.MakeWritable();
 	stringsFile.Clear( false );
 
 	// Setup the save pipeline
 	pipelineFile = new (TAG_SAVEGAMES) idFile_SaveGamePipelined();
 	pipelineFile->OpenForWriting( &saveFile );
 
 	// Write SaveGame Header: 
 	// Game Name / Version / Map Name / Persistant Player Info
 
 	// game
 	const char *gamename = GAME_NAME;
 	saveFile.WriteString( gamename );
 
 	// map
 	saveFile.WriteString( currentMapName );
 
 	saveFile.WriteBool( consoleUsed );
 
 	game->GetServerInfo().WriteToFileHandle( &saveFile );
 
 	// let the game save its state
 	game->SaveGame( pipelineFile, &stringsFile );
 
 	pipelineFile->Finish();
 
 	idSaveGameDetails gameDetails;
 	game->GetSaveGameDetails( gameDetails );
 
 	gameDetails.descriptors.Set( SAVEGAME_DETAIL_FIELD_LANGUAGE, sys_lang.GetString() );
 	gameDetails.descriptors.SetInt( SAVEGAME_DETAIL_FIELD_CHECKSUM, (int)gameDetails.descriptors.Checksum() );
 
 	gameDetails.slotName = saveName;
 	ScrubSaveGameFileName( gameDetails.slotName );
 
 	saveFileEntryList_t files;
 	files.Append( &stringsFile );
 	files.Append( &saveFile );
 
 	session->SaveGameSync( gameDetails.slotName, files, gameDetails );
 
 	if ( !insideExecuteMapChange ) {
 		renderSystem->EndAutomaticBackgroundSwaps();
 	}
 
 	syncNextGameFrame = true;
 
 	return true;
 }
 
 /*
 ===============
 idCommonLocal::LoadGame
 ===============
 */
 bool idCommonLocal::LoadGame( const char * saveName ) { 
 	if ( IsMultiplayer() ) {
 		common->Printf( "Can't load during net play.\n" );
 		if ( wipeForced ) {
 			ClearWipe();
 		}
 		return false;
 	}
 
 	if ( GetCurrentGame() != DOOM3_BFG ) {
 		return false;
 	}
 
 	if ( session->GetSignInManager().GetMasterLocalUser() == NULL ) {
 		return false;
 	}
 	if (mapSpawnData.savegameFile != NULL ) {
 		return false;
 	}
 
 	bool found = false;
 	const saveGameDetailsList_t & sgdl = session->GetSaveGameManager().GetEnumeratedSavegames();
 	for ( int i = 0; i < sgdl.Num(); i++ ) {
 		if ( sgdl[i].slotName == saveName ) {
 			if ( sgdl[i].GetLanguage() != sys_lang.GetString() ) {
 				idStaticList< idSWFScriptFunction *, 4 > callbacks;
 				idStaticList< idStrId, 4 > optionText;
 				optionText.Append( idStrId( "#str_swf_continue" ) );
 				idStrStatic<256> langName = "#str_lang_" + sgdl[i].GetLanguage();
 				idStrStatic<256> msg;
 				msg.Format( idLocalization::GetString( "#str_dlg_wrong_language" ), idLocalization::GetString( langName ) );
 				Dialog().AddDynamicDialog( GDM_SAVEGAME_WRONG_LANGUAGE, callbacks, optionText, true, msg, false, true );
 				if ( wipeForced ) {
 					ClearWipe();
 				}
 				return false;
 			}
 			found = true;
 			break;
 		}
 	}
 	if ( !found ) {
 		common->Printf( "Could not find save '%s'\n", saveName );
 		if ( wipeForced ) {
 			ClearWipe();
 		}
 		return false;
 	}
 
 	mapSpawnData.savegameFile = &saveFile;
 	mapSpawnData.stringTableFile = &stringsFile;
 
 	saveFileEntryList_t files;
 	files.Append( mapSpawnData.stringTableFile );
 	files.Append( mapSpawnData.savegameFile );
 
 	idStr slotName = saveName;
 	ScrubSaveGameFileName( slotName );
 	saveFile.Clear( false );
 	stringsFile.Clear( false );
 
 	saveGameHandle_t loadGameHandle = session->LoadGameSync( slotName, files );
 	if ( loadGameHandle != 0 ) {
 		return true;
 	}
 	mapSpawnData.savegameFile = NULL;
 	if ( wipeForced ) {
 		ClearWipe();
 	}
 	return false;
 }
 
 /*
 ========================
 HandleInsufficientStorage
 ========================
 */
 void HandleInsufficientStorage( const idSaveLoadParms & parms ) {
 	session->GetSaveGameManager().ShowRetySaveDialog( parms.directory, parms.requiredSpaceInBytes );
 }
 
 /*
 ========================
 HandleCommonErrors
 ========================
 */
 bool HandleCommonErrors( const idSaveLoadParms & parms ) {
 	if ( parms.GetError() == SAVEGAME_E_NONE ) {
 		return true;
 	}
 
 	common->Dialog().ShowSaveIndicator( false );
 
 	if ( parms.GetError() & SAVEGAME_E_CORRUPTED ) {
 		// This one might need to be handled by the game
 		common->Dialog().AddDialog( GDM_CORRUPT_CONTINUE, DIALOG_CONTINUE, NULL, NULL, false );
 
 		// Find the game in the enumerated details, mark as corrupt so the menus can show as corrupt
 		saveGameDetailsList_t & list = session->GetSaveGameManager().GetEnumeratedSavegamesNonConst();
 		for ( int i = 0; i < list.Num(); i++ ) {
 			if ( idStr::Icmp( list[i].slotName, parms.description.slotName ) == 0 ) {
 				list[i].damaged = true;
 			}
 		}
 		return true;
 	} else if ( parms.GetError() & SAVEGAME_E_INSUFFICIENT_ROOM ) {
 		HandleInsufficientStorage( parms );
 		return true;
 	} else if ( parms.GetError() & SAVEGAME_E_UNABLE_TO_SELECT_STORAGE_DEVICE && saveGame_enable.GetBool() ) {
 		common->Dialog().AddDialog( GDM_UNABLE_TO_USE_SELECTED_STORAGE_DEVICE, DIALOG_CONTINUE, NULL, NULL, false );
 		return true;
 	} else if ( parms.GetError() & SAVEGAME_E_INVALID_FILENAME ) {
 		idLib::Warning( va( "Invalid savegame filename [%s]!", parms.directory.c_str() ) );
 		return true;
 	} else if ( parms.GetError() & SAVEGAME_E_DLC_NOT_FOUND ) {
 		common->Dialog().AddDialog( GDM_DLC_ERROR_MISSING_GENERIC, DIALOG_CONTINUE, NULL, NULL, false );
 		return true;
 	} else if ( parms.GetError() & SAVEGAME_E_DISC_SWAP ) {
 		common->Dialog().AddDialog( GDM_DISC_SWAP, DIALOG_CONTINUE, NULL, NULL, false );
 		return true;
 	} else if ( parms.GetError() & SAVEGAME_E_INCOMPATIBLE_NEWER_VERSION ) {
 		common->Dialog().AddDialog( GDM_INCOMPATIBLE_NEWER_SAVE, DIALOG_CONTINUE, NULL, NULL, false );
 		return true;
 	}
 
 	return false;
 }
 
 /*
 ========================
 idCommonLocal::OnSaveCompleted
 ========================
 */
 void idCommonLocal::OnSaveCompleted( idSaveLoadParms & parms ) {
 	assert( pipelineFile != NULL );
 	delete pipelineFile;
 	pipelineFile = NULL;
 
 	if ( parms.GetError() == SAVEGAME_E_NONE ) {
 		game->Shell_UpdateSavedGames();
 	}
 
 	if ( !HandleCommonErrors( parms ) ) {
 		common->Dialog().AddDialog( GDM_ERROR_SAVING_SAVEGAME, DIALOG_CONTINUE, NULL, NULL, false );
 	}
 }
 
 /*
 ========================
 idCommonLocal::OnLoadCompleted
 ========================
 */
 void idCommonLocal::OnLoadCompleted( idSaveLoadParms & parms ) {
 	if ( !HandleCommonErrors( parms ) ) {
 		common->Dialog().AddDialog( GDM_ERROR_LOADING_SAVEGAME, DIALOG_CONTINUE, NULL, NULL, false );
 	}
 }
 
 /*
 ========================
 idCommonLocal::OnLoadFilesCompleted
 ========================
 */
 void idCommonLocal::OnLoadFilesCompleted( idSaveLoadParms & parms ) {
 	if ( ( mapSpawnData.savegameFile != NULL ) && ( parms.GetError() == SAVEGAME_E_NONE ) ) {
 		// just need to make the file readable
 		((idFile_Memory *)mapSpawnData.savegameFile)->MakeReadOnly();
 		((idFile_Memory *)mapSpawnData.stringTableFile)->MakeReadOnly();
 
 		idStr gamename;
 		idStr mapname;
 
 		mapSpawnData.savegameVersion = parms.description.GetSaveVersion();
 		mapSpawnData.savegameFile->ReadString( gamename );
 		mapSpawnData.savegameFile->ReadString( mapname );
 
 		if ( ( gamename != GAME_NAME ) || ( mapname.IsEmpty() ) || ( parms.description.GetSaveVersion() > BUILD_NUMBER ) ) {
 			// if this isn't a savegame for the correct game, abort loadgame
 			common->Warning( "Attempted to load an invalid savegame" );
 		} else {
 			common->DPrintf( "loading savegame\n" );
 
 			mapSpawnData.savegameFile->ReadBool( consoleUsed );
 			consoleUsed = consoleUsed || com_allowConsole.GetBool();
 
 			idMatchParameters matchParameters;
 			matchParameters.numSlots = 1;
 			matchParameters.gameMode = GAME_MODE_SINGLEPLAYER;
 			matchParameters.gameMap = GAME_MAP_SINGLEPLAYER;
 			matchParameters.mapName = mapname;
 			matchParameters.serverInfo.ReadFromFileHandle( mapSpawnData.savegameFile );
 
 			session->QuitMatchToTitle();
 			if ( WaitForSessionState( idSession::IDLE ) ) {
 				session->CreatePartyLobby( matchParameters );
 				if ( WaitForSessionState( idSession::PARTY_LOBBY ) ) {
 					session->CreateMatch( matchParameters );
 					if ( WaitForSessionState( idSession::GAME_LOBBY ) ) {
 						session->StartMatch();
 						return;
 					}
 				}
 			}
 		}
 	}
 	// If we got here then we didn't actually load the save game for some reason
 	mapSpawnData.savegameFile = NULL;
 }
 
 /*
 ========================
 idCommonLocal::TriggerScreenWipe
 ========================
 */
 void idCommonLocal::TriggerScreenWipe( const char * _wipeMaterial, bool hold ) {
 	StartWipe( _wipeMaterial, hold );
 	CompleteWipe();
 	wipeForced = true;
 	renderSystem->BeginAutomaticBackgroundSwaps( AUTORENDER_DEFAULTICON );
 }
 
 /*
 ========================
 idCommonLocal::OnEnumerationCompleted
 ========================
 */
 void idCommonLocal::OnEnumerationCompleted( idSaveLoadParms & parms ) {
 	if ( parms.GetError() == SAVEGAME_E_NONE ) {
 		game->Shell_UpdateSavedGames();
 	}
 }
 
 /*
 ========================
 idCommonLocal::OnDeleteCompleted
 ========================
 */
 void idCommonLocal::OnDeleteCompleted( idSaveLoadParms & parms ) {
 	if ( parms.GetError() == SAVEGAME_E_NONE ) {
 		game->Shell_UpdateSavedGames();
 	}
 }
 
 /*
 ===============
 LoadGame_f
 ===============
 */
 CONSOLE_COMMAND_SHIP( loadGame, "loads a game", idCmdSystem::ArgCompletion_SaveGame ) {
 	console->Close();
 	commonLocal.LoadGame( ( args.Argc() > 1 ) ? args.Argv(1) : "quick" );
 }
 
 /*
 ===============
 SaveGame_f
 ===============
 */
 CONSOLE_COMMAND_SHIP( saveGame, "saves a game", NULL ) {
 	const char * savename = ( args.Argc() > 1 ) ? args.Argv(1) : "quick";
 	if ( commonLocal.SaveGame( savename ) ) {
 		common->Printf( "Saved: %s\n", savename );
 	}
 }
 
 /*
 ==================
 Common_Map_f
 
 Restart the server on a different map
 ==================
 */
 CONSOLE_COMMAND_SHIP( map, "loads a map", idCmdSystem::ArgCompletion_MapName ) {
 	commonLocal.StartNewGame( args.Argv(1), false, GAME_MODE_SINGLEPLAYER );
 }
 
 /*
 ==================
 Common_RestartMap_f
 ==================
 */
 CONSOLE_COMMAND_SHIP( restartMap, "restarts the current map", NULL ) {
 	if ( g_demoMode.GetBool() ) {
 		cmdSystem->AppendCommandText( va( "devmap %s %d\n", commonLocal.GetCurrentMapName(), 0 ) );
 	}
 }
 
 /*
 ==================
 Common_DevMap_f
 
 Restart the server on a different map in developer mode
 ==================
 */
 CONSOLE_COMMAND_SHIP( devmap, "loads a map in developer mode", idCmdSystem::ArgCompletion_MapName ) {
 	commonLocal.StartNewGame( args.Argv(1), true, GAME_MODE_SINGLEPLAYER );
 }
 
 /*
 ==================
 Common_NetMap_f
 
 Restart the server on a different map in multiplayer mode
 ==================
 */
 CONSOLE_COMMAND_SHIP( netmap, "loads a map in multiplayer mode", idCmdSystem::ArgCompletion_MapName ) {
 	int gameMode = 0; // Default to deathmatch
 	if ( args.Argc() > 2 ) {
 		gameMode = atoi( args.Argv(2) );
 	}
 	commonLocal.StartNewGame( args.Argv(1), true, gameMode );
 }
 
 /*
 ==================
 Common_TestMap_f
 ==================
 */
 CONSOLE_COMMAND( testmap, "tests a map", idCmdSystem::ArgCompletion_MapName ) {
 	idStr map, string;
 
 	map = args.Argv(1);
 	if ( !map.Length() ) {
 		return;
 	}
 	map.StripFileExtension();
 
 	cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
 
 	sprintf( string, "dmap maps/%s.map", map.c_str() );
 	cmdSystem->BufferCommandText( CMD_EXEC_NOW, string );
 
 	sprintf( string, "devmap %s", map.c_str() );
 	cmdSystem->BufferCommandText( CMD_EXEC_NOW, string );
 }