doom3-bfg/neo/sys/sys_session_local.cpp

/*
===========================================================================

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 );
}