DOOM-3-BFG

sys_lobby.cpp (136561B)

---

 /*
 ===========================================================================
 
 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_lobby.h"
 
 extern idCVar net_connectTimeoutInSeconds;
 extern idCVar net_headlessServer;
 
 idCVar net_checkVersion( "net_checkVersion", "0", CVAR_INTEGER, "Check for matching version when clients connect. 0: normal rules, 1: force check, otherwise no check (pass always)" );
 idCVar net_peerTimeoutInSeconds( "net_peerTimeoutInSeconds", "30", CVAR_INTEGER, "If the host hasn't received a response from a peer in this amount of time (in seconds), the peer will be disconnected." );
 idCVar net_peerTimeoutInSeconds_Lobby( "net_peerTimeoutInSeconds_Lobby", "20", CVAR_INTEGER, "If the host hasn't received a response from a peer in this amount of time (in seconds), the peer will be disconnected." );
 
 // NOTE - The snapshot exchange does the bandwidth challenge
 idCVar net_bw_challenge_enable( "net_bw_challenge_enable", "0", CVAR_BOOL, "Enable pre game bandwidth challenge for throttling snap rate" ); 
 
 idCVar net_bw_test_interval( "net_bw_test_interval", "33", CVAR_INTEGER, "MS - how often to send packets in bandwidth test" );
 idCVar net_bw_test_numPackets( "net_bw_test_numPackets", "30", CVAR_INTEGER, "Number of bandwidth challenge packets to send" );
 idCVar net_bw_test_packetSizeBytes( "net_bw_test_packetSizeBytes", "1024", CVAR_INTEGER, "Size of each packet to send out" );
 idCVar net_bw_test_timeout( "net_bw_test_timeout", "500", CVAR_INTEGER, "MS after receiving a bw test packet that client will time out" );
 idCVar net_bw_test_host_timeout( "net_bw_test_host_timeout", "3000", CVAR_INTEGER, "How long host will wait in MS to hear bw results from peers" );
 
 idCVar net_bw_test_throttle_rate_pct( "net_bw_test_throttle_rate_pct", "0.80", CVAR_FLOAT, "Min rate % a peer must match in bandwidth challenge before being throttled. 1.0=perfect, 0.0=received nothing" );
 idCVar net_bw_test_throttle_byte_pct( "net_bw_test_throttle_byte_pct", "0.80", CVAR_FLOAT, "Min byte % a peer must match in bandwidth challenge before being throttled. 1.0=perfect (received everything) 0.0=Received nothing" );
 idCVar net_bw_test_throttle_seq_pct( "net_bw_test_throttle_seq_pct", "0.80", CVAR_FLOAT, "Min sequence % a peer must match in bandwidth test before being throttled. 1.0=perfect. This score will be more adversely affected by packet loss than byte %" );
 
 idCVar net_ignoreConnects( "net_ignoreConnects", "0", CVAR_INTEGER, "Test as if no one can connect to me. 0 = off, 1 = ignore with no reply, 2 = send goodbye" );
 
 idCVar net_skipGoodbye( "net_skipGoodbye", "0", CVAR_BOOL, "" ); 
 
 extern unsigned long NetGetVersionChecksum();
 
 /*
 ========================
 idLobby::idLobby
 ========================
 */
 idLobby::idLobby() {
 	lobbyType				= TYPE_INVALID;
 	sessionCB				= NULL;
 
 	localReadSS				= NULL;
 	objMemory				= NULL;
 	haveSubmittedSnaps		= false;
 
 	state					= STATE_IDLE;	
 	failedReason			= FAILED_UNKNOWN;
 
 	host					= -1;
 	peerIndexOnHost			= -1;
 	isHost					= false;
 	needToDisplayMigrateMsg	= false;
 	migrateMsgFlags			= 0;
 	
 	partyToken				= 0;		// will be initialized later
 	loaded					= false;
 	respondToArbitrate		= false;
 	waitForPartyOk			= false;
 	startLoadingFromHost	= false;
 	
 	nextSendPingValuesTime	= 0;
 	lastPingValuesRecvTime	= 0;
 
 	nextSendMigrationGameTime = 0;
 	nextSendMigrationGamePeer = 0;
 
 	bandwidthChallengeStartTime = 0;
 	bandwidthChallengeEndTime	= 0;
 	bandwidthChallengeFinished	= false;
 	bandwidthChallengeNumGoodSeq = 0;
 
 	lastSnapBspHistoryUpdateSequence = -1;
 
 	assert( userList.Max() == freeUsers.Max() );
 	assert( userList.Max() == userPool.Max() );
 
 	userPool.SetNum( userPool.Max() );
 
 	assert( freeUsers.Num() == 0 );
 	assert( freeUsers.Num() == 0 );
 
 	// Initialize free user list
 	for ( int i = 0; i < userPool.Num(); i++ ) {
 		freeUsers.Append( &userPool[i] );
 	}
 	
 	showHostLeftTheSession	= false;
 	connectIsFromInvite		= false;
 }
 
 /*
 ========================
 idLobby::Initialize
 ========================
 */
 void idLobby::Initialize( lobbyType_t sessionType_, idSessionCallbacks * callbacks ) {
 	assert( callbacks != NULL );
 
 	lobbyType = sessionType_;
 	sessionCB	= callbacks;
 
 	if ( lobbyType == GetActingGameStateLobbyType() ) {
 		// only needed in multiplayer mode
 		objMemory		= (uint8*)Mem_Alloc( SNAP_OBJ_JOB_MEMORY, TAG_NETWORKING );
 		lzwData			= (lzwCompressionData_t*)Mem_Alloc( sizeof( lzwCompressionData_t ), TAG_NETWORKING );
 	}
 }
 
 //===============================================================================
 //	** BEGIN PUBLIC INTERFACE ***
 //===============================================================================
 
 /*
 ========================
 idLobby::StartHosting
 ========================
 */
 void idLobby::StartHosting( const idMatchParameters & parms_ ) {
 	parms = parms_;
 
 	// Allow common to modify the parms
 	common->OnStartHosting( parms );
 
 	Shutdown();		// Make sure we're in a shutdown state before proceeding
 
 	assert( GetNumLobbyUsers() == 0 );
 	assert( lobbyBackend == NULL );
 
 	// Get the skill level of all the players that will eventually go into the lobby
 	StartCreating();
 }
 
 /*
 ========================
 idLobby::StartFinding
 ========================
 */
 void idLobby::StartFinding( const idMatchParameters & parms_ ) {
 	parms = parms_;
 
 	Shutdown();		// Make sure we're in a shutdown state before proceeding
 
 	assert( GetNumLobbyUsers() == 0 );
 	assert( lobbyBackend == NULL );
 
 	// Clear search results
 	searchResults.Clear();
 
 	lobbyBackend = sessionCB->FindLobbyBackend( parms, sessionCB->GetPartyLobby().GetNumLobbyUsers(), sessionCB->GetPartyLobby().GetAverageSessionLevel(), idLobbyBackend::TYPE_GAME );
 
 	SetState( STATE_SEARCHING );
 }
 
 /*
 ========================
 idLobby::Pump
 ========================
 */
 void idLobby::Pump() {
 	
 	// Check the heartbeat of all our peers, make sure we shouldn't disconnect from peers that haven't sent a heartbeat in awhile
 	CheckHeartBeats();
 
 	UpdateHostMigration();
 
 	UpdateLocalSessionUsers();
 
 	switch ( state ) {
 		case STATE_IDLE:					State_Idle();					break;
 		case STATE_CREATE_LOBBY_BACKEND:	State_Create_Lobby_Backend();	break;
 		case STATE_SEARCHING:				State_Searching();				break;
 		case STATE_OBTAINING_ADDRESS:		State_Obtaining_Address();		break;
 		case STATE_CONNECT_HELLO_WAIT:		State_Connect_Hello_Wait();		break;
 		case STATE_FINALIZE_CONNECT:		State_Finalize_Connect();		break;
 		case STATE_FAILED:													break;
 		default:	
 			idLib::Error( "idLobby::Pump:  Unknown state." );
 	}
 }
 
 /*
 ========================
 idLobby::ProcessSnapAckQueue
 ========================
 */
 void idLobby::ProcessSnapAckQueue() {
 	SCOPED_PROFILE_EVENT( "ProcessSnapAckQueue" );
 
 	const int SNAP_ACKS_TO_PROCESS_PER_FRAME = 1;
 
 	int numProcessed = 0;
 
 	while ( snapDeltaAckQueue.Num() > 0 && numProcessed < SNAP_ACKS_TO_PROCESS_PER_FRAME ) {
 		if ( ApplySnapshotDeltaInternal( snapDeltaAckQueue[0].p, snapDeltaAckQueue[0].snapshotNumber ) ) {
 			numProcessed++;
 		}
 		snapDeltaAckQueue.RemoveIndex( 0 );
 	}
 }
 
 /*
 ========================
 idLobby::Shutdown
 ========================
 */
 void idLobby::Shutdown( bool retainMigrationInfo, bool skipGoodbye ) {
 
 	// Cancel host migration if we were in the process of it and this is the session type that was migrating
 	if ( !retainMigrationInfo && migrationInfo.state != MIGRATE_NONE ) {
 		idLib::Printf( "Cancelling host migration on %s.\n", GetLobbyName() );
 		EndMigration();
 	}
 
 	failedReason = FAILED_UNKNOWN;
 
 	if ( lobbyBackend == NULL ) {
 		NET_VERBOSE_PRINT( "NET: ShutdownLobby (already shutdown) (%s)\n", GetLobbyName() );
 
 		// If we don't have this lobbyBackend type, we better be properly shutdown for this lobby
 		assert( GetNumLobbyUsers() == 0 );
 		assert( host == -1 );
 		assert( peerIndexOnHost == -1 );
 		assert( !isHost );
 		assert( lobbyType != GetActingGameStateLobbyType() || !loaded );
 		assert( lobbyType != GetActingGameStateLobbyType() || !respondToArbitrate );
 		assert( snapDeltaAckQueue.Num() == 0 );
 
 		// Make sure we don't have old peers connected to this lobby
 		for ( int p = 0; p < peers.Num(); p++ ) {
 			assert( peers[p].GetConnectionState() == CONNECTION_FREE );
 		}
 
 		state = STATE_IDLE;	
 
 		return;
 	}
 
 	NET_VERBOSE_PRINT( "NET: ShutdownLobby (%s)\n", GetLobbyName() );
 	
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		if ( peers[p].GetConnectionState() != CONNECTION_FREE ) {
 			SetPeerConnectionState( p, CONNECTION_FREE, skipGoodbye );		// This will send goodbye's
 		}
 	}
 	
 	// Remove any users that weren't handled in ResetPeers
 	// (this will happen as a client, because we won't get the reliable msg from the server since we are severing the connection)
 	for ( int i = 0; i < GetNumLobbyUsers(); i++ ) {
 		lobbyUser_t * user = GetLobbyUser( i );
 		UnregisterUser( user );
 	}
 
 	FreeAllUsers();
 
 	host					= -1;
 	peerIndexOnHost			= -1;
 	isHost					= false;
 	needToDisplayMigrateMsg	= false;
 	migrationDlg			= GDM_INVALID;
 
 	partyToken				= 0;		// Reset our party token so we recompute
 	loaded					= false;
 	respondToArbitrate		= false;
 	waitForPartyOk			= false;
 	startLoadingFromHost	= false;
 
 	snapDeltaAckQueue.Clear();
 
 	// Shutdown the lobbyBackend
 	if ( !retainMigrationInfo ) {
 		sessionCB->DestroyLobbyBackend( lobbyBackend );
 		lobbyBackend = NULL;
 	}
 
 	state = STATE_IDLE;
 }
 
 /*
 ========================
 idLobby::HandlePacket
 ========================
 */
 void idLobby::HandlePacket( lobbyAddress_t & remoteAddress, idBitMsg fragMsg, idPacketProcessor::sessionId_t sessionID ) {
 	SCOPED_PROFILE_EVENT( "HandlePacket" );
 
 	// msg will hold a fully constructed msg using the packet processor
 	byte msgBuffer[ idPacketProcessor::MAX_MSG_SIZE ];
 
 	idBitMsg msg;
 	msg.InitWrite( msgBuffer, sizeof( msgBuffer ) );
 
 	int peerNum		= FindPeer( remoteAddress, sessionID );
 	int type		= idPacketProcessor::RETURN_TYPE_NONE;
 	int	userData	= 0;
 
 	if ( peerNum >= 0 ) {
 		if ( !peers[peerNum].IsActive() ) {
 			idLib::Printf( "NET: Received in-band packet from peer %s with no active connection.\n", remoteAddress.ToString() );
 			return;
 		}
 		type = peers[ peerNum ].packetProc->ProcessIncoming( Sys_Milliseconds(), peers[peerNum].sessionID, fragMsg, msg, userData, peerNum );
 	} else {
 		if ( !idPacketProcessor::ProcessConnectionlessIncoming( fragMsg, msg, userData ) ) {
 			idLib::Printf( "ProcessConnectionlessIncoming FAILED from %s.\n", remoteAddress.ToString() );
 			// Not a valid connectionless packet
 			return;
 		}
 			
 		// Valid connectionless packets are always RETURN_TYPE_OOB
 		type = idPacketProcessor::RETURN_TYPE_OOB;
 			
 		// Find the peer this connectionless msg should go to
 		peerNum = FindPeer( remoteAddress, sessionID, true );
 	}
 
 	if ( type == idPacketProcessor::RETURN_TYPE_NONE ) {
 		// This packet is not necessarily invalid, it could be a start or middle of a fragmented packet that's not fully constructed.
 		return;
 	}
 
 	if ( peerNum >= 0 ) {
 		// Update their heart beat (only if we've received a valid packet (we've checked type == idPacketProcessor::RETURN_TYPE_NONE))
 		peers[peerNum].lastHeartBeat = Sys_Milliseconds();	
 	}
 
 	// Handle server query requests.  We do this before the STATE_IDLE check.  This is so we respond.
 	// We may want to change this to just ignore the request if we are idle, and change the timeout time
 	// on the requesters part to just timeout faster.
 	if ( type == idPacketProcessor::RETURN_TYPE_OOB ) {	
 		if ( userData == OOB_MATCH_QUERY || userData == OOB_SYSTEMLINK_QUERY ) {
 			sessionCB->HandleServerQueryRequest( remoteAddress, msg, userData );
 			return;
 		}
 		if ( userData == OOB_MATCH_QUERY_ACK ) {
 			sessionCB->HandleServerQueryAck( remoteAddress, msg );
 			return;
 		}
 	}		
 
 	if ( type == idPacketProcessor::RETURN_TYPE_OOB ) {	
 		if ( userData == OOB_VOICE_AUDIO ) {
 			sessionCB->HandleOobVoiceAudio( remoteAddress, msg );
 		} else if ( userData == OOB_HELLO ) {
 			// Handle new peer connect request
 			peerNum = HandleInitialPeerConnection( msg, remoteAddress, peerNum );
 			return;
 		} else if ( userData == OOB_MIGRATE_INVITE ) {
 			NET_VERBOSE_PRINT( "NET: Migration invite for session %s from %s (state = %s)\n", GetLobbyName(), remoteAddress.ToString(), session->GetStateString() );
 
 			// Get connection info
 			lobbyConnectInfo_t connectInfo;
 			connectInfo.ReadFromMsg( msg );
 
 			if ( lobbyBackend != NULL && lobbyBackend->GetState() != idLobbyBackend::STATE_FAILED && lobbyBackend->IsOwnerOfConnectInfo( connectInfo ) ) {		// Ignore duplicate invites
 				idLib::Printf( "NET: Already migrated to %s.\n", remoteAddress.ToString() );
 				return;
 			}
 
 			if ( migrationInfo.state == MIGRATE_NONE ) {
 				if ( IsPeer() && host >= 0 && host < peers.Num() && Sys_Milliseconds() - peers[host].lastHeartBeat > 8 * 1000 ) {
 					// Force migration early if we get an invite, and it has been some time since we've heard from the host
 					PickNewHost();
 				} else {
 					idLib::Printf( "NET: Ignoring migration invite because we are not migrating %s\n", remoteAddress.ToString() );
 					SendGoodbye( remoteAddress );	// So they can remove us from their invite list
 					return;
 				}
 			}
 
 			if ( !sessionCB->PreMigrateInvite( *this ) ) {
 				NET_VERBOSE_PRINT( "NET: sessionCB->PreMigrateInvite( *this ) failed from %s\n", remoteAddress.ToString() );
 				return;
 			}
 
 			// If we are also becoming a new host, see who wins
 			if ( migrationInfo.state == MIGRATE_BECOMING_HOST ) {
 				int inviteIndex = FindMigrationInviteIndex( remoteAddress );
 
 				if ( inviteIndex != -1 ) {
 					// We found them in our list, check to make sure our ping is better
 					int				ping1	= migrationInfo.ourPingMs;
 					lobbyUserID_t	userId1 = migrationInfo.ourUserId;
 					int				ping2	= migrationInfo.invites[inviteIndex].pingMs;
 					lobbyUserID_t	userId2 = migrationInfo.invites[inviteIndex].userId;
 
 					if ( IsBetterHost( ping1, userId1, ping2, userId2 ) ) {
 						idLib::Printf( "NET: Ignoring migration invite from %s, since our ping is better (%i / %i).\n", remoteAddress.ToString(), ping1, ping2 );
 						return;
 					}
 				}
 			}
 
 			bool fromGame = msg.ReadBool();
 
 			// Kill the current lobbyBackend
 			Shutdown();
 
 			// Connect to the lobby
 			ConnectTo( connectInfo, true );		// Pass in true for the invite flag, so we can connect to invite only lobby if we need to
 
 			if ( verify( sessionCB != NULL ) ) {
 				if ( sessionCB->BecomingPeer( *this ) ) {
 					migrationInfo.persistUntilGameEndsData.wasMigratedJoin = true;
 					migrationInfo.persistUntilGameEndsData.wasMigratedGame = fromGame;
 				}
 			}
 
 		} else if ( userData == OOB_GOODBYE || userData == OOB_GOODBYE_W_PARTY || userData == OOB_GOODBYE_FULL ) {
 			HandleGoodbyeFromPeer( peerNum, remoteAddress, userData );
 			return;
 		} else if ( userData == OOB_RESOURCE_LIST ) {
 
 			if ( !verify( lobbyType == GetActingGameStateLobbyType() ) ) {
 				return;
 			}
 
 			if ( peerNum != host ) {
 				NET_VERBOSE_PRINT( "NET: Resource list from non-host %i, %s\n", peerNum, remoteAddress.ToString() );
 				return;
 			}
 
 			if ( peerNum >= 0 && !peers[peerNum].IsConnected() ) {
 				NET_VERBOSE_PRINT( "NET: Resource list from host with no game connection: %i, %s\n", peerNum, remoteAddress.ToString() );
 				return;
 			}
 		} else if ( userData == OOB_BANDWIDTH_TEST ) {
 			int seqNum = msg.ReadLong();
 			// TODO: We should read the random data and verify the MD5 checksum
 
 			int time = Sys_Milliseconds();
 			bool inOrder = ( seqNum == 0 || peers[peerNum].bandwidthSequenceNum + 1 == seqNum );
 			int timeSinceLast = 0;
 
 			if ( bandwidthChallengeStartTime <= 0 ) {
 				// Reset the test
 				NET_VERBOSE_PRINT( "\nNET: Starting bandwidth test @ %d\n", time );
 				bandwidthChallengeStartTime = time;
 				peers[peerNum].bandwidthSequenceNum = 0;
 				peers[peerNum].bandwidthTestBytes = peers[peerNum].packetProc->GetIncomingBytes();
 			} else {
 				timeSinceLast = time - (bandwidthChallengeEndTime - session->GetTitleStorageInt( "net_bw_test_timeout", net_bw_test_timeout.GetInteger() ) );
 			}
 
 			if ( inOrder ) {
 				bandwidthChallengeNumGoodSeq++;
 			}
 
 			bandwidthChallengeEndTime = time + session->GetTitleStorageInt( "net_bw_test_timeout", net_bw_test_timeout.GetInteger() );
 			NET_VERBOSE_PRINT( "  NET: %sRecevied OOB bandwidth test %d delta time: %d incoming rate: %.2f  incoming rate 2: %d\n", inOrder ? "^2" : "^1", seqNum, timeSinceLast, peers[peerNum].packetProc->GetIncomingRateBytes(), peers[peerNum].packetProc->GetIncomingRate2() );
 			peers[peerNum].bandwidthSequenceNum = seqNum;
 
 		} else {
 			NET_VERBOSE_PRINT( "NET: Unknown oob packet %d from %s (%d)\n", userData, remoteAddress.ToString(), peerNum );
 		}
 	} else if ( type == idPacketProcessor::RETURN_TYPE_INBAND ) {
 		// Process in-band message
 		if ( peerNum < 0 ) {
 			idLib::Printf( "NET: In-band message from unknown peer: %s\n", remoteAddress.ToString() );
 			return;
 		}
 			
 		if ( !verify( peers[ peerNum ].address.Compare( remoteAddress ) ) ) {
 			idLib::Printf( "NET: Peer with wrong address: %i, %s\n", peerNum, remoteAddress.ToString() );
 			return;
 		}
 
 		// Handle reliable
 		int numReliable = peers[ peerNum ].packetProc->GetNumReliables();
 		for ( int r = 0; r < numReliable; r++ ) {
 			// Just in case one of the reliable msg's cause this peer to disconnect
 			// (this can happen when our party/game host is the same, he quits the game lobby, and sends a reliable msg for us to leave the game)
 			peerNum	= FindPeer( remoteAddress, sessionID );
 
 			if ( peerNum == -1 ) {
 				idLib::Printf( "NET: Dropped peer while processing reliable msg's: %i, %s\n", peerNum, remoteAddress.ToString() );
 				break;
 			}
 
 			const byte * reliableData = peers[ peerNum ].packetProc->GetReliable( r );
 			int reliableSize = peers[ peerNum ].packetProc->GetReliableSize( r );
 			idBitMsg reliableMsg( reliableData, reliableSize );
 			reliableMsg.SetSize( reliableSize );
 
 			HandleReliableMsg( peerNum, reliableMsg );
 		}
 	
 		if ( peerNum == -1 || !peers[ peerNum ].IsConnected() ) {
 			// If the peer still has no connection after HandleReliableMsg, then something is wrong.
 			// (We could have been in CONNECTION_CONNECTING state for this session type, but the first message
 			// we should receive from the server is the ack, otherwise, something went wrong somewhere)
 			idLib::Printf( "NET: In-band message from host with no active connection: %i, %s\n", peerNum, remoteAddress.ToString() );
 			return;
 		}
 
 		// Handle unreliable part (if any)
 		if ( msg.GetRemainingData() > 0 && loaded ) {
 			if ( !verify( lobbyType == GetActingGameStateLobbyType() ) ) {
 				idLib::Printf( "NET: Snapshot msg for non game session lobby %s\n", remoteAddress.ToString() );
 				return;
 			}
 				
 			if ( peerNum == host ) {
 				idSnapShot	localSnap;
 				int			sequence = -1;
 				int			baseseq = -1;
 				bool		fullSnap = false;
 				localReadSS = &localSnap;
 
 				// If we are the peer, we assume we only receive snapshot data on the in-band channel
 				const byte * deltaData = msg.GetReadData() + msg.GetReadCount();
 				int deltaLength = msg.GetRemainingData();
 
 				if ( peers[ peerNum ].snapProc->ReceiveSnapshotDelta( deltaData, deltaLength, 0, sequence, baseseq, localSnap, fullSnap ) ) {						
 						
 					NET_VERBOSESNAPSHOT_PRINT_LEVEL( 2, va( "NET: Got %s snapshot %d delta'd against %d. SS Time: %d\n", ( fullSnap ? "partial" : "full" ), sequence, baseseq, localSnap.GetTime() ) );
 						
 					if ( sessionCB->GetState() != idSession::INGAME && sequence != -1 ) {
 						int seq = peers[ peerNum ].snapProc->GetLastAppendedSequence();
 
 						// When we aren't in the game, we need to send this as reliable msg's, since usercmds won't be taking care of it for us
 						byte ackbuffer[32];
 						idBitMsg ackmsg( ackbuffer, sizeof( ackbuffer ) );
 						ackmsg.WriteLong( seq );
 
 						// Add incoming BPS for QoS
 						float incomingBPS = peers[ peerNum ].receivedBps;
 						if ( peers[ peerNum ].receivedBpsIndex != seq ) {
 							incomingBPS = idMath::ClampFloat( 0.0f, static_cast<float>( idLobby::BANDWIDTH_REPORTING_MAX ), peers[host].packetProc->GetIncomingRateBytes() );
 							peers[ peerNum ].receivedBpsIndex = seq;
 							peers[ peerNum ].receivedBps = incomingBPS;
 						}
 
 						ackmsg.WriteQuantizedUFloat< idLobby::BANDWIDTH_REPORTING_MAX, idLobby::BANDWIDTH_REPORTING_BITS >( incomingBPS );
 						QueueReliableMessage( host, RELIABLE_SNAPSHOT_ACK, ackbuffer, sizeof( ackbuffer ) );
 					}					
 				}
 
 				if ( fullSnap ) {
 					sessionCB->ReceivedFullSnap();
 					common->NetReceiveSnapshot( localSnap );
 				}
 
 				localReadSS = NULL;
 					
 			} else {
 				// If we are the host, we assume we only receive usercmds on the inband channel
 
 				int snapNum = 0;
 				uint16 receivedBps_quantized = 0;
 
 				byte usercmdBuffer[idPacketProcessor::MAX_FINAL_PACKET_SIZE];
 
 				lzwCompressionData_t lzwData;
 				idLZWCompressor lzwCompressor( &lzwData );
 				lzwCompressor.Start( const_cast<byte *>( msg.GetReadData() ) + msg.GetReadCount(), msg.GetRemainingData() );
 				lzwCompressor.ReadAgnostic( snapNum );
 				lzwCompressor.ReadAgnostic( receivedBps_quantized );
 				int usercmdSize = lzwCompressor.Read( usercmdBuffer, sizeof( usercmdBuffer ), true );
 				lzwCompressor.End();
 
 				float receivedBps = ( receivedBps_quantized / (float)( BIT( idLobby::BANDWIDTH_REPORTING_BITS ) - 1 ) ) * (float)idLobby::BANDWIDTH_REPORTING_MAX;
 				if ( peers[ peerNum ].receivedBpsIndex != snapNum ) {
 					peers[ peerNum ].receivedBps = receivedBps;
 					peers[ peerNum ].receivedBpsIndex = snapNum;
 				}
 
 				if ( snapNum < 50 ) {
 					NET_VERBOSE_PRINT( "NET: peer %d ack'd snapNum %d\n", peerNum, snapNum );
 				}
 				ApplySnapshotDelta( peerNum, snapNum );
 
 				idBitMsg usercmdMsg( (const byte *)usercmdBuffer, usercmdSize );
 				common->NetReceiveUsercmds( peerNum, usercmdMsg );
 			}
 		}
 	}
 }
 
 /*
 ========================
 idLobby::HasActivePeers
 ========================
 */
 bool idLobby::HasActivePeers() const {
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		if ( peers[p].GetConnectionState() != CONNECTION_FREE ) {	
 			return true;
 		}
 	}
 	
 	return false;
 }
 
 /*
 ========================
 idLobby::NumFreeSlots
 ========================
 */
 int idLobby::NumFreeSlots() const {
 	if ( parms.matchFlags & MATCH_JOIN_IN_PROGRESS ) {
 		return parms.numSlots - GetNumConnectedUsers();
 	} else {
 		return parms.numSlots - GetNumLobbyUsers();
 	}
 }
 
 //===============================================================================
 //	** END PUBLIC INTERFACE ***
 //===============================================================================
 
 //===============================================================================
 //	** BEGIN STATE CODE ***
 //===============================================================================
 
 const char * idLobby::stateToString[ NUM_STATES ] = {
 	ASSERT_ENUM_STRING( STATE_IDLE, 0 ),
 	ASSERT_ENUM_STRING( STATE_CREATE_LOBBY_BACKEND, 1 ),
 	ASSERT_ENUM_STRING( STATE_SEARCHING, 2 ),
 	ASSERT_ENUM_STRING( STATE_OBTAINING_ADDRESS, 3 ),
 	ASSERT_ENUM_STRING( STATE_CONNECT_HELLO_WAIT, 4 ),
 	ASSERT_ENUM_STRING( STATE_FINALIZE_CONNECT, 5 ),
 	ASSERT_ENUM_STRING( STATE_FAILED, 6 ),
 };
 
 /*
 ========================
 idLobby::State_Idle
 ========================
 */
 void idLobby::State_Idle() {
 	// If lobbyBackend is in a failed state, shutdown, go to a failed state ourself, and return
 	if ( lobbyBackend != NULL && lobbyBackend->GetState() == idLobbyBackend::STATE_FAILED ) {
 		HandleConnectionAttemptFailed();
 		common->Dialog().ClearDialog( GDM_MIGRATING );
 		common->Dialog().ClearDialog( GDM_MIGRATING_WAITING );
 		common->Dialog().ClearDialog( GDM_MIGRATING_RELAUNCHING );
 		return;
 	}
 
 	if ( migrationInfo.persistUntilGameEndsData.hasGameData && sessionCB->GetState() <= idSession::IDLE ) {
 		// This can happen with 'leaveGame' or 'disconnect' since those paths don't go through endMatch
 		// This seems like an ok catch all place but there may be a better way to handle this
 		ResetAllMigrationState();
 		common->Dialog().ClearDialog( GDM_MIGRATING );
 		common->Dialog().ClearDialog( GDM_MIGRATING_WAITING );
 		common->Dialog().ClearDialog( GDM_MIGRATING_RELAUNCHING );
 	}
 }
 
 /*
 ========================
 idLobby::State_Create_Lobby_Backend
 ========================
 */
 void idLobby::State_Create_Lobby_Backend() {
 	if ( !verify( lobbyBackend != NULL ) ) { 
 		SetState( STATE_FAILED );
 		return;
 	}
 
 	assert( lobbyBackend != NULL );
 
 	if ( migrationInfo.state == MIGRATE_BECOMING_HOST ) {
 		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() - migrationInfo.migrationStartTime > 1000 * DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS ) {
 				SetState( STATE_FAILED );
 				return;
 			}
 		}
 	}
 
 	if ( lobbyBackend->GetState() == idLobbyBackend::STATE_CREATING ) {
 		return;		// Busy but valid
 	}
 
 	if ( lobbyBackend->GetState() != idLobbyBackend::STATE_READY ) {
 		SetState( STATE_FAILED );
 		return;
 	}
 
 	// Success
 	InitStateLobbyHost();
 	
 	// Set state to idle to signify to session we are done creating
 	SetState( STATE_IDLE );
 }
 
 /*
 ========================
 idLobby::State_Searching
 ========================
 */
 void idLobby::State_Searching() {
 	if ( !verify( lobbyBackend != NULL ) ) { 
 		SetState( STATE_FAILED );
 		return;
 	}
 
 	if ( lobbyBackend->GetState() == idLobbyBackend::STATE_SEARCHING ) {
 		return;		// Busy but valid
 	}
 
 	if ( lobbyBackend->GetState() != idLobbyBackend::STATE_READY ) {
 		SetState( STATE_FAILED );		// Any other lobbyBackend state is invalid
 		return;
 	}
 	
 	// Done searching, get results from lobbyBackend
 	lobbyBackend->GetSearchResults( searchResults );
 
 	if ( searchResults.Num() == 0 ) {
 		// If we didn't get any results, set state to failed
 		SetState( STATE_FAILED );
 		return;
 	}
 
 	extern idCVar net_maxSearchResultsToTry;
 	const int maxSearchResultsToTry = session->GetTitleStorageInt( "net_maxSearchResultsToTry", net_maxSearchResultsToTry.GetInteger() );
 
 	if ( searchResults.Num() > maxSearchResultsToTry ) {
 		searchResults.SetNum( maxSearchResultsToTry );
 	}
 
 	// Set state to idle to signify we are done searching
 	SetState( STATE_IDLE );
 }
 
 /*
 ========================
 idLobby::State_Obtaining_Address
 ========================
 */
 void idLobby::State_Obtaining_Address() {
 	if ( lobbyBackend->GetState() == idLobbyBackend::STATE_OBTAINING_ADDRESS ) {
 		return;		// Valid but not ready
 	}
 	
 	if ( lobbyBackend->GetState() != idLobbyBackend::STATE_READY ) {
 		// There was an error, signify to caller
 		failedReason = migrationInfo.persistUntilGameEndsData.wasMigratedJoin ? FAILED_MIGRATION_CONNECT_FAILED : FAILED_CONNECT_FAILED;
 		NET_VERBOSE_PRINT("idLobby::State_Obtaining_Address: the lobby backend failed." );
 		SetState( STATE_FAILED );
 		return;
 	}
 
 	//
 	//	We have the address of the lobbyBackend, we can now send a hello packet
 	//
 
 	// This will be the host for this lobby type
 	host = AddPeer( hostAddress, GenerateSessionID() );
 
 	// Record start time of connection attempt to the host
 	helloStartTime		= Sys_Milliseconds();
 	lastConnectRequest	= helloStartTime;
 	connectionAttempts	= 0;
 
 	// Change state to connecting
 	SetState( STATE_CONNECT_HELLO_WAIT );
 
 	// Send first connect attempt now (we'll send more periodically if we fail to receive an ack)
 	// (we do this after changing state, since the function expects we're in the right state)
 	SendConnectionRequest();
 }
 
 /*
 ========================
 idLobby::State_Finalize_Connect
 ========================
 */
 void idLobby::State_Finalize_Connect() {
 	if ( lobbyBackend->GetState() == idLobbyBackend::STATE_CREATING ) {
 		// Valid but busy
 		return;
 	}
 
 	if ( lobbyBackend->GetState() != idLobbyBackend::STATE_READY ) {
 		// Any other state not valid, failed
 		SetState( STATE_FAILED );
 		return;
 	}
 	
 	// Success
 	SetState( STATE_IDLE );
 
 	// Tell session mgr if this was a migration
 	if ( migrationInfo.persistUntilGameEndsData.wasMigratedJoin ) {
 		sessionCB->BecamePeer( *this );
 	}
 }
 
 /*
 ========================
 idLobby::State_Connect_Hello_Wait
 ========================
 */
 void idLobby::State_Connect_Hello_Wait() {
 	if ( lobbyBackend->GetState() != idLobbyBackend::STATE_READY ) {
 		// If the lobbyBackend is in an error state, shut everything down
 		NET_VERBOSE_PRINT( "NET: Lobby is no longer ready while waiting for lobbyType %s hello.\n", GetLobbyName() );
 		HandleConnectionAttemptFailed();
 		return;
 	}
 
 	int time = Sys_Milliseconds();
 	
 	const int timeoutMs = session->GetTitleStorageInt( "net_connectTimeoutInSeconds", net_connectTimeoutInSeconds.GetInteger() ) * 1000;
 
 	if ( timeoutMs != 0 && time - helloStartTime > timeoutMs ) {
 		NET_VERBOSE_PRINT( "NET: Timeout waiting for lobbyType %s for party hello.\n", GetLobbyName() );
 		HandleConnectionAttemptFailed();
 		return;
 	}
 
 	if ( connectionAttempts < MAX_CONNECT_ATTEMPTS ) {
 		assert( connectionAttempts >= 1 );		// Should have at least the initial connection attempt
 
  		// See if we need to send another hello request
 		// (keep getting more frequent to increase chance due to possible packet loss, but clamp to MIN_CONNECT_FREQUENCY seconds)
 		// TODO: We could eventually make timing out a function of actual number of attempts rather than just plain time.
 		int resendTime = Max( MIN_CONNECT_FREQUENCY_IN_SECONDS, CONNECT_REQUEST_FREQUENCY_IN_SECONDS / connectionAttempts ) * 1000;
 		
 		if ( time - lastConnectRequest > resendTime ) {
 			SendConnectionRequest();
 			lastConnectRequest = time;
 		}
 	}
 }
 
 /*
 ========================
 idLobby::SetState
 ========================
 */
 void idLobby::SetState( lobbyState_t newState ) {	
 	assert( newState < NUM_STATES );
 	assert( state < NUM_STATES );
 
 	verify_array_size( stateToString, NUM_STATES );
 
 	if ( state == newState ) {
 		NET_VERBOSE_PRINT( "NET: idLobby::SetState: State SAME %s for session %s\n", stateToString[ newState ], GetLobbyName() );
 		return;
 	}
 
 	// Set the current state
 	NET_VERBOSE_PRINT( "NET: idLobby::SetState: State changing from %s to %s for session %s\n", stateToString[ state ], stateToString[ newState ], GetLobbyName() );
 
 	state = newState;
 }
 
 //===============================================================================
 //	** END STATE CODE ***
 //===============================================================================
 
 /*
 ========================
 idLobby::StartCreating
 ========================
 */
 void idLobby::StartCreating() {
 	assert( lobbyBackend == NULL );
 	assert( state == STATE_IDLE );
 
 	float skillLevel = GetAverageLocalUserLevel( true );
 
 	lobbyBackend = sessionCB->CreateLobbyBackend( parms, skillLevel, (idLobbyBackend::lobbyBackendType_t)lobbyType );
 
 	SetState( STATE_CREATE_LOBBY_BACKEND );	
 }
 
 /*
 ========================
 idLobby::FindPeer
 ========================
 */
 int idLobby::FindPeer( const lobbyAddress_t & remoteAddress, idPacketProcessor::sessionId_t sessionID, bool ignoreSessionID ) {
 
 	bool connectionless = ( sessionID == idPacketProcessor::SESSION_ID_CONNECTIONLESS_PARTY || 
 							sessionID == idPacketProcessor::SESSION_ID_CONNECTIONLESS_GAME || 
 							sessionID == idPacketProcessor::SESSION_ID_CONNECTIONLESS_GAME_STATE );
 	
 	if ( connectionless && !ignoreSessionID ) {
 		return -1;		// This was meant to be connectionless. FindPeer is meant for connected (or connecting) peers
 	}
 
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		if ( peers[p].GetConnectionState() == CONNECTION_FREE ) {
 			continue;
 		}
 
 		if ( peers[p].address.Compare( remoteAddress ) ) {
 			if ( connectionless && ignoreSessionID ) {
 				return p;
 			}
 
 			// Using a rolling check, so that we account for possible packet loss, and out of order issues
 			if ( IsPeer() ) {
 				idPacketProcessor::sessionId_t searchStart = peers[p].sessionID;
 	
 				// Since we only roll the code between matches, we should only need to look ahead a couple increments.
 				// Worse case, if the stars line up, the client doesn't see the new sessionId, and times out, and gets booted.
 				// This should be impossible though, since the timings won't be possible considering how long it takes to end the match, 
 				// and restart, and then restart again.
 				int numTries = 2;
 
 				while ( numTries-- > 0 && searchStart != sessionID ) {
 					searchStart = IncrementSessionID( searchStart );
 					if ( searchStart == sessionID ) {
 						idLib::Printf( "NET: Rolling session ID check found new ID: %i\n", searchStart );
 						if ( peers[p].packetProc != NULL ) {
 							peers[p].packetProc->VerifyEmptyReliableQueue( RELIABLE_GAME_DATA, RELIABLE_DUMMY_MSG );
 						}
 						peers[p].sessionID = searchStart;
 						break;
 					}
 				}
 			}
 
 			if ( peers[p].sessionID != sessionID ) {
 				continue;
 			}
 			return p;
 		}
 	}
 	return -1;
 }
 
 /*
 ========================
 idLobby::FindAnyPeer
 Find a peer when we don't know the session id, and we don't care since it's a connectionless msg
 ========================
 */
 int idLobby::FindAnyPeer( const lobbyAddress_t & remoteAddress ) const {
 
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		if ( peers[p].GetConnectionState() == CONNECTION_FREE ) {
 			continue;
 		}
 
 		if ( peers[p].address.Compare( remoteAddress ) ) {
 			return p;
 		}
 	}
 	return -1;
 }
 
 /*
 ========================
 idLobby::FindFreePeer
 ========================
 */
 int idLobby::FindFreePeer() const {
 	
 	// Return the first non active peer
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		if ( !peers[p].IsActive()  ) {
 			return p;
 		}
 	}
 	return -1;
 }
 
 /*
 ========================
 idLobby::AddPeer
 ========================
 */
 int idLobby::AddPeer( const lobbyAddress_t & remoteAddress, idPacketProcessor::sessionId_t sessionID ) { 
 	// First, make sure we don't already have this peer
 	int p = FindPeer( remoteAddress, sessionID );
 	assert( p == -1 );		// When using session ID's, we SHOULDN'T find this remoteAddress/sessionID combo
 
 	if ( p == -1 ) {
 		// If we didn't find the peer, we need to add a new one
 		
 		p = FindFreePeer();
 
 		if ( p == -1 ) {
 			peer_t newPeer;
 			p = peers.Append( newPeer );
 		}
 		
 		peer_t & peer = peers[p];
 		
 		peer.ResetAllData();
 		
 		assert( peer.connectionState == CONNECTION_FREE );
 
 		peer.address	= remoteAddress;
 
 		peer.sessionID	= sessionID;
 
 		NET_VERBOSE_PRINT( "NET: Added peer %s at index %i\n", remoteAddress.ToString(), p );
 	} else {
 		NET_VERBOSE_PRINT( "NET: Found peer %s at index %i\n", remoteAddress.ToString(), p );
 	}
 
 	SetPeerConnectionState( p, CONNECTION_CONNECTING );
 	
 	if ( lobbyType == GetActingGameStateLobbyType() ) {
 		// Reset various flags used in game mode
 		peers[p].ResetMatchData();
 	}
 
 	return p;
 }
 
 /*
 ========================
 idLobby::DisconnectPeerFromSession
 ========================
 */
 void idLobby::DisconnectPeerFromSession( int p ) {
 	if ( !verify( IsHost() ) ) {
 		return;
 	}
 	
 	peer_t & peer = peers[p];
 
 	if ( peer.GetConnectionState() != CONNECTION_FREE ) {
 		SetPeerConnectionState( p, CONNECTION_FREE );
 	}
 }
 
 /*
 ========================
 idLobby::DisconnectAllPeers
 ========================
 */
 void idLobby::DisconnectAllPeers() {
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		DisconnectPeerFromSession( p );
 	}
 }
 
 /*
 ========================
 idLobby::SendGoodbye
 ========================
 */
 void idLobby::SendGoodbye( const lobbyAddress_t & remoteAddress, bool wasFull ) { 
 
 	if ( net_skipGoodbye.GetBool() ) {
 		return;
 	}
 
 	NET_VERBOSE_PRINT( "NET: Sending goodbye to %s for %s (wasFull = %i)\n", remoteAddress.ToString(), GetLobbyName(), wasFull );
 
 	static const int NUM_REDUNDANT_GOODBYES = 10;
 	
 	int msgType = OOB_GOODBYE;
 
 	if ( wasFull ) {
 		msgType = OOB_GOODBYE_FULL;
 	} else if ( lobbyType == TYPE_GAME && ( sessionCB->GetSessionOptions() & idSession::OPTION_LEAVE_WITH_PARTY ) && !( parms.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) ) {
 		msgType = OOB_GOODBYE_W_PARTY;
 	}
 	
 	for ( int i = 0; i < NUM_REDUNDANT_GOODBYES; i++ ) { 
 		SendConnectionLess( remoteAddress, msgType ); 
 	} 
 }
 
 /*
 ========================
 idLobby::SetPeerConnectionState
 ========================
 */
 void idLobby::SetPeerConnectionState( int p, connectionState_t newState, bool skipGoodbye ) {
 
 	if ( !verify( p >= 0 && p < peers.Num() ) ) {
 		idLib::Printf( "NET: SetPeerConnectionState invalid peer index %i\n", p );
 		return;
 	}
 
 	peer_t & peer = peers[p];
 
 	const lobbyType_t actingGameStateLobbyType = GetActingGameStateLobbyType();
 
 	if ( peer.GetConnectionState() == newState ) {
 		idLib::Printf( "NET: SetPeerConnectionState: Peer already in state %i\n", newState );
 		assert( 0 );	// This case means something is most likely bad, and it's the programmers fault
 		assert( ( peer.packetProc != NULL ) == peer.IsActive() );
 		assert( ( ( peer.snapProc != NULL ) == peer.IsActive() ) == ( actingGameStateLobbyType == lobbyType ) );
 		return;
 	}
 
 	if ( newState == CONNECTION_CONNECTING ) {
 		//mem.PushHeap();
 
 		// We better be coming from a free connection state if we are trying to connect
 		assert( peer.GetConnectionState() == CONNECTION_FREE );
 
 		assert( peer.packetProc == NULL );
 		peer.packetProc = new ( TAG_NETWORKING )idPacketProcessor();
 
 		if ( lobbyType == actingGameStateLobbyType ) {
 			assert( peer.snapProc == NULL );
 			peer.snapProc = new ( TAG_NETWORKING )idSnapshotProcessor();
 		}
 
 		//mem.PopHeap();
 	} else if ( newState == CONNECTION_ESTABLISHED ) {
 		// If we are marking this peer as connected for the first time, make sure this peer was actually trying to connect.
 		assert( peer.GetConnectionState() == CONNECTION_CONNECTING );
 	} else if ( newState == CONNECTION_FREE ) {
 		// If we are freeing this connection and we had an established connection before, make sure to send a goodbye
 		if ( peer.GetConnectionState() == CONNECTION_ESTABLISHED && !skipGoodbye ) {
 			idLib::Printf("SetPeerConnectionState: Sending goodbye to peer %s from session %s\n", peer.address.ToString(), GetLobbyName() );
 			SendGoodbye( peer.address );
 		}
 	}
 
 	peer.connectionState = newState;
 
 	if ( !peer.IsActive() ) {
 		if ( peer.packetProc != NULL ) {
 			delete peer.packetProc;
 			peer.packetProc = NULL;
 		}
 
 		if ( peer.snapProc != NULL ) {
 			assert( lobbyType == actingGameStateLobbyType );
 			delete peer.snapProc;
 			peer.snapProc = NULL;
 		}
 	}
 
 	// Do this in case we disconnected the peer
 	if ( IsHost() ) {
 		RemoveUsersWithDisconnectedPeers();
 	}
 }
 
 /*
 ========================
 idLobby::QueueReliableMessage
 ========================
 */
 void idLobby::QueueReliableMessage( int p, byte type, const byte * data, int dataLen ) {
 	if ( !verify( p >= 0 && p < peers.Num() ) ) {
 		return;
 	}
 
 	peer_t & peer = peers[p];
 	
 	if ( !peer.IsConnected() ) {
 		// Don't send to this peer if we don't have an established connection of this session type
 		NET_VERBOSE_PRINT( "NET: Not sending reliable type %i to peer %i because connectionState is %i\n", type, p, peer.GetConnectionState() );
 		return;
 	}
 
 	if ( peer.packetProc->NumQueuedReliables() > 2 ) {
 		idLib::PrintfIf( false, "NET: peer.packetProc->NumQueuedReliables() > 2: %i (%i / %s)\n", peer.packetProc->NumQueuedReliables(), p, peer.address.ToString() );
 	}
 
 	if ( !peer.packetProc->QueueReliableMessage( type, data, dataLen ) ) {
 		// For now, when this happens, disconnect from all session types
 		NET_VERBOSE_PRINT( "NET: Dropping peer because we overflowed his reliable message queue\n" );
 		if ( IsHost() ) {
 			// Disconnect peer from this session type
 			DisconnectPeerFromSession( p );
 		} else {
 			Shutdown();		// Shutdown session if we can't queue the reliable
 		}
 	}
 }
 
 /*
 ========================
 idLobby::GetNumConnectedPeers
 ========================
 */
 int idLobby::GetNumConnectedPeers() const {
 	int numConnected = 0;
 	for ( int i = 0; i < peers.Num(); i++ ) {
 		if ( peers[i].IsConnected() ) {
 			numConnected++;
 		}
 	}
 
 	return numConnected;
 }
 
 /*
 ========================
 idLobby::GetNumConnectedPeersInGame
 ========================
 */
 int idLobby::GetNumConnectedPeersInGame() const {
 	int numActive = 0;
 	for ( int i = 0; i < peers.Num(); i++ ) {
 		if ( peers[i].IsConnected() && peers[i].inGame ) {
 			numActive++;
 		}
 	}
 
 	return numActive;
 }
 
 
 /*
 ========================
 idLobby::SendMatchParmsToPeers
 ========================
 */
 void idLobby::SendMatchParmsToPeers() {	
 	if ( !IsHost() ) {
 		return;
 	}
 
 	if ( GetNumConnectedPeers() == 0 ) {
 		return;
 	}
 
 	byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
 	idBitMsg msg( buffer, sizeof( buffer ) );
 	parms.Write( msg );
 	
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		if ( !peers[p].IsConnected() ) {
 			continue;
 		}
 		QueueReliableMessage( p, RELIABLE_MATCH_PARMS, msg.GetReadData(), msg.GetSize() );
 	}
 }
 
 /*
 ========================
 STATIC idLobby::IsReliablePlayerToPlayerType
 ========================
 */
 bool idLobby::IsReliablePlayerToPlayerType( byte type ) {
 	return ( type >= RELIABLE_PLAYER_TO_PLAYER_BEGIN ) && ( type < RELIABLE_PLAYER_TO_PLAYER_END );
 }
 
 /*
 ========================
 idLobby::HandleReliablePlayerToPlayerMsg
 ========================
 */
 void idLobby::HandleReliablePlayerToPlayerMsg( int peerNum, idBitMsg & msg, int type ) {
 	reliablePlayerToPlayerHeader_t info;
 	int c, b;
 	msg.SaveReadState( c, b ); // in case we need to forward or fail
 
 	if ( !info.Read( this, msg ) ) {
 		idLib::Warning( "NET: Ignoring invalid reliable player to player message" );
 		msg.RestoreReadState( c, b );
 		return;
 	}
 
 	const bool isForLocalPlayer = IsSessionUserIndexLocal( info.toSessionUserIndex );
 
 	if ( isForLocalPlayer ) {
 		HandleReliablePlayerToPlayerMsg( info, msg, type );
 	} else if ( IsHost() ) {
 		const int targetPeer = PeerIndexForSessionUserIndex( info.toSessionUserIndex );
 		msg.RestoreReadState( c, b );
 		// forward the rest of the data
 		const byte * data = msg.GetReadData() + msg.GetReadCount();
 		int dataLen = msg.GetSize() - msg.GetReadCount();
 
 		QueueReliableMessage( targetPeer, type, data, dataLen );
 	} else {
 		idLib::Warning( "NET: Can't forward reliable message for remote player: I'm not the host" );
 	}
 }
 
 /*
 ========================
 idLobby::HandleReliablePlayerToPlayerMsg
 ========================
 */
 void idLobby::HandleReliablePlayerToPlayerMsg( const reliablePlayerToPlayerHeader_t & info, idBitMsg & msg, int reliableType ) {
 #if 0
 	// Remember that the reliablePlayerToPlayerHeader_t was already removed from the msg
 	reliablePlayerToPlayer_t type = (reliablePlayerToPlayer_t)( reliableType - RELIABLE_PLAYER_TO_PLAYER_BEGIN );
 
 	switch( type ) {
 		case RELIABLE_PLAYER_TO_PLAYER_VOICE_EVENT: {
 			sessionCB->HandleReliableVoiceEvent( *this, info.fromSessionUserIndex, info.toSessionUserIndex, msg );
 			break;
 		}
 
 		default: {
 			idLib::Warning( "NET: Ignored unknown player to player reliable type %i", (int) type );
 		}
 	};
 #endif
 }
 
 /*
 ========================
 idLobby::SendConnectionLess
 ========================
 */
 void idLobby::SendConnectionLess( const lobbyAddress_t & remoteAddress, byte type, const byte * data, int dataLen ) {
 	idBitMsg msg( data, dataLen );
 	msg.SetSize( dataLen );
 
 	byte buffer[ idPacketProcessor::MAX_OOB_MSG_SIZE ];
 	idBitMsg processedMsg( buffer, sizeof( buffer ) );
 
 	// Process the send
 	idPacketProcessor::ProcessConnectionlessOutgoing( msg, processedMsg, lobbyType, type );
 
 	const bool useDirectPort = ( lobbyType == TYPE_GAME_STATE );
 
 	// Send it
 	sessionCB->SendRawPacket( remoteAddress, processedMsg.GetReadData(), processedMsg.GetSize(), useDirectPort ); 
 }
 
 /*
 ========================
 idLobby::SendConnectionRequest
 ========================
 */
 void idLobby::SendConnectionRequest() {
 	// Some sanity checking
 	assert( state == STATE_CONNECT_HELLO_WAIT );
 	assert( peers[host].GetConnectionState() == CONNECTION_CONNECTING );
 	assert( GetNumLobbyUsers() == 0 );
 
 	// Buffer to hold connect msg
 	byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
 	idBitMsg msg( buffer, sizeof( buffer ) );
 
 	// Add the current version info to the handshake
 	const unsigned long localChecksum = NetGetVersionChecksum();
 	
 	NET_VERBOSE_PRINT( "NET: version = %i\n", localChecksum );
 
 	msg.WriteLong( localChecksum );
 	msg.WriteUShort( peers[host].sessionID );
 	msg.WriteBool( connectIsFromInvite );
 
 	// We use InitSessionUsersFromLocalUsers here to copy the current local users over to session users simply to have a list
 	// to send on the initial connection attempt.  We immediately clear our session user list once sent.
 	InitSessionUsersFromLocalUsers( true );
 
 	if ( GetNumLobbyUsers() > 0 ) {
 		// Fill up the msg with the users on this machine
 		msg.WriteByte( GetNumLobbyUsers() );
 
 		for ( int u = 0; u < GetNumLobbyUsers(); u++ ) {
 			GetLobbyUser( u )->WriteToMsg( msg );
 		}
 	} else {
 		FreeAllUsers();
 		SetState( STATE_FAILED );
 
 		return;
 	}
 
 	// We just used these users to fill up the msg above, we will get the real list from the server if we connect.
 	FreeAllUsers();
 
 	NET_VERBOSE_PRINT( "NET: Sending hello to: %s (lobbyType: %s, session ID %i, attempt: %i)\n", hostAddress.ToString(), GetLobbyName(), peers[host].sessionID, connectionAttempts );
 
 	SendConnectionLess( hostAddress, OOB_HELLO, msg.GetReadData(), msg.GetSize() );
 	
 	connectionAttempts++;
 }
 
 /*
 ========================
 idLobby::ConnectTo
 
 Fires off a request to get the address of a lobbyBackend owner, and then attempts to connect (eventually handled in HandleObtainingLobbyOwnerAddress)
 ========================
 */
 void idLobby::ConnectTo( const lobbyConnectInfo_t & connectInfo, bool fromInvite ) {
 	NET_VERBOSE_PRINT( "NET: idSessionLocal::ConnectTo: fromInvite = %i\n", fromInvite );
 
 	// Make sure current session is shutdown
 	Shutdown();
 
 	connectIsFromInvite = fromInvite;
 
 	lobbyBackend = sessionCB->JoinFromConnectInfo( connectInfo, (idLobbyBackend::lobbyBackendType_t)lobbyType );
 
 	// First, we need the address of the lobbyBackend owner
 	lobbyBackend->GetOwnerAddress( hostAddress );
 
 	SetState( STATE_OBTAINING_ADDRESS );
 
 }
 
 /*
 ========================
 idLobby::HandleGoodbyeFromPeer
 ========================
 */
 void idLobby::HandleGoodbyeFromPeer( int peerNum, lobbyAddress_t & remoteAddress, int msgType ) {
 	if ( migrationInfo.state != MIGRATE_NONE ) {
 		// If this peer is on our invite list, remove them
 		for ( int i = 0; i < migrationInfo.invites.Num(); i++ ) {
 			if ( migrationInfo.invites[i].address.Compare( remoteAddress, true ) ) {
 				migrationInfo.invites.RemoveIndex( i );
 				break;
 			}
 		}
 	}
 
 	if ( peerNum < 0 ) {
 		NET_VERBOSE_PRINT( "NET: Goodbye from unknown peer %s on session %s\n", remoteAddress.ToString(), GetLobbyName() );
 		return;
 	}
 
 	if ( peers[peerNum].GetConnectionState() == CONNECTION_FREE ) {
 		NET_VERBOSE_PRINT( "NET: Goodbye from peer %s on session %s that is not connected\n", remoteAddress.ToString(), GetLobbyName() );
 		return;
 	}
 
 	if ( IsHost() ) {
 		// Goodbye from peer, remove him
 		NET_VERBOSE_PRINT( "NET: Goodbye from peer %s, on session %s\n", remoteAddress.ToString(), GetLobbyName() );
 		DisconnectPeerFromSession( peerNum );
 	} else {
 		// Let session handler take care of this
 		NET_VERBOSE_PRINT( "NET: Goodbye from host %s, on session %s\n", remoteAddress.ToString(), GetLobbyName() );
 		sessionCB->GoodbyeFromHost( *this, peerNum, remoteAddress, msgType );
 	}
 }
 
 /*
 ========================
 idLobby::HandleGoodbyeFromPeer
 ========================
 */
 void idLobby::HandleConnectionAttemptFailed() {
 	Shutdown();
 	failedReason = migrationInfo.persistUntilGameEndsData.wasMigratedJoin ? FAILED_MIGRATION_CONNECT_FAILED : FAILED_CONNECT_FAILED;
 	SetState( STATE_FAILED );
 
 	if ( migrationInfo.persistUntilGameEndsData.wasMigratedJoin ) {
 		sessionCB->FailedGameMigration( *this );
 	}
 
 	ResetAllMigrationState();
 
 	needToDisplayMigrateMsg = false;
 	migrateMsgFlags			= 0;
 }
 
 /*
 ========================
 idLobby::ConnectToNextSearchResult
 ========================
 */
 bool idLobby::ConnectToNextSearchResult() {
 	if ( lobbyType != TYPE_GAME ) {
 		return false;		// Only game sessions use matchmaking searches
 	}
 
 	// End current session lobby (this WON'T free search results)
 	Shutdown();
 
 	if ( searchResults.Num() == 0 ) {
 		return false;		// No more search results to connect to, give up
 	}
 	
 	// Get next search result
 	lobbyConnectInfo_t connectInfo = searchResults[0];
 
 	// Remove this search result
 	searchResults.RemoveIndex( 0 );
 
 	// If we are connecting to a game lobby, tell our party to connect to this lobby as well
 	if ( lobbyType == TYPE_GAME && sessionCB->GetPartyLobby().IsLobbyActive() ) {
 		sessionCB->GetPartyLobby().SendMembersToLobby( lobbyType, connectInfo, true );
 	}
 
 	// Attempt to connect the lobby
 	ConnectTo( connectInfo, true );		// Pass in true for invite, since searches are for matchmaking, and we should always be able to connect to those types of matches
 
 	// Clear the "Lobby was Full" dialog in case it's up, since we are going to try to connect to a different lobby now
 	common->Dialog().ClearDialog( GDM_LOBBY_FULL );
 
 	return true;	// Notify caller we are attempting to connect
 }
 
 /*
 ========================
 idLobby::CheckVersion
 ========================
 */
 bool idLobby::CheckVersion( idBitMsg & msg, lobbyAddress_t peerAddress ) {
 	const unsigned long remoteChecksum = msg.ReadLong();
 
 	if ( net_checkVersion.GetInteger() == 1 ) {
 		const unsigned long localChecksum = NetGetVersionChecksum();
 
 		NET_VERBOSE_PRINT( "NET: Comparing handshake version - localChecksum = %i, remoteChecksum = %i\n", localChecksum, remoteChecksum );
 		return ( remoteChecksum == localChecksum );
 	}
 	return true;
 }
 
 /*
 ========================
 idLobby::VerifyNumConnectingUsers
 Make sure number of users connecting is valid, and make sure we have enough room
 ========================
 */
 bool idLobby::VerifyNumConnectingUsers( idBitMsg & msg ) {
 	int c, b;
 	msg.SaveReadState( c, b );
 	const int numUsers = msg.ReadByte();
 	msg.RestoreReadState( c, b );
 
 	const int numFreeSlots = NumFreeSlots();
 
 	NET_VERBOSE_PRINT( "NET: VerifyNumConnectingUsers %i users, %i free slots for %s\n", numUsers, numFreeSlots, GetLobbyName() );
 
 	if ( numUsers <= 0 || numUsers > MAX_PLAYERS - 1 ) {
 		NET_VERBOSE_PRINT( "NET: Invalid numUsers %i\n", numUsers );
 		return false;
 	} else if ( numUsers > numFreeSlots ) {
 		NET_VERBOSE_PRINT( "NET: %i slots requested, but only %i are available\n", numUsers, numFreeSlots );
 		return false;
 	} else if ( lobbyType == TYPE_PARTY && sessionCB->GetState() >= idSession::GAME_LOBBY && sessionCB->GetGameLobby().IsLobbyActive() && !IsMigrating() ) {
 		const int numFreeGameSlots = sessionCB->GetGameLobby().NumFreeSlots();
 
 		if ( numUsers > numFreeGameSlots ) {
 			NET_VERBOSE_PRINT( "NET: %i slots requested, but only %i are available on the active game session\n", numUsers, numFreeGameSlots );
 			return false;
 		}
 	}
 
 	return true;
 }
 
 /*
 ========================
 idLobby::VerifyLobbyUserIDs
 ========================
 */
 bool idLobby::VerifyLobbyUserIDs( idBitMsg & msg ) {
 	int c, b;
 	msg.SaveReadState( c, b );
 	const int numUsers = msg.ReadByte();
 
 	// Add the new users to our own list
 	for ( int u = 0; u < numUsers; u++ ) {
 		lobbyUser_t newUser;
 		
 		// Read in the new user
 		newUser.ReadFromMsg( msg );
 
 		if ( GetLobbyUserIndexByID( newUser.lobbyUserID, true ) != -1 ) {
 			msg.RestoreReadState( c, b );
 			return false;
 		}
 	}
 
 	msg.RestoreReadState( c, b );
 
 	return true;
 }
 
 /*
 ========================
 idLobby::HandleInitialPeerConnection
 Received on an initial peer connect request (OOB_HELLO)
 ========================
 */
 int idLobby::HandleInitialPeerConnection( idBitMsg & msg, const lobbyAddress_t & peerAddress, int peerNum ) {
 	if ( net_ignoreConnects.GetInteger() > 0 ) {
 		if ( net_ignoreConnects.GetInteger() == 2 ) {
 			SendGoodbye( peerAddress );
 		}
 		return -1;
 	}
 
 	if ( !IsHost() ) {
 		NET_VERBOSE_PRINT( "NET: Got connectionless hello from peer %s on session, and we are not a host\n", peerAddress.ToString() );
 		SendGoodbye( peerAddress );
 		return -1;
 	}
 	
 	// See if this is a peer migrating to us, if so, remove them from our invite list
 	bool migrationInvite = false;
 	int migrationGameData = -1;
 
 	
 	for ( int i = migrationInfo.invites.Num() - 1; i >= 0; i-- ) {
 		if ( migrationInfo.invites[i].address.Compare( peerAddress, true ) ) {
 				
 			migrationGameData = migrationInfo.invites[i].migrationGameData;
 			migrationInfo.invites.RemoveIndex( i );	// Remove this peer from the list, since this peer will now be connected (or rejected, either way we don't want to keep sending invites)
 			migrationInvite = true;
 			NET_VERBOSE_PRINT( "^2NET: Response from migration invite %s. GameData: %d\n", peerAddress.ToString(), migrationGameData );
 		}
 	}
 
 	if ( !MatchTypeIsJoinInProgress( parms.matchFlags ) && lobbyType == TYPE_GAME && migrationInfo.persistUntilGameEndsData.wasMigratedHost && IsMigratedStatsGame() && !migrationInvite ) {
 		// No matter what, don't let people join migrated game sessions that are going to continue on to the same game
 		// Not on invite list in a migrated game session - bounce him
 		NET_VERBOSE_PRINT( "NET: Denying game connection from %s since not on migration invite list\n", peerAddress.ToString() );
 		for ( int i = migrationInfo.invites.Num() - 1; i >= 0; i-- ) {
 			NET_VERBOSE_PRINT( "   Invite[%d] addr: %s\n", i, migrationInfo.invites[i].address.ToString() );
 		}
 		SendGoodbye( peerAddress );
 		return -1;
 	}
 
 	
 	if ( MatchTypeIsJoinInProgress( parms.matchFlags ) ) {
 		// If this is for a game connection, make sure we have a game lobby
 		if ( ( lobbyType == TYPE_GAME || lobbyType == TYPE_GAME_STATE ) && sessionCB->GetState() < idSession::GAME_LOBBY ) {
 			NET_VERBOSE_PRINT( "NET: Denying game connection from %s because we don't have a game lobby\n", peerAddress.ToString() );
 			SendGoodbye( peerAddress );
 			return -1;
 		}
 	} else {
 		// If this is for a game connection, make sure we are in the game lobby
 		if ( lobbyType == TYPE_GAME && sessionCB->GetState() != idSession::GAME_LOBBY ) {
 			NET_VERBOSE_PRINT( "NET: Denying game connection from %s while not in game lobby\n", peerAddress.ToString() );
 			SendGoodbye( peerAddress );
 			return -1;
 		}
 	
 		// If this is for a party connection, make sure we are not in game, unless this was for host migration invite
 		if ( !migrationInvite && lobbyType == TYPE_PARTY && ( sessionCB->GetState() == idSession::INGAME || sessionCB->GetState() == idSession::LOADING ) ) {
 			NET_VERBOSE_PRINT( "NET: Denying party connection from %s because we were already in a game\n", peerAddress.ToString() );
 			SendGoodbye( peerAddress );
 			return -1;
 		}
 	}
 
 	if ( !CheckVersion( msg, peerAddress ) ) {
 		idLib::Printf( "NET: Denying user %s with wrong version number\n", peerAddress.ToString() );
 		SendGoodbye( peerAddress );
 		return -1;
 	}
 
 	idPacketProcessor::sessionId_t sessionID = msg.ReadUShort();
 
 	// Check to see if this is a peer trying to connect with a different sessionID
 	// If the peer got abruptly disconnected, the peer could be trying to reconnect from a non clean disconnect
 	if ( peerNum >= 0 ) {
 		peer_t & existingPeer = peers[peerNum];
 
 		assert( existingPeer.GetConnectionState() != CONNECTION_FREE );
 
 		if ( existingPeer.sessionID == sessionID ) {
 			return peerNum;		// If this is the same sessionID, then assume redundant connection attempt
 		}
 		
 		//
 		// This peer must be trying to reconnect from a previous abrupt disconnect
 		//
 
 		NET_VERBOSE_PRINT( "NET: Reconnecting peer %s for session %s\n", peerAddress.ToString(), GetLobbyName() );
 
 		// Assume a peer is trying to reconnect from a non clean disconnect
 		// We want to set the connection back to FREE manually, so we don't send a goodbye
 		existingPeer.connectionState = CONNECTION_FREE;
 		
 		if ( existingPeer.packetProc != NULL ) {
 			delete existingPeer.packetProc;
 			existingPeer.packetProc = NULL;
 		}
 		
 		if ( existingPeer.snapProc != NULL ) {
 			assert( lobbyType == TYPE_GAME );		// Only games sessions should be creating snap processors
 			delete existingPeer.snapProc;
 			existingPeer.snapProc = NULL;
 		}
 
 		RemoveUsersWithDisconnectedPeers();
 
 		peerNum = -1;
 	}
 
 	// See if this was from an invite we sent out. If it wasn't, make sure we aren't invite only
 	const bool fromInvite = msg.ReadBool();
 
 	if ( !fromInvite && MatchTypeInviteOnly( parms.matchFlags ) ) {
 		idLib::Printf( "NET: Denying user %s because they were not invited to an invite only match\n", peerAddress.ToString() );
 		SendGoodbye( peerAddress );
 		return -1;
 	}
 
 	// Make sure we have room for the users connecting
 	if ( !VerifyNumConnectingUsers( msg ) ) {
 		NET_VERBOSE_PRINT( "NET: Denying connection from %s in session %s due to being out of user slots\n", peerAddress.ToString(), GetLobbyName() );
 		SendGoodbye( peerAddress, true );
 		return -1;
 	}
 
 	// Make sure there are no lobby id conflicts
 	if ( !verify( VerifyLobbyUserIDs( msg ) ) ) {
 		NET_VERBOSE_PRINT( "NET: Denying connection from %s in session %s due to lobby id conflict\n", peerAddress.ToString(), GetLobbyName() );
 		SendGoodbye( peerAddress, true );
 		return -1;
 	}
 
 	// Calling AddPeer will set our connectionState to this peer as CONNECTION_CONNECTING (which will get set to CONNECTION_ESTABLISHED below)
 	peerNum = AddPeer( peerAddress, sessionID );
 
 	peer_t & newPeer = peers[peerNum];
 
 	assert( newPeer.GetConnectionState() == CONNECTION_CONNECTING );
 	assert( lobbyType != GetActingGameStateLobbyType() || newPeer.snapProc != NULL );
 	
 	// First, add users from this new peer to our user list 
 	// (which will then forward the list to all peers except peerNum)
 	AddUsersFromMsg( msg, peerNum );
 
 	// Mark the peer as connected for this session type
 	SetPeerConnectionState( peerNum, CONNECTION_ESTABLISHED );
 	
 	// Update their heart beat to current
 	newPeer.lastHeartBeat = Sys_Milliseconds();
 
 	byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
 	idBitMsg outmsg( buffer, sizeof( buffer ) );
 
 	// Let them know their peer index on this host
 	// peerIndexOnHost (put this here so it shows up in search results when finding out where it's used/referenced)
 	outmsg.WriteLong( peerNum );
 
 	// If they are connecting to our party lobby, let them know the party token
 	if ( lobbyType == TYPE_PARTY ) {
 		outmsg.WriteLong( GetPartyTokenAsHost() );
 	}
 
 	if ( lobbyType == TYPE_GAME || lobbyType == TYPE_GAME_STATE ) {
 		// If this is a game session, reset the loading and ingame flags
 		newPeer.loaded = false;
 		newPeer.inGame = false;
 	}
 	
 	// Write out current match parms
 	parms.Write( outmsg );
 
 	// Send list of existing users to this new peer 
 	// (the users from the new peer will also be in this list, since we already called AddUsersFromMsg)
 	outmsg.WriteByte( GetNumLobbyUsers() );
 
 	for ( int u = 0; u < GetNumLobbyUsers(); u++ ) {
 		GetLobbyUser( u )->WriteToMsg( outmsg );
 	}
 
 	lobbyBackend->FillMsgWithPostConnectInfo( outmsg );
 
 	NET_VERBOSE_PRINT( "NET: Sending response to %s, lobbyType %s, sessionID %i\n", peerAddress.ToString(), GetLobbyName(), sessionID );
 
 	QueueReliableMessage( peerNum, RELIABLE_HELLO, outmsg.GetReadData(), outmsg.GetSize() );
 
 	if ( MatchTypeIsJoinInProgress( parms.matchFlags ) ) {
 		// If have an active game lobby, and someone joins our party, tell them to join our game
 		if ( lobbyType == TYPE_PARTY && sessionCB->GetState() >= idSession::GAME_LOBBY ) {
 			SendPeerMembersToLobby( peerNum, TYPE_GAME, false );
 		}
 
 		// We are are ingame, then start the client loading immediately
 		if ( ( lobbyType == TYPE_GAME || lobbyType == TYPE_GAME_STATE ) && sessionCB->GetState() >= idSession::LOADING ) {
 			idLib::Printf( "******* JOIN IN PROGRESS ********\n" );
 			if ( sessionCB->GetState() == idSession::INGAME ) {
 				newPeer.pauseSnapshots = true;		// Since this player joined in progress, let game dictate when to start sending snaps
 			}
 			QueueReliableMessage( peerNum, idLobby::RELIABLE_START_LOADING );
 		}
 	} else {
 		// If we are in a game lobby, and someone joins our party, tell them to join our game
 		if ( lobbyType == TYPE_PARTY && sessionCB->GetState() == idSession::GAME_LOBBY ) {
 			SendPeerMembersToLobby( peerNum, TYPE_GAME, false );
 		}
 	}
 
 	// Send mic status of the current lobby to applicable peers
 	SendPeersMicStatusToNewUsers( peerNum );
 
 	// If we made is this far, update the users migration game data index
 	for ( int u = 0; u < GetNumLobbyUsers(); u++ ) {
 		if ( GetLobbyUser( u )->peerIndex == peerNum ) {
 			GetLobbyUser( u )->migrationGameData = migrationGameData;
 		}
 	}
 
 	return peerNum;
 }
 
 /*
 ========================
 idLobby::InitStateLobbyHost
 ========================
 */
 void idLobby::InitStateLobbyHost() {
 	assert( lobbyBackend != NULL );
 
 	// We will be the host
 	isHost = true;
 
 	if ( net_headlessServer.GetBool() ) {
 		return;		// Don't add any players to headless server
 	}
 
 	if ( migrationInfo.state != MIGRATE_NONE  ) {
 		migrationInfo.persistUntilGameEndsData.wasMigratedHost = true; // InitSessionUsersFromLocalUsers needs to know this
 		migrationInfo.persistUntilGameEndsData.hasRelaunchedMigratedGame = false;
 		// migrationDlg = GDM_MIGRATING_WAITING;
 	}
 
 	// Initialize the initial user list for this lobby
 	InitSessionUsersFromLocalUsers( MatchTypeIsOnline( parms.matchFlags ) );
 
 	// Set the session's hostAddress to the local players' address.
 	const int myUserIndex = GetLobbyUserIndexByLocalUserHandle( sessionCB->GetSignInManager().GetMasterLocalUserHandle() );
 	if ( myUserIndex != -1 ) {
 		hostAddress = GetLobbyUser( myUserIndex )->address;
 	}
 
 	// Since we are the host, we have to register our initial session users with the lobby
 	// All additional users will join through AddUsersFromMsg, and RegisterUser is handled in there from here on out.
 	// Peers will add users exclusively through AddUsersFromMsg.
 	for ( int i = 0; i < GetNumLobbyUsers(); i++ ) {
 		lobbyUser_t * user = GetLobbyUser( i );
 		RegisterUser( user );
 		if ( lobbyType == TYPE_PARTY ) {
 			user->partyToken = GetPartyTokenAsHost();
 		}
 	}
 
 	// Set the lobbies skill level
 	lobbyBackend->UpdateLobbySkill( GetAverageSessionLevel() );
 
 	// Make sure and register all the addresses of the invites we'll send out as the new host
 	if ( migrationInfo.state != MIGRATE_NONE ) {
 		// Tell the session that we became the host, so the session mgr can adjust state if needed
 		sessionCB->BecameHost( *this );
 
 		// Register this address with this lobbyBackend
 		for ( int i = 0; i < migrationInfo.invites.Num(); i++ ) {
 			lobbyBackend->RegisterAddress( migrationInfo.invites[i].address );
 		}
 	}
 }
 
 /*
 ========================
 idLobby::SendMembersToLobby
 ========================
 */
 void idLobby::SendMembersToLobby( lobbyType_t destLobbyType, const lobbyConnectInfo_t & connectInfo, bool waitForOtherMembers ) {
 
 	// It's not our job to send party members to a game if we aren't the party host
 	if ( !IsHost() ) {
 		return;
 	}
 
 	// Send the message to all connected peers
 	for ( int i = 0; i < peers.Num(); i++ ) {
 		if ( peers[ i ].IsConnected() ) {
 			SendPeerMembersToLobby( i, destLobbyType, connectInfo, waitForOtherMembers );
 		}
 	}
 }
 
 /*
 ========================
 idLobby::SendMembersToLobby
 ========================
 */
 void idLobby::SendMembersToLobby( idLobby & destLobby, bool waitForOtherMembers ) {
 	if ( destLobby.lobbyBackend == NULL ) {
 		return;		// We don't have a game lobbyBackend to get an address for
 	}
 
 	lobbyConnectInfo_t connectInfo = destLobby.lobbyBackend->GetConnectInfo();
 
 	SendMembersToLobby( destLobby.lobbyType, connectInfo, waitForOtherMembers );
 }
 
 /*
 ========================
 idLobby::SendPeerMembersToLobby
 Give the address of a game lobby to a particular peer, notifying that peer to send a hello to the same server.
 ========================
 */
 void idLobby::SendPeerMembersToLobby( int peerIndex, lobbyType_t destLobbyType, const lobbyConnectInfo_t & connectInfo, bool waitForOtherMembers ) {
 	// It's not our job to send party members to a game if we aren't the party host
 	if ( !IsHost() ) {
 		return;
 	}
 
 	assert( peerIndex >= 0 );
 	assert( peerIndex < peers.Num() );
 	peer_t & peer = peers[ peerIndex ];
 
 	NET_VERBOSE_PRINT( "NET: Sending peer %i (%s) to game lobby\n", peerIndex, peer.address.ToString() );
 
 	if ( !peer.IsConnected() ) {
 		idLib::Warning( "NET: Can't send peer %i to game lobby: peer isn't in party", peerIndex );
 		return;
 	}
 
 	byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
 	idBitMsg outmsg( buffer, sizeof( buffer ) );
 
 	// Have lobby fill out msg with connection info
 	connectInfo.WriteToMsg( outmsg );
 
 	outmsg.WriteByte( destLobbyType );
 	outmsg.WriteBool( waitForOtherMembers );
 
 	QueueReliableMessage( peerIndex, RELIABLE_CONNECT_AND_MOVE_TO_LOBBY, outmsg.GetReadData(), outmsg.GetSize() );
 }
 
 /*
 ========================
 idLobby::SendPeerMembersToLobby
 
 Give the address of a game lobby to a particular peer, notifying that peer to send a hello to the same server.
 ========================
 */
 void idLobby::SendPeerMembersToLobby( int peerIndex, lobbyType_t destLobbyType, bool waitForOtherMembers ) {
 	idLobby * lobby = sessionCB->GetLobbyFromType( destLobbyType );
 
 	if ( !verify( lobby != NULL ) ) {
 		return;
 	}
 
 	if ( !verify( lobby->lobbyBackend != NULL ) ) {
 		return;
 	}
 
 	lobbyConnectInfo_t connectInfo = lobby->lobbyBackend->GetConnectInfo();
 
 	SendPeerMembersToLobby( peerIndex, destLobbyType, connectInfo, waitForOtherMembers );
 }
 
 /*
 ========================
 idLobby::NotifyPartyOfLeavingGameLobby
 ========================
 */
 void idLobby::NotifyPartyOfLeavingGameLobby() {
 	if ( lobbyType != TYPE_PARTY ) {
 		return;		// We are not a party lobby
 	}
 
 	if ( !IsHost() ) {
 		return;		// We are not the host of a party lobby, we can't do this
 	}
 
 	if ( !( sessionCB->GetSessionOptions() & idSession::OPTION_LEAVE_WITH_PARTY ) ) {
 		return;		// Options aren't set to notify party of leaving
 	}
 
 	// Tell our party to leave the game they are in
 	for ( int i = 0; i < peers.Num(); i++ ) {
 		if ( peers[ i ].IsConnected() ) {
 			QueueReliableMessage( i, RELIABLE_PARTY_LEAVE_GAME_LOBBY );
 		}
 	}
 }
 
 /*
 ========================
 idLobby::GetPartyTokenAsHost
 ========================
 */
 uint32 idLobby::GetPartyTokenAsHost() {
 	assert( lobbyType == TYPE_PARTY );
 	assert( IsHost() );
 
 	if ( partyToken == 0 ) {
 		// I don't know if this is mathematically sound, but it seems reasonable.
 		// Don't do this at app startup (i.e. in the constructor) or it will be a lot less random.
 		unsigned long seed = Sys_Milliseconds(); // time app has been running
 		idLocalUser * masterUser = session->GetSignInManager().GetMasterLocalUser();
 		if ( masterUser != NULL ) {
 			seed += idStr::Hash( masterUser->GetGamerTag() );
 		}
 		partyToken = idRandom( seed ).RandomInt();
 		idLib::Printf( "NET: PartyToken is %u (seed = %u)\n", partyToken, seed );
 	}
 	return partyToken;
 }
 
 /*
 ========================
 idLobby::EncodeSessionID
 ========================
 */
 idPacketProcessor::sessionId_t idLobby::EncodeSessionID( uint32 key ) const {
 	assert( sizeof( uint32 ) >= sizeof( idPacketProcessor::sessionId_t ) );
 	const int numBits = sizeof( idPacketProcessor::sessionId_t ) * 8 - idPacketProcessor::NUM_LOBBY_TYPE_BITS;
 	const uint32 mask = ( 1 << numBits ) - 1;
 	idPacketProcessor::sessionId_t sessionID = ( key & mask ) << idPacketProcessor::NUM_LOBBY_TYPE_BITS;
 	sessionID |= ( lobbyType + 1 );
 	return sessionID;
 }
 
 /*
 ========================
 idLobby::EncodeSessionID
 ========================
 */
 void idLobby::DecodeSessionID( idPacketProcessor::sessionId_t sessionID, uint32 & key ) const {
 	assert( sizeof( uint32 ) >= sizeof( idPacketProcessor::sessionId_t ) );
 	key = sessionID >> idPacketProcessor::NUM_LOBBY_TYPE_BITS;
 }
 
 /*
 ========================
 idLobby::GenerateSessionID
 ========================
 */
 idPacketProcessor::sessionId_t idLobby::GenerateSessionID() const {
 	idPacketProcessor::sessionId_t sessionID = EncodeSessionID( Sys_Milliseconds() );
 	
 	// Make sure we can use it
 	while ( !SessionIDCanBeUsedForInBand( sessionID ) ) {
 		sessionID = IncrementSessionID( sessionID );
 	}
 	
 	return sessionID;
 }
 
 /*
 ========================
 idLobby::SessionIDCanBeUsedForInBand
 ========================
 */
 bool idLobby::SessionIDCanBeUsedForInBand( idPacketProcessor::sessionId_t sessionID ) const {
 	if ( sessionID == idPacketProcessor::SESSION_ID_INVALID ) {
 		return false;
 	}
 
 	if ( sessionID == idPacketProcessor::SESSION_ID_CONNECTIONLESS_PARTY ) {
 		return false;
 	}
 	
 	if ( sessionID == idPacketProcessor::SESSION_ID_CONNECTIONLESS_GAME ) {
 		return false;
 	}
 
 	if ( sessionID == idPacketProcessor::SESSION_ID_CONNECTIONLESS_GAME_STATE ) {
 		return false;
 	}
 
 	return true;
 }
 
 /*
 ========================
 idLobby::IncrementSessionID
 ========================
 */
 idPacketProcessor::sessionId_t idLobby::IncrementSessionID( idPacketProcessor::sessionId_t sessionID ) const {
 	// Increment, taking into account valid id's
 	while ( 1 ) {
 		uint32 key = 0;
 		
 		DecodeSessionID( sessionID, key );
 		
 		key++;
 		
 		sessionID = EncodeSessionID( key );
 	
 		if ( SessionIDCanBeUsedForInBand( sessionID ) ) {
 			break;
 		}
 	}
 	
 	return sessionID;
 }
 
 #define VERIFY_CONNECTED_PEER( p, sessionType_, msgType )				\
 	if ( !verify( lobbyType == sessionType_ ) ) {						\
 		idLib::Printf( "NET: " #msgType ", peer:%s invalid session type for " #sessionType_ " %i.\n", peer.address.ToString(), sessionType_ );	\
 		return;															\
 	}																	\
 	if ( peers[p].GetConnectionState() != CONNECTION_ESTABLISHED ) {	\
 		idLib::Printf( "NET: " #msgType ", peer:%s not connected for " #sessionType_ " %i.\n", peer.address.ToString(), sessionType_ );	\
 		return;															\
 	}
 
 #define VERIFY_CONNECTING_PEER( p, sessionType_, msgType )				\
 	if ( !verify( lobbyType == sessionType_ ) ) {						\
 		idLib::Printf( "NET: " #msgType ", peer:%s invalid session type for " #sessionType_ " %i.\n", peer.address.ToString(), sessionType_ );	\
 		return;															\
 	}																	\
 	if ( peers[p].GetConnectionState() != CONNECTION_CONNECTING ) {		\
 		idLib::Printf( "NET: " #msgType ", peer:%s not connecting for " #sessionType_ " %i.\n", peer.address.ToString(), sessionType_ );	\
 		return;															\
 	}
 
 #define VERIFY_FROM_HOST( p, sessionType_, msgType )					\
 	VERIFY_CONNECTED_PEER( p, sessionType_, msgType );					\
 	if ( p != host ) {													\
 		idLib::Printf( "NET: "#msgType", not from "#sessionType_" host: %s\n", peer.address.ToString() );	\
 		return;															\
 	}																	\
 
 #define VERIFY_FROM_CONNECTING_HOST( p, sessionType_, msgType )			\
 	VERIFY_CONNECTING_PEER( p, sessionType_, msgType );					\
 	if ( p != host ) {													\
 		idLib::Printf( "NET: "#msgType", not from "#sessionType_" host: %s\n", peer.address.ToString() );	\
 		return;															\
 	}																	\
 
 /*
 ========================
 idLobby::HandleHelloAck
 ========================
 */
 void idLobby::HandleHelloAck( int p, idBitMsg & msg ) {
 	peer_t & peer = peers[p];
 
 	if ( state != STATE_CONNECT_HELLO_WAIT ) {
 		idLib::Printf( "NET: Hello ack for session type %s while not waiting for hello.\n", GetLobbyName() );
 		SendGoodbye( peer.address );		// We send a customary goodbye to make sure we are not in their list anymore
 		return;
 	}
 	if ( p != host ) {
 		// This shouldn't be possible
 		idLib::Printf( "NET: Hello ack for session type %s, not from correct host.\n", GetLobbyName() );
 		SendGoodbye( peer.address );		// We send a customary goodbye to make sure we are not in their list anymore
 		return;
 	}
 
 	assert( GetNumLobbyUsers() == 0 );
 
 	NET_VERBOSE_PRINT( "NET: Hello ack for session type %s from %s\n", GetLobbyName(), peer.address.ToString() );
 
 	// We are now connected to this session type
 	SetPeerConnectionState( p, CONNECTION_ESTABLISHED );
 
 	// Obtain what our peer index is on the host is
 	peerIndexOnHost = msg.ReadLong();
 
 	// If we connected to a party lobby, get the party token from the lobby owner
 	if ( lobbyType == TYPE_PARTY ) {
 		partyToken = msg.ReadLong();
 	}
 
 	// Read match parms
 	parms.Read( msg );
 
 	// Update lobbyBackend with parms
 	if ( lobbyBackend != NULL ) {
 		lobbyBackend->UpdateMatchParms( parms );
 	}
 
 	// Populate the user list with the one from the host (which will also include our local users)
 	// This ensures the user lists are kept in sync
 	FreeAllUsers();
 	AddUsersFromMsg( msg, p );
 
 	// Make sure the host has a current heartbeat
 	peer.lastHeartBeat = Sys_Milliseconds();
 
 	lobbyBackend->PostConnectFromMsg( msg );
 
 	// Tell the lobby controller to finalize the connection
 	SetState( STATE_FINALIZE_CONNECT );
 
 	//
 	// Success - We've received an ack from the server, letting us know we've been registered with the lobbies
 	//
 }
 
 /*
 ========================
 idLobby::GetLobbyUserName
 ========================
 */
 const char * idLobby::GetLobbyUserName( lobbyUserID_t lobbyUserID ) const { 
 	const int index = GetLobbyUserIndexByID( lobbyUserID );
 	const lobbyUser_t * user = GetLobbyUser( index );
 
 	if ( user == NULL ) {
 		for ( int i = 0; i < disconnectedUsers.Num(); i++ ) {
 			if ( disconnectedUsers[i].lobbyUserID.CompareIgnoreLobbyType( lobbyUserID ) ) {
 				return disconnectedUsers[i].gamertag;
 			}
 		}
 		return INVALID_LOBBY_USER_NAME;
 	}
 
 	return user->gamertag;
 }
 
 /*
 ========================
 idLobby::GetLobbyUserSkinIndex
 ========================
 */
 int idLobby::GetLobbyUserSkinIndex( lobbyUserID_t lobbyUserID ) const {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 	const lobbyUser_t * user = GetLobbyUser( userIndex );
 	return user ? user->selectedSkin : 0;
 }
 
 /*
 ========================
 idLobby::GetLobbyUserWeaponAutoSwitch
 ========================
 */
 bool idLobby::GetLobbyUserWeaponAutoSwitch( lobbyUserID_t lobbyUserID ) const {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 	const lobbyUser_t * user = GetLobbyUser( userIndex );
 	return user ? user->weaponAutoSwitch : true;
 }
 
 /*
 ========================
 idLobby::GetLobbyUserWeaponAutoReload
 ========================
 */
 bool idLobby::GetLobbyUserWeaponAutoReload( lobbyUserID_t lobbyUserID ) const {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 	const lobbyUser_t * user = GetLobbyUser( userIndex );
 	return user ? user->weaponAutoReload: true;
 }
 
 /*
 ========================
 idLobby::GetLobbyUserLevel
 ========================
 */
 int idLobby::GetLobbyUserLevel( lobbyUserID_t lobbyUserID ) const {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 	const lobbyUser_t * user = GetLobbyUser( userIndex );
 	return user ? user->level : 0;
 }
 
 /*
 ========================
 idLobby::GetLobbyUserQoS
 ========================
 */
 int idLobby::GetLobbyUserQoS( lobbyUserID_t lobbyUserID ) const {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 
 	if ( IsHost() && IsSessionUserIndexLocal( userIndex ) ) {
 		return 0;		// Local users on the host of the active session have 0 ping
 	}
 
 	const lobbyUser_t * user = GetLobbyUser( userIndex );
 
 	if ( !verify( user != NULL ) ) {
 		return 0;
 	}
 
 	return user->pingMs;
 }
 
 /*
 ========================
 idLobby::GetLobbyUserTeam
 ========================
 */
 int idLobby::GetLobbyUserTeam( lobbyUserID_t lobbyUserID ) const {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 	const lobbyUser_t * user = GetLobbyUser( userIndex );
 	return user ? user->teamNumber : 0;
 }
 
 /*
 ========================
 idLobby::SetLobbyUserTeam
 ========================
 */
 bool idLobby::SetLobbyUserTeam( lobbyUserID_t lobbyUserID, int teamNumber ) {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 	lobbyUser_t * user = GetLobbyUser( userIndex );
 
 	if ( user != NULL ) {
 		if ( teamNumber != user->teamNumber ) {
 			user->teamNumber = teamNumber;
 			if ( IsHost() ) {
 				byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
 				idBitMsg msg( buffer, sizeof( buffer ) );
 				CreateUserUpdateMessage( userIndex, msg );
 				idBitMsg readMsg;
 				readMsg.InitRead( buffer, msg.GetSize() );
 				UpdateSessionUserOnPeers( readMsg );
 			}
 			return true;
 		}
 	}
 	return false;
 }
 
 /*
 ========================
 idLobby::GetLobbyUserPartyToken
 ========================
 */
 int idLobby::GetLobbyUserPartyToken( lobbyUserID_t lobbyUserID ) const {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 	const lobbyUser_t * user = GetLobbyUser( userIndex );
 	return user ? user->partyToken : 0;
 }
 
 /*
 ========================
 idLobby::GetProfileFromLobbyUser
 ========================
 */
 idPlayerProfile * idLobby::GetProfileFromLobbyUser( lobbyUserID_t lobbyUserID ) {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 
 	idPlayerProfile * profile = NULL;
 
 	idLocalUser * localUser = GetLocalUserFromLobbyUserIndex( userIndex );
 	
 	if ( localUser != NULL ) {
 		profile = localUser->GetProfile();
 	}
 	
 	if ( profile == NULL ) {
 		// Whoops
 		profile = session->GetSignInManager().GetDefaultProfile();
 		//idLib::Warning( "Returning fake profile until the code is fixed to handle NULL profiles." );
 	}
 	
 	return profile;
 }
 
 /*
 ========================
 idLobby::GetLocalUserFromLobbyUser
 ========================
 */
 idLocalUser * idLobby::GetLocalUserFromLobbyUser( lobbyUserID_t lobbyUserID ) {
 	const int userIndex = GetLobbyUserIndexByID( lobbyUserID );
 
 	return GetLocalUserFromLobbyUserIndex( userIndex );
 }
 
 /*
 ========================
 idLobby::GetNumLobbyUsersOnTeam
 ========================
 */
 int idLobby::GetNumLobbyUsersOnTeam( int teamNumber ) const {
 	int numTeam = 0;
 	for ( int i = 0; i < GetNumLobbyUsers(); ++i ) {
 		if ( GetLobbyUser( i )->teamNumber == teamNumber ) {
 			++numTeam;
 		}
 	}
 	return numTeam;
 }
 
 /*
 ========================
 idLobby::GetPeerName
 ========================
 */
 const char * idLobby::GetPeerName( int peerNum ) const {
 
 	for ( int i = 0; i < GetNumLobbyUsers(); ++i ) {
 		if ( !verify( GetLobbyUser( i ) != NULL ) ) {
 			continue;
 		}
 
 		if ( GetLobbyUser( i )->peerIndex == peerNum ) {
 			return GetLobbyUserName( GetLobbyUser( i )->lobbyUserID );
 		}
 	}
 
 	return INVALID_LOBBY_USER_NAME;
 }
 
 /*
 ========================
 idLobby::HandleReliableMsg
 ========================
 */
 void idLobby::HandleReliableMsg( int p, idBitMsg & msg ) {
 	peer_t & peer = peers[p];
 
 	int reliableType = msg.ReadByte();
 	
 	//idLib::Printf(" Received reliable msg: %i \n", reliableType );
 
 	const lobbyType_t actingGameStateLobbyType = GetActingGameStateLobbyType();
 
 	if ( reliableType == RELIABLE_HELLO ) {		
 		VERIFY_FROM_CONNECTING_HOST( p, lobbyType, RELIABLE_HELLO );
 		// This is sent from the host acking a request to join the game lobby
 		HandleHelloAck( p, msg );
 		return;		
 	} else if ( reliableType == RELIABLE_USER_CONNECT_REQUEST ) {
 		VERIFY_CONNECTED_PEER( p, lobbyType, RELIABLE_USER_CONNECT_REQUEST );
 
 		// This message is sent from a peer requesting for a new user to join the game lobby
 		// This will be sent while we are in a game lobby as a host.  otherwise, denied.
 		NET_VERBOSE_PRINT( "NET: RELIABLE_USER_CONNECT_REQUEST (%s) from %s\n", GetLobbyName(), peer.address.ToString() );
 		
 		idSession::sessionState_t expectedState = ( lobbyType == TYPE_PARTY ) ? idSession::PARTY_LOBBY : idSession::GAME_LOBBY;
 
 		if ( sessionCB->GetState() == expectedState && IsHost() && NumFreeSlots() > 0 ) {	// This assumes only one user in the msg
 			// Add user to session, which will also forward the operation to all other peers
 			AddUsersFromMsg( msg, p );
 		} else {
 			// Let peer know user couldn't be added
 			HandleUserConnectFailure( p, msg, RELIABLE_USER_CONNECT_DENIED );
 		}
 	} else if ( reliableType == RELIABLE_USER_CONNECT_DENIED ) {
 		// This message is sent back from the host when a RELIABLE_PARTY_USER_CONNECT_REQUEST failed
 		VERIFY_FROM_HOST( p, lobbyType, RELIABLE_PARTY_USER_CONNECT_DENIED );
 		
 		// Remove this user from the sign-in manager, so we don't keep trying to add them
 		if ( !sessionCB->GetSignInManager().RemoveLocalUserByHandle( localUserHandle_t( msg.ReadLong() ) ) ) {
 			NET_VERBOSE_PRINT( "NET: RELIABLE_PARTY_USER_CONNECT_DENIED, local user not found\n" );
 			return;
 		}
 	} else if ( reliableType == RELIABLE_KICK_PLAYER ) {
 		VERIFY_FROM_HOST( p, lobbyType, RELIABLE_KICK_PLAYER );
 		common->Dialog().AddDialog( GDM_KICKED, DIALOG_ACCEPT, NULL, NULL, false );
 		if ( sessionCB->GetPartyLobby().IsHost() ) {
 			session->SetSessionOption( idSession::OPTION_LEAVE_WITH_PARTY );
 		}
 		session->Cancel();
 	} else if ( reliableType == RELIABLE_HEADSET_STATE ) {
 		HandleHeadsetStateChange( p, msg );
 	} else if ( reliableType == RELIABLE_USER_CONNECTED ) {
 		// This message is sent back from the host when users have connected, and we need to update our lists to reflect that
 		VERIFY_FROM_HOST( p, lobbyType, RELIABLE_USER_CONNECTED );
 
 		NET_VERBOSE_PRINT( "NET: RELIABLE_USER_CONNECTED (%s) from %s\n", GetLobbyName(), peer.address.ToString() );
 		AddUsersFromMsg( msg, p );
 	} else if ( reliableType == RELIABLE_USER_DISCONNECTED ) {
 		// This message is sent back from the host when users have diconnected, and we need to update our lists to reflect that
 		VERIFY_FROM_HOST( p, lobbyType, RELIABLE_USER_DISCONNECTED );
 
 		ProcessUserDisconnectMsg( msg );
 	} else if ( reliableType == RELIABLE_MATCH_PARMS ) {
 		parms.Read( msg );
 		// Update lobby with parms
 		if ( lobbyBackend != NULL ) {
 			lobbyBackend->UpdateMatchParms( parms );
 		}
 	} else if ( reliableType == RELIABLE_START_LOADING ) {
 		// This message is sent from the host to start loading a map
 		VERIFY_FROM_HOST( p, actingGameStateLobbyType, RELIABLE_START_LOADING );
 
 		NET_VERBOSE_PRINT( "NET: RELIABLE_START_LOADING from %s\n", peer.address.ToString() );
 
 		startLoadingFromHost = true;
 	} else if ( reliableType == RELIABLE_LOADING_DONE ) {
 		// This message is sent from the peers to state they are done loading the map
 		VERIFY_CONNECTED_PEER( p, actingGameStateLobbyType, RELIABLE_LOADING_DONE );
 
 		unsigned long networkChecksum = 0;
 		networkChecksum = msg.ReadLong();
 
 		peer.networkChecksum = networkChecksum;
 		peer.loaded = true;
 	} else if ( reliableType == RELIABLE_IN_GAME ) {
 		VERIFY_CONNECTED_PEER( p, actingGameStateLobbyType, RELIABLE_IN_GAME );
 
 		peer.inGame = true;
 	} else if ( reliableType == RELIABLE_SNAPSHOT_ACK ) {
 		VERIFY_CONNECTED_PEER( p, actingGameStateLobbyType, RELIABLE_SNAPSHOT_ACK );
 
 		// update our base state for his last received snapshot
 		int snapNum = msg.ReadLong();
 		float receivedBps = msg.ReadQuantizedUFloat< BANDWIDTH_REPORTING_MAX, BANDWIDTH_REPORTING_BITS >();
 
 		// Update reported received bps
 		if ( peer.receivedBpsIndex != snapNum ) {
 			// Only do this the first time we get reported bps per snapshot. Subsequent ACKs of the same shot will usually have lower reported bps
 			// due to more time elapsing but not receiving a new ss
 			peer.receivedBps = receivedBps;
 			peer.receivedBpsIndex = snapNum;
 		}
 
 		ApplySnapshotDelta( p, snapNum );
 		
 		//idLib::Printf( "NET: Peer %d Ack'd snapshot %d\n", p, snapNum );
 		NET_VERBOSESNAPSHOT_PRINT_LEVEL( 2, va( "NET: Peer %d Ack'd snapshot %d\n", p, snapNum ) );
 
 	} else if ( reliableType == RELIABLE_RESOURCE_ACK ) {
 	} else if ( reliableType == RELIABLE_UPDATE_MATCH_PARMS ) {
 		VERIFY_CONNECTED_PEER( p, TYPE_GAME, RELIABLE_UPDATE_MATCH_PARMS );
 		int msgType = msg.ReadLong();
 		sessionCB->HandlePeerMatchParamUpdate( p, msgType );
 
 	} else if ( reliableType == RELIABLE_MATCHFINISHED ) {
 		VERIFY_FROM_HOST( p, actingGameStateLobbyType, RELIABLE_MATCHFINISHED );
 
 		sessionCB->ClearMigrationState();
 
 	} else if ( reliableType == RELIABLE_ENDMATCH ) {
 		VERIFY_FROM_HOST( p, actingGameStateLobbyType, RELIABLE_ENDMATCH );
 
 		sessionCB->EndMatchInternal();
 
 	}  else if ( reliableType == RELIABLE_ENDMATCH_PREMATURE ) {
 		VERIFY_FROM_HOST( p, actingGameStateLobbyType, RELIABLE_ENDMATCH_PREMATURE );	
 
 		sessionCB->EndMatchInternal( true );
 
 	} else if ( reliableType == RELIABLE_START_MATCH_GAME_LOBBY_HOST ) {
 		// This message should be from the host of the game lobby, telling us (as the host of the GameStateLobby) to start loading
 		VERIFY_CONNECTED_PEER( p, TYPE_GAME_STATE, RELIABLE_START_MATCH_GAME_LOBBY_HOST );
 
 		if ( session->GetState() >= idSession::LOADING ) {
 			NET_VERBOSE_PRINT( "NET: RELIABLE_START_MATCH_GAME_LOBBY_HOST already loading\n" );
 			return;
 		}
 
 		// Read match parms, and start loading
 		parms.Read( msg );
 
 		// Send these new match parms to currently connected peers
 		SendMatchParmsToPeers();
 
 		startLoadingFromHost = true;		// Hijack this flag
 	} else if ( reliableType == RELIABLE_ARBITRATE ) {
 		VERIFY_CONNECTED_PEER( p, TYPE_GAME, RELIABLE_ARBITRATE );
 		// Host telling us to arbitrate
 		// Set a flag to do this later, since the lobby may not be in a state where it can fulfil the request at the moment
 		respondToArbitrate = true;
 	} else if ( reliableType == RELIABLE_ARBITRATE_OK ) {
 		VERIFY_CONNECTED_PEER( p, TYPE_GAME, RELIABLE_ARBITRATE_OK );
 		
 		NET_VERBOSE_PRINT( "NET: Got an arbitration ok from %d\n", p );
 
 		everyoneArbitrated = true;
 		for ( int i = 0; i < GetNumLobbyUsers(); i++ ) {
 			lobbyUser_t * user = GetLobbyUser( i );
 			if ( !verify( user != NULL ) ) {
 				continue;
 			}
 			if ( user->peerIndex == p ) {
 				user->arbitrationAcked = true;
 			} else if ( !user->arbitrationAcked ) {
 				everyoneArbitrated = false;
 			}
 		}
 
 		if ( everyoneArbitrated ) {
 			NET_VERBOSE_PRINT( "NET: Everyone says they registered for arbitration, verifying\n" );
 			lobbyBackend->Arbitrate();
 			//sessionCB->EveryoneArbitrated();
 			return;
 		}
 	} else if ( reliableType == RELIABLE_POST_STATS ) {
 		VERIFY_FROM_HOST( p, actingGameStateLobbyType, RELIABLE_POST_STATS );
 		sessionCB->RecvLeaderboardStats( msg );
 	} else if ( reliableType == RELIABLE_SESSION_USER_MODIFIED ) {
 		VERIFY_CONNECTED_PEER( p, lobbyType, RELIABLE_SESSION_USER_MODIFIED );
 		UpdateSessionUserOnPeers( msg );
 
 	} else if ( reliableType == RELIABLE_UPDATE_SESSION_USER ) {
 		VERIFY_FROM_HOST( p, lobbyType, RELIABLE_UPDATE_SESSION_USER );
 		HandleUpdateSessionUser( msg );
 	} else if ( reliableType == RELIABLE_CONNECT_AND_MOVE_TO_LOBBY ) {		
 		VERIFY_FROM_HOST( p, lobbyType, RELIABLE_CONNECT_AND_MOVE_TO_LOBBY );
 		
 		NET_VERBOSE_PRINT( "NET: RELIABLE_CONNECT_AND_MOVE_TO_LOBBY\n" );
 
 		if ( IsHost() ) {
 			idLib::Printf( "RELIABLE_CONNECT_AND_MOVE_TO_LOBBY: We are the host.\n" ); 
 			return;
 		}
 
 		// Get connection info
 		lobbyConnectInfo_t connectInfo;
 		connectInfo.ReadFromMsg( msg );
 
 		const lobbyType_t	destLobbyType	= (lobbyType_t)msg.ReadByte();
 		const bool			waitForMembers	= msg.ReadBool();
 
 		assert( destLobbyType > lobbyType );		// Make sure this is a proper transition (i.e. TYPE_PARTY moves to TYPE_GAME, TYPE_GAME moves to TYPE_GAME_STATE)
 
 		sessionCB->ConnectAndMoveToLobby( destLobbyType, connectInfo, waitForMembers );
 	} else if ( reliableType == RELIABLE_PARTY_CONNECT_OK ) {
 		VERIFY_FROM_HOST( p, TYPE_PARTY, RELIABLE_PARTY_CONNECT_OK );
 		if ( !sessionCB->GetGameLobby().waitForPartyOk ) {
 			idLib::Printf( "RELIABLE_PARTY_CONNECT_OK: Wasn't waiting for ok.\n" ); 
 		}
 		sessionCB->GetGameLobby().waitForPartyOk = false;
 	} else if ( reliableType == RELIABLE_PARTY_LEAVE_GAME_LOBBY ) {		
 		VERIFY_FROM_HOST( p, TYPE_PARTY, RELIABLE_PARTY_LEAVE_GAME_LOBBY );
 		
 		NET_VERBOSE_PRINT( "NET: RELIABLE_PARTY_LEAVE_GAME_LOBBY\n" );
 		
 		if ( sessionCB->GetState() != idSession::GAME_LOBBY ) {
 			idLib::Printf( "RELIABLE_PARTY_LEAVE_GAME_LOBBY: Not in a game lobby, ignoring.\n" ); 
 			return;
 		}
 
 		if ( IsHost() ) {
 			idLib::Printf( "RELIABLE_PARTY_LEAVE_GAME_LOBBY: Host of party, ignoring.\n" ); 
 			return;
 		}
 
 		sessionCB->LeaveGameLobby();
 	} else if ( IsReliablePlayerToPlayerType( reliableType ) ) {
 		HandleReliablePlayerToPlayerMsg( p, msg, reliableType );
 	} else if ( reliableType == RELIABLE_PING ) {
 		HandleReliablePing( p, msg );
 	} else if ( reliableType == RELIABLE_PING_VALUES ) {
 		HandlePingValues( msg );
 	} else if ( reliableType == RELIABLE_BANDWIDTH_VALUES ) {
 		HandleBandwidhTestValue( p, msg );
 	} else if ( reliableType == RELIABLE_MIGRATION_GAME_DATA ) {
 		HandleMigrationGameData( msg );
 	} else if ( reliableType >= RELIABLE_GAME_DATA ) {
 
 		VERIFY_CONNECTED_PEER( p, lobbyType, RELIABLE_GAME_DATA );
 
 		common->NetReceiveReliable( p, reliableType - RELIABLE_GAME_DATA, msg );
 	} else if ( reliableType == RELIABLE_DUMMY_MSG ) {
 		// Ignore dummy msg's
 		NET_VERBOSE_PRINT( "NET: ignoring dummy msg from %s\n", peer.address.ToString() );
 	} else {
 		NET_VERBOSE_PRINT( "NET: Unknown reliable packet type %d from %s\n", reliableType, peer.address.ToString() );
 	}
 }
 
 /*
 ========================
 idLobby::GetTotalOutgoingRate
 ========================
 */
 int idLobby::GetTotalOutgoingRate() {
 	int totalSendRate = 0;
 	for ( int p = 0; p < peers.Num(); p++ ) {		
 		const peer_t & peer = peers[p];
 		
 		if ( !peer.IsConnected() ) {
 			continue;
 		}
 		
 		const idPacketProcessor & proc = *peer.packetProc;
 
 		totalSendRate += proc.GetOutgoingRateBytes();
 	}
 	return totalSendRate;
 }
 
 /*
 ========================
 idLobby::DrawDebugNetworkHUD
 ========================
 */
 extern idCVar net_forceUpstream;
 void idLobby::DrawDebugNetworkHUD() const {
 	int		totalSendRate = 0;
 	int		totalRecvRate = 0;
 	float	totalSentMB = 0.0f;
 	float	totalRecvMB = 0.0f;
 	
 	const float Y_OFFSET	= 20.0f;
 	const float X_OFFSET	= 20.0f;
 	const float Y_SPACING	= 15.0f;
 
 	float curY = Y_OFFSET;
 
 	int numLines = ( net_forceUpstream.GetFloat() != 0.0f ? 6: 5 );
 
 	renderSystem->DrawFilled( idVec4( 0.0f, 0.0f, 0.0f, 0.7f ), X_OFFSET - 10.0f, curY - 10.0f, 1550, ( peers.Num() + numLines ) * Y_SPACING + 20.0f );
 
 	renderSystem->DrawSmallStringExt( idMath::Ftoi( X_OFFSET ), idMath::Ftoi( curY ), "# Peer                   | Sent kB/s | Recv kB/s | Sent MB | Recv MB | Ping   | L |  %  | R.NM | R.SZ | R.AK | T", colorGreen, false );
 	curY += Y_SPACING;
 
 	renderSystem->DrawSmallStringExt( idMath::Ftoi( X_OFFSET ), idMath::Ftoi( curY ), "------------------------------------------------------------------------------------------------------------------------------------", colorGreen, false );
 	curY += Y_SPACING;
 
 	for ( int p = 0; p < peers.Num(); p++ ) {		
 		const peer_t & peer = peers[p];
 		
 		if ( !peer.IsConnected() ) {
 			continue;
 		}
 		
 		const idPacketProcessor & proc = *peer.packetProc;
 		
 		totalSendRate += proc.GetOutgoingRateBytes();
 		totalRecvRate += proc.GetIncomingRateBytes();
 		float sentKps = (float)proc.GetOutgoingRateBytes() / 1024.0f;
 		float recvKps = (float)proc.GetIncomingRateBytes() / 1024.0f;
 		float sentMB = (float)proc.GetOutgoingBytes() / ( 1024.0f * 1024.0f );
 		float recvMB = (float)proc.GetIncomingBytes() / ( 1024.0f * 1024.0f );
 		
 		totalSentMB += sentMB;
 		totalRecvMB += recvMB;
 		
 		idVec4 color = sentKps > 20.0f ? colorRed : colorGreen;
 
 		int resourcePercent = 0;
 		idStr name = peer.address.ToString();
 		
 		name += lobbyType == TYPE_PARTY ? "(P": "(G";
 		name += host == p ? ":H)" : ":C)";
 
 		renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "%i %22s | %2.02f kB/s | %2.02f kB/s | %2.02f MB | %2.02f MB |%4i ms | %i | %i%% | %i | %i | %i | %2.2f / %2.2f / %i", p, name.c_str(), sentKps, recvKps, sentMB, recvMB, peer.lastPingRtt, peer.loaded, resourcePercent, peer.packetProc->NumQueuedReliables(), peer.packetProc->GetReliableDataSize(), peer.packetProc->NeedToSendReliableAck(), peer.snapHz, peer.maxSnapBps, peer.failedPingRecoveries ), color, false );
 		curY += Y_SPACING;
 	}
 
 	renderSystem->DrawSmallStringExt( idMath::Ftoi( X_OFFSET ), idMath::Ftoi( curY ), "------------------------------------------------------------------------------------------------------------------------------------", colorGreen, false );
 	curY += Y_SPACING;
 
 	float totalSentKps = (float)totalSendRate / 1024.0f;
 	float totalRecvKps = (float)totalRecvRate / 1024.0f;
 	
 	idVec4 color = totalSentKps > 100.0f ? colorRed : colorGreen;
 	
 	renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "# %20s | %2.02f KB/s | %2.02f KB/s | %2.02f MB | %2.02f MB", "", totalSentKps, totalRecvKps, totalSentMB, totalRecvMB ), color, false );
 	curY += Y_SPACING;
 
 	if ( net_forceUpstream.GetFloat() != 0.0f ) {
 		float upstreamDropRate = session->GetUpstreamDropRate();
 		float upstreamQueuedRate = session->GetUpstreamQueueRate();
 
 		int queuedBytes = session->GetQueuedBytes();
 		renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "Queued: %d | Dropping: %2.02f kB/s Queue: %2.02f kB/s -> Effective %2.02f kB/s", queuedBytes, upstreamDropRate / 1024.0f, upstreamQueuedRate / 1024.0f, totalSentKps - ( upstreamDropRate / 1024.0f ) + ( upstreamQueuedRate / 1024.0f ) ), color, false );
 	}
 }
 
 /*
 ========================
 idLobby::DrawDebugNetworkHUD2
 ========================
 */
 void idLobby::DrawDebugNetworkHUD2() const {
 	int		totalSendRate = 0;
 	int		totalRecvRate = 0;
 
 	const float Y_OFFSET	= 20.0f;
 	const float X_OFFSET	= 20.0f;
 	const float Y_SPACING	= 15.0f;
 
 	float	curY = Y_OFFSET;
 	
 	renderSystem->DrawFilled( idVec4( 0.0f, 0.0f, 0.0f, 0.7f ), X_OFFSET - 10.0f, curY - 10.0f, 550, (peers.Num() + 4) * Y_SPACING + 20.0f );	
 
 	const char* stateName = session->GetStateString();
 
 	renderSystem->DrawFilled( idVec4( 1.0f, 1.0f, 1.0f, 0.7f ), X_OFFSET - 10.0f, curY - 10.0f, 550, (peers.Num() + 5) * Y_SPACING + 20.0f );
 
 	renderSystem->DrawSmallStringExt( idMath::Ftoi( X_OFFSET ), idMath::Ftoi( curY ), va("State: %s. Local time: %d", stateName, Sys_Milliseconds() ), colorGreen, false );
 	curY += Y_SPACING;
 
 	renderSystem->DrawSmallStringExt( idMath::Ftoi( X_OFFSET ), idMath::Ftoi( curY ), "Peer           | Sent kB/s | Recv kB/s | L | R | Resources", colorGreen, false );
 	curY += Y_SPACING;
 
 	renderSystem->DrawSmallStringExt( idMath::Ftoi( X_OFFSET ), idMath::Ftoi( curY ), "------------------------------------------------------------------", colorGreen, false );
 	curY += Y_SPACING;
 
 	for ( int p = 0; p < peers.Num(); p++ ) {
 
 		if ( !peers[ p ].IsConnected() ) {
 			continue;
 		}
 
 		idPacketProcessor & proc = *peers[ p ].packetProc;
 
 		totalSendRate += proc.GetOutgoingRate2();
 		totalRecvRate += proc.GetIncomingRate2();
 		float sentKps = ( float )proc.GetOutgoingRate2() / 1024.0f;
 		float recvKps = ( float )proc.GetIncomingRate2() / 1024.0f;
 
 		// should probably complement that with a bandwidth reading
 		// right now I am mostly concerned about fragmentation and the latency spikes it will cause
 		idVec4 color = proc.TickFragmentAccumulator() ? colorRed : colorGreen;
 		
 		int rLoaded = peers[ p ].numResources;
 		int rTotal = 0;
 
 		// show the names of the clients connected to the server. Also make sure it looks reasonably good.
 		idStr peerName;
 		if ( IsHost() ) {
 			peerName = GetPeerName( p );
 
 			int MAX_PEERNAME_LENGTH = 10;
 			int nameLength = peerName.Length();
 			if ( nameLength > MAX_PEERNAME_LENGTH ) {
 				peerName = peerName.Left( MAX_PEERNAME_LENGTH );
 			} else if ( nameLength < MAX_PEERNAME_LENGTH ) {
 				idStr filler;
 				filler.Fill( ' ', MAX_PEERNAME_LENGTH );
 				peerName += filler.Left( MAX_PEERNAME_LENGTH - nameLength );
 			}
 		} else {
 			peerName = "Local     ";
 		}
 
 		renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "%i - %s | %2.02f kB/s | %2.02f kB/s | %i | %i | %d/%d", p, peerName.c_str(), sentKps, recvKps, peers[p].loaded, peers[p].address.UsingRelay(), rLoaded, rTotal ), color, false );
 		curY += Y_SPACING;
 	}
 
 	renderSystem->DrawSmallStringExt( idMath::Ftoi( X_OFFSET ), idMath::Ftoi( curY ), "------------------------------------------------------------------", colorGreen, false );
 	curY += Y_SPACING;
 
 	float totalSentKps = (float)totalSendRate / 1024.0f;
 	float totalRecvKps = (float)totalRecvRate / 1024.0f;
 
 	renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "Total | %2.02f KB/s | %2.02f KB/s", totalSentKps, totalRecvKps ), colorGreen, false );
 }
 
 
 /*
 ========================
 idLobby::DrawDebugNetworkHUD_ServerSnapshotMetrics
 ========================
 */
 idCVar net_debughud3_bps_max( "net_debughud3_bps_max", "5120.0f", CVAR_FLOAT, "Highest factor of server base snapRate that a client can be throttled" );
 void idLobby::DrawDebugNetworkHUD_ServerSnapshotMetrics( bool draw ) {
 	const float Y_OFFSET	= 20.0f;
 	const float X_OFFSET	= 20.0f;
 	const float Y_SPACING	= 15.0f;
 	idVec4 color = colorWhite;
 
 	float	curY = Y_OFFSET;
 
 	if ( !draw ) {
 		for ( int p=0; p < peers.Num(); p++ ) {
 			for ( int i=0; i < peers[p].debugGraphs.Num(); i++ ) {
 				if ( peers[p].debugGraphs[i] != NULL ) {
 					peers[p].debugGraphs[i]->Enable( false );
 				} else {
 					return;
 				}
 			}
 		}
 		return;
 	}
 
 	static int lastTime = 0;
 	int time = Sys_Milliseconds();
 
 	for ( int p = 0; p < peers.Num(); p++ ) {
 
 		peer_t & peer = peers[p];
 
 		if ( !peer.IsConnected() ) {
 			continue;
 		}
 
 		idPacketProcessor * packetProc = peer.packetProc;
 		idSnapshotProcessor * snapProc = peer.snapProc;
 
 		if ( !verify( packetProc != NULL && snapProc != NULL ) ) {
 			continue;
 		}
 
 		int snapSeq = snapProc->GetSnapSequence();
 		int snapBase = snapProc->GetBaseSequence();
 		int deltaSeq = snapSeq - snapBase;
 		bool throttled = peer.throttledSnapRate > common->GetSnapRate();
 
 		int numLines =  net_forceUpstream.GetBool() ? 5 : 4;
 
 		const int width = renderSystem->GetWidth()/2.0f - (X_OFFSET * 2);
 
 		enum netDebugGraphs_t {
 			GRAPH_SNAPSENT,
 			GRAPH_OUTGOING,
 			GRAPH_INCOMINGREPORTED,
 			GRAPH_MAX
 		};
 
 		peer.debugGraphs.SetNum( GRAPH_MAX, NULL );
 		for ( int i=0; i < GRAPH_MAX; i++ ) {
 			// Initialize graphs 
 			if ( peer.debugGraphs[i] == NULL ) {
 				peer.debugGraphs[i] = console->CreateGraph( 500 );
 				if ( !verify( peer.debugGraphs[i] != NULL ) ) {
 					continue;
 				}
 				
 				peer.debugGraphs[i]->SetPosition( X_OFFSET - 10.0f + width, curY - 10.0f, width , Y_SPACING * numLines );
 			}
 			
 			peer.debugGraphs[i]->Enable( true );		
 		}
 
 		renderSystem->DrawFilled( idVec4( 0.0f, 0.0f, 0.0f, 0.7f ), X_OFFSET - 10.0f, curY - 10.0f, width, ( Y_SPACING * numLines ) + 20.0f );
 
 		renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "Peer %d - %s RTT %d %sPeerSnapRate: %d %s", p, GetPeerName( p ), peer.lastPingRtt, throttled ? "^1" : "^2", peer.throttledSnapRate/1000, throttled ? "^1Throttled" : ""  ), color, false );
 		curY += Y_SPACING;
 
 		renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "SnapSeq %d  BaseSeq %d  Delta %d  Queue %d", snapSeq, snapBase, deltaSeq, snapProc->GetSnapQueueSize() ), color, false );
 		curY += Y_SPACING;
 
 		renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "Reliables: %d / %d bytes Reliable Ack: %d", packetProc->NumQueuedReliables(), packetProc->GetReliableDataSize(), packetProc->NeedToSendReliableAck() ), color, false );
 		curY += Y_SPACING;
 
 		renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "Outgoing %.2f kB/s  Reported %.2f kB/s Throttle: %.2f", peer.packetProc->GetOutgoingRateBytes() / 1024.0f, peers[p].receivedBps / 1024.0f, peer.receivedThrottle ), color, false );
 		curY += Y_SPACING;
 
 		if ( net_forceUpstream.GetFloat() != 0.0f ) {
 			float upstreamDropRate = session->GetUpstreamDropRate();
 			float upstreamQueuedRate = session->GetUpstreamQueueRate();
 			int queuedBytes = session->GetQueuedBytes();
 			renderSystem->DrawSmallStringExt( X_OFFSET, curY, va( "Queued: %d | Dropping: %2.02f kB/s Queue: %2.02f kB/s ", queuedBytes, upstreamDropRate / 1024.0f, upstreamQueuedRate / 1024.0f ), color, false );
 			
 		}
 
 		curY += Y_SPACING;		
 
 		
 
 		if ( peer.debugGraphs[GRAPH_SNAPSENT] != NULL ) {
 			if ( peer.lastSnapTime > lastTime ) {
 				peer.debugGraphs[GRAPH_SNAPSENT]->SetValue(-1, 1.0f, colorBlue );
 			} else {
 				peer.debugGraphs[GRAPH_SNAPSENT]->SetValue(-1, 0.0f, colorBlue );
 			}
 		}
 
 		if ( peer.debugGraphs[GRAPH_OUTGOING] != NULL ) {
 			idVec4 bgColor( vec4_zero );
 			peer.debugGraphs[GRAPH_OUTGOING]->SetBackgroundColor( bgColor );
 
 			idVec4 lineColor = colorLtGrey;
 			lineColor.w	 = 0.5f;
 			float outgoingRate = peer.sentBpsHistory[ peer.receivedBpsIndex % MAX_BPS_HISTORY ];
 			// peer.packetProc->GetOutgoingRateBytes()
 			peer.debugGraphs[GRAPH_OUTGOING]->SetValue(-1, idMath::ClampFloat( 0.0f, 1.0f, outgoingRate / net_debughud3_bps_max.GetFloat() ), lineColor );
 		}
 
 
 		if ( peer.debugGraphs[GRAPH_INCOMINGREPORTED] != NULL ) {			
 			idVec4 lineColor = colorYellow;
 			extern idCVar net_peer_throttle_bps_peer_threshold_pct;
 			extern idCVar net_peer_throttle_bps_host_threshold;
 			
 			if ( peer.packetProc->GetOutgoingRateBytes() > net_peer_throttle_bps_host_threshold.GetFloat() ) {
 				float pct = peer.packetProc->GetOutgoingRateBytes() > 0.0f ? peer.receivedBps / peer.packetProc->GetOutgoingRateBytes() : 0.0f;
 				if ( pct < net_peer_throttle_bps_peer_threshold_pct.GetFloat() ) {
 					lineColor = colorRed;
 				} else {
 					lineColor = colorGreen;
 				}
 			}
 			idVec4 bgColor( vec4_zero );
 			peer.debugGraphs[GRAPH_INCOMINGREPORTED]->SetBackgroundColor( bgColor );
 			peer.debugGraphs[GRAPH_INCOMINGREPORTED]->SetFillMode( idDebugGraph::GRAPH_LINE );
 			peer.debugGraphs[GRAPH_INCOMINGREPORTED]->SetValue(-1, idMath::ClampFloat( 0.0f, 1.0f, peer.receivedBps / net_debughud3_bps_max.GetFloat() ), lineColor );
 		}
 	
 
 
 		// Skip down
 		curY += ( Y_SPACING * 2.0f);
 	}
 
 	lastTime = time;
 }
 
 /*
 ========================
 idLobby::CheckHeartBeats
 ========================
 */
 void idLobby::CheckHeartBeats() {
 	// Disconnect peers that haven't responded within net_peerTimeoutInSeconds
 	int time = Sys_Milliseconds();
 
 	int timeoutInMs = session->GetTitleStorageInt( "net_peerTimeoutInSeconds", net_peerTimeoutInSeconds.GetInteger() ) * 1000;
 
 	if ( sessionCB->GetState() < idSession::LOADING && migrationInfo.state == MIGRATE_NONE ) {
 		// Use shorter timeout in lobby (TCR)
 		timeoutInMs = session->GetTitleStorageInt( "net_peerTimeoutInSeconds_Lobby", net_peerTimeoutInSeconds_Lobby.GetInteger() ) * 1000;
 	}
 
 	if ( timeoutInMs > 0 ) {
 		for ( int p = 0; p < peers.Num(); p++ ) {		
 			if ( peers[p].IsConnected() ) {
 
 				bool peerTimeout = false;
 
 				if( time - peers[p].lastHeartBeat > timeoutInMs ) {
 					peerTimeout = true;
 				}
 
 				// if reliable queue is almost full, disconnect the peer. 
 				// (this seems reasonable since the reliable queue is set to 64 currently. In practice we should never 
 				// have more than 3 or 4 queued)
 				if ( peers[ p ].packetProc->NumQueuedReliables() > idPacketProcessor::MAX_RELIABLE_QUEUE - 1 ) {
 					peerTimeout = true;
 				}
 				
 				if( peerTimeout ) {
 					// Disconnect the peer from any sessions we are a host of
 					if ( IsHost() ) {
 						idLib::Printf("Peer %i timed out for %s session @ %d (lastHeartBeat %d)\n", p, GetLobbyName(), time, peers[p].lastHeartBeat );
 						DisconnectPeerFromSession( p );
 					}
 
 					// Handle peers not receiving a heartbeat from the host in awhile
 					if ( IsPeer() ) {
 						if ( migrationInfo.state != MIGRATE_PICKING_HOST ) {
 							idLib::Printf("Host timed out for %s session\n", GetLobbyName() );
 
 							// Pick a host for this session
 							PickNewHost();
 						}
 					}
 				}
 			}
 		}
 	}
 
 	if ( IsHost() && lobbyType == GetActingGameStateLobbyType() ) {
 		for ( int p = 0; p < peers.Num(); p++ ) {		
 			if ( !peers[p].IsConnected() ) {
 				continue;
 			}
 
 			CheckPeerThrottle( p );
 		}
 	}
 }
 
 /*
 ========================
 idLobby::CheckHeartBeats
 ========================
 */
 bool idLobby::IsLosingConnectionToHost() const {
 	if ( !verify( IsPeer() && host >= 0 && host < peers.Num() ) ) {
 		return false;
 	}
 
 	if ( !peers[ host ].IsConnected() ) {
 		return true;
 	}
 
 	int time = Sys_Milliseconds();
 
 	int timeoutInMs = session->GetTitleStorageInt( "net_peerTimeoutInSeconds", net_peerTimeoutInSeconds.GetInteger() ) * 1000;
 
 	// return true if heartbeat > half the timeout length
 	if ( timeoutInMs > 0 &&  time - peers[ host ].lastHeartBeat > timeoutInMs / 2 ) {
 		return true;
 	}
 
 	// return true if reliable queue is more than half full
 	// (this seems reasonable since the reliable queue is set to 64 currently. In practice we should never 
 	// have more than 3 or 4 queued)
 	if ( peers[ host ].packetProc->NumQueuedReliables() > idPacketProcessor::MAX_RELIABLE_QUEUE / 2 ) {
 		return true;
 	}
 
 	return false;
 }
 
 /*
 ========================
 idLobby::IsMigratedStatsGame
 ========================
 */
 bool idLobby::IsMigratedStatsGame() const {
 	if ( !IsLobbyActive() ) {
 		return false;
 	}
 
 	if ( lobbyType != TYPE_GAME ) {
 		return false;		// Only game session migrates games stats
 	}
 
 	if ( !MatchTypeHasStats( parms.matchFlags ) ) {
 		return false;		// Only stats games migrate stats
 	}
 
 	if ( !MatchTypeIsRanked( parms.matchFlags ) ) {
 		return false;		// Only ranked games should migrate stats into new game
 	}
 
 	return migrationInfo.persistUntilGameEndsData.wasMigratedGame && migrationInfo.persistUntilGameEndsData.hasGameData;
 }
 
 /*
 ========================
 idLobby::ShouldRelaunchMigrationGame
 returns true if we are hosting a migrated game and we had valid migration data
 ========================
 */
 bool idLobby::ShouldRelaunchMigrationGame() const { 
 	if ( IsMigrating() ) {
 		return false;		// Don't relaunch until all clients have reconnected
 	}
 
 	if ( !IsMigratedStatsGame() ) {
 		return false;		// If we are not migrating stats, we don't want to relaunch a new game
 	}
 
 	if ( !migrationInfo.persistUntilGameEndsData.wasMigratedHost ) {
 		return false;		// Only relaunch if we are the host
 	}
 
 	if ( migrationInfo.persistUntilGameEndsData.hasRelaunchedMigratedGame ) {
 		return false;		// We already relaunched this game
 	}
 
 	return true;
 }
 
 /*
 ========================
 idLobby::ShouldShowMigratingDialog
 ========================
 */
 bool idLobby::ShouldShowMigratingDialog() const {
 	if ( IsMigrating() ) {
 		return true;	// If we are in the process of truly migrating, then definitely return true
 	}
 
 	if ( sessionCB->GetState() == idSession::INGAME ) {
 		return false;
 	}
 
 	// We're either waiting on the server (which could be us) to relaunch, so show the dialog
 	return IsMigratedStatsGame() && sessionCB->GetState() != idSession::INGAME;
 }
 
 /*
 ========================
 idLobby::IsMigrating
 ========================
 */
 bool idLobby::IsMigrating() const {
 	return migrationInfo.state != idLobby::MIGRATE_NONE;
 }
 
 /*
 ========================
 idLobby::PingPeers
 Host only.
 ========================
 */
 void idLobby::PingPeers() {
 	if ( !verify( IsHost() ))  {
 		return;
 	}
 
 	const int now = Sys_Milliseconds();
 
 	pktPing_t packet;
 	memset( &packet, 0, sizeof( packet ) ); // We're gonna memset like it's 1999.
 	packet.timestamp = now;
 
 	byte packetCopy[ sizeof( packet ) ];
 	idBitMsg msg( packetCopy, sizeof( packetCopy ) );
 	msg.WriteLong( packet.timestamp );
 
 	for ( int i = 0; i < peers.Num(); ++i ) {
 		peer_t & peer = peers[ i ];
 		if ( !peer.IsConnected() ) {
 			continue;
 		}
 		if ( peer.nextPing <= now ) {
 			peer.nextPing = now + PING_INTERVAL_MS;
 			QueueReliableMessage( i, RELIABLE_PING, msg.GetReadData(), msg.GetSize() );
 		}
 	}
 }
 
 /*
 ========================
 idLobby::ThrottlePeerSnapRate
 ========================
 */
 void idLobby::ThrottlePeerSnapRate( int p ) {
 	if ( !verify( IsHost() ) || !verify( p >= 0 ) ) {
 		return;
 	}
 
 	peers[p].throttledSnapRate = common->GetSnapRate() * 2;
 	idLib::Printf( "^1Throttling peer %d %s!\n", p, GetPeerName(p) );
 	idLib::Printf( "  New snaprate: %d\n", peers[p].throttledSnapRate / 1000 );
 }
 
 /*
 ========================
 idLobby::SaturatePeers
 ========================
 */
 void idLobby::BeginBandwidthTest() {
 	if ( !verify( IsHost() ) )  {
 		idLib::Warning("Bandwidth test should only be done on host");
 		return;
 	}
 
 	if ( bandwidthChallengeStartTime > 0 ) {
 		idLib::Warning("Already started bandwidth test");
 		return;
 	}
 
 	int time = Sys_Milliseconds();
 	bandwidthChallengeStartTime = time;
 	bandwidthChallengeEndTime = 0;
 	bandwidthChallengeFinished = false;
 	bandwidthChallengeNumGoodSeq = 0;
 
 	for ( int p = 0; p < peers.Num(); ++p ) {
 		if ( !peers[ p ].IsConnected() ) {
 			continue;
 		}
 
 		if ( !verify( peers[ p ].packetProc != NULL ) ) {
 			continue;
 		}
 
 		peers[ p ].bandwidthSequenceNum = 0;
 		peers[ p ].bandwidthChallengeStartSendTime = 0;
 		peers[ p ].bandwidthChallengeResults = false;
 		peers[ p ].bandwidthChallengeSendComplete	 = false;
 		peers[ p ].bandwidthTestBytes = peers[ p ].packetProc->GetOutgoingBytes(); // cache this off so we can see the difference when we are done
 	}
 }
 
 /*
 ========================
 idLobby::SaturatePeers
 ========================
 */
 bool idLobby::BandwidthTestStarted() {
 	return bandwidthChallengeStartTime != 0;
 }
 /*
 ========================
 idLobby::ServerUpdateBandwidthTest
 ========================
 */
 void idLobby::ServerUpdateBandwidthTest() {
 	if ( bandwidthChallengeStartTime <= 0 ) {
 		// Not doing a test
 		return;
 	}
 	
 	if ( !verify( IsHost() ))  {
 		return;
 	}
 	
 	int time = Sys_Milliseconds();
 
 	if ( bandwidthChallengeFinished ) {
 		// test is over
 		return;
 	}
 
 	idRandom random;
 	random.SetSeed( time );
 
 	bool sentAll = true;
 	bool recAll = true;
 
 	for ( int i = 0; i < peers.Num(); ++i ) {
 		peer_t & peer = peers[ i ];
 		if ( !peer.IsConnected() ) {
 			continue;
 		}
 
 		if ( peer.bandwidthChallengeResults ) {
 			continue;
 		}
 		recAll = false;
 
 		if ( peer.bandwidthChallengeSendComplete ) {
 			continue;
 		}
 		sentAll = false;
 
 		if ( time - peer.bandwidthTestLastSendTime < session->GetTitleStorageInt( "net_bw_test_interval", net_bw_test_interval.GetInteger() ) ) {
 			continue;
 		}
 
 		if ( peer.packetProc->HasMoreFragments() ) {
 			continue;
 		}
 
 		if ( peer.bandwidthChallengeStartSendTime == 0 ) {
 			peer.bandwidthChallengeStartSendTime = time;
 		}
 
 		peer.bandwidthTestLastSendTime = time;
 
 		// Ok, send him a big packet
 		byte buffer[ idPacketProcessor::MAX_OOB_MSG_SIZE ];		// <---- NOTE - When calling ProcessOutgoingMsg with true for oob, we can't go over this size
 		idBitMsg msg( buffer, sizeof(buffer) );
 
 		msg.WriteLong( peer.bandwidthSequenceNum++ );
 
 		unsigned int randomSize = Min( (unsigned int)(sizeof(buffer) - 12), (unsigned int)session->GetTitleStorageInt( "net_bw_test_packetSizeBytes", net_bw_test_packetSizeBytes.GetInteger() ) );
 		msg.WriteLong( randomSize );
 		
 		for ( unsigned int j=0; j < randomSize; j++ ) {
 			msg.WriteByte( random.RandomInt( 255 ) );
 		}
 		
 		unsigned int checksum = MD5_BlockChecksum( &buffer[8], randomSize );
 		msg.WriteLong( checksum );
 
 		NET_VERBOSE_PRINT("Net: Sending bw challenge to peer %d time %d packet size %d\n", i, time, msg.GetSize() );
 
 		ProcessOutgoingMsg( i, buffer, msg.GetSize(), true, OOB_BANDWIDTH_TEST );
 
 		if ( session->GetTitleStorageInt( "net_bw_test_numPackets", net_bw_test_numPackets.GetInteger() ) > 0 && peer.bandwidthSequenceNum >= net_bw_test_numPackets.GetInteger() ) {
 			int sentBytes = peers[i].packetProc->GetOutgoingBytes() - peers[i].bandwidthTestBytes; // FIXME: this won't include the last sent msg
 			peers[i].bandwidthTestBytes = sentBytes; // this now means total bytes sent (we don't care about starting/ending total bytes sent to peer)
 			peers[i].bandwidthChallengeSendComplete = true;
 
 			NET_VERBOSE_PRINT("Sent enough packets to peer %d for bandwidth test in %dms. Total bytes: %d\n", i, time - bandwidthChallengeStartTime, sentBytes );
 		}
 	}
 
 	if ( sentAll ) {
 		if ( bandwidthChallengeEndTime == 0 ) {
 			// We finished sending all our packets, set the timeout time
 			bandwidthChallengeEndTime = time + session->GetTitleStorageInt( "net_bw_test_host_timeout", net_bw_test_host_timeout.GetInteger() );
 			NET_VERBOSE_PRINT("Net: finished sending BWC to peers. Waiting until %d to hear back\n", bandwidthChallengeEndTime );
 		}
 	}
 	
 	if ( recAll ) {
 		bandwidthChallengeFinished = true;
 		bandwidthChallengeStartTime = 0;
 
 	} else if ( bandwidthChallengeEndTime != 0 && bandwidthChallengeEndTime < time ) {
 		// Timed out waiting for someone - throttle them and move on
 		NET_VERBOSE_PRINT("^2Net: timed out waiting for bandwidth challenge results \n");
 		for ( int i=0; i < peers.Num(); i++ ) {
 			NET_VERBOSE_PRINT("  Peer[%d] %s. SentAll: %d  RecAll: %d\n", i, GetPeerName(i), peers[i].bandwidthChallengeSendComplete, peers[i].bandwidthChallengeResults );
 			if ( peers[i].bandwidthChallengeSendComplete && !peers[i].bandwidthChallengeResults ) {
 				ThrottlePeerSnapRate( i );
 			}
 		}
 		bandwidthChallengeFinished = true;
 		bandwidthChallengeStartTime = 0;
 	}
 }
 
 /*
 ========================
 idLobby::UpdateBandwidthTest
 This will be called on clients to check current state of bandwidth testing
 ========================
 */
 void idLobby::ClientUpdateBandwidthTest() {
 	if ( !verify( !IsHost() ) || !verify( host >= 0 ) )  {
 		return;
 	}
 
 	if ( !peers[host].IsConnected() ) {
 		return;
 	}
 
 	if ( bandwidthChallengeStartTime <= 0 ) {
 		// Not doing a test
 		return;
 	}
 
 	int time = Sys_Milliseconds();
 	if ( bandwidthChallengeEndTime > time ) {
 		// Test is still going on
 		return;
 	}
 
 	// Its been long enough since we last received bw test msg. So lets send the results to the server
 	byte buffer[ idPacketProcessor::MAX_MSG_SIZE ];
 	idBitMsg msg( buffer, sizeof( buffer ) );
 
 	// Send total time it took to receive all the msgs
 	// (note, subtract net_bw_test_timeout to get 'last recevied bandwidth test packet')
 	// (^^ Note if the last packet is fragmented and we never get it, this is technically wrong!)
 	int totalTime = ( bandwidthChallengeEndTime - session->GetTitleStorageInt( "net_bw_test_timeout", net_bw_test_timeout.GetInteger() ) ) - bandwidthChallengeStartTime;
 	msg.WriteLong( totalTime );
 
 	// Send total number of complete, in order packets we got
 	msg.WriteLong( bandwidthChallengeNumGoodSeq );
 
 	// Send the overall average bandwidth in KBS
 	// Note that sending the number of good packets is not enough. If the packets going out are fragmented, and we 
 	// drop fragments, the number of good sequences will be lower than the bandwidth we actually received.
 	int totalIncomingBytes = peers[host].packetProc->GetIncomingBytes() - peers[host].bandwidthTestBytes;
 	msg.WriteLong( totalIncomingBytes );
 
 	idLib::Printf("^3Finished Bandwidth test: \n");
 	idLib::Printf("  Total time: %d\n", totalTime );
 	idLib::Printf("  Num good packets: %d\n", bandwidthChallengeNumGoodSeq );
 	idLib::Printf("  Total received byes: %d\n\n", totalIncomingBytes );
 
 	bandwidthChallengeStartTime = 0;
 	bandwidthChallengeNumGoodSeq = 0;
 
 	QueueReliableMessage( host, RELIABLE_BANDWIDTH_VALUES, msg.GetReadData(), msg.GetSize() );
 }
 
 /*
 ========================
 idLobby::HandleBandwidhTestValue
 ========================
 */
 void idLobby::HandleBandwidhTestValue( int p, idBitMsg & msg ) {
 	if ( !IsHost() ) {
 		return;
 	}
 
 	idLib::Printf("Received RELIABLE_BANDWIDTH_CHECK %d\n", Sys_Milliseconds() );
 
 	if ( bandwidthChallengeStartTime < 0 || bandwidthChallengeFinished ) {
 		idLib::Warning("Received bandwidth test results too early from peer %d", p );
 		return;
 	}
 
 	int totalTime = msg.ReadLong();
 	int totalGoodSeq = msg.ReadLong();
 	int totalReceivedBytes = msg.ReadLong();
 
 	// This is the % of complete packets we received. If the packets used in the BWC are big enough to fragment, then pctPackets
 	// will be lower than bytesPct (we will have received a larger PCT of overall bandwidth than PCT of full packets received).
 	// Im not sure if this is a useful distinction or not, but it may be good to compare against for now.
 	float pctPackets = peers[p].bandwidthSequenceNum > 0 ? (float) totalGoodSeq / (float)peers[p].bandwidthSequenceNum : -1.0f;
 
 	// This is the % of total bytes sent/bytes received.
 	float bytesPct = peers[p].bandwidthTestBytes > 0 ? (float) totalReceivedBytes / (float)peers[p].bandwidthTestBytes : -1.0f;
 
 	// Calculate overall bandwidth for the test. That is, total amount received over time.
 	// We may want to expand this to also factor in an average instantaneous rate. 
 	// For now we are mostly concerned with culling out poor performing clients
 	float peerKBS = -1.0f;
 	if ( verify( totalTime > 0 ) ) {
 		peerKBS = ( (float)totalReceivedBytes / 1024.0f ) / MS2SEC(totalTime);
 	}
 
 	int totalSendTime = peers[p].bandwidthTestLastSendTime - peers[p].bandwidthChallengeStartSendTime;
 	float outgoingKBS = -1.0f;
 	if ( verify( totalSendTime > 0 ) ) {
 		outgoingKBS = ( (float)peers[p].bandwidthTestBytes / 1024.0f ) / MS2SEC(totalSendTime);
 	}
 
 	float pctKBS = peerKBS / outgoingKBS;
 
 	bool failedRate = ( pctKBS < session->GetTitleStorageFloat( "net_bw_test_throttle_rate_pct", net_bw_test_throttle_rate_pct.GetFloat() ) );
 	bool failedByte = ( bytesPct < session->GetTitleStorageFloat( "net_bw_test_throttle_byte_pct", net_bw_test_throttle_byte_pct.GetFloat() ) );
 	bool failedSeq	= ( pctPackets < session->GetTitleStorageFloat( "net_bw_test_throttle_seq_pct", net_bw_test_throttle_seq_pct.GetFloat() ) );
 
 	idLib::Printf("^3Finished Bandwidth test %s: \n", GetPeerName(p) );
 	idLib::Printf("  Total time: %dms\n", totalTime );
 	idLib::Printf("  %sNum good packets: %d  (%.2f%)\n", ( failedSeq ? "^1" : "^2" ), totalGoodSeq, pctPackets );
 	idLib::Printf("  %sTotal received bytes: %d  (%.2f%)\n", ( failedByte ? "^1" : "^2" ), totalReceivedBytes, bytesPct );
 	idLib::Printf("  %sEffective downstream: %.2fkbs (host: %.2fkbs) -> %.2f%\n\n", ( failedRate ? "^1" : "^2" ), peerKBS, outgoingKBS, pctKBS );
 
 	// If shittConnection(totalTime, totalGoodSeq/totalSeq, totalReceivedBytes/totalSentBytes)
 	//	throttle this user: 
 	//	peers[p].throttledSnapRate = baseSnapRate * 2
 	if ( failedRate || failedByte || failedSeq ) {		
 		ThrottlePeerSnapRate( p );
 	}
 	
 
 	// See if we are finished
 	peers[p].bandwidthChallengeResults = true;
 	bandwidthChallengeFinished = true;
 	for ( int i=0; i < peers.Num(); i++ ) {
 		if ( peers[i].bandwidthChallengeSendComplete && !peers[i].bandwidthChallengeResults ) {
 			bandwidthChallengeFinished = false;
 		}
 	}
 
 	if ( bandwidthChallengeFinished ) {
 		bandwidthChallengeStartTime = 0;
 	}
 }
 
 /*
 ========================
 idLobby::SendPingValues
 Host only
 Periodically send all peers' pings to all peers (for the UI).
 ========================
 */
 void idLobby::SendPingValues() {
 	if ( !verify( IsHost() ) )  {
 		// paranoia
 		return;
 	}
 
 	const int now = Sys_Milliseconds();
 
 	if ( nextSendPingValuesTime > now ) {
 		return;
 	}
 
 	nextSendPingValuesTime = now + PING_INTERVAL_MS;
 
 	pktPingValues_t packet;
 
 	memset( &packet, 0, sizeof(packet) );
 
 	for( int i = 0; i < peers.Max(); ++i ) {
 		if ( i >= peers.Num() ) {
 			packet.pings[ i ] = -1;
 		} else if ( peers[ i ].IsConnected() ) {
 			packet.pings[ i ] = peers[ i ].lastPingRtt;
 		} else {
 			packet.pings[ i ] = -1;
 		}
 	}
 
 	byte packetCopy[ sizeof(packet) ];
 	idBitMsg msg( packetCopy, sizeof(packetCopy) );
 	for( int i = 0; i < peers.Max(); ++i ) {
 		msg.WriteShort( packet.pings[ i ] );
 	}
 
 	for ( int i = 0; i < peers.Num(); i++ ) {
 		if ( peers[ i ].IsConnected() ) {
 			QueueReliableMessage( i, RELIABLE_PING_VALUES, msg.GetReadData(), msg.GetSize() );
 		}
 	}
 }
 
 /*
 ========================
 idLobby::PumpPings
 Host: Periodically determine the round-trip time for a packet to all peers, and tell everyone
 	what everyone else's ping to the host is so they can display it in the UI.
 Client: Indicate to the player when the server hasn't updated the ping values in too long.
 	This is usually going to preceed a connection timeout.
 ========================
 */
 void idLobby::PumpPings() {
 	if ( IsHost() ) {
 		// Calculate ping to all peers
 		PingPeers();
 		// Send the hosts calculated ping values to each peer to everyone has updated ping times
 		SendPingValues();
 		// Do bandwidth testing 
 		ServerUpdateBandwidthTest();
 		// Send Migration Data
 		SendMigrationGameData();
 	} else if ( IsPeer() ) {
 		ClientUpdateBandwidthTest();
 
 		if ( lastPingValuesRecvTime + PING_INTERVAL_MS + 1000 < Sys_Milliseconds() && migrationInfo.state == MIGRATE_NONE ) {
 			for ( int userIndex = 0; userIndex < GetNumLobbyUsers(); ++userIndex ) {
 				lobbyUser_t * user = GetLobbyUser( userIndex );
 				if ( !verify( user != NULL ) ) {
 					continue;
 				}
 				user->pingMs = 999999;
 			}
 		}
 	}
 }
 
 /*
 ========================
 idLobby::HandleReliablePing
 ========================
 */
 void idLobby::HandleReliablePing( int p, idBitMsg & msg ) {
 	int c, b;
 	msg.SaveReadState( c, b );
 
 	pktPing_t ping;
 
 	memset( &ping, 0, sizeof( ping ) );
 	if ( !verify( sizeof( ping ) <= msg.GetRemainingData() ) ) {
 		NET_VERBOSE_PRINT( "NET: Ignoring ping from peer %i because packet was the wrong size\n", p );
 		return;
 	}
 
 	ping.timestamp = msg.ReadLong();
 
 	if ( IsHost() ) {
 		// we should probably verify here whether or not this ping was solicited or not
 		HandlePingReply( p, ping );
 	} else {
 		// this means the server is requesting a ping, so reply
 		msg.RestoreReadState( c, b );
 		QueueReliableMessage( p, RELIABLE_PING, msg.GetReadData() + msg.GetReadCount(), msg.GetRemainingData() );
 	}
 }
 
 /*
 ========================
 idLobby::HandlePingReply
 ========================
 */
 void idLobby::HandlePingReply( int p, const pktPing_t & ping ) {
 	const int now = Sys_Milliseconds();
 
 	const int rtt = now - ping.timestamp;
 	peers[p].lastPingRtt = rtt;
 
 	for ( int userIndex = 0; userIndex < GetNumLobbyUsers(); ++userIndex ) {
 		lobbyUser_t * u = GetLobbyUser( userIndex );
 		if ( u->peerIndex == p ) {
 			u->pingMs = rtt;
 		}
 	}
 }
 
 /*
 ========================
 idLobby::HandlePingValues
 ========================
 */
 void idLobby::HandlePingValues( idBitMsg & msg ) {
 	pktPingValues_t packet;
 	memset( &packet, 0, sizeof( packet ) );
 	for( int i = 0; i < peers.Max(); ++i ) {
 		 packet.pings[ i ] = msg.ReadShort();
 	}
 
 	assert( IsPeer() );
 
 	lastPingValuesRecvTime = Sys_Milliseconds();
 
 	for ( int userIndex = 0; userIndex < GetNumLobbyUsers(); ++userIndex ) {
 		lobbyUser_t * u = GetLobbyUser( userIndex );
 		if ( u->peerIndex != -1 && verify( u->peerIndex >= 0 && u->peerIndex < MAX_PEERS ) ) {
 			u->pingMs = packet.pings[ u->peerIndex ];
 		} else {
 			u->pingMs = 0;
 		}
 	}
 	
 	// Stuff our ping in the hosts slot
 	if ( peerIndexOnHost != -1 && verify( peerIndexOnHost >= 0 && peerIndexOnHost < MAX_PEERS ) ) {
 		peers[host].lastPingRtt = packet.pings[ peerIndexOnHost ];
 	} else {
 		peers[host].lastPingRtt = 0;
 	}
 }
 
 /*
 ========================
 idLobby::SendAnotherFragment
 Other than connectionless sends, this should be the chokepoint for sending packets to peers.
 ========================
 */
 bool idLobby::SendAnotherFragment( int p ) {
 	peer_t & peer = peers[p];
 	
 	if ( !peer.IsConnected() ) {	// Not connected to any mode (party or game), so no need to send
 		return false;
 	}
 	
 	if ( !peer.packetProc->HasMoreFragments() ) {
 		return false;		// No fragments to send for this peer
 	}
 	
 	if ( !CanSendMoreData( p ) ) {
 		return false;		// We need to throttle the sends so we don't saturate the connection
 	}
 
 	int time = Sys_Milliseconds();
 
 	if ( time - peer.lastFragmentSendTime < 2 ) {
 		NET_VERBOSE_PRINT("Too soon to send another packet. Delta: %d \n", ( time-peer.lastFragmentSendTime) );
 		return false;		// Too soon to send another fragment
 	}
 	
 	peer.lastFragmentSendTime = time;
 
 	bool sentFragment = false;
 	
 	while ( true ) {
 		idBitMsg msg;
 		// We use the final packet size here because it has been processed, and no more headers will be added
 		byte buffer[ idPacketProcessor::MAX_FINAL_PACKET_SIZE ];	
 		msg.InitWrite( buffer, sizeof( buffer ) );
 		
 		if ( !peers[p].packetProc->GetSendFragment( time, peers[p].sessionID, msg ) ) {
 			break;
 		}
 
 		const bool useDirectPort = ( lobbyType == TYPE_GAME_STATE );
 
 		msg.BeginReading();
 		sessionCB->SendRawPacket( peers[p].address, msg.GetReadData(), msg.GetSize(), useDirectPort ); 
 		sentFragment = true;
 		break;		// Comment this out to send all fragments in one burst
 	}
 
 	if ( peer.packetProc->HasMoreFragments() ) {
 		NET_VERBOSE_PRINT("More packets left after ::SendAnotherFragment\n");
 	}
 		
 	return sentFragment;
 }
 
 /*
 ========================
 idLobby::CanSendMoreData
 ========================
 */
 bool idLobby::CanSendMoreData( int p ) {
 	if ( !verify( p >= 0 && p < peers.Num() ) ) {
 		NET_VERBOSE_PRINT( "NET: CanSendMoreData %i NO: not a peer\n", p );
 		return false;
 	}
 	peer_t & peer = peers[p];
 	if ( !peer.IsConnected() ) {
 		NET_VERBOSE_PRINT( "NET: CanSendMoreData %i NO: not connected\n", p );
 		return false;
 	}
 
 	return peer.packetProc->CanSendMoreData();
 }
 
 /*
 ========================
 idLobby::ProcessOutgoingMsg
 ========================
 */
 void idLobby::ProcessOutgoingMsg( int p, const void * data, int size, bool isOOB, int userData ) {
 
 	peer_t & peer = peers[p];
 	
 	if ( peer.GetConnectionState() != CONNECTION_ESTABLISHED ) {
 		idLib::Printf( "peer.GetConnectionState() != CONNECTION_ESTABLISHED\n" );
 		return;	// Peer not fully connected for this session type, return
 	}
 
 	if ( peer.packetProc->HasMoreFragments() ) {
 		idLib::Error( "FATAL: Attempt to process a packet while fragments still need to be sent.\n" ); // We can't handle this case
 	}
 
 	int currentTime = Sys_Milliseconds();
 	
 	// if ( currentTime - peer.lastProcTime < 30 ) {
 	//	 idLib::Printf("ProcessOutgoingMsg called within %dms %s\n", (currentTime - peer.lastProcTime), GetLobbyName() );
 	// }
 
 	peer.lastProcTime = currentTime;
 
 	if ( !isOOB ) {
 		// Keep track of the last time an in-band packet was sent 
 		// (used for things like knowing when reliables could have been last sent)
 		peer.lastInBandProcTime = peer.lastProcTime;
 	}
 		
 	idBitMsg msg;
 	msg.InitRead( (byte*)data, size );
 	peer.packetProc->ProcessOutgoing( currentTime, msg, isOOB, userData );
 }
 
 /*
 ========================
 idLobby::ResendReliables
 ========================
 */
 void idLobby::ResendReliables( int p ) {
 
 	peer_t & peer = peers[p];
 	
 	if ( !peer.IsConnected() ) {
 		return;
 	}
 	
 	if ( peer.packetProc->HasMoreFragments() ) {
 		return;		// We can't send more data while fragments are still being sent out
 	}
 	
 	if ( !CanSendMoreData( p ) ) {
 		return;
 	}
 
 	int time = Sys_Milliseconds();
 
 	const int DEFAULT_MIN_RESEND		= 20;		// Quicker resend while not in game to speed up resource transmission acks
 	const int DEFAULT_MIN_RESEND_INGAME	= 100;
 
 	int resendWait = DEFAULT_MIN_RESEND_INGAME;
 
 	if ( sessionCB->GetState() == idSession::INGAME ) {
 		// setup some minimum waits and account for ping
 		resendWait = Max( DEFAULT_MIN_RESEND_INGAME, peer.lastPingRtt / 2 );
 		if ( lobbyType == TYPE_PARTY ) {
 			resendWait = Max( 500, resendWait ); // party session does not need fast frequency at all once in game
 		}
 	} else {
 		// don't trust the ping when still loading stuff
 		// need to resend fast to speed up transmission of network decls
 		resendWait = DEFAULT_MIN_RESEND;
 	}
 
 	if ( time - peer.lastInBandProcTime < resendWait ) {
 		// no need to resend reliables if they went out on an in-band packet recently
 		return;
 	}
 
 	if ( peer.packetProc->NumQueuedReliables() > 0 || peer.packetProc->NeedToSendReliableAck() ) {
 		//NET_VERBOSE_PRINT( "NET: ResendReliables %s\n", GetLobbyName() );
 		ProcessOutgoingMsg( p, NULL, 0, false, 0 );		// Force an empty unreliable msg so any reliables will get processed as well
 	}
 }
 
 /*
 ========================
 idLobby::PumpPackets
 ========================
 */
 void idLobby::PumpPackets() {
 	int newTime = Sys_Milliseconds();
 		
 	for ( int p = 0; p < peers.Num(); p++ ) {		
 		if ( peers[p].IsConnected() ) {
 			peers[p].packetProc->RefreshRates( newTime );
 		}
 	}
 
 	// Resend reliable msg's (do this before we send out the fragments)
 	for ( int p = 0; p < peers.Num(); p++ ) {		
 		ResendReliables( p );
 	}
 	
 	// If we haven't sent anything to our peers in a long time, make sure to send an empty packet (so our heartbeat gets updated) so we don't get disconnected
 	// NOTE - We used to only send these to the host, but the host needs to also send these to clients
 	for ( int p = 0; p < peers.Num(); p++ ) {		
 		if ( !peers[p].IsConnected() || peers[p].packetProc->HasMoreFragments() ) {
 			continue;
 		}
 		if ( newTime - peers[p].lastProcTime > 1000 * PEER_HEARTBEAT_IN_SECONDS ) {
 			//NET_VERBOSE_PRINT( "NET: ProcessOutgoing Heartbeat %s\n", GetLobbyName() );
 			ProcessOutgoingMsg( p, NULL, 0, false, 0 );		
 		}
 	}
 
 	// Send any unsent fragments for each peer (do this last)
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		SendAnotherFragment( p );
 	}
 }
 
 /*
 ========================
 idLobby::UpdateMatchParms
 ========================
 */
 void idLobby::UpdateMatchParms( const idMatchParameters & p ) {
 	if ( !IsHost() ) {
 		return;
 	}
 
 	parms = p;
 
 	// Update lobbyBackend with parms
 	if ( lobbyBackend != NULL ) {
 		lobbyBackend->UpdateMatchParms( parms );
 	}
 	
 	SendMatchParmsToPeers();
 }
 
 /*
 ========================
 idLobby::GetHostUserName
 ========================
 */
 const char * idLobby::GetHostUserName() const {
 	if ( !IsLobbyActive() ) {
 		return INVALID_LOBBY_USER_NAME;
 	}
 	return GetPeerName( -1 );		// This will just grab the first user with this peerIndex (which should be the host)
 }
 
 /*
 ========================
 idLobby::SendReliable
 ========================
 */
 void idLobby::SendReliable( int type, idBitMsg & msg, bool callReceiveReliable /*= true*/, peerMask_t sessionUserMask /*= MAX_UNSIGNED_TYPE( peerMask_t ) */ ) {
 	//assert( lobbyType == GetActingGameStateLobbyType() );
 
 	assert( type < 256 ); // QueueReliable only accepts a byte for message type
 
 	// the queuing below sends the whole message
 	// I don't know if whole message is a good thing or a bad thing, but if the passed message has been read from already, this is most likely not going to do what the caller expects
 	assert( msg.GetReadCount() + msg.GetReadBit() == 0 );
 
 	if ( callReceiveReliable ) {
 		// NOTE: this will put the msg's read status to fully read - which is why the assert check is above
 		common->NetReceiveReliable( -1, type, msg );
 	}
 
 	uint32 sentPeerMask = 0;
 	for ( int i = 0; i < GetNumLobbyUsers(); ++i ) {
 		lobbyUser_t * user = GetLobbyUser( i );
 		if ( user->peerIndex == -1 ) {
 			continue;
 		}
 
 		// We only care about sending these to peers in our party lobby
 		if ( user->IsDisconnected() ) {
 			continue;
 		}
 
 		// Don't sent to a user if they are in the exlusion session user mask
 		if ( sessionUserMask != 0 && ( sessionUserMask & ( BIT( i ) ) ) == 0 ) {
 			continue;
 		}
 
 		const int peerIndex = user->peerIndex;
 
 		if ( peerIndex >= peers.Num() ) {
 			continue;
 		}
 
 		peer_t & peer = peers[peerIndex];
 
 		if ( !peer.IsConnected() ) {
 			continue;
 		}
 
 		if ( ( sentPeerMask & ( 1 << user->peerIndex ) ) == 0 ) {
 			QueueReliableMessage( user->peerIndex, idLobby::RELIABLE_GAME_DATA + type, msg.GetReadData(), msg.GetSize() );
 			sentPeerMask |= 1 << user->peerIndex;
 		}
 	}
 }
 
 /*
 ========================
 idLobby::SendReliableToLobbyUser
 can only be used on the server. will take care of calling locally if addressed to player 0
 ========================
 */
 void idLobby::SendReliableToLobbyUser( lobbyUserID_t lobbyUserID, int type, idBitMsg & msg ) {
 	assert( lobbyType == GetActingGameStateLobbyType() );
 	assert( type < 256 );			// QueueReliable only accepts a byte for message type
 	assert( IsHost() );				// This function should only be called in the server atm
 	const int peerIndex = PeerIndexFromLobbyUser( lobbyUserID );
 	if ( peerIndex >= 0 ) {
 		// will send the remainder of a message that was started reading through, but not handling a partial byte read
 		assert( msg.GetReadBit() == 0 );
 		QueueReliableMessage( peerIndex, idLobby::RELIABLE_GAME_DATA + type, msg.GetReadData() + msg.GetReadCount(), msg.GetRemainingData() );
 	} else {
 		common->NetReceiveReliable( -1, type, msg );
 	}
 }
 
 /*
 ========================
 idLobby::SendReliableToHost
 will make sure to invoke locally if used on the server
 ========================
 */
 void idLobby::SendReliableToHost( int type, idBitMsg & msg ) {
 	assert( lobbyType == GetActingGameStateLobbyType() );
 
 	if ( IsHost() ) {
 		common->NetReceiveReliable( -1, type, msg );
 	} else {
 		// will send the remainder of a message that was started reading through, but not handling a partial byte read
 		assert( msg.GetReadBit() == 0 );
 		QueueReliableMessage( host, idLobby::RELIABLE_GAME_DATA + type, msg.GetReadData() + msg.GetReadCount(), msg.GetRemainingData() );
 	}
 }
 
 /*
 ================================================================================================
 idLobby::reliablePlayerToPlayerHeader_t
 ================================================================================================
 */
 
 /*
 ========================
 idLobby::reliablePlayerToPlayerHeader_t::reliablePlayerToPlayerHeader_t
 ========================
 */
 idLobby::reliablePlayerToPlayerHeader_t::reliablePlayerToPlayerHeader_t() : fromSessionUserIndex( -1 ), toSessionUserIndex( -1 ) {
 }
 
 /*
 ========================
 idSessionLocal::reliablePlayerToPlayerHeader_t::Read
 ========================
 */
 bool idLobby::reliablePlayerToPlayerHeader_t::Read( idLobby * lobby, idBitMsg & msg ) {
 	assert( lobby != NULL );
 
 	lobbyUserID_t lobbyUserIDFrom;
 	lobbyUserID_t lobbyUserIDTo;
 
 	lobbyUserIDFrom.ReadFromMsg( msg );
 	lobbyUserIDTo.ReadFromMsg( msg );
 
 	fromSessionUserIndex	= lobby->GetLobbyUserIndexByID( lobbyUserIDFrom );
 	toSessionUserIndex		= lobby->GetLobbyUserIndexByID( lobbyUserIDTo );
 
 	if ( !verify( lobby->GetLobbyUser( fromSessionUserIndex ) != NULL ) ) {
 		return false;
 	}
 
 	if ( !verify( lobby->GetLobbyUser( toSessionUserIndex ) != NULL ) ) {
 		return false;
 	}
 
 	return true;
 }
 
 /*
 ========================
 idLobby::reliablePlayerToPlayerHeader_t::Write
 ========================
 */
 bool idLobby::reliablePlayerToPlayerHeader_t::Write( idLobby * lobby, idBitMsg & msg ) {
 
 	
 	if ( !verify( lobby->GetLobbyUser( fromSessionUserIndex ) != NULL ) ) {
 		return false;
 	}
 
 	if ( !verify( lobby->GetLobbyUser( toSessionUserIndex ) != NULL ) ) {
 		return false;
 	}
 	
 	lobby->GetLobbyUser( fromSessionUserIndex )->lobbyUserID.WriteToMsg( msg );
 	lobby->GetLobbyUser( toSessionUserIndex )->lobbyUserID.WriteToMsg( msg );
 
 	return true;
 }
 
 /*
 ========================
 idLobby::GetNumActiveLobbyUsers
 ========================
 */
 int idLobby::GetNumActiveLobbyUsers() const {
 	int numActive = 0;
 	for ( int i = 0; i < GetNumLobbyUsers(); ++i ) {
 		if ( !GetLobbyUser( i )->IsDisconnected() ) {
 			numActive++;
 		}
 	}
 	return numActive;
 }
 
 /*
 ========================
 idLobby::AllPeersInGame
 ========================
 */
 bool idLobby::AllPeersInGame() const {
 	assert( lobbyType == GetActingGameStateLobbyType() );		// This function doesn't make sense on a party lobby currently
 
 	for ( int p = 0; p < peers.Num(); p++ ) {
 		if ( peers[p].IsConnected() && !peers[p].inGame ) {
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 /*
 ========================
 idLobby::PeerIndexFromLobbyUser
 ========================
 */
 int	idLobby::PeerIndexFromLobbyUser( lobbyUserID_t lobbyUserID ) const {
 	const int lobbyUserIndex = GetLobbyUserIndexByID( lobbyUserID );
 
 	const lobbyUser_t * user = GetLobbyUser( lobbyUserIndex );
 
 	if ( user == NULL ) {
 		// This needs to be OK for bot support ( or else add bots at the session level )
 		return -1;
 	}
 
 	return user->peerIndex;
 }
 
 /*
 ========================
 idLobby::GetPeerTimeSinceLastPacket
 ========================
 */
 int idLobby::GetPeerTimeSinceLastPacket( int peerIndex ) const {
 	if ( peerIndex < 0 ) {
 		return 0;
 	}
 	return Sys_Milliseconds() - peers[peerIndex].lastHeartBeat;
 }
 
 /*
 ========================
 idLobby::GetActingGameStateLobbyType
 ========================
 */
 idLobby::lobbyType_t idLobby::GetActingGameStateLobbyType() const {
 	extern idCVar net_useGameStateLobby;
 	return ( net_useGameStateLobby.GetBool() ) ? TYPE_GAME_STATE : TYPE_GAME;
 }
 
 //========================================================================================================================
 //	idLobby::peer_t
 //========================================================================================================================
 
 /*
 ========================
 idLobby::peer_t::GetConnectionState
 ========================
 */
 idLobby::connectionState_t idLobby::peer_t::GetConnectionState() const {
 	return connectionState;
 }