DOOM-3-BFG

sys_session_local.cpp (130853B)

---

 /*
 ===========================================================================
 
 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.
 
 ===========================================================================
 */
 #pragma hdrstop
 #include "../idlib/precompiled.h"
 #include "sys_session_local.h"
 #include "sys_voicechat.h"
 #include "sys_dedicated_server_search.h"
 
 
 idCVar ui_skinIndex( "ui_skinIndex", "0", CVAR_ARCHIVE, "Selected skin index" );
 idCVar ui_autoSwitch( "ui_autoSwitch", "1", CVAR_ARCHIVE | CVAR_BOOL, "auto switch weapon" );
 idCVar ui_autoReload( "ui_autoReload", "1", CVAR_ARCHIVE | CVAR_BOOL, "auto reload weapon" );
 
 idCVar net_maxSearchResults( "net_maxSearchResults", "25", CVAR_INTEGER, "Max results that are allowed to be returned in a search request" );
 idCVar net_maxSearchResultsToTry( "net_maxSearchResultsToTry", "5", CVAR_INTEGER, "Max results to try before giving up." );		// At 15 second timeouts per, 1 min 15 worth of connecting attempt time
 
 idCVar net_LobbyCoalesceTimeInSeconds( "net_LobbyCoalesceTimeInSeconds", "30", CVAR_INTEGER, "Time in seconds when a lobby will try to coalesce with another lobby when there is only one user." );
 idCVar net_LobbyRandomCoalesceTimeInSeconds( "net_LobbyRandomCoalesceTimeInSeconds", "3", CVAR_INTEGER, "Random time to add to net_LobbyCoalesceTimeInSeconds" );
 
 idCVar net_useGameStateLobby( "net_useGameStateLobby", "0", CVAR_BOOL, "" );
 //idCVar net_useGameStateLobby( "net_useGameStateLobby", "1", CVAR_BOOL, "" );
 
 #if !defined( ID_RETAIL ) || defined( ID_RETAIL_INTERNAL )
 idCVar net_ignoreTitleStorage( "net_ignoreTitleStorage", "0", CVAR_BOOL, "Ignore title storage" );
 #endif
 
 idCVar net_maxLoadResourcesTimeInSeconds( "net_maxLoadResourcesTimeInSeconds", "0", CVAR_INTEGER, "How long, in seconds, clients have to load resources. Used for loose asset builds." );
 idCVar net_migrateHost( "net_migrateHost", "-1", CVAR_INTEGER, "Become host of session (0 = party, 1 = game) for testing purposes" );
 extern idCVar net_debugBaseStates;
 
 idCVar net_testPartyMemberConnectFail( "net_testPartyMemberConnectFail", "-1", CVAR_INTEGER, "Force this party member index to fail to connect to games." );
 
 //FIXME: this could use a better name.
 idCVar net_offlineTransitionThreshold( "net_offlineTransitionThreshold", "1000", CVAR_INTEGER, "Time, in milliseconds, to wait before kicking back to the main menu when a profile losses backend connection during an online game");
 
 idCVar net_port( "net_port", "27015", CVAR_INTEGER, "host port number" ); // Port to host when using dedicated servers, port to broadcast on when looking for a dedicated server to connect to
 idCVar net_headlessServer( "net_headlessServer", "0", CVAR_BOOL, "toggle to automatically host a game and allow peer[0] to control menus" );
 
 const char * idSessionLocal::stateToString[ NUM_STATES ] = {
 	ASSERT_ENUM_STRING( STATE_PRESS_START, 0 ),
 	ASSERT_ENUM_STRING( STATE_IDLE, 1 ),
 	ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_HOST, 2 ),
 	ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_PEER, 3 ),
 	ASSERT_ENUM_STRING( STATE_GAME_LOBBY_HOST, 4 ),
 	ASSERT_ENUM_STRING( STATE_GAME_LOBBY_PEER, 5 ),
 	ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_HOST, 6 ),
 	ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_PEER, 7 ),
 	ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY, 8 ),
 	ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_LOBBY, 9 ),
 	ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY, 10 ),
 	ASSERT_ENUM_STRING( STATE_FIND_OR_CREATE_MATCH, 11 ),
 	ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_PARTY, 12 ),
 	ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME, 13 ),
 	ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME_STATE, 14 ),
 	ASSERT_ENUM_STRING( STATE_BUSY, 15 ),
 	ASSERT_ENUM_STRING( STATE_LOADING, 16 ),
 	ASSERT_ENUM_STRING( STATE_INGAME, 17 ),
 };
 
 struct netVersion_s {
 	netVersion_s() { sprintf( string, "%s.%d", ENGINE_VERSION, BUILD_NUMBER ); }
 	char	string[256];
 } netVersion;
 
 /*
 ========================
 NetGetVersionChecksum
 ========================
 */
 unsigned long NetGetVersionChecksum() {
 #if 0
 	return idStr( com_version.GetString() ).Hash();
 #else
 	unsigned long ret = 0;
 
 	CRC32_InitChecksum( ret );
 	CRC32_UpdateChecksum( ret, netVersion.string, idStr::Length( netVersion.string ) );
 	CRC32_FinishChecksum( ret );
 
 	NET_VERBOSE_PRINT( "NetGetVersionChecksum - string   : %s\n", netVersion.string );
 	NET_VERBOSE_PRINT( "NetGetVersionChecksum - checksum : %i\n", ret );
 	return ret; 
 #endif
 }
 
 /*
 ========================
 idSessionLocal::idSessionLocal
 ========================
 */
 idSessionLocal::idSessionLocal() :
 	processorSaveFiles( new (TAG_SAVEGAMES) idSaveGameProcessorSaveFiles ),
 	processorLoadFiles( new (TAG_SAVEGAMES) idSaveGameProcessorLoadFiles ),
 	processorDelete(	new (TAG_SAVEGAMES) idSaveGameProcessorDelete ),
 	processorEnumerate( new (TAG_SAVEGAMES) idSaveGameProcessorEnumerateGames ) {
 	InitBaseState();
 }
 
 /*
 ========================
 idSessionLocal::idSessionLocal
 ========================
 */
 idSessionLocal::~idSessionLocal() {
 	delete processorSaveFiles;
 	delete processorLoadFiles;
 	delete processorDelete;
 	delete processorEnumerate;
 	delete sessionCallbacks;
 }
 
 
 /*
 ========================
 idSessionLocal::InitBaseState
 ========================
 */
 void idSessionLocal::InitBaseState() {
 	
 	//assert( mem.IsGlobalHeap() );
 
 	localState						= STATE_PRESS_START;
 	sessionOptions					= 0;
 	currentID						= 0;
 
 	sessionCallbacks				= new (TAG_NETWORKING) idSessionLocalCallbacks( this );
 
 	connectType						= CONNECT_NONE;
 	connectTime						= 0;
 	
 	upstreamDropRate				= 0.0f;
 	upstreamDropRateTime			= 0;
 	upstreamQueueRate				= 0.0f;
 	upstreamQueueRateTime			= 0;
 	queuedBytes						= 0;
 
 	lastVoiceSendtime				= 0;
 	hasShownVoiceRestrictionDialog	= false;
 
 	isSysUIShowing					= false;
 
 	pendingInviteDevice				= 0;
 	pendingInviteMode				= PENDING_INVITE_NONE;
 
 	downloadedContent.Clear();
 	marketplaceHasNewContent		= false;
 
 	offlineTransitionTimerStart		= 0;
 	showMigratingInfoStartTime		= 0;
 	nextGameCoalesceTime			= 0;
 	gameLobbyWasCoalesced			= false;
 	numFullSnapsReceived			= 0;
 
 	flushedStats					= false;
 
 	titleStorageLoaded				= false;
 
 	droppedByHost					= false;
 	loadingID						= 0;
 
 	storedPeer						= -1;
 	storedMsgType					= -1;
 
 	inviteInfoRequested				= false;
 
 	enumerationHandle				= 0;
 
 	waitingOnGameStateMembersToLeaveTime	= 0;
 	waitingOnGameStateMembersToJoinTime		= 0;
 }
 
 /*
 ========================
 idSessionLocal::FinishDisconnect
 ========================
 */
 void idSessionLocal::FinishDisconnect() { 
 	GetPort().Close(); 
 	while ( sendQueue.Peek() != NULL ) {
 		sendQueue.RemoveFirst();
 	}
 	while ( recvQueue.Peek() != NULL ) {
 		recvQueue.RemoveFirst();
 	}
 }
 
 //====================================================================================
 
 idCVar net_connectTimeoutInSeconds( "net_connectTimeoutInSeconds", "15", CVAR_INTEGER, "timeout (in seconds) while connecting" );
 
 /*
 ========================
 idSessionLocal::CreatePartyLobby
 ========================
 */
 void idSessionLocal::CreatePartyLobby( const idMatchParameters & parms_ ) { 
 	NET_VERBOSE_PRINT( "NET: CreatePartyLobby\n" );
 
 	// Shutdown any possible party lobby
 	GetPartyLobby().Shutdown();
 	GetPartyLobby().ResetAllMigrationState();
 
 	// Shutdown any possible game lobby
 	GetGameLobby().Shutdown();
 	GetGameStateLobby().Shutdown();
 
 	// Start hosting a new party lobby
 	GetPartyLobby().StartHosting( parms_ );
 
 	connectType = CONNECT_NONE;
 	connectTime = Sys_Milliseconds();
 
 	// Wait for it to complete
 	SetState( STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY );
 }
 
 /*
 ========================
 idSessionLocal::CreateMatch
 ========================
 */
 void idSessionLocal::CreateMatch( const idMatchParameters & p ) {
 	NET_VERBOSE_PRINT( "NET: CreateMatch\n" );
 
 	if ( ( p.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) && !GetPartyLobby().IsLobbyActive() ) {
 		NET_VERBOSE_PRINT( "NET: CreateMatch MATCH_PARTY_INVITE_PLACEHOLDER\n" );
 		CreatePartyLobby( p );
 		connectType = CONNECT_NONE;
 		return;
 	}
 
 	// Shutdown any possible game lobby
 	GetGameLobby().Shutdown();
 	GetGameStateLobby().Shutdown();
 	GetGameLobby().ResetAllMigrationState();
 
 	// Start hosting a new game lobby
 	GetGameLobby().StartHosting( p );
 
 	connectType = CONNECT_NONE;
 	connectTime = Sys_Milliseconds();
 
 	// Wait for it to complete
 	SetState( STATE_CREATE_AND_MOVE_TO_GAME_LOBBY );
 }
 
 /*
 ========================
 idSessionLocal::CreateGameStateLobby
 ========================
 */
 void idSessionLocal::CreateGameStateLobby( const idMatchParameters & p ) {
 	NET_VERBOSE_PRINT( "NET: CreateGameStateLobby\n" );
 
 	// Shutdown any possible game state lobby
 	GetGameStateLobby().Shutdown();
 	GetGameStateLobby().ResetAllMigrationState();
 
 	// Start hosting a new game lobby
 	GetGameStateLobby().StartHosting( p );
 
 	connectType = CONNECT_NONE;
 	connectTime = Sys_Milliseconds();
 
 	waitingOnGameStateMembersToLeaveTime	= 0;		// Make sure to reset
 	waitingOnGameStateMembersToJoinTime		= 0;
 
 	// Wait for it to complete
 	SetState( STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY );
 }
 
 /*
 ========================
 idSessionLocal::FindOrCreateMatch
 ========================
 */
 void idSessionLocal::FindOrCreateMatch( const idMatchParameters & p ) { 
 	NET_VERBOSE_PRINT( "NET: FindOrCreateMatch\n" );
 
 	if ( ( p.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) && !GetPartyLobby().IsLobbyActive() ) {
 		NET_VERBOSE_PRINT( "NET: FindOrCreateMatch MATCH_PARTY_INVITE_PLACEHOLDER\n" );
 		CreatePartyLobby( p );
 		connectType = CONNECT_FIND_OR_CREATE;
 		return;
 	}
 
 	// Shutdown any possible game lobby
 	GetGameLobby().Shutdown();
 	GetGameStateLobby().Shutdown();
 	GetGameLobby().ResetAllMigrationState();
 
 	// Start searching for a game
 	GetGameLobby().StartFinding( p );
 
 	connectType				= CONNECT_FIND_OR_CREATE;
 	connectTime				= Sys_Milliseconds();
 	gameLobbyWasCoalesced	= false;
 	numFullSnapsReceived	= 0;
 
 	// Wait for searching to complete
 	SetState( STATE_FIND_OR_CREATE_MATCH );
 }
 
 /*
 ========================
 idSessionLocal::StartLoading
 ========================
 */
 void idSessionLocal::StartLoading() {
 	NET_VERBOSE_PRINT( "NET: StartLoading\n" );
 
 	if ( MatchTypeIsOnline( GetActingGameStateLobby().parms.matchFlags ) ) {
 		if ( !GetActingGameStateLobby().IsHost() ) {
 			idLib::Warning( "Ignoring call to StartLoading because we are not the host.  state is %s", stateToString[ localState ] );
 			return;
 		}
 
 		for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 			if ( GetActingGameStateLobby().peers[p].IsConnected() ) {
 				GetActingGameStateLobby().QueueReliableMessage( p, idLobby::RELIABLE_START_LOADING );
 				GetActingGameStateLobby().peers[p].startResourceLoadTime = Sys_Milliseconds();
 			}
 		}
 	}
 
 	VerifySnapshotInitialState();
 
 	SetState( STATE_LOADING );
 }
 
 /*
 ========================
 idSessionLocal::StartMatch
 ========================
 */
 void idSessionLocal::StartMatch() {
 	NET_VERBOSE_PRINT( "NET: StartMatch\n" );
 
 	if ( net_headlessServer.GetBool() ) {
 		StartLoading();		// This is so we can force start matches on headless servers to test performance using bots
 		return;
 	}
 
 	if ( localState != STATE_GAME_LOBBY_HOST ) {
 		idLib::Warning( "idSessionLocal::StartMatch called when not hosting game lobby" );
 		return;
 	}
 
 	assert( !GetGameStateLobby().IsLobbyActive() );
 
 	// make absolutely sure we only call StartMatch once per migrate
 	GetGameLobby().migrationInfo.persistUntilGameEndsData.hasRelaunchedMigratedGame = true;
 	
 	// Clear snap ack queue between games
 	GetGameLobby().snapDeltaAckQueue.Clear();
 
 	extern idCVar net_bw_challenge_enable;
 	if ( session->GetTitleStorageBool( "net_bw_challenge_enable", net_bw_challenge_enable.GetBool() ) && GetGameLobby().HasActivePeers() ) {
 	    GetGameLobby().bandwidthChallengeFinished = false;
 		StartOrContinueBandwidthChallenge( false );
 	}
 
 	if ( GetGameLobby().BandwidthTestStarted() ) {
 		// Put session in busy state 
 		NET_VERBOSE_PRINT( "NET: StartMatch -> Start Bandwidth Challenge\n" );
 		SetState( STATE_BUSY );
 	} else {
 		// Start loading
 		StartLoading();
 	}
 }
 
 /*
 ========================
 idSessionLocal::GetBackState
 ========================
 */
 idSessionLocal::sessionState_t idSessionLocal::GetBackState() {
 	sessionState_t currentState = GetState();
 
 	const bool isInGameLobby		= currentState == GAME_LOBBY;
 	const bool isInPartyLobby		= currentState == PARTY_LOBBY;
 	const bool isInGame				= currentState == INGAME || currentState == LOADING;		// Counting loading as ingame as far as what back state to go to
 	
 	if ( isInGame ) {
 		return GAME_LOBBY;		// If in the game, go back to game lobby
 	}
 
 	if ( !isInPartyLobby && isInGameLobby && ShouldHavePartyLobby() ) {
 		return PARTY_LOBBY;		// If in the game lobby, and we should have a party lobby, and we are the host, go back to party lobby
 	}
 
 	if ( currentState != IDLE ) {
 		return IDLE;			// From here, go to idle if we aren't there yet
 	}
 
 	return PRESS_START;			// Otherwise, go back to press start
 }
 
 /*
 ========================
 idSessionLocal::Cancel
 ========================
 */
 void idSessionLocal::Cancel() {
 	NET_VERBOSE_PRINT( "NET: Cancel\n" );
 
 	if ( localState == STATE_PRESS_START ) {
 		return;		// We're as far back as we can go
 	}
 
 	ClearVoiceGroups(); // this is here as a catch-all
 
 	// See what state we need to go to
 	switch ( GetBackState() ) {
 		case GAME_LOBBY:
 			EndMatch();		// End current match to go to game lobby
 			break;
 
 		case PARTY_LOBBY:
 			if ( GetPartyLobby().IsHost() ) {
 				if ( sessionOptions & OPTION_LEAVE_WITH_PARTY ) {
 					// NOTE - This will send a message on the team lobby channel, 
 					// so it won't be affected by the fact that we're shutting down the game lobby
 					GetPartyLobby().NotifyPartyOfLeavingGameLobby();
 				} else {
 					// Host wants to be alone, disconnect all peers from the party
 					GetPartyLobby().DisconnectAllPeers();		
 				}
 
 				// End the game lobby, and go back to party lobby as host
 				GetGameLobby().Shutdown();
 				GetGameStateLobby().Shutdown();
 				SetState( STATE_PARTY_LOBBY_HOST );
 
 				// Always remove this flag.  SendGoodbye uses this to determine if we should send a "leave with party"
 				// and we don't want this flag hanging around, and causing false positives when it's called in the future.
 				// Make them set this each time.
 				sessionOptions &= ~OPTION_LEAVE_WITH_PARTY;
 			} else {
 				// If we aren't the host of a party and we want to go back to one, we need to create a party now
 				CreatePartyLobby( GetPartyLobby().parms );
 			}
 			break;
 
 		case IDLE:
 			// Go back to main menu
 			GetGameLobby().Shutdown();
 			GetGameStateLobby().Shutdown();
 			GetPartyLobby().Shutdown();
 			SetState( STATE_IDLE );
 			break;
 
 		case PRESS_START:
 			// Go back to press start/main
 			GetGameLobby().Shutdown();
 			GetGameStateLobby().Shutdown();
 			GetPartyLobby().Shutdown();
 			SetState( STATE_PRESS_START );
 			break;
 	}
 
 	// Validate the current lobby immediately
 	ValidateLobbies();
 }
 
 /*
 ========================
 idSessionLocal::MoveToPressStart
 ========================
 */
 void idSessionLocal::MoveToPressStart() {	
 	if ( localState != STATE_PRESS_START ) {
 		assert( signInManager != NULL );
 		signInManager->RemoveAllLocalUsers();
 		hasShownVoiceRestrictionDialog = false;
 		MoveToMainMenu();
 		session->FinishDisconnect();
 		SetState( STATE_PRESS_START );
 	}
 }
 
 /*
 ========================
 idSessionLocal::ShouldShowMigratingDialog
 ========================
 */
 bool idSessionLocal::ShouldShowMigratingDialog() const {
 	const idLobby * activeLobby = GetActivePlatformLobby();
 
 	if ( activeLobby == NULL ) {
 		return false;
 	}
 	
 	return activeLobby->ShouldShowMigratingDialog();
 }
 
 /*
 ========================
 idSessionLocal::IsCurrentLobbyMigrating
 ========================
 */
 bool idSessionLocal::IsCurrentLobbyMigrating() const {
 	const idLobby * activeLobby = GetActivePlatformLobby();
 
 	if ( activeLobby == NULL ) {
 		return false;
 	}
 
 	return activeLobby->IsMigrating();
 }
 
 /*
 ========================
 idSessionLocal::IsLosingConnectionToHost
 ========================
 */
 bool idSessionLocal::IsLosingConnectionToHost() const {
 	return GetActingGameStateLobby().IsLosingConnectionToHost();
 }
 
 /*
 ========================
 idSessionLocal::WasMigrationGame
 returns true if we are hosting a migrated game and we had valid migration data
 ========================
 */
 bool idSessionLocal::WasMigrationGame() const {
 	return GetGameLobby().IsMigratedStatsGame();
 }
 
 /*
 ========================
 idSessionLocal::ShouldRelaunchMigrationGame
 returns true if we are hosting a migrated game and we had valid migration data
 ========================
 */
 bool idSessionLocal::ShouldRelaunchMigrationGame() const { 
 	return GetGameLobby().ShouldRelaunchMigrationGame() && !IsCurrentLobbyMigrating();
 }
 
 /*
 ========================
 idSessionLocal::GetMigrationGameData
 ========================
 */
 bool idSessionLocal::GetMigrationGameData( idBitMsg & msg, bool reading ) {
 	return GetGameLobby().GetMigrationGameData( msg, reading );
 }
 
 /*
 ========================
 idSessionLocal::GetMigrationGameDataUser
 ========================
 */
 bool idSessionLocal::GetMigrationGameDataUser( lobbyUserID_t lobbyUserID, idBitMsg & msg, bool reading ) {
 	if ( GetGameStateLobby().IsHost() ) {
 		return false;
 	}
 
 	return GetGameLobby().GetMigrationGameDataUser( lobbyUserID, msg, reading );
 }
 
 
 /*
 ========================
 idSessionLocal::GetMatchParamUpdate
 ========================
 */
 bool idSessionLocal::GetMatchParamUpdate( int &peer, int &msg ){
 	if ( storedPeer != -1 && storedMsgType != -1 ) {
 		peer = storedPeer;
 		msg = storedMsgType;
 		storedPeer = -1;
 		storedMsgType = -1;
 		return true;
 	}
 	return false;
 }
 
 
 
 /*
 ========================
 idSessionLocal::UpdatePartyParms
 
 Updates the party parameters when in a party lobby OR a game lobby in order to keep them always in sync.
 ========================
 */
 void idSessionLocal::UpdatePartyParms( const idMatchParameters & p ) {
 	if ( ( GetState() != PARTY_LOBBY && GetState() != GAME_LOBBY ) || !GetPartyLobby().IsHost() ) {
 		return;
 	}
 
 	// NET_VERBOSE_PRINT( "NET: UpdatePartyParms\n" );
 
 	GetPartyLobby().UpdateMatchParms( p );
 }
 
 /*
 ========================
 idSessionLocal::UpdateMatchParms
 ========================
 */
 void idSessionLocal::UpdateMatchParms( const idMatchParameters & p ) {
 	if ( GetState() != GAME_LOBBY || !GetGameLobby().IsHost() ) {
 		return;
 	}
 
 	NET_VERBOSE_PRINT( "NET: UpdateMatchParms\n" );
 
 	GetGameLobby().UpdateMatchParms( p );
 }
 
 /*
 ========================
 idSessionLocal::StartSessions
 ========================
 */
 void idSessionLocal::StartSessions() {
 	if ( GetPartyLobby().lobbyBackend != NULL ) {
 		GetPartyLobby().lobbyBackend->StartSession();
 	}
 
 	if ( GetGameLobby().lobbyBackend != NULL ) {
 		GetGameLobby().lobbyBackend->StartSession();
 	}
 	
 	SetLobbiesAreJoinable( false );
 }
 
 /*
 ========================
 idSessionLocal::EndSessions
 ========================
 */
 void idSessionLocal::EndSessions() {
 	if ( GetPartyLobby().lobbyBackend != NULL ) {
 		GetPartyLobby().lobbyBackend->EndSession();
 	}
 
 	if ( GetGameLobby().lobbyBackend != NULL ) {
 		GetGameLobby().lobbyBackend->EndSession();
 	}
 
 	SetLobbiesAreJoinable( true );
 }
 
 /*
 ========================
 idSessionLocal::SetLobbiesAreJoinable
 ========================
 */
 void idSessionLocal::SetLobbiesAreJoinable( bool joinable ) {
 	// NOTE - We don't manipulate the joinable state when we are supporting join in progress
 	// Lobbies will naturally be non searchable when there are no free slots
 	if ( GetPartyLobby().lobbyBackend != NULL && !MatchTypeIsJoinInProgress( GetPartyLobby().parms.matchFlags ) ) {
 		NET_VERBOSE_PRINT( "Party lobbyBackend SetIsJoinable: %d\n", joinable );
 		GetPartyLobby().lobbyBackend->SetIsJoinable( joinable );
 	}
 	
 	if ( GetGameLobby().lobbyBackend != NULL && !MatchTypeIsJoinInProgress( GetGameLobby().parms.matchFlags ) ) {
 		GetGameLobby().lobbyBackend->SetIsJoinable( joinable );
 		NET_VERBOSE_PRINT( "Game lobbyBackend SetIsJoinable: %d\n", joinable );
 
 	}
 }
 
 /*
 ========================
 idSessionLocal::MoveToMainMenu
 ========================
 */
 void idSessionLocal::MoveToMainMenu() {
 	GetPartyLobby().Shutdown();
 	GetGameLobby().Shutdown();
 	GetGameStateLobby().Shutdown();
 	SetState( STATE_IDLE );
 }
 
 /*
 ========================
 idSessionLocal::HandleVoiceRestrictionDialog
 ========================
 */
 void idSessionLocal::HandleVoiceRestrictionDialog() {
 	// don't bother complaining about voice restrictions when in a splitscreen lobby
 	if ( MatchTypeIsLocal( GetActivePlatformLobby()->parms.matchFlags ) ) {
 		return;
 	}
 
 	// Pop a dialog up the first time we are in a lobby and have voice chat restrictions due to account privileges
 	if ( voiceChat != NULL && voiceChat->IsRestrictedByPrivleges() && !hasShownVoiceRestrictionDialog ) {
 		common->Dialog().AddDialog( GDM_VOICE_RESTRICTED, DIALOG_ACCEPT, NULL, NULL, false );
 		hasShownVoiceRestrictionDialog = true;
 	}
 }
 
 /*
 ========================
 idSessionLocal::WaitOnLobbyCreate
 
 Called from State_Create_And_Move_To_Party_Lobby and State_Create_And_Move_To_Game_Lobby and State_Create_And_Move_To_Game_State_Lobby.
 This function will create the lobby, then wait for it to either succeed or fail.
 ========================
 */
 bool idSessionLocal::WaitOnLobbyCreate( idLobby & lobby ) {
 
 	assert( localState == STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY || localState == STATE_CREATE_AND_MOVE_TO_GAME_LOBBY || localState == STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY );
 	assert( connectType == CONNECT_FIND_OR_CREATE || connectType == CONNECT_NONE );
 
 	if ( lobby.GetState() == idLobby::STATE_FAILED ) {
 		NET_VERBOSE_PRINT( "NET: idSessionLocal::WaitOnLobbyCreate lobby.GetState() == idLobby::STATE_FAILED (%s)\n", lobby.GetLobbyName() );
 		// If we failed to create a lobby, assume connection to backend service was lost
 		MoveToMainMenu();
 		common->Dialog().ClearDialogs( true );
 		common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, true, "", 0, true );
 		return false;
 	}
 	
 	if ( DetectDisconnectFromService( true ) ) {
 		return false;
 	}
 
 	if ( lobby.GetState() != idLobby::STATE_IDLE ) {
 		return false;		// Valid but busy
 	}
 
 	NET_VERBOSE_PRINT( "NET: idSessionLocal::WaitOnLobbyCreate SUCCESS (%s)\n", lobby.GetLobbyName() );
 
 	return true;
 }
 
 /*
 ========================
 idSessionLocal::DetectDisconnectFromService
 Called from CreateMatch/CreatePartyLobby/FindOrCreateMatch state machines
 ========================
 */
 bool idSessionLocal::DetectDisconnectFromService( bool cancelAndShowMsg ) {
 	const int DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS = session->GetTitleStorageInt( "DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS", 30 );
 
 	// If we are taking too long, cancel the connection
 	if ( DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS > 0 ) {
 		if ( Sys_Milliseconds() - connectTime > 1000 * DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS ) {
 			NET_VERBOSE_PRINT( "NET: idSessionLocal::DetectDisconnectFromService timed out\n" );
 			if ( cancelAndShowMsg ) {
 				MoveToMainMenu();
 				common->Dialog().ClearDialogs( true );
 				common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true );
 			}
 
 			return true;
 		}
 	}
 
 	return false;
 }
 
 /*
 ========================
 idSessionLocal::HandleConnectionFailed
 Called anytime a connection fails, and does the right thing.
 ========================
 */
 void idSessionLocal::HandleConnectionFailed( idLobby & lobby, bool wasFull ) {
 	assert( localState == STATE_CONNECT_AND_MOVE_TO_PARTY || localState == STATE_CONNECT_AND_MOVE_TO_GAME || localState == STATE_CONNECT_AND_MOVE_TO_GAME_STATE );
 	assert( connectType == CONNECT_FIND_OR_CREATE || connectType == CONNECT_DIRECT );
 	bool canPlayOnline = true;
 	
 	// Check for online status (this is only a problem on the PS3 at the moment. The 360 LIVE system handles this for us
 	if ( GetSignInManager().GetMasterLocalUser() != NULL ) {
 		canPlayOnline = GetSignInManager().GetMasterLocalUser()->CanPlayOnline();
 	}
 	
 	if ( connectType == CONNECT_FIND_OR_CREATE ) {
 		// Clear the "Lobby was Full" dialog in case it's up
 		// We only want to see this msg when doing a direct connect (CONNECT_DIRECT)
 		common->Dialog().ClearDialog( GDM_LOBBY_FULL );
 
 		assert( localState == STATE_CONNECT_AND_MOVE_TO_GAME || localState == STATE_CONNECT_AND_MOVE_TO_GAME_STATE );
 		assert( lobby.lobbyType == idLobby::TYPE_GAME );
 		if ( !lobby.ConnectToNextSearchResult() ) {
 			CreateMatch( GetGameLobby().parms );		// Assume any time we are connecting to a game lobby, it is from a FindOrCreateMatch call, so create a match
 		}
 	} else if ( connectType == CONNECT_DIRECT ) {
 		if ( localState == STATE_CONNECT_AND_MOVE_TO_GAME && GetPartyLobby().IsPeer() ) {
 			int flags = GetPartyLobby().parms.matchFlags;
 
 			if ( MatchTypeIsOnline( flags ) && ( flags & MATCH_REQUIRE_PARTY_LOBBY ) && ( ( flags & MATCH_PARTY_INVITE_PLACEHOLDER ) == 0 ) ) {
 				// We get here when our party host told us to connect to a game, but the game didn't exist.  
 				// Just drop back to the party lobby and wait for further orders.
 				SetState( STATE_PARTY_LOBBY_PEER );
 				return;
 			}
 		}
 
 		if ( wasFull ) {
 			common->Dialog().AddDialog( GDM_LOBBY_FULL, DIALOG_ACCEPT, NULL, NULL, false );
 		} else if ( !canPlayOnline ) {
 			common->Dialog().AddDialog( GDM_PLAY_ONLINE_NO_PROFILE, DIALOG_ACCEPT, NULL, NULL, false );
 		} else {
 			// TEMP HACK: We detect the steam lobby is full in idLobbyBackendWin, and then STATE_FAILED, which brings us here. Need to find a way to notify
 			// session local that the game was full so we don't do this check here
 			// eeubanks: Pollard, how do you think we should handle this?
 			if ( !common->Dialog().HasDialogMsg( GDM_LOBBY_FULL, NULL ) ) {
 				common->Dialog().AddDialog( GDM_INVALID_INVITE, DIALOG_ACCEPT, NULL, NULL, false );
 			}
 		}
 		MoveToMainMenu();
 	} else {
 		// Shouldn't be possible, but just in case
 		MoveToMainMenu();
 	}
 }
 
 /*
 ========================
 idSessionLocal::HandleConnectAndMoveToLobby
 Called from State_Connect_And_Move_To_Party/State_Connect_And_Move_To_Game
 ========================
 */
 bool idSessionLocal::HandleConnectAndMoveToLobby( idLobby & lobby ) {	
 	assert( localState == STATE_CONNECT_AND_MOVE_TO_PARTY || localState == STATE_CONNECT_AND_MOVE_TO_GAME || localState == STATE_CONNECT_AND_MOVE_TO_GAME_STATE );
 	assert( connectType == CONNECT_FIND_OR_CREATE || connectType == CONNECT_DIRECT );
 
 	if ( lobby.GetState() == idLobby::STATE_FAILED ) {
 		// If we get here, we were trying to connect to a lobby (from state State_Connect_And_Move_To_Party/State_Connect_And_Move_To_Game)
 		HandleConnectionFailed( lobby, false );
 		return true;
 	}
 
 	if ( lobby.GetState() != idLobby::STATE_IDLE ) {
 		return HandlePackets();	// Valid but busy
 	}
 
 	assert( !GetPartyLobby().waitForPartyOk );
 
 	//
 	// Past this point, we've connected to the lobby
 	//
 
 	// If we are connecting to a game lobby, see if we need to keep waiting as either a host or peer while we're confirming all party members made it
 	if ( lobby.lobbyType == idLobby::TYPE_GAME ) {
 		if ( GetPartyLobby().IsHost() ) {
 			// As a host, wait until all party members make it
 			assert( !GetGameLobby().waitForPartyOk );
 
 			const int timeoutMs = session->GetTitleStorageInt( "net_connectTimeoutInSeconds", net_connectTimeoutInSeconds.GetInteger() ) * 1000;
 
 			if ( timeoutMs != 0 && Sys_Milliseconds() - lobby.helloStartTime > timeoutMs ) {
 				// Took too long, move to next result, or create a game instead
 				HandleConnectionFailed( lobby, false );
 				return true;
 			}
 
 			int numUsersIn = 0;
 
 			for ( int i = 0; i < GetPartyLobby().GetNumLobbyUsers(); i++ ) {
 
 				if ( net_testPartyMemberConnectFail.GetInteger() == i ) {
 					continue;
 				}
 
 				bool foundUser = false;
 
 				lobbyUser_t * partyUser = GetPartyLobby().GetLobbyUser( i );
 
 				for ( int j = 0; j < GetGameLobby().GetNumLobbyUsers(); j++ ) {
 					lobbyUser_t * gameUser = GetGameLobby().GetLobbyUser( j );
 
 					if ( GetGameLobby().IsSessionUserLocal( gameUser ) || gameUser->address.Compare( partyUser->address, true ) ) {
 						numUsersIn++;
 						foundUser = true;
 						break;
 					}
 				}
 	
 				assert( !GetPartyLobby().IsSessionUserIndexLocal( i ) || foundUser );
 			}
 
 			if ( numUsersIn != GetPartyLobby().GetNumLobbyUsers() ) {
 				return HandlePackets();		// All users not in, keep waiting until all user make it, or we time out
 			} 
 		
 			NET_VERBOSE_PRINT( "NET: All party members made it into the game lobby.\n" );
 			
 			// Let all the party members know everyone made it, and it's ok to stay at this server
 			for ( int i = 0; i < GetPartyLobby().peers.Num(); i++ ) {
 				if ( GetPartyLobby().peers[ i ].IsConnected() ) {
 					GetPartyLobby().QueueReliableMessage( i, idLobby::RELIABLE_PARTY_CONNECT_OK );
 				}
 			}
 		} else {
 			if ( !verify ( lobby.host != -1 ) ) {
 				MoveToMainMenu();
 				connectType = CONNECT_NONE;
 				return false;
 			}
 
 			// As a peer, wait for server to tell us everyone made it
 			if ( GetGameLobby().waitForPartyOk ) {
 				const int timeoutMs = session->GetTitleStorageInt( "net_connectTimeoutInSeconds", net_connectTimeoutInSeconds.GetInteger() ) * 1000;
 
 				if ( timeoutMs != 0 && Sys_Milliseconds() - lobby.helloStartTime > timeoutMs ) {
 					GetGameLobby().waitForPartyOk = false;		// Just connect to this game lobby if we haven't heard from the party host for the entire timeout duration
 				}
 			}
 
 			if ( GetGameLobby().waitForPartyOk ) {
 				return HandlePackets();			// Waiting on party host to tell us everyone made it
 			}
 		}
 	}
 
 	// Success
 	switch ( lobby.lobbyType ) {
 		case idLobby::TYPE_PARTY:		
 			SetState( STATE_PARTY_LOBBY_PEER );
 			break;
 		case idLobby::TYPE_GAME:		
 			SetState( STATE_GAME_LOBBY_PEER );
 			break;
 		case idLobby::TYPE_GAME_STATE:	
 			waitingOnGameStateMembersToJoinTime = Sys_Milliseconds();
 			// As a host of the game lobby, it's our duty to notify our members to also join this game state lobby
 			GetGameLobby().SendMembersToLobby( GetGameStateLobby(), false );
 			SetState( STATE_GAME_STATE_LOBBY_PEER );
 			break;
 	}
 
 	connectType = CONNECT_NONE;
 
 	return false;
 }
 
 /*
 ========================
 idSessionLocal::State_Create_And_Move_To_Party_Lobby
 ========================
 */
 bool idSessionLocal::State_Create_And_Move_To_Party_Lobby() {
 	if ( WaitOnLobbyCreate( GetPartyLobby() ) ) {
 
 		if ( GetPartyLobby().parms.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) {
 			// If this party lobby was for a placeholder, continue on with either finding or creating a game lobby
 			if ( connectType == CONNECT_FIND_OR_CREATE ) {
 				FindOrCreateMatch( GetPartyLobby().parms );
 				return true;
 			} else if ( connectType == CONNECT_NONE ) {
 				CreateMatch( GetPartyLobby().parms );
 				return true;
 			}
 		}
 
 		// Success
 		SetState( STATE_PARTY_LOBBY_HOST );
 
 		return true;
 	}
 
 	return HandlePackets();		// Valid but busy
 }
 
 /*
 ========================
 idSessionLocal::State_Create_And_Move_To_Game_Lobby
 ========================
 */
 bool idSessionLocal::State_Create_And_Move_To_Game_Lobby() {
 
 	if ( WaitOnLobbyCreate( GetGameLobby() ) ) {
 		// Success
 		SetState( STATE_GAME_LOBBY_HOST );
 
 		// Now that we've created our game lobby, send our own party users to it
 		// NOTE - We pass in false to wait on party members since we are the host, and we know they can connect to us
 		GetPartyLobby().SendMembersToLobby( GetGameLobby(), false );
 		return true;		
 	}
 
 	return false;
 }
 
 /*
 ========================
 idSessionLocal::State_Create_And_Move_To_Game_State_Lobby
 ========================
 */
 bool idSessionLocal::State_Create_And_Move_To_Game_State_Lobby() {
 
 	if ( WaitOnLobbyCreate( GetGameStateLobby() ) ) {
 		// Success
 		SetState( STATE_GAME_STATE_LOBBY_HOST );
 
 		// Now that we've created our game state lobby, send our own game users to it
 		// NOTE - We pass in false to wait on party members since we are the host, and we know they can connect to us
 		GetGameLobby().SendMembersToLobby( GetGameStateLobby(), false );
 
 		// If we are the host of a game lobby, we know we are not using dedicated servers, so we want to start the match immediately
 		// as soon as we detect all users have connected.
 		if ( GetGameLobby().IsHost() ) {
 			waitingOnGameStateMembersToJoinTime = Sys_Milliseconds();
 		}
 
 		return true;		
 	}
 
 	return false;
 }
 
 /*
 ========================
 idSessionLocal::State_Find_Or_Create_Match
 ========================
 */
 bool idSessionLocal::State_Find_Or_Create_Match() {
 	assert( connectType == CONNECT_FIND_OR_CREATE );
 
 	if ( GetGameLobby().GetState() == idLobby::STATE_FAILED ) {
 		// Failed to find any games.  Create one instead (we're assuming this always gets called from FindOrCreateMatch
 		CreateMatch( GetGameLobby().parms );
 		return true;
 	}
 
 	if ( DetectDisconnectFromService( true ) ) {
 		return false;
 	}
 
 	if ( GetGameLobby().GetState() != idLobby::STATE_IDLE ) {
 		return HandlePackets();		// Valid but busy
 	}
 
 	// Done searching, connect to the first search result
 	if ( !GetGameLobby().ConnectToNextSearchResult() ) {
 		// Failed to find any games.  Create one instead (we're assuming this always gets called from FindOrCreateMatch
 		CreateMatch( GetGameLobby().parms );
 		return true;
 	}
 
 	SetState( STATE_CONNECT_AND_MOVE_TO_GAME );
 
 	return true;
 }
 
 /*
 ========================
 idSessionLocal::State_Connect_And_Move_To_Party
 ========================
 */
 bool idSessionLocal::State_Connect_And_Move_To_Party() {
 	return HandleConnectAndMoveToLobby( GetPartyLobby() );	
 }
 
 /*
 ========================
 idSessionLocal::State_Connect_And_Move_To_Game
 ========================
 */
 bool idSessionLocal::State_Connect_And_Move_To_Game() {
 	return HandleConnectAndMoveToLobby( GetGameLobby() );	
 }
 
 /*
 ========================
 idSessionLocal::State_Connect_And_Move_To_Game_State
 ========================
 */
 bool idSessionLocal::State_Connect_And_Move_To_Game_State() {
 	return HandleConnectAndMoveToLobby( GetGameStateLobby() );	
 }
 
 /*
 ========================
 idSessionLocal::State_InGame
 ========================
 */
 bool idSessionLocal::State_InGame() {
 	return HandlePackets();
 }
 
 /*
 ========================
 idSessionLocal::State_Loading
 ========================
 */
 bool idSessionLocal::State_Loading() {
 
 	HandlePackets();
 
 	if ( !GetActingGameStateLobby().loaded ) {
 		return false;
 	}
 
 	SetVoiceGroupsToTeams();
 
 	if ( GetActingGameStateLobby().IsHost() ) {
 		bool everyoneLoaded = true;
 		for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 			idLobby::peer_t & peer = GetActingGameStateLobby().peers[p];
 
 			if ( !peer.IsConnected() ) {
 				continue;		// We don't care about peers that aren't connected as a game session
 			}
 
 			if ( !peer.loaded ) {
 				everyoneLoaded = false;
 				continue;		// Don't waste time sending resources to a peer who hasn't loaded the map yet
 			}
 
 			if ( GetActingGameStateLobby().SendResources( p ) ) {
 				everyoneLoaded = false;
 
 				// if client is taking a LONG time to load up - give them the boot: they're just holding up the lunch line. Useful for loose assets playtesting.
 				int time = Sys_Milliseconds();
 				int maxLoadTime = net_maxLoadResourcesTimeInSeconds.GetInteger();
 				if ( maxLoadTime > 0 && peer.startResourceLoadTime + SEC2MS( maxLoadTime ) < time ) {
 					NET_VERBOSERESOURCE_PRINT( "NET: dropping client %i - %s because they took too long to load resources.\n Check 'net_maxLoadResourcesTimeInSeconds' to adjust the time allowed.\n", p, GetPeerName( p ) );
 					GetActingGameStateLobby().DisconnectPeerFromSession( p );
 					continue;
 				}
 			}
 		}
 		if ( !everyoneLoaded ) {
 			return false;
 		}
 	} else {
 		// not sure how we got there, but we won't be receiving anything that could get us out of this state anymore
 		// possible step towards fixing the join stalling/disconnect problems
 		if ( GetActingGameStateLobby().peers.Num() == 0 ) {
 			NET_VERBOSE_PRINT( "NET: no peers in idSessionLocal::State_Loading - giving up\n" );
 			MoveToMainMenu();
 		}
 		// need at least a peer with a real connection
 		bool haveOneGoodPeer = false;
 		for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 			if ( GetActingGameStateLobby().peers[p].IsConnected() ) {
 				haveOneGoodPeer = true;
 				break;
 			}
 		}
 		if ( !haveOneGoodPeer ) {
 			NET_VERBOSE_PRINT( "NET: no good peers in idSessionLocal::State_Loading - giving up\n" );
 			MoveToMainMenu();
 		}
 
 		return false;
 	}
 
 	GetActingGameStateLobby().ResetBandwidthStats();
 
 	// if we got here then we're the host and everyone indicated map load finished
 	NET_VERBOSE_PRINT( "NET: (loading) Starting Game\n" );
 	SetState( STATE_INGAME );		// NOTE - Only the host is in-game at this point, all peers will start becoming in-game when they receive their first full snap
 	return true;
 }
 
 /*
 ========================
 idSessionLocal::State_Busy
 ========================
 */
 bool idSessionLocal::State_Busy() {
 	idLobby * activeLobby = GetActivePlatformLobby();
 	if ( activeLobby == NULL ) {
 		idLib::Warning("No active session lobby when idSessionLocal::State_Busy called");
 		return false;
 	}
 
 	if ( activeLobby->bandwidthChallengeFinished ) {
 		// Start loading
 		NET_VERBOSE_PRINT( "NET: Bandwidth test finished - Start loading\n" );
 		StartLoading();
 	}
 
 	return HandlePackets();
 }
 
 /*
 ========================
 idSessionLocal::VerifySnapshotInitialState
 ========================
 */
 void idSessionLocal::VerifySnapshotInitialState() {
 	// Verify that snapshot state is reset
 	for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 		if ( !GetActingGameStateLobby().peers[p].IsConnected() ) {
 			assert( GetActingGameStateLobby().peers[p].snapProc == NULL );
 			continue;
 		}
 
 		assert( GetActingGameStateLobby().peers[p].snapProc != NULL );
 
 		if ( !verify( GetActingGameStateLobby().peers[p].needToSubmitPendingSnap == false ) ) {
 			idLib::Error( "Invalid needToSubmitPendingSnap state\n" );
 		}
 		if ( !verify( GetActingGameStateLobby().peers[p].snapProc->HasPendingSnap() == false ) ) {
 			idLib::Error( "Invalid HasPendingSnap state\n" );
 		}
 		if ( !verify( GetActingGameStateLobby().peers[p].snapProc->GetSnapSequence() == idSnapshotProcessor::INITIAL_SNAP_SEQUENCE ) ) {
 			idLib::Error( "Invalid INITIAL_SNAP_SEQUENCE state %d for peer %d \n", GetActingGameStateLobby().peers[p].snapProc->GetSnapSequence(), p  );
 		}
 		if ( !verify( GetActingGameStateLobby().peers[p].snapProc->GetBaseSequence() == -1 ) ) {
 			idLib::Error( "Invalid GetBaseSequence state\n" );
 		}
 	}
 }
 
 /*
 ========================
 idSessionLocal::State_Party_Lobby_Host
 ========================
 */
 bool idSessionLocal::State_Party_Lobby_Host() {
 	HandleVoiceRestrictionDialog();
 	return HandlePackets();
 }
 
 /*
 ========================
 idSessionLocal::State_Game_Lobby_Host
 ========================
 */
 bool idSessionLocal::State_Game_Lobby_Host() {
 	HandleVoiceRestrictionDialog();
 	return HandlePackets();
 }
 
 /*
 ========================
 idSessionLocal::State_Game_State_Lobby_Host
 ========================
 */
 bool idSessionLocal::State_Game_State_Lobby_Host() {
 	HandleVoiceRestrictionDialog();
 
 	if ( waitingOnGameStateMembersToLeaveTime != 0 ) {
 
 		const int MAX_LEAVE_WAIT_TIME_IN_SECONDS = 5;
 
 		const bool forceDisconnectMembers = ( Sys_Milliseconds() - waitingOnGameStateMembersToLeaveTime ) > MAX_LEAVE_WAIT_TIME_IN_SECONDS * 1000;
 
 		// Check to see if all peers have finally left
 		if ( GetGameStateLobby().GetNumConnectedPeers() == 0 || forceDisconnectMembers ) {
 
 			//
 			// All peers left, we can stop waiting
 			//
 
 			waitingOnGameStateMembersToLeaveTime = 0;	
 
 			assert( !GetGameLobby().IsPeer() );
 
 			if ( GetGameLobby().IsHost() ) {		
 				// If we aren't a dedicated game state host, then drop back to the game lobby as host
 				GetGameStateLobby().Shutdown();
 				SetState( STATE_GAME_LOBBY_HOST );
 			} else {
 				// A dedicated game state host will remain in State_Game_State_Lobby_Host mode while waiting for another set of users to join
 				// DEDICATED_SERVER_FIXME: Notify master server we can server another game now
 				GetGameStateLobby().DisconnectAllPeers();
 			}
 		}
 	} else {
 		// When all the players from the game lobby are in the game state lobby, StartLoading
 		if ( GetGameLobby().IsHost() ) {
 			if ( GetGameStateLobby().GetNumLobbyUsers() == GetGameLobby().GetNumLobbyUsers() ) {
 				waitingOnGameStateMembersToJoinTime = 0;
 				StartLoading();
 			}
 		} else {
 			// The dedicated server host relies on the game host to say when all users are in
 			if ( GetGameStateLobby().startLoadingFromHost ) {
 				GetGameStateLobby().startLoadingFromHost = false;
 				StartLoading();
 			}
 		}
 	}
 
 	return HandlePackets();
 }
 
 /*
 ========================
 idSessionLocal::State_Party_Lobby_Peer
 ========================
 */
 bool idSessionLocal::State_Party_Lobby_Peer() {
 	HandleVoiceRestrictionDialog();
 	return HandlePackets();
 }
 
 /*
 ========================
 idSessionLocal::State_Game_Lobby_Peer
 ========================
 */
 bool idSessionLocal::State_Game_Lobby_Peer() {
 	HandleVoiceRestrictionDialog();
 	bool saving = false;
 	idPlayerProfile * profile = GetProfileFromMasterLocalUser();
 	if ( profile != NULL && ( profile->GetState() == idPlayerProfile::SAVING || profile->GetRequestedState() == idPlayerProfile::SAVE_REQUESTED ) ) {
 		saving = true;
 	}
 
 	if ( GetActingGameStateLobby().startLoadingFromHost && !saving ) { 
 		common->Dialog().ClearDialog( GDM_HOST_RETURNED_TO_LOBBY );
 		common->Dialog().ClearDialog( GDM_HOST_RETURNED_TO_LOBBY_STATS_DROPPED );
 
 		VerifySnapshotInitialState();
 
 		// Set loading flag back to false
 		GetActingGameStateLobby().startLoadingFromHost = false;
 
 		// Set state to loading
 		SetState( STATE_LOADING );
 
 		loadingID++;
 
 		return true;
 	}
 
 	return HandlePackets();
 }
 
 /*
 ========================
 idSessionLocal::State_Game_State_Lobby_Peer
 ========================
 */
 bool idSessionLocal::State_Game_State_Lobby_Peer() {
 	// We are in charge of telling the dedicated host that all our members are in
 	if ( GetGameLobby().IsHost() && waitingOnGameStateMembersToJoinTime != 0 ) {		
 		int foundMembers = 0;
 
 		for ( int i = 0; i < GetGameLobby().GetNumLobbyUsers(); i++ ) {
 			if ( GetGameStateLobby().GetLobbyUserByID( GetGameLobby().GetLobbyUser( i )->lobbyUserID, true ) != NULL ) {
 				foundMembers++;
 			}
 		}
 
 		// Give all of our game members 10 seconds to join, otherwise start without them
 		const int MAX_JOIN_WAIT_TIME_IN_SECONDS = 10;
 
 		const bool forceStart = ( Sys_Milliseconds() - waitingOnGameStateMembersToJoinTime ) > MAX_JOIN_WAIT_TIME_IN_SECONDS * 1000;
 
 		if ( foundMembers == GetGameLobby().GetNumLobbyUsers() || forceStart ) {
 			byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
 
 			idBitMsg msg( buffer, sizeof( buffer ) );
 
 			// Write match paramaters to the game state host, and tell him to start
 			GetGameLobby().parms.Write( msg );
 
 			// Tell the game state lobby host we are ready
 			GetGameStateLobby().QueueReliableMessage( GetGameStateLobby().host, idLobby::RELIABLE_START_MATCH_GAME_LOBBY_HOST, msg.GetReadData(), msg.GetSize() );
 
 			waitingOnGameStateMembersToJoinTime = 0;
 		}
 	}
 
 	return State_Game_Lobby_Peer();
 }
 
 /*
 ========================
 idSessionLocal::~idSession
 ========================
 */
 idSession::~idSession() {
 	delete signInManager;
 	signInManager = NULL;
 	delete saveGameManager;
 	saveGameManager = NULL;
 	delete dedicatedServerSearch;
 	dedicatedServerSearch = NULL;
 }
 
 idCVar net_verbose( "net_verbose", "0", CVAR_BOOL, "Print a bunch of message about the network session" );
 idCVar net_verboseResource( "net_verboseResource", "0", CVAR_BOOL, "Prints a bunch of message about network resources" );
 idCVar net_verboseReliable( "net_verboseReliable", "0", CVAR_BOOL, "Prints the more spammy messages about reliable network msgs" );
 idCVar si_splitscreen( "si_splitscreen", "0", CVAR_INTEGER, "force splitscreen" );
 
 idCVar net_forceLatency( "net_forceLatency", "0", CVAR_INTEGER, "Simulate network latency (milliseconds round trip time - applied equally on the receive and on the send)" );
 idCVar net_forceDrop( "net_forceDrop", "0", CVAR_INTEGER, "Percentage chance of simulated network packet loss" );
 idCVar net_forceUpstream( "net_forceUpstream", "0", CVAR_FLOAT, "Force a maximum upstream in kB/s (256kbps <-> 32kB/s)" ); // I would much rather deal in kbps but most of the code is written in bytes ..
 idCVar net_forceUpstreamQueue( "net_forceUpstreamQueue", "64", CVAR_INTEGER, "How much data is queued when enforcing upstream (in kB)" );
 idCVar net_verboseSimulatedTraffic( "net_verboseSimulatedTraffic", "0", CVAR_BOOL, "Print some stats about simulated traffic (net_force* cvars)" );
 
 /*
 ========================
 idSessionLocal::Initialize
 ========================
 */
 void idSessionLocal::Initialize() {
 }
 
 /*
 ========================
 idSessionLocal::Shutdown
 ========================
 */
 void idSessionLocal::Shutdown() {
 }
 
 /*
 ========================
 idSession interface semi-common between platforms (#ifdef's in sys_session_local.cpp)
 ========================
 */
 
 idCVar com_deviceZeroOverride( "com_deviceZeroOverride", "-1", CVAR_INTEGER, "change input routing for device 0 to poll a different device" );
 idCVar mp_bot_input_override( "mp_bot_input_override", "-1", CVAR_INTEGER, "Override local input routing for bot control" );
 
 /*
 ========================
 idSessionLocal::GetInputRouting
 This function sets up inputRouting to be a mapping from inputDevice index to session user index.
 ========================
 */
 int idSessionLocal::GetInputRouting( int inputRouting[ MAX_INPUT_DEVICES ] ) {
 
 	int numLocalUsers = 0;
 	for ( int i = 0; i < MAX_INPUT_DEVICES; i++ ) {
 		inputRouting[i] = -1;
 	}
 	
 	for ( int i = 0; i < GetActingGameStateLobby().GetNumLobbyUsers(); i++ ) {
 		if ( GetActingGameStateLobby().IsSessionUserIndexLocal( i ) ) {
 
 			// Find the local user that this session user maps to
 			const idLocalUser * localUser = GetActingGameStateLobby().GetLocalUserFromLobbyUserIndex( i );
 			
 			if ( localUser != NULL ) {
 				int localDevice = localUser->GetInputDevice();
 				if ( localDevice == 0 && com_deviceZeroOverride.GetInteger() > 0 ) {
 					localDevice = com_deviceZeroOverride.GetInteger();
 				}
 				assert( localDevice < MAX_INPUT_DEVICES );
 				// Route the input device that this local user is mapped to
 				assert( inputRouting[localDevice] == -1 );	// Make sure to only initialize each entry once
 				inputRouting[localDevice] = i;
 
 				if ( mp_bot_input_override.GetInteger() >= 0 ) {
 					inputRouting[localDevice] = mp_bot_input_override.GetInteger();
 				}
 
 				numLocalUsers++;
 			}
 		}
 	}
 
 	// For testing swapping controllers
 	if ( si_splitscreen.GetInteger() == 2 && numLocalUsers == 2 ) {
 		SwapValues( inputRouting[0], inputRouting[1] );
 	}
 
 	return numLocalUsers;
 }
 
 /*
 ========================
 idSessionLocal::EndMatch
 EndMatch is meant for the host to cleanly end a match and return to the lobby page
 ========================
 */
 void idSessionLocal::EndMatch( bool premature /*=false*/ ) {
 	if ( verify( GetActingGameStateLobby().IsHost() ) ) {
 		// Host quits back to game lobby, and will notify peers internally to do the same
 		EndMatchInternal( premature );
 	}
 }
 
 /*
 ========================
 idSessionLocal::EndMatch
 this is for when the game is over before we go back to lobby. Need this incase the host leaves during this time
 ========================
 */
 void idSessionLocal::MatchFinished( ) {
 	if ( verify( GetActingGameStateLobby().IsHost() ) ) {
 		// host is putting up end game stats make sure other peers know and clear migration data
 		MatchFinishedInternal();
 	}
 }
 
 /*
 ========================
 idSessionLocal::QuitMatch
 QuitMatch is considered a premature ending of a match, and does the right thing depending on whether the host or peer is quitting
 ========================
 */
 void idSessionLocal::QuitMatch() {
 	if ( GetActingGameStateLobby().IsHost() && !MatchTypeIsRanked( GetActingGameStateLobby().parms.matchFlags ) ) {
 		EndMatch( true );		// When host quits private match, takes members back to game lobby
 	} else {
 		// Quitting a public match (or not being a host) before it ends takes you to an empty party lobby
 		CreatePartyLobby( GetActingGameStateLobby().parms );
 	}
 }
 
 /*
 ========================
 idSessionLocal::QuitMatchToTitle
 QuitMatchToTitle will forcefully quit the match and return to the title screen.
 ========================
 */
 void idSessionLocal::QuitMatchToTitle() {
 	MoveToMainMenu();
 }
 
 /*
 ========================
 idSessionLocal::ClearMigrationState
 ========================
 */
 void idSessionLocal::ClearMigrationState() {
 	// We are ending the match without migration, so clear that state
 	GetPartyLobby().ResetAllMigrationState();
 	GetGameLobby().ResetAllMigrationState();
 }
 
 /*
 ========================
 idSessionLocal::EndMatchInternal
 ========================
 */
 void idSessionLocal::EndMatchInternal( bool premature/*=false*/ ) {
 	assert( GetGameStateLobby().IsLobbyActive() == net_useGameStateLobby.GetBool() );
 
 	ClearVoiceGroups();
 
 	for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 		// If we are the host, increment the session ID.  The client will use a rolling check to catch it
 		if ( GetActingGameStateLobby().IsHost() ) {
 			if ( GetActingGameStateLobby().peers[p].IsConnected() ) {
 				if ( GetActingGameStateLobby().peers[p].packetProc != NULL ) {
 					GetActingGameStateLobby().peers[p].packetProc->VerifyEmptyReliableQueue( idLobby::RELIABLE_GAME_DATA, idLobby::RELIABLE_DUMMY_MSG );
 				}
 				GetActingGameStateLobby().peers[p].sessionID = GetActingGameStateLobby().IncrementSessionID( GetActingGameStateLobby().peers[p].sessionID );
 			}
 		}
 		GetActingGameStateLobby().peers[p].ResetMatchData();
 	}
 
 	GetActingGameStateLobby().snapDeltaAckQueue.Clear();
 
 	GetActingGameStateLobby().loaded	= false;
 
 	gameLobbyWasCoalesced	= false;		// Reset this back to false.  We use this so the lobby code doesn't randomly choose a map when we coalesce
 	numFullSnapsReceived	= 0;
 
 	ClearMigrationState();
 
 	if ( GetActingGameStateLobby().IsLobbyActive() && ( GetActingGameStateLobby().GetMatchParms().matchFlags & MATCH_REQUIRE_PARTY_LOBBY ) ) {
 		// All peers need to remove disconnected users to stay in sync
 		GetActingGameStateLobby().CompactDisconnectedUsers();
 
 		// Go back to the game lobby
 		if ( GetActingGameStateLobby().IsHost() ) {
 			// We want the game state host to go back to STATE_GAME_STATE_LOBBY_HOST, so he can wait on all his game state peers to leave
 			SetState( GetGameStateLobby().IsHost() ? STATE_GAME_STATE_LOBBY_HOST : STATE_GAME_LOBBY_HOST );		// We want the dedicated host to go back to STATE_GAME_STATE_LOBBY_HOST
 		} else {
 			SetState( STATE_GAME_LOBBY_PEER );
 		}
 	} else {
 		SetState( STATE_IDLE );
 	}
 
 	if ( GetActingGameStateLobby().IsHost() ) {
 		// Send a reliable msg to all peers to also "EndMatch"
 		for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 			GetActingGameStateLobby().QueueReliableMessage( p, premature ? idLobby::RELIABLE_ENDMATCH_PREMATURE : idLobby::RELIABLE_ENDMATCH );
 		}
 	} else if ( premature ) {
 		// Notify client that host left early and thats why we are back in the lobby
 		const bool stats = MatchTypeHasStats( GetActingGameStateLobby().GetMatchParms().matchFlags ) && ( GetFlushedStats() == false );
 		common->Dialog().AddDialog( stats ? GDM_HOST_RETURNED_TO_LOBBY_STATS_DROPPED : GDM_HOST_RETURNED_TO_LOBBY, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true );
 	}
 
 	if ( GetGameStateLobby().IsLobbyActive() ) {
 		if ( GetGameStateLobby().IsHost() ) {
 			// As a game state host, keep the lobby around, so we can make sure we know when everyone leaves (which means they got the reliable msg to EndMatch)
 			waitingOnGameStateMembersToLeaveTime = Sys_Milliseconds();
 		} else if ( GetGameStateLobby().IsPeer() ) {
 			// Game state lobby peers should disconnect now
 			GetGameStateLobby().Shutdown();
 		}
 	}
 }
 
 /*
 ========================
 idSessionLocal::MatchFinishedInternal
 ========================
 */
 void idSessionLocal::MatchFinishedInternal() {
 	ClearMigrationState();
 
 	if ( GetActingGameStateLobby().IsHost() ) {
 		// Send a reliable msg to all peers to also "EndMatch"
 		for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 			GetActingGameStateLobby().QueueReliableMessage( p, idLobby::RELIABLE_MATCHFINISHED );
 		}
 	}
 }
 
 /*
 ========================
 idSessionLocal::EndMatchForMigration
 ========================
 */
 void idSessionLocal::EndMatchForMigration() {
 	ClearVoiceGroups();	
 }
 
 /*
 ========================
 idSessionLocal::ShouldHavePartyLobby
 ========================
 */
 bool idSessionLocal::ShouldHavePartyLobby() {
 	if ( GetActivePlatformLobby() == NULL ) {
 		return false;
 	}
 
 	idMatchParameters & parms = GetActivePlatformLobby()->parms;
 
 	int flags = parms.matchFlags;
 
 	// Don't we always have a party lobby if we're online? At least in Doom 3?
 	return MatchTypeIsOnline( flags ) && ( ( flags & MATCH_PARTY_INVITE_PLACEHOLDER ) == 0 );
 }
 
 /*
 ========================
 idSessionLocal::ValidateLobbies
 Determines if any of the session instances need to become the host
 ========================
 */
 void idSessionLocal::ValidateLobbies() {
 	if ( localState == STATE_PRESS_START || localState == STATE_IDLE ) {
 		// At press start or main menu, don't do anything
 		return;
 	}
 
 	if ( GetActivePlatformLobby() == NULL ) {
 		// If we're in between lobbies, don't do anything yet (the state transitioning code will handle error cases)
 		return;
 	}
 
 	// Validate lobbies that should be alive and active
 	if ( ShouldHavePartyLobby() && GetState() >= idSession::PARTY_LOBBY ) {
 		ValidateLobby( GetPartyLobby() );
 	}
 	if ( GetState() >= idSession::GAME_LOBBY && !net_headlessServer.GetBool() ) {
 		ValidateLobby( GetGameLobby() );
 	}
 }
 
 /*
 ========================
 idSessionLocal::ValidateLobby
 ========================
 */
 void idSessionLocal::ValidateLobby( idLobby & lobby ) {
 	if ( lobby.lobbyBackend == NULL || lobby.lobbyBackend->GetState() == idLobbyBackend::STATE_FAILED || lobby.GetState() == idLobby::STATE_FAILED ) {
 		NET_VERBOSE_PRINT( "NET: ValidateLobby: FAILED (lobbyType = %i, state = %s)\n", lobby.lobbyType, stateToString[ localState ] );
 		if ( lobby.failedReason == idLobby::FAILED_MIGRATION_CONNECT_FAILED || lobby.failedReason == idLobby::FAILED_CONNECT_FAILED ) {
 			MoveToMainMenu();
 			common->Dialog().AddDialog( GDM_INVALID_INVITE, DIALOG_ACCEPT, NULL, NULL, false );		// The game session no longer exists
 		} else {
 			// If the lobbyBackend goes bad under our feet for no known reason, assume we lost connection to the back end service
 			MoveToMainMenu();
 			common->Dialog().ClearDialogs( true );
 			common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false );		// Lost connection to XBox LIVE
 		}
 	}	
 }
 
 /*
 ========================
 idSessionLocal::Pump
 ========================
 */
 void idSessionLocal::Pump() {
 	SCOPED_PROFILE_EVENT( "Session::Pump" );
 
 	static int lastPumpTime = -1;
 
 	const int time					= Sys_Milliseconds();
 	const int elapsedPumpSeconds	= ( time - lastPumpTime ) / 1000;
 
 	if ( lastPumpTime != -1 && elapsedPumpSeconds > 2 ) {
 		idLib::Warning( "idSessionLocal::Pump was not called for %i seconds", elapsedPumpSeconds );
 	}
 
 	lastPumpTime = time;
 
 	if ( net_migrateHost.GetInteger() >= 0 ) {
 		if ( net_migrateHost.GetInteger() <= 2 ) {
 			if ( net_migrateHost.GetInteger() == 0 ) {
 				GetPartyLobby().PickNewHost( true, true );				
 			} else {
 				GetGameLobby().PickNewHost( true, true );				
 			}
 		} else {
 			GetPartyLobby().PickNewHost( true, true );				
 			GetGameLobby().PickNewHost( true, true );				
 		}
 		net_migrateHost.SetInteger( -1 );
 	}
 
 	PlatformPump();
 
 	if ( HasAchievementSystem() ) {
 		GetAchievementSystem().Pump();
 	}
 
 	// Send any voice packets if it's time
 	SendVoiceAudio();
 
 	bool shouldContinue = true;
 
 	while ( shouldContinue ) {
 		// Each iteration, validate the session instances
 		ValidateLobbies();
 
 		// Pump state
 		shouldContinue = HandleState();
 
 		// Pump lobbies
 		PumpLobbies();
 	} 
 
 	if ( GetPartyLobby().lobbyBackend != NULL ) {
 		// Make sure game properties aren't set on the lobbyBackend if we aren't in a game lobby.
 		// This is so we show up properly in search results in Play with Friends option
 		GetPartyLobby().lobbyBackend->SetInGame( GetGameLobby().IsLobbyActive() );
 
 		// Temp location
 		UpdateMasterUserHeadsetState();
 	}
 
 	// Do some last minute checks, make sure everything about the current state and lobbyBackend state is valid, otherwise, take action
 	ValidateLobbies();
 
 	GetActingGameStateLobby().UpdateSnaps();
 
 	idLobby * activeLobby = GetActivePlatformLobby();
 
 	// Pump pings for the active lobby
 	if ( activeLobby != NULL ) {
 		activeLobby->PumpPings();
 	}
 
 	// Pump packet processing for all lobbies
 	GetPartyLobby().PumpPackets();
 	GetGameLobby().PumpPackets();
 	GetGameStateLobby().PumpPackets();
 
 	int currentTime = Sys_Milliseconds();
 
 	const int SHOW_MIGRATING_INFO_IN_SECONDS = 3;	// Show for at least this long once we start showing it
 
 	if ( ShouldShowMigratingDialog() ) {
 		showMigratingInfoStartTime = currentTime;
 	} else if ( showMigratingInfoStartTime > 0 && ( ( currentTime - showMigratingInfoStartTime ) > SHOW_MIGRATING_INFO_IN_SECONDS * 1000 ) ) {
 		showMigratingInfoStartTime = 0;
 	}
 
 	bool isShowingMigrate = common->Dialog().HasDialogMsg( GDM_MIGRATING, NULL );
 
 	if ( showMigratingInfoStartTime != 0 ) {
 		if ( !isShowingMigrate ) {
 			common->Dialog().AddDialog( GDM_MIGRATING, DIALOG_WAIT, NULL, NULL, false, "", 0, false, false, true );
 		}
 	} else if ( isShowingMigrate ) {
 		common->Dialog().ClearDialog( GDM_MIGRATING );
 	}
 
 	// Update possible pending invite
 	UpdatePendingInvite();
 
 	// Check to see if we should coalesce the lobby
 	if ( nextGameCoalesceTime != 0 ) {
 
 		if ( GetGameLobby().IsLobbyActive() &&
 			 GetGameLobby().IsHost() &&
 			 GetState() == idSession::GAME_LOBBY &&
 			 GetPartyLobby().GetNumLobbyUsers() <= 1 &&
 			 GetGameLobby().GetNumLobbyUsers() == 1 &&
 			 MatchTypeIsRanked( GetGameLobby().parms.matchFlags ) &&
 			 Sys_Milliseconds() > nextGameCoalesceTime ) {
 			
 			// If the player doesn't care about the mode or map,
 			// make sure the search is broadened.
 			idMatchParameters newGameParms = GetGameLobby().parms;
 			newGameParms.gameMap = GAME_MAP_RANDOM;
 
 			// Assume that if the party lobby's mode is random,
 			// the player chose "Quick Match" and doesn't care about the mode.
 			// If the player chose "Find Match" and a specific mode,
 			// the party lobby mode will be set to non-random.
 			if ( GetPartyLobby().parms.gameMode == GAME_MODE_RANDOM ) {
 				newGameParms.gameMode = GAME_MODE_RANDOM;
 			}
 
 			FindOrCreateMatch( newGameParms );
 
 			gameLobbyWasCoalesced	= true;		// Remember that this round was coalesced.  We so this so main menu doesn't randomize the map, which looks odd
 			nextGameCoalesceTime	= 0;
 		}
 	}
 }
 
 /*
 ========================
 idSessionLocal::ProcessSnapAckQueue
 ========================
 */
 void idSessionLocal::ProcessSnapAckQueue() {
 	if ( GetActingGameStateLobby().IsLobbyActive() ) {
 		GetActingGameStateLobby().ProcessSnapAckQueue();
 	}
 }
 
 /*
 ========================
 idSessionLocal::UpdatePendingInvite
 ========================
 */
 void idSessionLocal::UpdatePendingInvite() {
 	if ( pendingInviteMode == PENDING_INVITE_NONE ) {
 		return;		// No pending invite
 	}
 
 	idLocalUser * masterLocalUser = signInManager->GetMasterLocalUser();
 
 	if ( masterLocalUser == NULL && signInManager->IsDeviceBeingRegistered( pendingInviteDevice ) ) {
 		idLib::Printf( "masterLocalUser == NULL\n" );
 		return;		// Waiting on master to sign in to continue with invite
 	}
 
 	const bool wasFromInvite = pendingInviteMode == PENDING_INVITE_WAITING;	// Remember if this was a real invite, or a self invitation (matters when lobby is invite only)
 
 	// At this point, the invitee should be ready
 	pendingInviteMode = PENDING_INVITE_NONE;
 
 	if ( masterLocalUser == NULL || masterLocalUser->GetInputDevice() != pendingInviteDevice || !masterLocalUser->IsOnline() ) {
 		idLib::Printf( "ignoring invite - master local user is not setup properly\n" );
 		return; // If there is no master, if the invitee is not online, or different than the current master, then ignore invite
 	}
 
 	// Clear any current dialogs, as we're going into a state which will be unstable for any current dialogs.
 	// Do we want to throw an assert if a dialog is currently up?
 	common->Dialog().ClearDialogs( true );
 
 	// Everything looks good, let's join the party
 	ConnectAndMoveToLobby( GetPartyLobby(), pendingInviteConnectInfo, wasFromInvite );
 }
 
 /*
 ========================
 idSessionLocal::HandleState
 ========================
 */
 bool idSessionLocal::HandleState() {	
 	// Handle individual lobby states
 	GetPartyLobby().Pump();
 	GetGameLobby().Pump();
 	GetGameStateLobby().Pump();
 
 	// Let IsHost be authoritative on the qualification of peer/host state types
 	if ( GetPartyLobby().IsHost() && localState == STATE_PARTY_LOBBY_PEER ) {
 		SetState( STATE_PARTY_LOBBY_HOST );
 	} else if ( GetPartyLobby().IsPeer() && localState == STATE_PARTY_LOBBY_HOST ) {
 		SetState( STATE_PARTY_LOBBY_PEER );
 	}
 
 	// Let IsHost be authoritative on the qualification of peer/host state types
 	if ( GetGameLobby().IsHost() && localState == STATE_GAME_LOBBY_PEER ) {
 		SetState( STATE_GAME_LOBBY_HOST );
 	} else if ( GetGameLobby().IsPeer() && localState == STATE_GAME_LOBBY_HOST ) {
 		SetState( STATE_GAME_LOBBY_PEER );
 	}
 
 	switch ( localState ) {
 		case STATE_PRESS_START:							return false;
 		case STATE_IDLE:								HandlePackets(); return false;		// Call handle packets, since packets from old sessions could still be in flight, which need to be emptied
 		case STATE_PARTY_LOBBY_HOST:					return State_Party_Lobby_Host();
 		case STATE_PARTY_LOBBY_PEER:					return State_Party_Lobby_Peer();
 		case STATE_GAME_LOBBY_HOST:						return State_Game_Lobby_Host();
 		case STATE_GAME_LOBBY_PEER:						return State_Game_Lobby_Peer();
 		case STATE_GAME_STATE_LOBBY_HOST:				return State_Game_State_Lobby_Host();
 		case STATE_GAME_STATE_LOBBY_PEER:				return State_Game_State_Lobby_Peer();
 		case STATE_LOADING:								return State_Loading();
 		case STATE_INGAME:								return State_InGame();
 		case STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY:		return State_Create_And_Move_To_Party_Lobby();
 		case STATE_CREATE_AND_MOVE_TO_GAME_LOBBY:		return State_Create_And_Move_To_Game_Lobby();
 		case STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY:	return State_Create_And_Move_To_Game_State_Lobby();
 		case STATE_FIND_OR_CREATE_MATCH:				return State_Find_Or_Create_Match();
 		case STATE_CONNECT_AND_MOVE_TO_PARTY:			return State_Connect_And_Move_To_Party();
 		case STATE_CONNECT_AND_MOVE_TO_GAME:			return State_Connect_And_Move_To_Game();
 		case STATE_CONNECT_AND_MOVE_TO_GAME_STATE:		return State_Connect_And_Move_To_Game_State();
 		case STATE_BUSY:								return State_Busy();
 		default:
 			idLib::Error( "HandleState:  Unknown state in idSessionLocal" );
 	}
 }
 
 /*
 ========================
 idSessionLocal::GetState
 ========================
 */
 idSessionLocal::sessionState_t idSessionLocal::GetState() const {
 	// Convert our internal state to one of the external states
 	switch ( localState ) {
 		case STATE_PRESS_START:							return PRESS_START;
 		case STATE_IDLE:								return IDLE;
 		case STATE_PARTY_LOBBY_HOST:					return PARTY_LOBBY;
 		case STATE_PARTY_LOBBY_PEER:					return PARTY_LOBBY;
 		case STATE_GAME_LOBBY_HOST:						return GAME_LOBBY;
 		case STATE_GAME_LOBBY_PEER:						return GAME_LOBBY;
 		case STATE_GAME_STATE_LOBBY_HOST:				return GAME_LOBBY;
 		case STATE_GAME_STATE_LOBBY_PEER:				return GAME_LOBBY;
 		case STATE_LOADING:								return LOADING;
 		case STATE_INGAME:								return INGAME;
 		case STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY:		return CONNECTING;
 		case STATE_CREATE_AND_MOVE_TO_GAME_LOBBY:		return CONNECTING;
 		case STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY:	return CONNECTING;
 		case STATE_FIND_OR_CREATE_MATCH:				return SEARCHING;
 		case STATE_CONNECT_AND_MOVE_TO_PARTY:			return CONNECTING;
 		case STATE_CONNECT_AND_MOVE_TO_GAME:			return CONNECTING;
 		case STATE_CONNECT_AND_MOVE_TO_GAME_STATE:		return CONNECTING;
 		case STATE_BUSY:								return BUSY;
 		default: {
 			idLib::Error( "GetState: Unknown state in idSessionLocal" );
 		}	
 	};
 }
 
 const char * idSessionLocal::GetStateString() const {
 	static const char * stateToString[] = {
 		ASSERT_ENUM_STRING( STATE_PRESS_START, 0 ),
 		ASSERT_ENUM_STRING( STATE_IDLE, 1 ),
 		ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_HOST, 2 ),
 		ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_PEER, 3 ),
 		ASSERT_ENUM_STRING( STATE_GAME_LOBBY_HOST, 4 ),
 		ASSERT_ENUM_STRING( STATE_GAME_LOBBY_PEER, 5 ),
 		ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_HOST, 6 ),
 		ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_PEER, 7 ),
 		ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY, 8 ),
 		ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_LOBBY, 9 ),
 		ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY, 10 ),
 		ASSERT_ENUM_STRING( STATE_FIND_OR_CREATE_MATCH, 11 ),
 		ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_PARTY, 12 ),
 		ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME, 13 ),
 		ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME_STATE, 14 ),
 		ASSERT_ENUM_STRING( STATE_BUSY, 15 ),
 		ASSERT_ENUM_STRING( STATE_LOADING, 16 ),
 		ASSERT_ENUM_STRING( STATE_INGAME, 17 )
 	};
 	return stateToString[ localState ];
 }
 
 // idSession interface
 
 /*
 ========================
 idSessionLocal::LoadingFinished
 
 Only called by idCommonLocal::FinalizeMapChange
 ========================
 */
 void idSessionLocal::LoadingFinished() {
 	NET_VERBOSE_PRINT( "NET: Loading Finished\n" );
 
 	assert( GetState() == idSession::LOADING );
 
 	common->Dialog().ClearDialog( GDM_VOICE_RESTRICTED );
 	GetActingGameStateLobby().loaded = true;
 	
 	if ( MatchTypeIsLocal( GetActingGameStateLobby().parms.matchFlags ) ) {
 		SetState( STATE_INGAME );
 	} else if ( !GetActingGameStateLobby().IsHost() ) {	// Tell game host we're done loading
 		byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
 		idBitMsg msg( buffer, sizeof( buffer ) );
 		GetActingGameStateLobby().QueueReliableMessage( GetActingGameStateLobby().host, idLobby::RELIABLE_LOADING_DONE, msg.GetReadData(), msg.GetSize() );
 	} else  {
 		SetState( STATE_INGAME );
 	}
 
 	SetFlushedStats( false );
 }
 
 /*
 ========================
 idSessionLocal::SendUsercmds
 ========================
 */
 void idSessionLocal::SendUsercmds( idBitMsg & msg ) {
 	if ( localState != STATE_INGAME ) {
 		return;
 	}
 	
 	if ( GetActingGameStateLobby().IsPeer() ) {
 		idLobby::peer_t & hostPeer = GetActingGameStateLobby().peers[GetActingGameStateLobby().host];
 		
 		// Don't send user cmds if we have unsent packet fragments
 		//  (This can happen if we have packets to send, but SendAnotherFragment got throttled)
 		if ( hostPeer.packetProc->HasMoreFragments() ) {
 			idLib::Warning( "NET: Client called SendUsercmds while HasMoreFragments(). Skipping userCmds for this frame." );
 			return;
 		}
 
 		int sequence = hostPeer.snapProc->GetLastAppendedSequence();
 
 		// Add incoming BPS for QoS
 		float incomingBPS = hostPeer.receivedBps;
 		if ( hostPeer.receivedBpsIndex != sequence ) {
 			incomingBPS = idMath::ClampFloat( 0.0f, static_cast<float>( idLobby::BANDWIDTH_REPORTING_MAX ), hostPeer.packetProc->GetIncomingRateBytes() );
 			hostPeer.receivedBpsIndex = sequence;
 			hostPeer.receivedBps = incomingBPS;
 		}
 		uint16 incomingBPS_quantized = idMath::Ftoi( incomingBPS * ( ( BIT( idLobby::BANDWIDTH_REPORTING_BITS ) - 1 )  / idLobby::BANDWIDTH_REPORTING_MAX ) );
 
 		byte buffer[idPacketProcessor::MAX_FINAL_PACKET_SIZE];
 		lzwCompressionData_t lzwData;
 		idLZWCompressor lzwCompressor( &lzwData );
 		lzwCompressor.Start( buffer, sizeof( buffer ) );
 		lzwCompressor.WriteAgnostic( sequence );
 		lzwCompressor.WriteAgnostic( incomingBPS_quantized );
 		lzwCompressor.Write( msg.GetReadData(), msg.GetSize() );
 		lzwCompressor.End();
 
 		GetActingGameStateLobby().ProcessOutgoingMsg( GetActingGameStateLobby().host, buffer, lzwCompressor.Length(), false, 0 );
 		
 		if ( net_debugBaseStates.GetBool() && sequence < 50 ) {
 			idLib::Printf( "NET: Acking snap %d \n", sequence );
 		}
 	}
 }
 
 /*
 ========================
 idSessionLocal::SendSnapshot
 ========================
 */
 void idSessionLocal::SendSnapshot( idSnapShot & ss ) {
 	for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
 		idLobby::peer_t & peer = GetActingGameStateLobby().peers[p];
 	
 		if ( !peer.IsConnected() ) {
 			continue;
 		}
 		
 		if ( !peer.loaded ) {
 			continue;
 		}
 
 		if ( peer.pauseSnapshots ) {
 			continue;
 		}
 		
 		GetActingGameStateLobby().SendSnapshotToPeer( ss, p );
 	}
 }
 
 /*
 ========================
 idSessionLocal::UpdateSignInManager
 ========================
 */
 void idSessionLocal::UpdateSignInManager() {	
 	if ( !HasSignInManager() ) {
 		return;
 	}
 
 	if ( net_headlessServer.GetBool() ) {
 		return;
 	}
 			
 	// FIXME: We need to ask the menu system for this info.  Just making a best guess for now
 	// (assume we are allowed to join the party as a splitscreen user if we are in the party lobby)
 	bool allowJoinParty	= ( localState == STATE_PARTY_LOBBY_HOST || localState == STATE_PARTY_LOBBY_PEER ) && GetPartyLobby().state == idLobby::STATE_IDLE;
 	bool allowJoinGame	= ( localState == STATE_GAME_LOBBY_HOST || localState == STATE_GAME_LOBBY_PEER ) && GetGameLobby().state == idLobby::STATE_IDLE;
 
 	bool eitherLobbyRunning	= GetActivePlatformLobby() != NULL && ( GetPartyLobby().IsLobbyActive() || GetGameLobby().IsLobbyActive() );
 	bool onlineMatch		= eitherLobbyRunning && MatchTypeIsOnline( GetActivePlatformLobby()->parms.matchFlags );
 
 	//=================================================================================
 	// Get the number of desired signed in local users depending on what mode we're in.
 	//=================================================================================
 	int minDesiredUsers = 0;
 	int maxDesiredUsers = Max( 1, signInManager->GetNumLocalUsers() );
 	
 	if ( si_splitscreen.GetInteger() != 0 ) {
 		// For debugging, force 2 splitscreen players
 		minDesiredUsers = 2;
 		maxDesiredUsers = 2;
 		allowJoinGame = true;
 	} else if ( onlineMatch || ( eitherLobbyRunning == false ) ) {
 		// If this an online game, then only 1 user can join locally.
 		// Also, if no sessions are active, remove any extra players.
 		maxDesiredUsers = 1;
 	} else if ( allowJoinParty || allowJoinGame ) {
 		// If we are in the party lobby, allow 2 splitscreen users to join
 		maxDesiredUsers = 2;
 	}
 
 	// Set the number of desired users
 	signInManager->SetDesiredLocalUsers( minDesiredUsers, maxDesiredUsers );
 	
 	//=================================================================================
 	// Update signin manager
 	//=================================================================================
 	
 	// Update signin mgr.  This manager tracks signed in local users, which the session then uses
 	// to determine who should be in the lobby.
 	signInManager->Pump();
 			
 	// Get the master local user
 	idLocalUser * masterUser = signInManager->GetMasterLocalUser();
 
 	if ( onlineMatch && masterUser != NULL && !masterUser->CanPlayOnline() && !masterUser->HasOwnerChanged() ) { 
 		if ( localState > STATE_IDLE ) {
 			// User is still valid, just no longer online
 			if ( offlineTransitionTimerStart == 0 ) {
 				offlineTransitionTimerStart = Sys_Milliseconds();
 			}
 
 			if ( ( Sys_Milliseconds() - offlineTransitionTimerStart ) > net_offlineTransitionThreshold.GetInteger() ) {
 				MoveToMainMenu();
 				common->Dialog().ClearDialogs();
 				common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true );
 			}
 		}
 		return;		// Bail out so signInManager->ValidateLocalUsers below doesn't prematurely remove the master user before we can detect loss of connection
 	} else {
 		offlineTransitionTimerStart = 0;
 	}
 
 	// Remove local users (from the signin manager) who aren't allowed to be online if this is an online match.
 	// Remove local user (from the signin manager) who are not properly signed into a profile.
 	signInManager->ValidateLocalUsers( onlineMatch );
 
 	//=================================================================================
 	// Check to see if we need to go to "Press Start"
 	//=================================================================================
 
 	// Get the master local user (again, after ValidateOnlineLocalUsers, to make sure he is still valid)
 	masterUser = signInManager->GetMasterLocalUser();
 	
 	if ( masterUser == NULL ) { 
 		// If we don't have a master user at all, then we need to be at "Press Start"
 		MoveToPressStart( GDM_SP_SIGNIN_CHANGE_POST );
 		return;
 	} else if ( localState == STATE_PRESS_START ) {
 
 
 		// If we have a master user, and we are at press start, move to the menu area
 		SetState( STATE_IDLE );
 
 	}
 
 	// See if the master user either isn't persistent (but needs to be), OR, if the owner changed
 	// RequirePersistentMaster is poorly named, this really means RequireSignedInMaster
 	if ( masterUser->HasOwnerChanged() || ( RequirePersistentMaster() && !masterUser->IsProfileReady() ) ) {
 		MoveToPressStart( GDM_SP_SIGNIN_CHANGE_POST );
 		return;
 	}
 
 	//=================================================================================
 	// Sync lobby users with the signed in users
 	// The initial list of session users are normally determined at connect or create time.
 	// These functions allow splitscreen users to join in, or check to see if existing
 	// users (including the master) need to be removed.
 	//=================================================================================
 	GetPartyLobby().SyncLobbyUsersWithLocalUsers( allowJoinParty, onlineMatch );
 	GetGameLobby().SyncLobbyUsersWithLocalUsers( allowJoinGame, onlineMatch );
 	GetGameStateLobby().SyncLobbyUsersWithLocalUsers( allowJoinGame, onlineMatch );
 }
 
 /*
 ========================
 idSessionLocal::GetProfileFromMasterLocalUser
 ========================
 */
 idPlayerProfile * idSessionLocal::GetProfileFromMasterLocalUser() {
 	idPlayerProfile * profile = NULL;
 	idLocalUser * masterUser = signInManager->GetMasterLocalUser();
 	
 	if ( masterUser != NULL ) {
 		profile = masterUser->GetProfile();
 	}
 	
 	if ( profile == NULL ) {
 		// Whoops
 		profile = signInManager->GetDefaultProfile();
 		//idLib::Warning( "Returning fake profile until the code is fixed to handle NULL profiles." );
 	}
 	
 	return profile;
 }
 
 /*
 ========================
 /*
 ========================
 idSessionLocal::MoveToPressStart
 ========================
 */
 void idSessionLocal::MoveToPressStart( gameDialogMessages_t msg ) {	
 	if ( localState != STATE_PRESS_START ) {
 		MoveToPressStart();
 		common->Dialog().ClearDialogs();
 		common->Dialog().AddDialog( msg, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true );
 	}
 }
 
 /*
 ========================
 idSessionLocal::GetPeerName
 ========================
 */
 const char * idSessionLocal::GetPeerName( int peerNum ) {
 	return GetActingGameStateLobby().GetPeerName( peerNum );
 }
 
 
 /*
 ========================
 idSessionLocal::SetState
 ========================
 */
 void idSessionLocal::SetState( state_t newState ) {	
 
 	assert( newState < NUM_STATES );
 	assert( localState < NUM_STATES );
 	verify_array_size( stateToString, NUM_STATES );
 
 	if ( newState == localState ) {
 		NET_VERBOSE_PRINT( "NET: SetState: State SAME %s\n", stateToString[ newState ] );
 		return;
 	}
 
 	// Set the current state
 	NET_VERBOSE_PRINT( "NET: SetState: State changing from %s to %s\n", stateToString[ localState ], stateToString[ newState ] );
 
 	if ( localState < STATE_LOADING && newState >= STATE_LOADING ) {
 		// Tell lobby instances that the match has started
 		StartSessions();
 		// Clear certain dialog boxes we don't want to see in-game
 		common->Dialog().ClearDialog( GDM_LOBBY_DISBANDED );	// The lobby you were previously in has disbanded
 	} else if ( localState >= STATE_LOADING && newState < STATE_LOADING ) {
 		// Tell lobby instances that the match has ended
 		if ( !WasMigrationGame() ) { // Don't end the session if we are going right back into the game
 			EndSessions();
 		}
 	}
 
 	if ( newState == STATE_GAME_LOBBY_HOST || newState == STATE_GAME_LOBBY_PEER ) {
 		ComputeNextGameCoalesceTime();
 	}
 
 	localState = newState;
 }
 
 /*
 ========================
 idSessionLocal::HandlePackets
 ========================
 */
 bool idSessionLocal::HandlePackets() {
 	SCOPED_PROFILE_EVENT( "Session::HandlePackets" );
 
 	byte				packetBuffer[ idPacketProcessor::MAX_FINAL_PACKET_SIZE ];
 	lobbyAddress_t		remoteAddress;
 	int					recvSize = 0;
 	bool				fromDedicated = false;
 
 	while ( ReadRawPacket( remoteAddress, packetBuffer, recvSize, fromDedicated, sizeof( packetBuffer ) ) && recvSize > 0 ) {
 		
 		// fragMsg will hold the raw packet
 		idBitMsg fragMsg;
 		fragMsg.InitRead( packetBuffer, recvSize );
 
 		// Peek at the session ID
 		idPacketProcessor::sessionId_t sessionID = idPacketProcessor::GetSessionID( fragMsg );
 
 		// idLib::Printf( "NET: HandlePackets - session %d, size %d \n", sessionID, recvSize );
 
 		// Make sure it's valid
 		if ( sessionID == idPacketProcessor::SESSION_ID_INVALID ) {
 			idLib::Printf( "NET: Invalid sessionID %s.\n", remoteAddress.ToString() );
 			continue;
 		}
 
 		//
 		// Distribute the packet to the proper lobby
 		//
 
 		const int maskedType = sessionID & idPacketProcessor::LOBBY_TYPE_MASK;
 
 		if ( !verify( maskedType > 0 ) ) {
 			continue;
 		}
 
 		idLobby::lobbyType_t lobbyType = (idLobby::lobbyType_t)( maskedType - 1 );
 
 		switch ( lobbyType ) {
 			case idLobby::TYPE_PARTY:		GetPartyLobby().HandlePacket( remoteAddress, fragMsg, sessionID );		break;
 			case idLobby::TYPE_GAME:		GetGameLobby().HandlePacket( remoteAddress, fragMsg, sessionID );		break;
 			case idLobby::TYPE_GAME_STATE:	GetGameStateLobby().HandlePacket( remoteAddress, fragMsg, sessionID );	break;
 			default:						assert( 0 );
 		}
 	}
 
 	return false;
 }
 
 /*
 ========================
 idSessionLocal::GetActivePlatformLobby
 ========================
 */
 idLobby * idSessionLocal::GetActivePlatformLobby() {
 	sessionState_t state = GetState();
 
 	if ( ( state == GAME_LOBBY ) || ( state == BUSY ) || ( state == INGAME ) || ( state == LOADING ) ) {
 		return &GetGameLobby();
 	} else if ( state == PARTY_LOBBY ) {
 		return &GetPartyLobby();
 	}
 	
 	return NULL;
 }
 
 /*
 ========================
 idSessionLocal::GetActivePlatformLobby
 ========================
 */
 const idLobby * idSessionLocal::GetActivePlatformLobby() const {
 	sessionState_t state = GetState();
 
 	if ( ( state == GAME_LOBBY ) || ( state == BUSY ) || ( state == INGAME ) || ( state == LOADING ) ) {
 		return &GetGameLobby();
 	} else if ( state == PARTY_LOBBY ) {
 		return &GetPartyLobby();
 	}
 	
 	return NULL;
 }
 
 /*
 ========================
 idSessionLocal::GetActingGameStateLobby
 ========================
 */
 idLobby & idSessionLocal::GetActingGameStateLobby() {
 	if ( net_useGameStateLobby.GetBool() ) {
 		return GetGameStateLobby();
 	}
 
 	return GetGameLobby();
 }
 
 /*
 ========================
 idSessionLocal::GetActingGameStateLobby
 ========================
 */
 const idLobby & idSessionLocal::GetActingGameStateLobby() const {
 	if ( net_useGameStateLobby.GetBool() ) {
 		return GetGameStateLobby();
 	}
 
 	return GetGameLobby();
 }
 
 /*
 ========================
 idSessionLocal::GetLobbyFromType
 ========================
 */
 idLobby * idSessionLocal::GetLobbyFromType( idLobby::lobbyType_t lobbyType ) {
 	switch ( lobbyType ) {
 		case idLobby::TYPE_PARTY:		return &GetPartyLobby();
 		case idLobby::TYPE_GAME:		return &GetGameLobby();
 		case idLobby::TYPE_GAME_STATE:	return &GetGameStateLobby();
 	}
 
 	return NULL;
 }
 
 /*
 ========================
 idSessionLocal::GetActivePlatformLobbyBase
 This returns the base version for the idSession version
 ========================
 */
 idLobbyBase & idSessionLocal::GetActivePlatformLobbyBase() {
 	idLobby * activeLobby = GetActivePlatformLobby();
 
 	if ( activeLobby != NULL ) {
 		return *activeLobby;
 	}
 
 	return stubLobby;		// So we can return at least something
 }
 
 /*
 ========================
 idSessionLocal::GetLobbyFromLobbyUserID
 ========================
 */
 idLobbyBase & idSessionLocal::GetLobbyFromLobbyUserID( lobbyUserID_t lobbyUserID ) {
 	if ( !lobbyUserID.IsValid() ) {
 		return stubLobby;	// So we can return at least something
 	}
 
 	idLobby * lobby = GetLobbyFromType( (idLobby::lobbyType_t)lobbyUserID.GetLobbyType() );
 
 	if ( lobby != NULL ) {
 		return *lobby;
 	}
 
 	return stubLobby;		// So we can return at least something
 }
 
 /*
 ========================
 idSessionLocal::TickSendQueue
 ========================
 */
 void idSessionLocal::TickSendQueue() {
 	assert( !sendQueue.IsEmpty() );
 	int now = Sys_Milliseconds();
 	idQueuePacket * packet = sendQueue.Peek();
 	while ( packet != NULL ) {
 		if ( now < packet->time ) {
 			break;
 		}
 
 		GetPort( packet->dedicated ).SendRawPacket( packet->address, packet->data, packet->size );
 
 		if ( net_forceUpstream.GetFloat() != 0.0f && net_forceUpstreamQueue.GetFloat() != 0.0f ) {
 			// FIXME: no can do both
 			assert( net_forceLatency.GetInteger() == 0 );
 			// compute / update an added traffic due to the queuing
 			// we can't piggyback on upstreamDropRate because of the way it's computed and clamped to zero
 			int time = Sys_Milliseconds();
 			if ( time > upstreamQueueRateTime ) {
 				upstreamQueueRate -= upstreamQueueRate * ( float )( time - upstreamQueueRateTime ) / 1000.0f;
 				if ( upstreamQueueRate < 0.0f ) {
 					upstreamQueueRate = 0.0f;
 				}
 				upstreamQueueRateTime = time;
 			}
 			// update queued bytes
 			queuedBytes -= packet->size;
 			if ( net_verboseSimulatedTraffic.GetBool() ) {
 				idLib::Printf( "send queued packet size %d to %s\n", packet->size, packet->address.ToString() );
 			}
 		}
 
 		sendQueue.RemoveFirst(); // we have it already, just push it off the queue before freeing
 		packetAllocator.Free( packet );
 		packet = sendQueue.Peek();
 	}
 }
 
 /*
 ========================
 idSessionLocal::QueuePacket
 ========================
 */
 void idSessionLocal::QueuePacket( idQueue< idQueuePacket,&idQueuePacket::queueNode > & queue, int time, const lobbyAddress_t & to, const void * data, int size, bool dedicated ) {
 	//mem.PushHeap();
 
 	idQueuePacket * packet = packetAllocator.Alloc();
 
 	packet->address		= to;
 	packet->size		= size;
 	packet->dedicated	= dedicated;
 	packet->time		= time;
 
 	memcpy( packet->data, data, size );
 
 	queue.Add( packet );
 
 	//mem.PopHeap();
 }
 
 /*
 ========================
 idSessionLocal::ReadRawPacketFromQueue
 ========================
 */
 bool idSessionLocal::ReadRawPacketFromQueue( int time, lobbyAddress_t & from, void * data, int & size, bool & outDedicated, int maxSize ) {
 	idQueuePacket * packet = recvQueue.Peek();
 
 	if ( packet == NULL || time < packet->time ) {
 		return false;		// Either there are no packets, or no packet is ready
 	}
 
 	//idLib::Printf( "NET: Packet recvd: %d ms\n", now );
 
 	from = packet->address;
 	size = packet->size;
 	assert( size <= maxSize );
 	outDedicated = packet->dedicated;
 	memcpy( data, packet->data, packet->size );
 	recvQueue.RemoveFirst(); // we have it already, just push it off the queue before freeing
 	packetAllocator.Free( packet );
 
 	return true;
 }
 
 /*
 ========================
 idSessionLocal::SendRawPacket
 ========================
 */
 void idSessionLocal::SendRawPacket( const lobbyAddress_t & to, const void * data, int size, bool dedicated ) {
 	const int now = Sys_Milliseconds();
 
 	if ( net_forceUpstream.GetFloat() != 0 ) {
 
 		// the total bandwidth rate at which the networking systems are trying to push data through
 		float totalOutgoingRate = (float)GetActingGameStateLobby().GetTotalOutgoingRate(); // B/s
 
 		// update the rate at which we have been taking data out by dropping it
 		int time = Sys_Milliseconds();
 		if ( time > upstreamDropRateTime ) {
 			upstreamDropRate -= upstreamDropRate * ( float )( time - upstreamDropRateTime ) / 1000.0f;
 			if ( upstreamDropRate < 0.0f ) {
 				upstreamDropRate = 0.0f;
 			}
 			upstreamDropRateTime = time;
 		}
 
 		if ( (float)( totalOutgoingRate - upstreamDropRate + upstreamQueueRate ) > net_forceUpstream.GetFloat() * 1024.0f ) { // net_forceUpstream is in kB/s, everything else in B/s
 			if ( net_forceUpstreamQueue.GetFloat() == 0.0f ) {
 				// just drop the packet - not representative, but simple
 				if ( net_verboseSimulatedTraffic.GetBool() ) {
 					idLib::Printf( "drop %d bytes to %s\n", size, to.ToString() );
 				}
 				// increase the instant drop rate with the data we just dropped
 				upstreamDropRate += size;
 				return;
 			}
 
 			// simulate a network device with a send queue
 			// do we have room in the queue?
 			assert( net_forceUpstreamQueue.GetFloat() > 0.0f );
 			if ( (float)( queuedBytes + size ) > net_forceUpstreamQueue.GetFloat() * 1024.0f ) { // net_forceUpstreamQueue is in kB/s
 				// too much queued, this is still a drop
 				// FIXME: factorize
 				// just drop the packet - not representative, but simple
 				if ( net_verboseSimulatedTraffic.GetBool() ) {
 					idLib::Printf( "full queue: drop %d bytes to %s\n", size, to.ToString() );
 				}
 				// increase the instant drop rate with the data we just dropped
 				upstreamDropRate += size;
 				return;
 			}
 			// there is room to buffer up in the queue
 			queuedBytes += size;
 			// with queuedBytes and the current upstream, when should this packet be sent?
 			int queuedPacketSendDelay = 1000.0f * ( (float)queuedBytes / ( net_forceUpstream.GetFloat() * 1024.0f ) ); // in ms
 			// queue for sending
 			if ( net_verboseSimulatedTraffic.GetBool() ) {
 				idLib::Printf( "queuing packet: %d bytes delayed %d ms\n", size, queuedPacketSendDelay );
 			}
 
 			QueuePacket( sendQueue, now + queuedPacketSendDelay, to, data, size, dedicated );
 
 			// will abuse the forced latency code below to take care of the sending
 			// FIXME: right now, can't have both on
 			assert( net_forceLatency.GetInteger() == 0 );
 		}
 	}
 
 	// short path
 	// NOTE: network queuing: will go to tick the queue whenever sendQueue isn't empty, regardless of latency
 	if ( net_forceLatency.GetInteger() == 0 && sendQueue.IsEmpty() ) {
 		GetPort( dedicated ).SendRawPacket( to, data, size );
 		return;
 	}
 
 	if ( net_forceUpstream.GetFloat() != 0.0f && net_forceUpstreamQueue.GetFloat() != 0.0f ) {
 		// FIXME: not doing both just yet
 		assert( net_forceLatency.GetInteger() == 0 );
 		TickSendQueue();
 		return; // we done (at least for queue only path)
 	}
 
 	// queue up
 	assert( size != 0 && size <= idPacketProcessor::MAX_FINAL_PACKET_SIZE );
 
 	QueuePacket( sendQueue, now + net_forceLatency.GetInteger() / 2, to, data, size, dedicated );
 
 	TickSendQueue();
 }
 
 /*
 ========================
 idSessionLocal::ReadRawPacket
 ========================
 */
 bool idSessionLocal::ReadRawPacket( lobbyAddress_t & from, void * data, int & size, bool & outDedicated, int maxSize ) {
 	SCOPED_PROFILE_EVENT( "Session::ReadRawPacket" );
 
 	assert( maxSize <= idPacketProcessor::MAX_FINAL_PACKET_SIZE );
 
 	if ( !sendQueue.IsEmpty() ) {
 		TickSendQueue();
 	}
 
 	const int now = Sys_Milliseconds();
 
 	// Make sure we give both ports equal time
 	static bool currentDedicated = false;
 	currentDedicated = !currentDedicated;
 
 	for ( int i = 0; i < 2; i++ ) {
 		// BRIAN_FIXME: Dedicated servers fuck up running 2 instances on the same machine
 		// outDedicated = ( i == 0 ) ? currentDedicated : !currentDedicated;
 		outDedicated = false;
 
 		if ( GetPort( outDedicated ).ReadRawPacket( from, data, size, maxSize ) ) {
 			if ( net_forceLatency.GetInteger() == 0 && recvQueue.IsEmpty() ) {
 				// If we aren't forcing latency, and queue is empty, return result immediately
 				return true;
 			}
 			
 			// the cvar is meant to be a round trip latency so we're applying half on the send and half on the recv
 			const int time = ( net_forceLatency.GetInteger() == 0 ) ? 0 : now + net_forceLatency.GetInteger() / 2;
 
 			// Otherwise, queue result
 			QueuePacket( recvQueue, time, from, data, size, outDedicated );
 		}
 	}
 
 	// Return any queued results
 	return ReadRawPacketFromQueue( now, from, data, size, outDedicated, maxSize );
 }
 
 /*
 ========================
 idSessionLocal::ConnectAndMoveToLobby
 ========================
 */
 void idSessionLocal::ConnectAndMoveToLobby( idLobby & lobby, const lobbyConnectInfo_t & connectInfo, bool fromInvite ) {
 
 	// Since we are connecting directly to a lobby, make sure no search results are left over from previous FindOrCreateMatch results
 	// If we don't do this, we might think we should attempt to connect to an old search result, and we don't want to in this case
 	lobby.searchResults.Clear();
 
 	// Attempt to connect to the lobby
 	lobby.ConnectTo( connectInfo, fromInvite );
 
 	connectType = CONNECT_DIRECT;
 
 	// Wait for connection
 	switch ( lobby.lobbyType ) {
 		case idLobby::TYPE_PARTY:		SetState( STATE_CONNECT_AND_MOVE_TO_PARTY );		break;
 		case idLobby::TYPE_GAME:		SetState( STATE_CONNECT_AND_MOVE_TO_GAME );			break;
 		case idLobby::TYPE_GAME_STATE:	SetState( STATE_CONNECT_AND_MOVE_TO_GAME_STATE );	break;
 	}
 }
 
 /*
 ========================
 idSessionLocal::GoodbyeFromHost
 ========================
 */
 void idSessionLocal::GoodbyeFromHost( idLobby & lobby, int peerNum, const lobbyAddress_t & remoteAddress, int msgType ) {
 	if ( !verify( localState > STATE_IDLE ) ) {
 		idLib::Printf( "NET: Got disconnected from host %s on session %s when we were not in a lobby or game.\n", remoteAddress.ToString(), lobby.GetLobbyName() );
 		MoveToMainMenu();
 		return;		// Ignore if we are not past the main menu
 	}
 
 	// Goodbye from host.  See if we were connecting vs connected
 	if ( ( localState == STATE_CONNECT_AND_MOVE_TO_PARTY || localState == STATE_CONNECT_AND_MOVE_TO_GAME ) && lobby.peers[peerNum].GetConnectionState() == idLobby::CONNECTION_CONNECTING ) {
 		// We were denied a connection attempt
 		idLib::Printf( "NET: Denied connection attempt from host %s on session %s. MsgType %i.\n", remoteAddress.ToString(), lobby.GetLobbyName(), msgType );
 		// This will try to move to the next connection if one exists, otherwise will create a match
 		HandleConnectionFailed( lobby, msgType == idLobby::OOB_GOODBYE_FULL );
 	} else {
 		// We were disconnected from a server we were previously connected to
 		idLib::Printf( "NET: Disconnected from host %s on session %s. MsgType %i.\n", remoteAddress.ToString(), lobby.GetLobbyName(), msgType );
 
 		const bool leaveGameWithParty = ( msgType == idLobby::OOB_GOODBYE_W_PARTY );
 
 		if ( leaveGameWithParty && lobby.lobbyType == idLobby::TYPE_GAME && lobby.IsPeer() && GetState() == idSession::GAME_LOBBY && GetPartyLobby().host >= 0 &&
 				lobby.peers[peerNum].address.Compare( GetPartyLobby().peers[GetPartyLobby().host].address, true ) ) {
 			// If a host is telling us goodbye from a game lobby, and the game host is the same as our party host, 
 			// and we aren't in a game, and the host wants us to leave with him, then do so now
 			GetGameLobby().Shutdown();
 			GetGameStateLobby().Shutdown();
 			SetState( STATE_PARTY_LOBBY_PEER );
 		} else {
 			// Host left, so pick a new host (possibly even us) for this lobby
 			lobby.PickNewHost();
 		}
 	}
 }
 
 /*
 ========================
 idSessionLocal::WriteLeaderboardToMsg
 ========================
 */
 void idSessionLocal::WriteLeaderboardToMsg( idBitMsg & msg, const leaderboardDefinition_t * leaderboard, const column_t * stats ) {
 	assert( Sys_FindLeaderboardDef( leaderboard->id ) == leaderboard );
 	
 	msg.WriteLong( leaderboard->id );
 
 	for ( int i = 0; i < leaderboard->numColumns; ++i ) {
 		uint64 value = stats[i].value;
 
 		//idLib::Printf( "value = %i\n", (int32)value );
 
 		for ( int j = 0; j < leaderboard->columnDefs[i].bits; j++ ) {
 			msg.WriteBits( value & 1, 1 );
 			value >>= 1;
 		}
 		//msg.WriteData( &stats[i].value, sizeof( stats[i].value ) );
 	}
 }
 
 /*
 ========================
 idSessionLocal::ReadLeaderboardFromMsg
 ========================
 */
 const leaderboardDefinition_t * idSessionLocal::ReadLeaderboardFromMsg( idBitMsg & msg, column_t * stats ) {
 	int id = msg.ReadLong();
 	
 	const leaderboardDefinition_t * leaderboard = Sys_FindLeaderboardDef( id );
 	
 	if ( leaderboard == NULL ) {
 		idLib::Printf( "NET: Invalid leaderboard id: %i\n", id );
 		return NULL;
 	}
 	
 	for ( int i = 0; i < leaderboard->numColumns; ++i ) {
 		uint64 value = 0;
 
 		for ( int j = 0; j < leaderboard->columnDefs[i].bits; j++ ) {
 			value |= (uint64)( msg.ReadBits( 1 ) & 1 ) << j;
 		}
 
 		stats[i].value = value;
 
 		//idLib::Printf( "value = %i\n", (int32)value );
 		//msg.ReadData( &stats[i].value, sizeof( stats[i].value ) );
 	}
 	
 	return leaderboard;
 }
 
 /*
 ========================
 idSessionLocal::SendLeaderboardStatsToPlayer
 ========================
 */
 void idSessionLocal::SendLeaderboardStatsToPlayer( lobbyUserID_t lobbyUserID, const leaderboardDefinition_t * leaderboard, const column_t * stats ) {
 
 	const int sessionUserIndex = GetActingGameStateLobby().GetLobbyUserIndexByID( lobbyUserID );
 
 	if ( GetActingGameStateLobby().IsLobbyUserDisconnected( sessionUserIndex ) ) {
 		idLib::Warning( "Tried to tell disconnected user to report stats" );
 		return;
 	}
 	
 	const int peerIndex = GetActingGameStateLobby().PeerIndexFromLobbyUser( lobbyUserID );
 	
 	if ( peerIndex == -1 ) {
 		idLib::Warning( "Tried to tell invalid peer index to report stats" );
 		return;
 	}
 
 	if ( !verify( GetActingGameStateLobby().IsHost() ) || 
 		!verify( peerIndex < GetActingGameStateLobby().peers.Num() ) || 
 		!verify( GetActingGameStateLobby().peers[ peerIndex ].IsConnected() ) ) {
 		idLib::Warning( "Tried to tell invalid peer to report stats" );
 		return;
 	}
 
 	NET_VERBOSE_PRINT( "Telling sessionUserIndex %i (peer %i) to report stats\n", sessionUserIndex, peerIndex );
 
 	lobbyUser_t * gameUser = GetActingGameStateLobby().GetLobbyUser( sessionUserIndex );
 
 	if ( !verify( gameUser != NULL ) ) {
 		return;
 	}
 
 	byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
 	idBitMsg msg( buffer, sizeof( buffer ) );
 
 	// Use the user ID
 	gameUser->lobbyUserID.WriteToMsg( msg );
 
 	WriteLeaderboardToMsg( msg, leaderboard, stats );
 	
 	GetActingGameStateLobby().QueueReliableMessage( peerIndex, idLobby::RELIABLE_POST_STATS, msg.GetReadData(), msg.GetSize() );
 }
 
 /*
 ========================
 idSessionLocal::RecvLeaderboardStatsForPlayer
 ========================
 */
 void idSessionLocal::RecvLeaderboardStatsForPlayer( idBitMsg & msg ) {
 	column_t stats[ MAX_LEADERBOARD_COLUMNS ];
 
 	lobbyUserID_t lobbyUserID;
 	lobbyUserID.ReadFromMsg( msg );
 
 	const leaderboardDefinition_t * leaderboard = ReadLeaderboardFromMsg( msg, stats );
 	
 	if ( leaderboard == NULL ) {
 		idLib::Printf( "RecvLeaderboardStatsForPlayer: Invalid lb.\n" );
 		return;
 	}
 
 	LeaderboardUpload( lobbyUserID, leaderboard, stats );
 }
 
 /*
 ========================
 idSessionLocal::RequirePersistentMaster
 ========================
 */
 bool idSessionLocal::RequirePersistentMaster() {
 	return signInManager->RequirePersistentMaster();
 }
 
 /*
 ========================
 CheckAndUpdateValue
 ========================
 */
 template<typename T>
 bool CheckAndUpdateValue( T & value, const T & newValue ) {
 	if ( value == newValue ) {
 		return false;
 	}
 	value = newValue;
 	return true;
 }
 
 /*
 ========================
 lobbyUser_t::UpdateClientMutableData
 ========================
 */
 bool lobbyUser_t::UpdateClientMutableData( const idLocalUser * localUser ) {
 	bool updated = false;
 	const idPlayerProfile * profile = localUser->GetProfile();
 	if ( profile != NULL ) {
 		updated |= CheckAndUpdateValue( level, profile->GetLevel() );
 	}
 	updated |= CheckAndUpdateValue( selectedSkin, ui_skinIndex.GetInteger() );
 	updated |= CheckAndUpdateValue( weaponAutoSwitch, ui_autoSwitch.GetBool() );
 	updated |= CheckAndUpdateValue( weaponAutoReload, ui_autoReload.GetBool() );
 	return updated;
 }
 
 /*
 ========================
 idSessionLocal::ComputeNextGameCoalesceTime
 ========================
 */
 void idSessionLocal::ComputeNextGameCoalesceTime() {
 	const int coalesceTimeInSeconds			= session->GetTitleStorageInt( "net_LobbyCoalesceTimeInSeconds", net_LobbyCoalesceTimeInSeconds.GetInteger() );
 	const int randomCoalesceTimeInSeconds	= session->GetTitleStorageInt( "net_LobbyRandomCoalesceTimeInSeconds", net_LobbyRandomCoalesceTimeInSeconds.GetInteger() );
 
 	if ( coalesceTimeInSeconds != 0 ) {
 		static idRandom2 random( Sys_Milliseconds() );
 
 		nextGameCoalesceTime = Sys_Milliseconds() + ( coalesceTimeInSeconds + random.RandomInt( randomCoalesceTimeInSeconds ) ) * 1000;
 	} else {
 		nextGameCoalesceTime = 0;
 	}
 }
 
 /*
 ========================
 lobbyUser_t::Net_BandwidthChallenge
 ========================
 */
 CONSOLE_COMMAND( Net_BandwidthChallenge, "Test network bandwidth", 0 ) {
 	session->StartOrContinueBandwidthChallenge( true );
 }
 
 /*
 ========================
 lobbyUser_t::Net_ThrottlePeer
 ========================
 */
 CONSOLE_COMMAND( Net_ThrottlePeer, "Test network bandwidth", 0 ) {
 	
 	int peerNum = -1;
 	int snapRate = 0;
 
 	if ( args.Argc() >= 3 ) {		
 		peerNum = atoi( args.Argv(1) );
 		snapRate = atoi( args.Argv(2) );		
 	}
 
 	// Note DebugSetPeerSnaprate will handle peerNum=-1 by printing out list of peers
 	session->DebugSetPeerSnaprate( peerNum, snapRate );
 }
 
 
 // FIXME: Move to sys_stats.cpp
 idStaticList< leaderboardDefinition_t *, MAX_LEADERBOARDS > registeredLeaderboards;
 
 /*
 ========================
 Sys_FindLeaderboardDef
 ========================
 */
 const leaderboardDefinition_t * Sys_FindLeaderboardDef( int id ) {
 	for ( int i = 0; i < registeredLeaderboards.Num() ; i++ ) {
 		if ( registeredLeaderboards[i] && registeredLeaderboards[i]->id == id ) {
 			return registeredLeaderboards[i];
 		}
 	}
 	
 	return NULL;
 }
 
 /*
 ========================
 Sys_CreateLeaderboardDef
 ========================
 */
 leaderboardDefinition_t * Sys_CreateLeaderboardDef( int id_, int numColumns_, const columnDef_t * columnDefs_,
 													rankOrder_t rankOrder_, bool supportsAttachments_, bool checkAgainstCurrent_ ) {
 	
 	leaderboardDefinition_t * newDef = new (TAG_NETWORKING) leaderboardDefinition_t(	id_, numColumns_, columnDefs_, rankOrder_, supportsAttachments_, checkAgainstCurrent_ );	
 
 	// try and reuse a free spot
 	int leaderboardHandle = registeredLeaderboards.FindNull();
 
 	if ( leaderboardHandle == -1 ) {
 		leaderboardHandle = registeredLeaderboards.Append( NULL );
 	} 
 
 	registeredLeaderboards[ leaderboardHandle ]  = newDef;
 
 	return newDef;
 }
 
 /*
 ========================
 Sys_CreateLeaderboardDef
 ========================
 */
 void Sys_DestroyLeaderboardDefs() {
 
 	// delete and clear all the contents of the registeredLeaderboards static list. 
 	registeredLeaderboards.DeleteContents( true );
 }
 
 /*
 ========================
 idSessionLocal::StartOrContinueBandwidthChallenge
 This will start a bandwidth test if one is not active
 returns true if a test has completed
 ========================
 */
 bool idSessionLocal::StartOrContinueBandwidthChallenge( bool forceStart ) {
 	idLobby * activeLobby = GetActivePlatformLobby();
 	if ( activeLobby == NULL ) {
 		idLib::Warning("No active session lobby when idSessionLocal::StartBandwidthChallenge called");
 		return true;
 	}
 
 	if ( !forceStart && activeLobby->bandwidthChallengeFinished ) {
 		activeLobby->bandwidthChallengeFinished = false;
 		return true;
 	}
 
 	if ( !activeLobby->BandwidthTestStarted() ) {
 		activeLobby->BeginBandwidthTest();
 	}
 
 	return false;
 }
 
 /*
 ========================
 idSessionLocal::DebugSetPeerSnaprate
 This is debug function for manually setting peer's snaprate in game
 ========================
 */
 void idSessionLocal::DebugSetPeerSnaprate( int peerIndex, int snapRateMS ) {
 	idLobby * activeLobby = GetActivePlatformLobby();
 	if ( activeLobby == NULL ) {
 		idLib::Warning("No active session lobby when idSessionLocal::StartBandwidthChallenge called");
 		return;
 	}
 
 	if ( peerIndex < 0 || peerIndex > activeLobby->peers.Num() ) {
 		idLib::Printf("Invalid peer %d\n", peerIndex );
 		for ( int i=0; i < activeLobby->peers.Num(); i++ ) {
 			idLib::Printf( "Peer[%d] %s\n", i, activeLobby->GetPeerName(i) );
 		}
 		return;
 	}
 
 	activeLobby->peers[peerIndex].throttledSnapRate = snapRateMS * 1000;
 	activeLobby->peers[peerIndex].receivedThrottle = 0;
 	idLib::Printf( "Set peer %s new snapRate: %d\n", activeLobby->GetPeerName(peerIndex), activeLobby->peers[peerIndex].throttledSnapRate );
 }
 
 /*
 ========================
 idSessionLocal::DebugSetPeerSnaprate
 This is debug function for manually setting peer's snaprate in game
 ========================
 */
 float idSessionLocal::GetIncomingByteRate() {
 	idLobby * activeLobby = GetActivePlatformLobby();
 	if ( activeLobby == NULL ) {
 		idLib::Warning("No active session lobby when idSessionLocal::GetIncomingByteRate called");
 		return 0;
 	}
 
 	float total = 0;
 	for ( int p=0; p < activeLobby->peers.Num(); p++ ) {
 		if ( activeLobby->peers[p].IsConnected() ) {
 			total += activeLobby->peers[p].packetProc->GetIncomingRateBytes();
 		}
 	}
 
 	return total;
 }
 
 /*
 ========================
 idSessionLocal::OnLocalUserSignin
 ========================
 */
 void idSessionLocal::OnLocalUserSignin( idLocalUser * user ) {
 	// Do stuff before calling OnMasterLocalUserSignin()
 	session->GetAchievementSystem().RegisterLocalUser( user );
 
 	// We may not have a profile yet, need to call user's version...
 	user->LoadProfileSettings();
 
 	// for all consoles except the PS3 we enumerate right away because they don't 
 	// take such a long time as the PS3. PS3 enumeration is done in the 
 	// background and kicked off when the profile callback is triggered
 	if ( user == GetSignInManager().GetMasterLocalUser() ) {
 		OnMasterLocalUserSignin();
 	}
 }
 
 /*
 ========================
 idSessionLocal::OnLocalUserSignout
 ========================
 */
 void idSessionLocal::OnLocalUserSignout( idLocalUser * user ) {
 	// Do stuff before calling OnMasterLocalUserSignout()
 	session->GetAchievementSystem().RemoveLocalUser( user );
 
 	if ( GetSignInManager().GetMasterLocalUser() == NULL ) {
 		OnMasterLocalUserSignout();
 	}
 }
 
 /*
 ========================
 idSessionLocal::OnMasterLocalUserSignout
 ========================
 */
 void idSessionLocal::OnMasterLocalUserSignout() {
 	CancelSaveGameWithHandle( enumerationHandle );
 	enumerationHandle = 0;
 	GetSaveGameManager().GetEnumeratedSavegamesNonConst().Clear();
 }
 
 /*
 ========================
 idSessionLocal::OnMasterLocalUserSignin
 ========================
 */
 void idSessionLocal::OnMasterLocalUserSignin() {
 	enumerationHandle = EnumerateSaveGamesAsync();
 }
 
 /*
 ========================
 idSessionLocal::OnLocalUserProfileLoaded
 ========================
 */
 void idSessionLocal::OnLocalUserProfileLoaded( idLocalUser * user ) {
 	user->RequestSyncAchievements();
 }
 
 /*
 ========================
 idSessionLocal::SetVoiceGroupsToTeams
 ========================
 */
 void idSessionLocal::SetVoiceGroupsToTeams() {
 	// move voice chat to team 
 	int myTeam = 0;
 	for ( int i = 0; i < GetGameLobby().GetNumLobbyUsers(); ++i ) {
 		const lobbyUser_t * gameUser = GetGameLobby().GetLobbyUser( i );
 
 		if ( !verify( gameUser != NULL ) ) {
 			continue;
 		}
 
 		if ( gameUser->IsDisconnected() ) {
 			continue;
 		}
 
 		int userTeam = gameUser->teamNumber;
 
 		voiceChat->SetTalkerGroup( gameUser, GetGameLobby().lobbyType, userTeam );
 
 		if ( GetGameLobby().IsSessionUserIndexLocal( i ) ) {
 			myTeam = userTeam;
 		} 
 	}
 
 	SetActiveChatGroup( myTeam );
 }
 
 /*
 ========================
 idSessionLocal::ClearVoiceGroups
 ========================
 */
 void idSessionLocal::ClearVoiceGroups() {
 	for ( int i = 0; i < GetGameLobby().GetNumLobbyUsers(); ++i ) {
 		const lobbyUser_t * gameUser = GetGameLobby().GetLobbyUser( i );
 
 		if ( !verify( gameUser != NULL ) ) {
 			continue;
 		}
 
 		if ( gameUser->IsDisconnected() ) {
 			continue;
 		}
 
 		voiceChat->SetTalkerGroup( gameUser, GetGameLobby().lobbyType, 0 );
 	}
 
 	SetActiveChatGroup( 0 );
 }
 
 /*
 ========================
 idSessionLocal::SendVoiceAudio
 ========================
 */
 void idSessionLocal::SendVoiceAudio() {
 	if ( voiceChat == NULL ) {
 		return;
 	}
 
 	idLobby * activeLobby = GetActivePlatformLobby();
 
 	int activeSessionIndex = ( activeLobby != NULL ) ? activeLobby->lobbyType : -1;
 
 	voiceChat->SetActiveLobby( activeSessionIndex );
 	voiceChat->Pump();
 
 	if ( activeLobby == NULL ) {
 		return;
 	}
 
 	int time = Sys_Milliseconds();
 
 	const int VOICE_THROTTLE_TIME_IN_MS	= session->GetTitleStorageInt( "VOICE_THROTTLE_TIME_IN_MS", 33) ;		// Don't allow faster than 30hz send rate
 
 	if ( time - lastVoiceSendtime < VOICE_THROTTLE_TIME_IN_MS ) {
 		return;
 	}
 
 	lastVoiceSendtime = time;
 
 	idStaticList< int, MAX_PLAYERS > localTalkers;
 	
 	voiceChat->GetActiveLocalTalkers( localTalkers );
 	
 	for ( int i = 0; i < localTalkers.Num(); i++ ) {
 						
 		// NOTE - For 360, we don't need more than XHV_MAX_VOICECHAT_PACKETS * XHV_VOICECHAT_MODE_PACKET_SIZE bytes
 		const int MAX_VDP_DATA_SIZE = 1000;
 
 		byte buffer[MAX_VDP_DATA_SIZE];
 		
 		const int titleStorageDataSize = session->GetTitleStorageInt( "MAX_VDP_DATA_SIZE", 1000 );
 		const int dataSizeAvailable = Min< int >( titleStorageDataSize, sizeof( buffer ) );
 
 		// in-out parameter
 		int dataSize = dataSizeAvailable;
 		if ( !voiceChat->GetLocalChatData( localTalkers[i], buffer, dataSize ) ) {
 			continue;
 		}
 		assert( dataSize <= sizeof( buffer ) );
 
 		idStaticList< const lobbyAddress_t *, MAX_PLAYERS > recipients;
 		
 		voiceChat->GetRecipientsForTalker( localTalkers[i], recipients );
 
 		for ( int j = 0; j < recipients.Num(); j++ ) {
 			activeLobby->SendConnectionLess( *recipients[j], idLobby::OOB_VOICE_AUDIO, buffer, dataSize );
 		}		
 	}
 }
 
 /*
 ========================
 idSessionLocal::HandleOobVoiceAudio
 ========================
 */
 void idSessionLocal::HandleOobVoiceAudio( const lobbyAddress_t & from, const idBitMsg & msg ) {
 
 	idLobby * activeLobby = GetActivePlatformLobby();
 	
 	if ( activeLobby == NULL ) {
 		return;
 	}
 
 	voiceChat->SetActiveLobby( activeLobby->lobbyType );
 
 	voiceChat->SubmitIncomingChatData( msg.GetReadData() + msg.GetReadCount(), msg.GetRemainingData() );
 }
 
 /*
 ========================
 idSessionLocal::SetActiveChatGroup
 ========================
 */
 void idSessionLocal::SetActiveChatGroup( int groupIndex ) { 
 	voiceChat->SetActiveChatGroup( groupIndex );
 }
 
 /*
 ========================
 idSessionLocal::GetLobbyUserVoiceState
 ========================
 */
 voiceState_t idSessionLocal::GetLobbyUserVoiceState( lobbyUserID_t lobbyUserID ) {
 	idLobby * activeLobby = GetActivePlatformLobby();
 
 	if ( activeLobby == NULL ) {
 		return VOICECHAT_STATE_NOT_TALKING;
 	}
 
 	const lobbyUser_t * user = activeLobby->GetLobbyUserByID( lobbyUserID );
 
 	if ( !verify( user != NULL ) ) {
 		return VOICECHAT_STATE_NOT_TALKING;
 	}
 
 	return voiceChat->GetVoiceState( user );
 }
 
 /*
 ========================
 idSessionLocal::GetDisplayStateFromVoiceState
 ========================
 */
 voiceStateDisplay_t idSessionLocal::GetDisplayStateFromVoiceState( voiceState_t voiceState ) const {
 	if ( ( GetState() == GAME_LOBBY && MatchTypeIsLocal( GetGameLobby().GetMatchParms().matchFlags ) )
 			|| ( GetState() == PARTY_LOBBY && MatchTypeIsLocal( GetPartyLobby().GetMatchParms().matchFlags ) ) ) {
 		return VOICECHAT_DISPLAY_NONE;	// never show voice stuff in splitscreen
 	}
 
 	switch ( voiceState ) {
 		case VOICECHAT_STATE_MUTED_REMOTE:
 		case VOICECHAT_STATE_MUTED_LOCAL:
 		case VOICECHAT_STATE_MUTED_ALL:
 			return VOICECHAT_DISPLAY_MUTED;
 		case VOICECHAT_STATE_NOT_TALKING:
 			return VOICECHAT_DISPLAY_NOTTALKING;
 		case VOICECHAT_STATE_TALKING:
 			return VOICECHAT_DISPLAY_TALKING;
 		case VOICECHAT_STATE_TALKING_GLOBAL:
 			return VOICECHAT_DISPLAY_TALKING_GLOBAL;
 		case VOICECHAT_STATE_NO_MIC:
 		default:
 			return VOICECHAT_DISPLAY_NOTTALKING;
 	}
 }
 
 /*
 ========================
 idSessionLocal::ToggleLobbyUserVoiceMute
 ========================
 */
 void idSessionLocal::ToggleLobbyUserVoiceMute( lobbyUserID_t lobbyUserID ) {
 	idLobby * activeLobby = GetActivePlatformLobby();
 
 	if ( activeLobby == NULL ) {
 		return;
 	}
 
 	// Get the master local user
 	idLocalUser * masterUser = signInManager->GetMasterLocalUser();
 
 	if ( masterUser == NULL ) {
 		return;
 	}
 
 	const lobbyUser_t * srcUser = activeLobby->GetLobbyUser( activeLobby->GetLobbyUserIndexByLocalUserHandle( masterUser->GetLocalUserHandle() ) );
 
 	if ( srcUser == NULL ) {
 		return;
 	}
 
 	const lobbyUser_t * targetUser = activeLobby->GetLobbyUserByID( lobbyUserID );
 
 	if ( !verify( targetUser != NULL ) ) {
 		return;
 	}
 
 	if ( srcUser == targetUser ) {
 		return;		// Can't toggle yourself
 	}
 
 	voiceChat->ToggleMuteLocal( srcUser, targetUser );
 }
 
 /*
 ========================
 idSessionLocal::UpdateMasterUserHeadsetState
 ========================
 */
 void idSessionLocal::UpdateMasterUserHeadsetState()
 {
 	if ( GetState() != PARTY_LOBBY && GetState() != GAME_LOBBY && GetState() != INGAME ) {
 		return;
 	}
 
 	lobbyUser_t * user = GetActivePlatformLobby()->GetSessionUserFromLocalUser( signInManager->GetMasterLocalUser() );
 
 	// TODO: Is this possible?
 	if ( user == NULL ) {
 		return;
 	}
 
 	int talkerIndex = voiceChat->FindTalkerByUserId( user->lobbyUserID, GetActivePlatformLobby()->lobbyType );
 	bool voiceChanged = voiceChat->HasHeadsetStateChanged( talkerIndex );
 
 	if ( voiceChanged ) {
 		byte buffer[ idPacketProcessor::MAX_MSG_SIZE ];
 		idBitMsg msg( buffer, sizeof( buffer ) );
 		msg.WriteLong( 1 );
 		user->lobbyUserID.WriteToMsg( msg );
 		msg.WriteBool( voiceChat->GetHeadsetState( talkerIndex ) );
 
 		idLib::Printf( "Sending voicestate %d for user %d %s\n", voiceChat->GetHeadsetState( talkerIndex ), talkerIndex, user->gamertag );
 
 		if ( GetActivePlatformLobby()->IsHost() ) {
 			for ( int p = 0; p < GetActivePlatformLobby()->peers.Num(); p++ ) {
 				if ( GetActivePlatformLobby()->peers[p].IsConnected() ) {
 					GetActivePlatformLobby()->QueueReliableMessage( p, idLobby::RELIABLE_HEADSET_STATE, msg.GetReadData(), msg.GetSize() );
 				}
 			}
 
 		} else {
 			GetActivePlatformLobby()->QueueReliableMessage( GetActivePlatformLobby()->host, idLobby::RELIABLE_HEADSET_STATE, msg.GetReadData(), msg.GetSize() );
 		}
 	}
 	
 }
 
 /*
 ========================
 idSessionLocal::GetNumContentPackages
 ========================
 */
 int	idSessionLocal::GetNumContentPackages() const {
 	return downloadedContent.Num();
 }
 
 /*
 ========================
 idSessionLocal::GetContentPackageID
 ========================
 */
 int idSessionLocal::GetContentPackageID( int contentIndex ) const {
 	assert( contentIndex < MAX_CONTENT_PACKAGES );
 
 	if ( downloadedContent[ contentIndex ].isMounted ) {
 		return downloadedContent[ contentIndex ].dlcID;
 	}
 
 	return 0;
 }
 
 /*
 ========================
 idSessionLocal::GetContentPackagePath
 ========================
 */
 const char * idSessionLocal::GetContentPackagePath( int contentIndex ) const {
 	assert( contentIndex < MAX_CONTENT_PACKAGES );
 
 	if ( downloadedContent[ contentIndex ].isMounted ) {
 		return downloadedContent[ contentIndex ].rootPath.c_str();
 	}
 
 	return NULL;
 }
 
 /*
 ========================
 idSessionLocal::GetContentPackageIndexForID
 ========================
 */
 int idSessionLocal::GetContentPackageIndexForID( int contentID ) const {
 	int contentIndex = -1;
 
 	for ( int i = 0; i < downloadedContent.Num(); i++ ) {
 		if ( downloadedContent[i].dlcID == contentID ) {
 			contentIndex = i;
 			break;
 		}
 	}
 
 	return contentIndex;
 }
 
 /*
 ========================
 idSessionLocal::SetLobbyUserRelativeScore
 ========================
 */
 void idSessionLocal::SetLobbyUserRelativeScore( lobbyUserID_t lobbyUserID, int relativeScore, int team ) {
 	// All platforms but 360 stub this out
 }
 
 /*
 ========================
 idSessionLocal::ReadTitleStorage
 ========================
 */
 void idSessionLocal::ReadTitleStorage( void * buffer, int bufferLen ) {
 	// https://ps3.scedev.net/projects/ps3_sdk_docs/docs/ps3-en,NP_Lookup-Reference,sceNpLookupTitleSmallStorageAsync/1
 	// If the file is not on the server, this will be handled as though a file of 0 bytes were on the server.
 	// This means that 0 will be set to contentLength and 0 (for normal termination) will return for the return value.
 	// This situation can occur with problems in actual operation, so the application must be designed not to hang up even in such situations
 	//bufferLen = 0;
 
 	idLib::Printf( "ReadTitleStorage: %i bytes\n", bufferLen );
 
 #if !defined( ID_RETAIL ) || defined( ID_RETAIL_INTERNAL )
 	if ( net_ignoreTitleStorage.GetBool() ) {//&& idLib::GetProduction() < PROD_PRODUCTION ) {
 		idLib::Printf( "ReadTitleStorage: *********************** IGNORING ********************\n" );
 		return;
 	}
 #endif
 
 	//idScopedGlobalHeap	everythingHereGoesInTheGlobalHeap;
 
 	idParser parser( LEXFL_NOERRORS | LEXFL_NOFATALERRORS | LEXFL_NOSTRINGCONCAT );
 	parser.LoadMemory( ( const char* )buffer, bufferLen, "default.tss" );
 
 	bool valid = true;
 
 	while ( true ) {
 		idToken token;
 
 		if ( !parser.ReadToken( &token ) ) {
 			break;
 		}
 
 		if ( token.Icmp( "netvars" ) == 0 ) {
 			if ( !titleStorageVars.Parse( parser ) ) {
 				valid = false;
 				break;
 			}
 		} else {
 			valid = false;
 			break;
 		}
 	}
 
 	if ( valid ) {
 		titleStorageLoaded = true;
 		idLib::Printf( "ReadTitleStorage: SUCCESS\n" );
 		titleStorageVars.Print();
 	} else {
 		titleStorageLoaded = false;
 		idLib::Printf( "ReadTitleStorage: FAILED\n" );
 		titleStorageVars.Clear();
 	}
 }
 
 /*
 ========================
 idSessionLocal::ReadDLCInfo
 ========================
 */
 bool idSessionLocal::ReadDLCInfo( idDict & dlcInfo, void * buffer, int bufferLen ) {
 	idParser parser( LEXFL_NOERRORS | LEXFL_NOFATALERRORS | LEXFL_NOSTRINGCONCAT );
 	parser.LoadMemory( ( const char* )buffer, bufferLen, "info.txt" );
 
 	bool valid = true;
 
 	while ( true ) {
 		idToken token;
 
 		if ( !parser.ReadToken( &token ) ) {
 			break;
 		}
 
 		if ( token.Icmp( "dlcInfo" ) == 0 ) {
 			if ( !dlcInfo.Parse( parser ) ) {
 				valid = false;
 				break;
 			}
 		} else {
 			valid = false;
 			break;
 		}
 	}
 
 	return valid;
 }
 
 /*
 ========================
 idSessionLocal::IsPlatformPartyInLobby
 ========================
 */
 bool idSessionLocal::IsPlatformPartyInLobby() {
 	idLocalUser * user = session->GetSignInManager().GetMasterLocalUser();
 	idLobby * lobby = GetActivePlatformLobby();
 
 	if ( user == NULL || lobby == NULL ) {
 		return false;
 	}
 
 	if ( user->GetPartyCount() > MAX_PLAYERS || user->GetPartyCount() < 2 ) {
 		return false;
 	}
 
 	// TODO: Implement PC
 	return false;
 }
 
 /*
 ========================
 idSessionLocal::PrePickNewHost
 This is called when we have determined that we need to pick a new host.
 Call PickNewHostInternal to continue on with the host picking process.
 ========================
 */
 void idSessionLocal::PrePickNewHost( idLobby & lobby, bool forceMe, bool inviteOldHost ) {
 	NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: (%s)\n", lobby.GetLobbyName() );
 
 	if ( GetActivePlatformLobby() == NULL ) {
 		NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: GetActivePlatformLobby() == NULL (%s)\n", lobby.GetLobbyName() );
 		return;
 	}
 
 	// Check to see if we can migrate AT ALL
 	// This is checking for coop, we should make this a specific option (MATCH_ALLOW_MIGRATION)
 	if ( GetPartyLobby().parms.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) {
 		NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: MATCH_PARTY_INVITE_PLACEHOLDER (%s)\n", lobby.GetLobbyName() );
 
 		// Can't migrate, shut both lobbies down, and create a new match using the original parms
 		GetGameStateLobby().Shutdown();
 		GetGameLobby().Shutdown();
 		GetPartyLobby().Shutdown();
 		
 		// Throw up the appropriate dialog message so the player knows what happeend
 		if ( localState >= idSessionLocal::STATE_LOADING ) {
 			NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: localState >= idSessionLocal::STATE_LOADING (%s)\n", lobby.GetLobbyName() );
 			common->Dialog().AddDialog( GDM_BECAME_HOST_GAME_STATS_DROPPED, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true );
 		} else {
 			NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: localState < idSessionLocal::STATE_LOADING (%s)\n", lobby.GetLobbyName() );
 			common->Dialog().AddDialog( GDM_LOBBY_BECAME_HOST_GAME, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true  );
 		}
 
 		CreateMatch( GetActivePlatformLobby()->parms );
 
 		return;
 	}
 
 	// Check to see if the match is searchable
 	if ( GetState() >= idSession::GAME_LOBBY && MatchTypeIsSearchable( GetGameLobby().parms.matchFlags ) ) {
 		NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: MatchTypeIsSearchable (%s)\n", lobby.GetLobbyName() );
 		// Searchable games migrate lobbies independently, and don't need to stay in sync
 		lobby.PickNewHostInternal( forceMe, inviteOldHost );	
 		return;
 	}
 
 	//
 	// Beyond this point, game lobbies must be sync'd with party lobbies as far as host status
 	// So to enforce that, we pull you out of the game lobby if you are in one when migration occurs
 	//
 
 	// Check to see if we should go back to a party lobby
 	if ( GetBackState() >= idSessionLocal::PARTY_LOBBY || GetState() == idSession::PARTY_LOBBY ) {
 		NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: GetBackState() >= idSessionLocal::PARTY_LOBBY || GetState() == idSession::PARTY_LOBBY (%s)\n", lobby.GetLobbyName() );
 		// Force the party lobby to start picking a new host if we lost the game lobby host
 		GetPartyLobby().PickNewHostInternal( forceMe, inviteOldHost );
 
 		// End the game lobby, and go back to party lobby
 		GetGameStateLobby().Shutdown();
 		GetGameLobby().Shutdown();
 		SetState( GetPartyLobby().IsHost() ? idSessionLocal::STATE_PARTY_LOBBY_HOST : idSessionLocal::STATE_PARTY_LOBBY_PEER );
 	} else {
 		NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: GetBackState() < idSessionLocal::PARTY_LOBBY && GetState() != idSession::PARTY_LOBBY (%s)\n", lobby.GetLobbyName() );
 		if ( localState >= idSessionLocal::STATE_LOADING ) {
 			common->Dialog().AddDialog( GDM_HOST_QUIT, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true  );		// The host has quit the session. Returning to the main menu.
 		}
 
 		// Go back to main menu
 		GetGameLobby().Shutdown();
 		GetGameStateLobby().Shutdown();
 		GetPartyLobby().Shutdown();
 		SetState( idSessionLocal::STATE_IDLE );
 	}
 }
 /*
 ========================
 idSessionLocal::PreMigrateInvite
 This is called just before we get invited to a migrated session
 If we return false, the invite will be ignored
 ========================
 */
 bool idSessionLocal::PreMigrateInvite( idLobby & lobby )
 {
 	if ( GetActivePlatformLobby() == NULL ) {
 		return false;
 	}
 
 	// Check to see if we can migrate AT ALL
 	// This is checking for coop, we should make this a specific option (MATCH_ALLOW_MIGRATION)
 	if ( !verify( ( GetPartyLobby().parms.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) == 0 ) ) {
 		return false;	// Shouldn't get invites for coop (we should make this a specific option (MATCH_ALLOW_MIGRATION))
 	}
 
 	// Check to see if the match is searchable
 	if ( MatchTypeIsSearchable( GetGameLobby().parms.matchFlags ) ) {
 		// Searchable games migrate lobbies independently, and don't need to stay in sync
 		return true;	
 	}
 
 	//
 	// Beyond this point, game lobbies must be sync'd with party lobbies as far as host status
 	// So to enforce that, we pull you out of the game lobby if you are in one when migration occurs
 	//
 
 	if ( lobby.lobbyType != idLobby::TYPE_PARTY ) {
 		return false;		// We shouldn't be getting invites from non party lobbies when in a non searchable game
 	}
 
 	// Non placeholder Party lobbies can always migrate
 	if ( GetBackState() >= idSessionLocal::PARTY_LOBBY ) {
 		// Non searchable games go back to the party lobby
 		GetGameLobby().Shutdown();
 		SetState( GetPartyLobby().IsHost() ? idSessionLocal::STATE_PARTY_LOBBY_HOST : idSessionLocal::STATE_PARTY_LOBBY_PEER );
 	}
 
 	return true;	// Non placeholder Party lobby invites joinable
 }
 
 /*
 ================================================================================================
 lobbyAddress_t
 ================================================================================================
 */
 
 /*
 ========================
 lobbyAddress_t::lobbyAddress_t
 ========================
 */
 lobbyAddress_t::lobbyAddress_t() {
 	memset( &netAddr, 0, sizeof( netAddr ) );
 	netAddr.type = NA_BAD;
 }
 
 /*
 ========================
 lobbyAddress_t::InitFromIPandPort
 ========================
 */
 void lobbyAddress_t::InitFromIPandPort( const char * ip, int port ) {
 	Sys_StringToNetAdr( ip, &netAddr, true );
 	if ( !netAddr.port ) {
 		netAddr.port = port;
 	}
 }
 
 
 /*
 ========================
 lobbyAddress_t::InitFromNetadr
 ========================
 */
 void lobbyAddress_t::InitFromNetadr( const netadr_t & netadr ) {
 	assert( netadr.type != NA_BAD );
 	netAddr = netadr;
 }
 
 /*
 ========================
 lobbyAddress_t::ToString
 ========================
 */
 const char * lobbyAddress_t::ToString() const {
 	return Sys_NetAdrToString( netAddr );
 }
 
 /*
 ========================
 lobbyAddress_t::UsingRelay
 ========================
 */
 bool lobbyAddress_t::UsingRelay() const {
 	return false;
 }
 
 /*
 ========================
 lobbyAddress_t::Compare
 ========================
 */
 bool lobbyAddress_t::Compare( const lobbyAddress_t & addr, bool ignoreSessionCheck ) const {
 	return Sys_CompareNetAdrBase( netAddr, addr.netAddr );
 }
 
 /*
 ========================
 lobbyAddress_t::WriteToMsg
 ========================
 */
 void lobbyAddress_t::WriteToMsg( idBitMsg & msg ) const {
 	msg.WriteData( &netAddr, sizeof( netAddr ) );
 }
 
 /*
 ========================
 lobbyAddress_t::ReadFromMsg
 ========================
 */
 void lobbyAddress_t::ReadFromMsg( idBitMsg & msg ) {
 	msg.ReadData( &netAddr, sizeof( netAddr ) );
 }
 
 /*
 ================================================================================================
 idNetSessionPort
 ================================================================================================
 */
 
 /*
 ========================
 idNetSessionPort::idNetSessionPort
 ========================
 */
 idNetSessionPort::idNetSessionPort() :
 	forcePacketDropPrev( 0.0f ),
 	forcePacketDropCurr( 0.0f )
 {
 }
 
 /*
 ========================
 idNetSessionPort::InitPort
 ========================
 */
 bool idNetSessionPort::InitPort( int portNumber, bool useBackend ) {
 	return UDP.InitForPort( portNumber );
 }
 
 /*
 ========================
 idNetSessionPort::ReadRawPacket
 ========================
 */
 bool idNetSessionPort::ReadRawPacket( lobbyAddress_t & from, void * data, int & size, int maxSize  ) {
 	bool result = UDP.GetPacket( from.netAddr, data, size, maxSize );
 	
 	static idRandom2 random( Sys_Milliseconds() );
 	if ( net_forceDrop.GetInteger() != 0 ) {
 		forcePacketDropCurr = random.RandomInt( 100 );		
 		if ( net_forceDrop.GetInteger() >= forcePacketDropCurr ) {
 			return false;
 		}
 	}
 
 	return result;
 }
 
 /*
 ========================
 idNetSessionPort::SendRawPacket
 ========================
 */
 void idNetSessionPort::SendRawPacket( const lobbyAddress_t & to, const void * data, int size ) {
 	static idRandom2 random( Sys_Milliseconds() );
 	if ( net_forceDrop.GetInteger() != 0 && net_forceDrop.GetInteger() >= random.RandomInt( 100 ) ) {
 		return;
 	}
 	assert( size <= idPacketProcessor::MAX_FINAL_PACKET_SIZE );
 	
 	UDP.SendPacket( to.netAddr, data, size );
 }
 
 /*
 ========================
 idNetSessionPort::IsOpen
 ========================
 */
 bool idNetSessionPort::IsOpen() {
 	return UDP.IsOpen();
 }
 
 /*
 ========================
 idNetSessionPort::Close
 ========================
 */
 void idNetSessionPort::Close() {
 	UDP.Close();
 }
 
 /*
 ================================================================================================
 Commands
 ================================================================================================
 */
 
 //====================================================================================
 
 CONSOLE_COMMAND( voicechat_mute, "TEMP", 0 ) {
 	if ( args.Argc() != 2 ) {
 		idLib::Printf( "Usage: voicechat_mute <user index>\n" );
 		return;
 	}
 
 	int i = atoi( args.Argv( 1 ) );
 	session->ToggleLobbyUserVoiceMute( session->GetActivePlatformLobbyBase().GetLobbyUserIdByOrdinal( i ) );
 }
 
 /*
 ========================
 force_disconnect_all
 ========================
 */
 CONSOLE_COMMAND( force_disconnect_all, "force disconnect on all users", 0 ) {
 	session->GetSignInManager().RemoveAllLocalUsers();
 }
 
 /*
 ========================
 void Net_DebugOutputSignedInUsers_f
 ========================
 */
 void Net_DebugOutputSignedInUsers_f( const idCmdArgs &args ) {
 	session->GetSignInManager().DebugOutputLocalUserInfo();
 }
 idCommandLink Net_DebugOutputSignedInUsers( "net_debugOutputSignedInUsers", Net_DebugOutputSignedInUsers_f, "Outputs all the local users and other debugging information from the sign in manager" );
 
 /*
 ========================
 void Net_RemoveUserFromLobby_f
 ========================
 */
 void Net_RemoveUserFromLobby_f( const idCmdArgs &args ) {
 	if ( args.Argc() > 1 ) {
 		int localUserNum = atoi( args.Argv( 1 ) );
 		if ( localUserNum < session->GetSignInManager().GetNumLocalUsers() ) {
 			session->GetSignInManager().RemoveLocalUserByIndex( localUserNum );
 		} else {
 			idLib::Printf( "This user is not in the lobby\n" );
 		}
 	} else {
 		idLib::Printf( "Usage: net_RemoveUserFromLobby <localUserNum>\n" );
 	}
 }
 
 idCommandLink Net_RemoveUserFromLobby( "net_removeUserFromLobby", Net_RemoveUserFromLobby_f, "Removes the given user from the lobby" );
 
 /*
 ========================
 Net_dropClient
 ========================
 */
 CONSOLE_COMMAND( Net_DropClient, "Drop a client", 0 ) {
 	if ( args.Argc() < 3 ) {
 		idLib::Printf( "usage: Net_DropClient <clientnum> [<session>] 0/default: drop from game, 1: drop from party, otherwise drop from both\n" );
 		return;
 	}
 	int lobbyType = 0;
 	if ( args.Argc() > 2 ) {
 		lobbyType = atoi( args.Argv( 2 ) );
 	}
 	session->DropClient( atoi( args.Argv(1) ), lobbyType ); 
 }
 
 /*
 ========================
 idSessionLocal::DropClient
 ========================
 */
 void idSessionLocal::DropClient( int peerNum, int session ) {
 	if ( session == 1 || session >= 2 ) {
 		GetPartyLobby().DisconnectPeerFromSession( peerNum );
 	}
 	if ( session == 0 || session >= 2 ) {
 		GetGameLobby().DisconnectPeerFromSession( peerNum );
 	}
 }
 
 /*
 ========================
 idSessionLocal::ListServersCommon
 ========================
 */
 void idSessionLocal::ListServersCommon() { 
 	netadr_t broadcast;
 	memset( &broadcast, 0, sizeof( broadcast ) );
 	broadcast.type = NA_BROADCAST;
 	broadcast.port = net_port.GetInteger();
 		
 	lobbyAddress_t address;
 	address.InitFromNetadr( broadcast );
 
 	byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
 	idBitMsg msg( buffer, sizeof( buffer ) );
 				
 	// Add the current version info to the query
 	const unsigned long localChecksum = NetGetVersionChecksum();
 
 	NET_VERBOSE_PRINT( "ListServers: Hash checksum: %i, broadcasting to: %s\n", localChecksum, address.ToString() );
 
 	msg.WriteLong( localChecksum );
 
 	GetPort();
 	// Send the query as a broadcast
 	GetPartyLobby().SendConnectionLess( address, idLobby::OOB_MATCH_QUERY, msg.GetReadData(), msg.GetSize() );	
 }
 
 /*
 ========================
 idSessionLocal::HandleDedicatedServerQueryRequest
 ========================
 */
 void idSessionLocal::HandleDedicatedServerQueryRequest( lobbyAddress_t & remoteAddr, idBitMsg & msg, int msgType ) {
 	NET_VERBOSE_PRINT( "HandleDedicatedServerQueryRequest from %s\n", remoteAddr.ToString() );
 	
 	bool canJoin = true;
 	
 	const unsigned long localChecksum = NetGetVersionChecksum();
 	const unsigned long remoteChecksum = msg.ReadLong();
 
 	if ( remoteChecksum != localChecksum ) {
 		NET_VERBOSE_PRINT( "HandleServerQueryRequest: Invalid version from %s\n", remoteAddr.ToString() );
 		canJoin = false;
 	}
 
 	// Make sure we are the host of this party session
 	if ( !GetPartyLobby().IsHost() ) {
 		NET_VERBOSE_PRINT( "HandleServerQueryRequest: Not host of party\n" );
 		canJoin = false;
 	}
 
 	// Make sure there is a session active
 	if ( GetActivePlatformLobby() == NULL ) {
 		canJoin = false;
 	}
 
 	// Make sure we have enough free slots
 	if ( GetPartyLobby().NumFreeSlots() == 0 || GetGameLobby().NumFreeSlots() == 0 ) {
 		NET_VERBOSE_PRINT( "No free slots\n" );
 		canJoin = false;
 	}
 	
 	if ( MatchTypeInviteOnly( GetPartyLobby().parms.matchFlags ) ) {
 		canJoin = false;
 	} 
 
 	// Buffer to hold reply msg
 	byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
 	idBitMsg retmsg( buffer, sizeof( buffer ) );
 	
 	idLocalUser * masterUser = GetSignInManager().GetMasterLocalUser();
 
 	if ( masterUser == NULL && !net_headlessServer.GetBool() ) {
 		canJoin = false;
 	}
 	
 	// Send the info about this game session to the caller
 	retmsg.WriteBool( canJoin );
 	
 	if ( canJoin ) {
 		serverInfo_t serverInfo;
 		serverInfo.joinable = ( session->GetState() >= idSession::LOADING );
 
 		if ( !net_headlessServer.GetBool() ) {
 			serverInfo.serverName = masterUser->GetGamerTag();
 		}
 		
 		if ( GetGameLobby().IsLobbyActive() ) {
 			serverInfo.gameMap = GetGameLobby().parms.gameMap;
 			serverInfo.gameMode = GetGameLobby().parms.gameMode;
 		} else {
 			serverInfo.gameMode = -1;
 		}
 
 		serverInfo.numPlayers = GetActivePlatformLobby()->GetNumLobbyUsers();
 		serverInfo.maxPlayers = GetActivePlatformLobby()->parms.numSlots;
 		serverInfo.Write( retmsg );
 
 		for ( int i = 0; i < GetActivePlatformLobby()->GetNumLobbyUsers(); i++ ) {
 			retmsg.WriteString( GetActivePlatformLobby()->GetLobbyUserName( GetActivePlatformLobby()->GetLobbyUserIdByOrdinal( i ) ) );
 		}
 	}
 
 	// Send it
 	GetPartyLobby().SendConnectionLess( remoteAddr, idLobby::OOB_MATCH_QUERY_ACK, retmsg.GetReadData(), retmsg.GetSize() );		
 }
 
 /*
 ========================
 idSessionLocal::HandleDedicatedServerQueryAck
 ========================
 */
 void idSessionLocal::HandleDedicatedServerQueryAck( lobbyAddress_t & remoteAddr, idBitMsg & msg ) {
 	NET_VERBOSE_PRINT( "HandleDedicatedServerQueryAck from %s\n", remoteAddr.ToString() );
 	dedicatedServerSearch->HandleQueryAck( remoteAddr, msg );
 }
 
 /*
 ========================
 idSessionLocal::ServerPlayerList
 ========================
 */
 const idList< idStr > * idSessionLocal::ServerPlayerList( int i ) {
 	return NULL;
 }
 
 /*
 ========================
 lobbyUserID_t::Serialize
 ========================
 */
 void lobbyUserID_t::Serialize( idSerializer & ser ) {
 	localUserHandle.Serialize( ser );
 	ser.Serialize( lobbyType );
 }