1HEADmaster

1 files changed, 2364 insertions, 0 deletions

diff --git a/engine/matchmakingshared.cpp b/engine/matchmakingshared.cpp
new file mode 100644
index 0000000..92eba94
--- /dev/null
+++ b/engine/matchmakingshared.cpp
@@ -0,0 +1,2364 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Handles joining clients together in a matchmaking session before a multiplayer
+//			game, tracking new players and dropped players during the game, and reporting
+//			game results and stats after the game is complete.
+//
+//=============================================================================//
+
+#include "proto_oob.h"
+#include "matchmaking.h"
+#include "matchmakingqos.h"
+#include "Session.h"
+#include "vgui_baseui_interface.h"
+#include "cdll_engine_int.h"
+#include "convar.h"
+#include "cmd.h"
+#include "iclient.h"
+#include "server.h"
+#include "host.h"
+
+#if defined( _X360 )   
+#include "xbox/xbox_win32stubs.h"
+#include "audio/private/snd_dev_xaudio.h"
+#include "audio_pch.h"
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static CMatchmaking s_Matchmaking;
+CMatchmaking *g_pMatchmaking = &s_Matchmaking;
+
+extern IVEngineClient *engineClient;
+extern IXboxSystem *g_pXboxSystem;
+
+// Expose an interface for GameUI
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CMatchmaking, IMatchmaking, VENGINE_MATCHMAKING_VERSION, s_Matchmaking );
+
+bool Channel_LessFunc( const uint &a, const uint &b )
+{
+	return a < b;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CMatchmaking::CMatchmaking() : m_Channels( Channel_LessFunc )
+{
+	m_bPreventFullServerStartup = false;
+	m_bCleanup = false;
+	m_bEnteredLobby = false;
+	m_nTotalTeams = 0;
+	m_pSearchResults = NULL;
+	m_pSessionKeys = new KeyValues( "SessionKeys" );
+
+	m_Session.SetParent( this );
+
+	m_CurrentState = MMSTATE_INITIAL;
+	m_InviteState = INVITE_NONE;
+
+	memset( &m_InviteWaitingInfo, 0, sizeof( m_InviteWaitingInfo ) );
+}
+
+CMatchmaking::~CMatchmaking()
+{
+	Cleanup();
+	m_pSessionKeys->deleteThis();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cleanup the matchmaking class to enable re-entry
+//-----------------------------------------------------------------------------
+void CMatchmaking::Cleanup()
+{
+	m_bInitialized = false;
+	m_bCleanup = false;
+	m_bEnteredLobby = false;
+
+	m_Host.Clear();
+
+#ifdef _X360
+	if ( Audio_GetXVoice() )
+	{
+		CClientInfo *pLocal = NULL;
+
+		if ( m_bCreatedLocalTalker )
+		{
+			pLocal = &m_Local;
+		}
+
+		Audio_GetXVoice()->RemoveAllTalkers( pLocal );
+	}
+#endif
+	m_bCreatedLocalTalker = false;
+	SetPreventFullServerStartup( false, "Cleanup\n" );
+
+	m_Session.ResetSession();
+
+	// TODO: Check on overlapped operations and cancel them
+	//	g_pXboxSystem->CancelAsyncOperations();
+
+	ClearSearchResults();
+	m_pSessionKeys->Clear();
+
+	m_pGameServer = NULL;
+
+	Q_memset( m_Mutelist, 0, sizeof( m_Mutelist ) );
+	for ( int i = 0; i < MAX_PLAYERS_PER_CLIENT; ++i )
+	{
+		m_MutedBy[i].Purge();
+	}
+
+	m_Channels.RemoveAll();
+
+	m_SessionContexts.Purge();
+	m_SessionProperties.Purge();
+	m_PlayerStats.Purge();
+	m_Remote.PurgeAndDeleteElements();
+
+	m_nGameSize = 0;
+	m_nPrivateSlots = 0;
+	m_nSendCount = 0;
+
+	m_fHeartbeatInterval = HEARTBEAT_INTERVAL_SHORT;
+	m_fNextHeartbeatTime = GetTime();
+}
+
+int CMatchmaking::FindOrCreateContext( const uint id )
+{
+	int idx = m_SessionContexts.InvalidIndex();
+	for ( int i = 0; i < m_SessionContexts.Count(); ++i )
+	{
+		if ( m_SessionContexts[i].dwContextId == id )
+		{
+			idx = i;
+		}
+	}
+	if ( !m_SessionContexts.IsValidIndex( idx ) )
+	{
+		idx = m_SessionContexts.AddToTail();
+	}
+	return idx;
+}
+
+int CMatchmaking::FindOrCreateProperty( const uint id )
+{
+	int idx = m_SessionProperties.InvalidIndex();
+	for ( int i = 0; i < m_SessionProperties.Count(); ++i )
+	{
+		if ( m_SessionProperties[i].dwPropertyId == id )
+		{
+			idx = i;
+		}
+	}
+	if ( !m_SessionProperties.IsValidIndex( idx ) )
+	{
+		idx = m_SessionProperties.AddToTail();
+	}
+	return idx;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add an additional property to the current session
+//-----------------------------------------------------------------------------
+void CMatchmaking::AddSessionProperty( const uint nType, const char *pID, const char *pValue, const char *pValueType )
+{
+	KeyValues *pProperty = m_pSessionKeys->FindKey( pID, true );
+	pProperty->SetName( pID );
+	pProperty->SetInt( "type", nType );
+	pProperty->SetString( "valuestring", pValue );
+	pProperty->SetString( "valuetype", pValueType );
+
+	AddSessionPropertyInternal( pProperty );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set properties and contexts for the current session
+//-----------------------------------------------------------------------------
+void CMatchmaking::SetSessionProperties( KeyValues *pPropertyKeys )
+{
+	m_SessionContexts.RemoveAll();
+	m_SessionProperties.RemoveAll();
+
+	m_pSessionKeys->Clear();
+	pPropertyKeys->CopySubkeys( m_pSessionKeys );
+
+	for ( KeyValues *pProperty = m_pSessionKeys->GetFirstSubKey(); pProperty != NULL; pProperty = pProperty->GetNextKey() )
+	{
+		AddSessionPropertyInternal( pProperty );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMatchmaking::AddSessionPropertyInternal( KeyValues *pProperty )
+{
+	const char *pID = pProperty->GetName();
+	const char *pValue = pProperty->GetString( "valuestring" );
+
+	switch( pProperty->GetInt( "type" ) )
+	{
+	case SESSION_CONTEXT:
+		{
+			Msg( "Adding Context: %s : %s\n", pID, pValue );
+
+			int id = g_ClientDLL->GetPresenceID( pID );
+			int val = g_ClientDLL->GetPresenceID( pValue );
+
+			int idx = FindOrCreateContext( id );
+			XUSER_CONTEXT &ctx = m_SessionContexts[idx];
+			ctx.dwContextId = id;
+			ctx.dwValue = val;
+
+			// Set the display string for gameUI
+			char szBuffer[MAX_PATH];
+			g_ClientDLL->GetPropertyDisplayString( ctx.dwContextId, ctx.dwValue, szBuffer, sizeof( szBuffer ) );
+			pProperty->SetString( "displaystring", szBuffer );
+
+			// X360TBD: Such game specifics as this shouldn't be hard-coded
+			if ( m_CurrentState != MMSTATE_INITIAL && !Q_stricmp( pID, "CONTEXT_SCENARIO" ) )
+			{
+				// Set the scenario in our host data structure
+				Q_strncpy( m_HostData.scenario, szBuffer, sizeof( m_HostData.scenario ) );
+				UpdateSessionReplyData( XNET_QOS_LISTEN_SET_DATA );
+			}
+		}
+		break;
+
+	case SESSION_PROPERTY:
+		{
+			Msg( "Adding Property: %s : %s\n", pID, pValue );
+
+			if ( !Q_stricmp( pID, "PROPERTY_PRIVATE_SLOTS" ) )
+			{
+				// "Private Slots" is not a search criteria
+				m_nPrivateSlots = atoi( pValue );
+				break;
+			}
+
+			int id = g_ClientDLL->GetPresenceID( pID );
+
+			int idx = FindOrCreateProperty( id );
+			XUSER_PROPERTY &prop = m_SessionProperties[idx];
+			prop.dwPropertyId = id;
+
+			if ( !Q_stricmp( pProperty->GetString( "valuetype" ), "int" ) )
+			{
+				prop.value.nData = atoi( pValue );
+				prop.value.type = XUSER_DATA_TYPE_INT32;
+			}
+
+			// Build out the property keyvalues for gameUI
+			char szBuffer[MAX_PATH];
+			g_ClientDLL->GetPropertyDisplayString( prop.dwPropertyId, prop.value.nData, szBuffer, sizeof( szBuffer ) );
+			pProperty->SetString( "displaystring", szBuffer );
+
+			// X360TBD: Such game specifics as these shouldn't be so hard-coded
+			if ( !Q_stricmp( pID, "PROPERTY_GAME_SIZE" ) )
+			{
+				m_nGameSize = atoi( pValue );
+			}
+			if ( !Q_stricmp( pID, "PROPERTY_NUMBER_OF_TEAMS" ) )
+			{
+				m_nTotalTeams = atoi( pValue );
+			}
+			if ( m_CurrentState != MMSTATE_INITIAL && !Q_stricmp( pID, "PROPERTY_MAX_GAME_TIME" ) )
+			{
+				// Set the game time in our host data structure
+				m_HostData.gameTime = prop.value.nData;
+				UpdateSessionReplyData( XNET_QOS_LISTEN_SET_DATA );
+			}
+		}
+		break;
+
+	case SESSION_FLAG:
+		m_Session.SetFlag( g_ClientDLL->GetPresenceID( pID ) );
+		break;
+
+	default:
+		Warning( "Session option type %d not recognized/n", pProperty->GetInt( "type" ) );
+		break;
+
+	}
+}
+
+KeyValues *CMatchmaking::GetSessionProperties()
+{
+	return m_pSessionKeys;
+}
+
+double CMatchmaking::GetTime()
+{
+	return Plat_FloatTime();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: At netchannel connection, register the messages
+//-----------------------------------------------------------------------------
+void CMatchmaking::ConnectionStart( INetChannel *chan )
+{
+	REGISTER_MM_MSG( JoinResponse );
+	REGISTER_MM_MSG( ClientInfo );
+	REGISTER_MM_MSG( RegisterResponse );
+	REGISTER_MM_MSG( Migrate );
+	REGISTER_MM_MSG( Mutelist );
+	REGISTER_MM_MSG( Checkpoint );
+	REGISTER_MM_MSG( Heartbeat );
+
+	REGISTER_CLC_MSG( VoiceData );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Process a networked voice packet
+//-----------------------------------------------------------------------------
+bool CMatchmaking::ProcessVoiceData( CLC_VoiceData *pVoice )
+{
+	char chReceived[4096];
+	DWORD dwLength = pVoice->m_nLength;
+	pVoice->m_DataIn.ReadBits( chReceived, dwLength );
+
+	if ( m_Session.IsHost() )
+	{
+		char chCopyBuffer[4096];
+
+		// Forward this message on to everyone else
+		pVoice->m_DataOut.StartWriting( chCopyBuffer, sizeof ( chCopyBuffer ) );
+		Q_memcpy( chCopyBuffer, chReceived, sizeof( chCopyBuffer ) );
+		pVoice->m_DataOut.SeekToBit( dwLength );
+
+		SendToRemoteClients( pVoice, true, pVoice->m_xuid );
+	}
+
+	// Playback the voice data locally through xaudio
+#if defined ( _X360 )
+	if ( pVoice->m_xuid != m_Local.m_xuids[0] )
+	{
+		Audio_GetXVoice()->PlayIncomingVoiceData( pVoice->m_xuid, (byte*)chReceived, dwLength );
+	}
+#endif
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Delete channels that have been marked for deletion
+//-----------------------------------------------------------------------------
+void CMatchmaking::CleanupMarkedChannels()
+{
+	// Clean up net channels that need to be deleted
+	for ( int i = 0; i < m_ChannelsToRemove.Count(); ++i )
+	{
+		INetChannel *pNetChannel = FindChannel( m_ChannelsToRemove[i] );
+		if ( pNetChannel )
+		{
+			if ( !m_Channels.Remove( m_ChannelsToRemove[i] ) )
+			{
+				Warning( "CleanupMarkedChannels: Failed to remove a channel!\n" );
+			}
+		}
+	}
+	m_ChannelsToRemove.Purge();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Channels can be flagged for deletion during packet processing.
+//			Now that processing is finished, delete them.
+//-----------------------------------------------------------------------------
+void CMatchmaking::PacketEnd()
+{
+	CleanupMarkedChannels();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find a specific client from a netchannel
+//-----------------------------------------------------------------------------
+CClientInfo *CMatchmaking::FindClient( netadr_t *adr )
+{
+	CClientInfo *pClient = NULL;
+	unsigned int ip = adr->GetIPNetworkByteOrder();
+
+	if ( ip == m_Host.m_adr.GetIPNetworkByteOrder() )
+	{
+		pClient = &m_Host;
+	}
+	else
+	{
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			if ( ip == m_Remote[i]->m_adr.GetIPNetworkByteOrder() )
+			{
+				pClient = m_Remote[i];
+				break;
+			}
+		}
+	}
+	return pClient;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find a specific client by his XUID
+//-----------------------------------------------------------------------------
+CClientInfo *CMatchmaking::FindClientByXUID( XUID xuid )
+{
+	CClientInfo *pClient = NULL;
+
+	if ( xuid == m_Host.m_xuids[0] )
+	{
+		pClient = &m_Host;
+	}
+	else
+	{
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			if ( xuid == m_Remote[i]->m_xuids[0] )
+			{
+				pClient = m_Remote[i];
+				break;
+			}
+		}
+	}
+
+	return pClient;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find a specific client's netchannel
+//-----------------------------------------------------------------------------
+INetChannel *CMatchmaking::FindChannel( const unsigned int ip )
+{
+	INetChannel *pChannel = NULL;
+
+	int idx = m_Channels.Find( ip );
+	if ( idx != m_Channels.InvalidIndex() )
+	{
+		pChannel = m_Channels.Element( idx );
+	}
+
+	return pChannel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a new netchannel
+//-----------------------------------------------------------------------------
+INetChannel *CMatchmaking::CreateNetChannel( netadr_t *adr )
+{
+	INetChannel *pNewChannel = FindChannel( adr->GetIPNetworkByteOrder() );
+	if ( !pNewChannel )
+	{
+		pNewChannel = NET_CreateNetChannel( NS_MATCHMAKING, adr, "MATCHMAKING", this );
+	}
+
+	if( pNewChannel )
+	{
+		// Set a rate limit and other relevant properties
+		pNewChannel->SetTimeout( HEARTBEAT_TIMEOUT );
+	}
+
+	return pNewChannel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a netchannel for a session client
+//-----------------------------------------------------------------------------
+INetChannel *CMatchmaking::AddRemoteChannel( netadr_t *adr )
+{
+	INetChannel *pNetChannel = CreateNetChannel( adr );
+	if ( pNetChannel )
+	{
+		// Save this new channel
+		m_Channels.Insert( adr->GetIPNetworkByteOrder(), pNetChannel );
+	}
+	return pNetChannel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove a netchannel for a session client
+//-----------------------------------------------------------------------------
+void CMatchmaking::RemoveRemoteChannel( netadr_t *adr, const char *pReason )
+{
+	INetChannel *pNetChannel = FindChannel( adr->GetIPNetworkByteOrder() );
+	if ( pNetChannel )
+	{
+		m_Channels.Remove( adr->GetIPNetworkByteOrder() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Mark a net channel to be removed
+//-----------------------------------------------------------------------------
+void CMatchmaking::MarkChannelForRemoval( netadr_t *adr )
+{
+	m_ChannelsToRemove.AddToTail( adr->GetIPNetworkByteOrder() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the timeout for a net channel
+//-----------------------------------------------------------------------------
+void CMatchmaking::SetChannelTimeout( netadr_t *adr, int timeout )
+{
+	INetChannel *pChannel = FindChannel( adr->GetIPNetworkByteOrder() );
+	if ( pChannel )
+	{
+		Msg( "Setting new timeout for ip %d: %d\n", adr->GetIPNetworkByteOrder(), timeout );
+		pChannel->SetTimeout( timeout );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Send a net message to a specific address
+//-----------------------------------------------------------------------------
+void CMatchmaking::SendMessage( INetMessage *msg, netadr_t *adr, bool bVoice )
+{
+	// Find the matching net channel
+	INetChannel *pChannel = FindChannel( adr->GetIPNetworkByteOrder() );
+	if ( pChannel )
+	{
+		pChannel->SendNetMsg( *msg, false, bVoice );
+		if ( !pChannel->Transmit() )
+		{
+			Msg( "Transmit failed\n" );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Send a net message to a specific client
+//-----------------------------------------------------------------------------
+void CMatchmaking::SendMessage( INetMessage *msg, CClientInfo *pClient, bool bVoice )
+{
+	// Find the matching net channel
+	INetChannel *pChannel = FindChannel( pClient->m_adr.GetIPNetworkByteOrder() );
+	if ( pChannel )
+	{
+		pChannel->SendNetMsg( *msg, false, bVoice );
+		if ( !pChannel->Transmit() )
+		{
+			Msg( "Transmit failed\n" );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Send a net message to all remote clients
+//-----------------------------------------------------------------------------
+void CMatchmaking::SendToRemoteClients( INetMessage *msg, bool bVoice, XUID excludeXUID )
+{
+	for ( int i = 0; i < m_Remote.Count(); ++i )
+	{
+		CClientInfo *pInfo = m_Remote[i];
+
+		if ( excludeXUID != -1 && pInfo->m_xuids[0] == excludeXUID )
+			continue;
+
+		SendMessage( msg, m_Remote[i], true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Send a heartbeat to a specific client
+//-----------------------------------------------------------------------------
+bool CMatchmaking::SendHeartbeat( CClientInfo *pClient )
+{
+	if ( pClient->m_adr.GetIPNetworkByteOrder() == 0 )
+		return false;
+
+	// Check for timeout
+	INetChannel *pChannel = FindChannel( pClient->m_adr.GetIPNetworkByteOrder() );
+	if ( pChannel )
+	{
+//		Msg( "Sending HB\n" );
+
+		if ( pChannel->IsTimedOut() )
+		{
+			ClientDropped( pClient );
+			return false;
+		}
+
+		// Send a heartbeat to the client
+		MM_Heartbeat beat;
+		pChannel->SendNetMsg( beat );	
+		pChannel->Transmit();
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Transmit regular messages to keep the connection alive
+//-----------------------------------------------------------------------------
+void CMatchmaking::SendHeartbeat()
+{
+	double time = GetTime();
+	if ( time < m_fNextHeartbeatTime )
+		return;
+
+	m_fNextHeartbeatTime = time + m_fHeartbeatInterval;
+
+	if ( m_Session.IsHost() )
+	{
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			SendHeartbeat( m_Remote[i] );
+		}
+	}
+	else
+	{
+		SendHeartbeat( &m_Host );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Look up a player by name
+//-----------------------------------------------------------------------------
+static uint64 FindPlayerByName( CClientInfo *pClient, const char *pName )
+{
+	for ( int i = 0; i < XUSER_MAX_COUNT; ++i )
+	{
+		if ( pClient->m_xuids[i] && !Q_stricmp( pClient->m_szGamertags[i], pName ) )
+		{
+			return pClient->m_xuids[i];
+		}
+	}
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get an xuid from a CBasePlayer id
+//-----------------------------------------------------------------------------
+uint64 CMatchmaking::PlayerIdToXuid( int playerId )
+{
+	uint64 ret = 0;
+
+	player_info_t info;
+	if ( engineClient->GetPlayerInfo( playerId, &info ) )
+	{
+		// find the client with a matching name
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			ret = FindPlayerByName( m_Remote[i], info.name );
+			if ( ret )
+			{
+				break;
+			}
+		}
+	}
+
+	if ( !ret )
+	{
+		// Try ourselves
+		ret = FindPlayerByName( &m_Local, info.name );
+	}
+
+	if ( !ret )
+	{
+		// Try the host
+		ret = FindPlayerByName( &m_Host, info.name );
+	}
+
+	return ret;
+}
+
+bool CMatchmaking::GameIsActive()
+{
+	return m_CurrentState > MMSTATE_GAME_ACTIVE;
+}
+
+bool CMatchmaking::GameIsLocked()
+{
+	return ( m_Session.IsArbitrated() && m_CurrentState > MMSTATE_GAME_LOCKED );
+}
+
+bool CMatchmaking::ConnectedToServer()
+{
+	return engineClient->IsConnected();
+}
+
+bool CMatchmaking::IsInMigration()
+{
+	return ( m_CurrentState >= MMSTATE_HOSTMIGRATE_STARTINGMIGRATION && 
+			 m_CurrentState <= MMSTATE_HOSTMIGRATE_WAITINGFORHOST );
+}
+
+bool CMatchmaking::IsAcceptingConnections()
+{
+	if ( !m_Session.IsHost() ||
+		 m_CurrentState < MMSTATE_ACCEPTING_CONNECTIONS ||
+		 m_CurrentState == MMSTATE_PREGAME ||
+		 m_CurrentState == MMSTATE_LOADING ||
+		 GameIsLocked() )
+	{
+		return false;
+	}
+	return true;
+}
+
+bool CMatchmaking::IsServer()
+{
+	// for now, the host is the server
+	return m_Session.IsHost();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Helpers to convert between CClientInfo and MM_ClientInfo
+//-----------------------------------------------------------------------------
+void CMatchmaking::ClientInfoToNetMessage( MM_ClientInfo *pInfo, const CClientInfo *pClient )
+{
+	pInfo->m_id			= pClient->m_id;
+	pInfo->m_xnaddr		= pClient->m_xnaddr;
+	pInfo->m_cPlayers	= pClient->m_cPlayers;
+	pInfo->m_bInvited	= pClient->m_bInvited;
+
+	Q_memcpy( pInfo->m_xuids, pClient->m_xuids, sizeof( pInfo->m_xuids ) );
+	Q_memcpy( pInfo->m_cVoiceState, pClient->m_cVoiceState, sizeof( pInfo->m_cVoiceState ) );
+	Q_memcpy( pInfo->m_iTeam, pClient->m_iTeam, sizeof( pInfo->m_iTeam ) );
+	Q_memcpy( pInfo->m_iControllers, pClient->m_iControllers, sizeof( pInfo->m_iControllers ) );
+	Q_memcpy( pInfo->m_szGamertags, pClient->m_szGamertags, sizeof( pInfo->m_szGamertags ) );
+}
+
+void CMatchmaking::NetMessageToClientInfo( CClientInfo *pClient, const MM_ClientInfo *pInfo )
+{
+	pClient->m_id		= pInfo->m_id;
+	pClient->m_xnaddr	= pInfo->m_xnaddr;
+	pClient->m_cPlayers = pInfo->m_cPlayers;
+	pClient->m_bInvited = pInfo->m_bInvited;
+
+#if defined( _X360 )
+	IN_ADDR winaddr;
+	XNKID xid = m_Session.GetSessionId();
+	if ( XNetXnAddrToInAddr( &pClient->m_xnaddr, &xid, &winaddr ) != 0 )
+	{
+		Warning( "Error resolving client IP\n" );
+	}
+ 	pClient->m_adr.SetType( NA_IP );
+ 	pClient->m_adr.SetIPAndPort( winaddr.S_un.S_addr, PORT_MATCHMAKING );
+#endif
+
+	Q_memcpy( pClient->m_xuids, pInfo->m_xuids, sizeof( pClient->m_xuids ) );
+	Q_memcpy( pClient->m_cVoiceState, pInfo->m_cVoiceState, sizeof( pClient->m_cVoiceState ) );
+	Q_memcpy( pClient->m_iTeam, pInfo->m_iTeam, sizeof( pClient->m_iTeam ) );
+	Q_memcpy( pClient->m_iControllers, pInfo->m_iControllers, sizeof( pClient->m_iControllers ) );
+	Q_memcpy( pClient->m_szGamertags, pInfo->m_szGamertags, sizeof( pClient->m_szGamertags ) );
+}
+
+//----------------------------------------
+//
+//	Host/Client Shared
+//
+//----------------------------------------
+//-----------------------------------------------------------------------------
+// Purpose: Set up the properties of the local client machine
+//-----------------------------------------------------------------------------
+bool CMatchmaking::InitializeLocalClient( bool bIsHost )
+{
+	Q_memset( &m_Local, 0, sizeof( m_Local ) );
+
+	m_Local.m_bInvited = bIsHost;
+
+#if defined( _X360 )
+	while( XNetGetTitleXnAddr( &m_Local.m_xnaddr ) == XNET_GET_XNADDR_PENDING )
+		;
+
+	// machine id
+	if ( 0 != XNetXnAddrToMachineId( &m_Local.m_xnaddr, &m_Local.m_id ) )
+	{
+		// User isn't signed in to live, use their xuid instead
+		XUserGetXUID( XBX_GetPrimaryUserId(), &m_Local.m_id );
+	}
+
+	m_Local.m_cPlayers = 0;
+
+	// Set up the players
+	for ( uint i = 0; i < MAX_PLAYERS_PER_CLIENT; ++i )
+	{
+		// We currently only allow one player per console
+		if ( i != XBX_GetPrimaryUserId() )
+		{
+			continue;
+		}
+
+		// xuid
+		uint ret = XUserGetXUID( i, &m_Local.m_xuids[m_Local.m_cPlayers] );
+		if ( ret == ERROR_NO_SUCH_USER )
+		{
+			continue;
+		}
+		else if ( ret != ERROR_SUCCESS )
+		{
+			return false;
+		}
+
+		// gamertag
+		ret = XUserGetName( XBX_GetPrimaryUserId(), m_Local.m_szGamertags[m_Local.m_cPlayers], MAX_PLAYER_NAME_LENGTH );
+		if ( ret != ERROR_SUCCESS )
+		{
+			return false;
+		}
+		m_Local.m_szGamertags[m_Local.m_cPlayers][MAX_PLAYER_NAME_LENGTH - 1] = '\0';
+
+		// Set the player's name in the game
+		char szNameCmd[MAX_PLAYER_NAME_LENGTH + 16];
+		Q_snprintf( szNameCmd, sizeof( szNameCmd ), "name %s", m_Local.m_szGamertags[m_Local.m_cPlayers] );
+		engineClient->ClientCmd( szNameCmd );
+
+		m_Local.m_iControllers[m_Local.m_cPlayers] = i;
+		m_Local.m_iTeam[m_Local.m_cPlayers] = -1;
+
+
+		m_Local.m_cVoiceState[m_Local.m_cPlayers] = 0;
+
+		// number of players on this console
+		++m_Local.m_cPlayers;
+	}
+
+	// Source can only support one player per console.
+	if( m_Local.m_cPlayers > 1 )
+	{
+		Warning( "Too many players on this console\n" );
+		return false;
+	}
+
+	// Set up the host data that gets sent back to searching clients
+	// By default, the first player is considered the host
+	Q_strncpy( m_HostData.hostName, m_Local.m_szGamertags[0], sizeof( m_HostData.hostName ) );
+	m_HostData.gameState = GAMESTATE_INLOBBY;
+	m_HostData.xuid = m_Local.m_xuids[ XBX_GetPrimaryUserId() ];
+
+#endif
+
+	m_bInitialized = true;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Connection to the game server has been established, so we can
+//			add the local players to the teams that were setup in the lobby.
+//-----------------------------------------------------------------------------
+void CMatchmaking::AddLocalPlayersToTeams()
+{
+	if ( !m_bInitialized || XBX_GetPrimaryUserId() == INVALID_USER_ID )
+		return;
+
+	if ( m_Local.m_iTeam[0] == -1 )
+		return;
+
+	// Convert the team number into a team name
+	char szTeamName[32];
+	uint id = g_ClientDLL->GetPresenceID( "PROPERTY_TEAM" );
+	g_ClientDLL->GetPropertyDisplayString( id, m_Local.m_iTeam[0], szTeamName, sizeof( szTeamName ) );
+
+	Msg( "Joining team: %s\n", szTeamName );
+
+	char cmd[32];
+	Q_snprintf( cmd, sizeof( cmd ), "jointeam_nomenus %s", szTeamName );
+	engineClient->ClientCmd( cmd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Map loading is completed - restore full communication
+//-----------------------------------------------------------------------------
+void CMatchmaking::OnLevelLoadingFinished()
+{
+	// This functions gets called from some odd places
+ 	if ( m_CurrentState != MMSTATE_CONNECTED_TO_SERVER )
+ 		return;
+
+	// Test code to force a disconnect at end of map load
+// 	if ( !IsServer() )
+// 	{
+// 		char cmd[MAX_PATH];
+// 		Q_snprintf( cmd, sizeof( cmd ), "connect 127.0.0.1\n" );		
+// 		Cbuf_AddText( cmd );
+// 		return;
+// 	}
+
+	SwitchToState( MMSTATE_INGAME );
+
+	MM_Checkpoint msg;
+	msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_LOADING_COMPLETE;
+
+	if ( m_Session.IsHost() )
+	{
+		if ( !m_Session.IsArbitrated() )
+		{
+			// Re-enable response to probes
+			m_HostData.gameState = GAMESTATE_INPROGRESS;
+			UpdateSessionReplyData( XNET_QOS_LISTEN_ENABLE|XNET_QOS_LISTEN_SET_DATA );
+		}
+
+		// Reset netchannel timeouts for any clients that are also finished loading
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			CClientInfo *pClient = m_Remote[i];
+			if ( pClient->m_bLoaded )
+			{
+				// Send a reply and reset the netchannel timeout
+				SendMessage( &msg, pClient );
+				SetChannelTimeout( &pClient->m_adr, HEARTBEAT_TIMEOUT );
+			}
+		}
+	}
+	else
+	{
+		// Tell the host we're finished loading
+		SendMessage( &msg, &m_Host );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Process packet from another client
+//-----------------------------------------------------------------------------
+bool CMatchmaking::ProcessConnectionlessPacket( netpacket_t *pPacket )
+{
+	Assert( pPacket );
+
+	bf_read &msg = pPacket->message;
+	int type = msg.ReadByte();
+	switch( type )
+	{
+	case PTH_SYSTEMLINK_SEARCH:
+		HandleSystemLinkSearch( pPacket );
+		break;
+
+	case HTP_SYSTEMLINK_REPLY:
+		HandleSystemLinkReply( pPacket );
+		break;
+
+	case PTH_CONNECT:
+		HandleJoinRequest( pPacket );
+		break;
+
+	default:
+		break;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Process an info update about another client
+//-----------------------------------------------------------------------------
+bool CMatchmaking::ProcessClientInfo( MM_ClientInfo *pInfo )
+{
+	CClientInfo *pClient = NULL;
+	bool bHost = false;
+
+	if ( m_CurrentState == MMSTATE_INITIAL )
+	{
+		// Session has been reset, this is a stale message
+		Msg( "Received MM_ClientInfo with MMSTATE_INITIAL\n" );
+		return true;
+	}
+
+	if ( pInfo->m_id == m_Local.m_id )
+	{
+		if ( pInfo->m_cPlayers == 0 )
+		{
+			if ( m_CurrentState != MMSTATE_SESSION_DISCONNECTING )
+			{
+				// We've been kicked
+				KickPlayerFromSession( 0 );
+				SessionNotification( SESSION_NOTIFY_CLIENT_KICKED );
+			}
+			return true;
+		}
+		else
+		{
+			pClient = &m_Local;
+		}
+	}
+
+	// Check against our host id
+	if ( pInfo->m_id == m_Host.m_id )
+	{
+		pClient = &m_Host;
+		bHost = true;
+	}
+	else
+	{
+		// Look for the client in our remote list
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			if ( m_Remote[i]->m_id == pInfo->m_id )
+			{
+				pClient = m_Remote[i];
+				break;
+			}
+		}
+	}
+
+	// If we didn't find it, this must be a new client
+	if ( !pClient && pInfo->m_cPlayers != 0 )
+	{
+		Msg( "New client. %s\n", pInfo->ToString() );
+
+		pClient = new CClientInfo();
+		m_Remote.AddToTail( pClient );
+
+		// Copy the new client info
+		NetMessageToClientInfo( pClient, pInfo );
+
+		AddPlayersToSession( pClient );
+		SendPlayerInfoToLobby( pClient );
+	}
+	else
+	{
+		// We're updating an existing client
+		if ( pInfo->m_cPlayers )
+		{
+			// Cache off the old client info, as pClient gets updated through this function
+			CClientInfo tempClient = *pClient;
+
+			// Check for player changes
+			if ( Q_memcmp( &tempClient.m_xuids, pInfo->m_xuids, sizeof( tempClient.m_xuids ) ) )
+			{
+				// Remove the old players and add the new
+				RemovePlayersFromSession( pClient );
+				NetMessageToClientInfo( pClient, pInfo );
+				AddPlayersToSession( pClient );
+			}
+
+			// Check for team changes
+			for ( int i = 0; i < pInfo->m_cPlayers; ++i )
+			{
+				if ( pInfo->m_iTeam[i] != tempClient.m_iTeam[i] || pInfo->m_cVoiceState[i] != tempClient.m_cVoiceState[i] )
+				{
+					// X360TBD: send real "ready" setting, or remove entirely?
+					EngineVGui()->UpdatePlayerInfo( pInfo->m_xuids[i], pInfo->m_szGamertags[i], pInfo->m_iTeam[i], pInfo->m_cVoiceState[i], GetPlayersNeeded(), bHost );
+				}
+			}
+
+			// Store the new info
+			NetMessageToClientInfo( pClient, pInfo );
+
+			if ( m_Session.IsHost() )
+			{
+				SendToRemoteClients( pInfo );
+			}
+		}
+		else
+		{
+			// A client has been dropped
+			ClientDropped( pClient );
+		}
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A connection was lost - respond accordingly
+//-----------------------------------------------------------------------------
+void CMatchmaking::ClientDropped( CClientInfo *pClient )
+{
+	if ( !pClient )
+	{
+		Warning( "Null client pointer in ClientDropped!\n" );
+		return;
+	}
+
+	if ( m_CurrentState == MMSTATE_SESSION_CONNECTING )
+	{
+		// Not really dropped, we just failed to connect to the host
+		SessionNotification( SESSION_NOTIFY_CONNECT_NOTAVAILABLE );
+		return;
+	}
+
+	Warning( "Dropped player: %llu!", pClient->m_id );
+
+	// Do this first, before the team assignment gets cleared
+	RemovePlayersFromSession( pClient );
+
+	// Remove all players from the lobby
+	for ( int i = 0; i < pClient->m_cPlayers; ++i )
+	{
+		pClient->m_iTeam[i] = -1;
+	}
+	SendPlayerInfoToLobby( pClient );
+
+	MarkChannelForRemoval( &pClient->m_adr );
+
+	if ( pClient == &m_Host )
+	{
+		// The host was lost
+		if ( m_Session.IsSystemLink() )
+		{
+			// Can't migrate system link sessions
+			SessionNotification( SESSION_NOTIFY_LOST_HOST );
+		}
+		else
+		{
+			// X360TBD: Migration still doesn't work correctly
+			SessionNotification( SESSION_NOTIFY_LOST_HOST );
+			/* 
+			// Start migrating
+			if ( !IsInMigration() )
+			{
+				m_PreMigrateState = m_CurrentState;
+				StartHostMigration();
+			}
+			*/
+		}
+	}
+	else
+	{
+		if ( m_Session.IsHost() )
+		{
+			// Send a disconnect ack back to the client
+			MM_Checkpoint msg;
+			msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_SESSION_DISCONNECT;
+			SendMessage( &msg, &pClient->m_adr );
+
+			// Tell everyone else this client is gone
+			MM_ClientInfo droppedPlayer;
+			ClientInfoToNetMessage( &droppedPlayer, pClient );
+			droppedPlayer.m_cPlayers = 0;
+
+			SendToRemoteClients( &droppedPlayer );
+
+			for ( int i = 0; i < sv.GetClientCount(); i++ )
+			{
+				IClient *pIClient = sv.GetClient(i);
+				bool bFound = false;
+				
+				if ( pIClient )
+				{
+					for ( int j = 0; j < pClient->m_cPlayers; ++j )
+					{
+						if ( pClient->m_xuids[j] == 0 )
+							continue;
+
+						if ( Q_stricmp( pIClient->GetClientName(), pClient->m_szGamertags[j] ) == 0 )
+						{
+							bFound = true;
+							pIClient->Disconnect( "Timed Out" );
+							break;
+						}
+					}
+				}
+
+				if ( bFound == true )
+					break;
+			}
+		}
+	}
+
+	if ( m_Remote.FindAndRemove( pClient ) )
+	{
+		delete pClient;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A player is leaving the session
+//-----------------------------------------------------------------------------
+void CMatchmaking::PerformDisconnect()
+{
+	if ( m_CurrentState == MMSTATE_SESSION_DISCONNECTING )
+	{
+		if ( ConnectedToServer() )
+		{
+			engineClient->ExecuteClientCmd( "disconnect" );
+			EngineVGui()->ActivateGameUI();
+		}
+
+		if ( m_bEnteredLobby )
+		{
+			EngineVGui()->SessionNotification( SESSION_NOTIFY_WELCOME );
+		}
+		SwitchToState( MMSTATE_INITIAL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A player is leaving the session
+//-----------------------------------------------------------------------------
+void CMatchmaking::KickPlayerFromSession( uint64 id )
+{
+	MM_ClientInfo droppedPlayer;
+
+	if ( m_Local.m_xuids[0] == id || id == 0 )
+	{
+		// We've been kicked, or voluntarily left the session
+		ClientInfoToNetMessage( &droppedPlayer, &m_Local );
+		droppedPlayer.m_cPlayers = 0;
+
+		if ( m_Session.IsHost() )
+		{
+			// Tell all the clients
+			SendToRemoteClients( &droppedPlayer );
+		}
+		else
+		{
+			// tell the host to drop us
+			SendMessage( &droppedPlayer, &m_Host );
+		}
+
+		// Prepare to close the session and reset
+		SwitchToState( MMSTATE_SESSION_DISCONNECTING );
+	}
+	else if ( m_Session.IsHost() )
+	{
+		// Host wants to kick a client
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			CClientInfo *pClient = m_Remote[i];
+			for ( int j = 0; j < pClient->m_cPlayers; ++j )
+			{
+				if ( pClient->m_xuids[j] == id )
+				{
+					ClientInfoToNetMessage( &droppedPlayer, pClient );
+					droppedPlayer.m_cPlayers = 0;
+					SendMessage( &droppedPlayer, pClient );
+					return;
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add players to the session
+//-----------------------------------------------------------------------------
+void CMatchmaking::AddPlayersToSession( CClientInfo *pClient )
+{
+	bool bIsLocal = false;
+
+	if ( &m_Local == pClient )
+	{
+		m_Session.JoinLocal( pClient );
+		bIsLocal = true;
+	}
+	else
+	{
+		m_Session.JoinRemote( pClient );
+	}
+
+#if defined ( _X360 )
+	if ( Audio_GetXVoice() )
+	{
+		Audio_GetXVoice()->AddPlayerToVoiceList( pClient, bIsLocal );
+		if ( bIsLocal )
+		{
+			m_bCreatedLocalTalker = true;
+		}
+	}
+#endif
+	UpdateMuteList();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove players from the session
+//-----------------------------------------------------------------------------
+void CMatchmaking::RemovePlayersFromSession( CClientInfo *pClient )
+{
+	if ( !pClient->m_cPlayers )
+		return;
+
+	bool bIsLocal = false;
+
+	if ( &m_Local == pClient )
+	{
+		m_Session.RemoveLocal( pClient );
+		bIsLocal = true;
+	}
+	else
+	{
+		m_Session.RemoveRemote( pClient );
+	}
+
+#if defined ( _X360 )
+	if ( Audio_GetXVoice() )
+	{
+		Audio_GetXVoice()->RemovePlayerFromVoiceList( pClient, bIsLocal );
+	}
+#endif
+	UpdateMuteList();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check if a client is muted
+//-----------------------------------------------------------------------------
+bool CMatchmaking::IsPlayerMuted( int iUserId, XUID playerId )
+{
+	for ( int i = 0; i < MAX_PLAYERS; ++i )
+	{
+		if ( m_Mutelist[iUserId][i] == playerId )
+		{
+			return true;
+		}
+	}
+	if ( m_MutedBy[iUserId].HasElement( playerId ) )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Determine which clients should be muted for the local client
+//-----------------------------------------------------------------------------
+void CMatchmaking::UpdateMuteList()
+{
+	// Process our mute list
+	MM_Mutelist msg;
+	GenerateMutelist( &msg );
+
+	// Send that to everyone else
+	if ( !m_Session.IsHost() )
+	{
+		SendMessage( &msg, &m_Host );
+	}
+	else
+	{
+		ProcessMutelist( &msg );
+	}
+}
+
+void Con_PrintTalkers( const CCommand &args )
+{
+	g_pMatchmaking->PrintVoiceStatus();
+}
+
+void CMatchmaking::PrintVoiceStatus( void )
+{
+#ifdef _X360
+	int iRemoteClient = 0;
+	int numRemoteTalkers;
+	XUID remoteTalkers[MAX_PLAYERS];
+	Audio_GetXVoice()->GetRemoteTalkers( &numRemoteTalkers, remoteTalkers );
+
+	CClientInfo *pClient = &m_Local;
+
+	if ( m_Session.IsHost() == false )
+	{
+		pClient = &m_Host;
+	}
+
+
+	Msg( "Num Remote Talkers: %d\n", numRemoteTalkers );
+
+	bool bFound = false;
+
+	while ( pClient )
+	{
+		if ( pClient != &m_Local )
+		{
+			for ( int iRemote = 0; iRemote < numRemoteTalkers; iRemote++ )
+			{
+				if ( pClient->m_xuids[0] == remoteTalkers[iRemote] )
+				{
+					bFound = true;
+					break;
+				}
+			}
+
+			if ( bFound == true )
+			{
+				Msg( "Found a Talker: %s\n", pClient->m_szGamertags[0] );
+			}
+			else
+			{
+				Msg( "ALERT!!! %s not in Talker list\n", pClient->m_szGamertags[0] );
+			}
+		}
+
+		if ( iRemoteClient < m_Remote.Count() )
+		{
+			pClient = m_Remote[iRemoteClient];
+			iRemoteClient++;
+		}
+		else
+		{
+			pClient = NULL;
+		}
+	}
+
+#endif
+
+}
+
+static ConCommand voice_printtalkers( "voice_printtalkers", Con_PrintTalkers, "voice debug.", FCVAR_DONTRECORD );
+
+//-----------------------------------------------------------------------------
+// Purpose: Update a client's mute list
+//-----------------------------------------------------------------------------
+void CMatchmaking::GenerateMutelist( MM_Mutelist *pMsg )
+{
+#if defined( _X360 )
+	// Get our remote talker list
+	if ( !Audio_GetXVoice() )
+		return;
+
+	int numRemoteTalkers;
+	XUID remoteTalkers[MAX_PLAYERS];
+	Audio_GetXVoice()->GetRemoteTalkers( &numRemoteTalkers, remoteTalkers );
+
+	pMsg->m_cPlayers = 0;
+
+	// Loop through local players and update mutes
+	for ( int iLocal = 0; iLocal < m_Local.m_cPlayers; ++iLocal )
+	{	
+		pMsg->m_cMuted[iLocal] = 0;
+
+		pMsg->m_xuid[pMsg->m_cPlayers] = m_Local.m_xuids[iLocal];
+
+		for ( int iRemote = 0; iRemote < numRemoteTalkers; ++iRemote )
+		{
+			BOOL bIsMuted = false;
+
+			DWORD ret = XUserMuteListQuery( m_Local.m_iControllers[iLocal], remoteTalkers[iRemote], &bIsMuted );
+			if( ERROR_SUCCESS != ret )
+			{
+				Warning( "Warning: XUserMuteListQuery() returned 0x%08x for user %d\n", ret, iLocal );
+			}
+
+			if( bIsMuted )
+			{
+				pMsg->m_Muted[pMsg->m_cPlayers].AddToTail( remoteTalkers[iRemote ] );
+				++pMsg->m_cMuted[pMsg->m_cPlayers];
+			}
+			else
+			{
+				bIsMuted = m_MutedBy[iLocal].HasElement( remoteTalkers[iRemote] );
+			}
+
+			if( bIsMuted )
+			{
+				Audio_GetXVoice()->SetPlaybackPriority( remoteTalkers[iRemote], m_Local.m_iControllers[iLocal], XHV_PLAYBACK_PRIORITY_NEVER );
+			}
+			else
+			{
+				Audio_GetXVoice()->SetPlaybackPriority( remoteTalkers[iRemote], m_Local.m_iControllers[iLocal], XHV_PLAYBACK_PRIORITY_MAX );
+			}
+		}
+
+		pMsg->m_cRemoteTalkers[pMsg->m_cPlayers] = m_MutedBy[pMsg->m_cPlayers].Count();
+		++pMsg->m_cPlayers;
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the mutelist from another client
+//-----------------------------------------------------------------------------
+bool CMatchmaking::ProcessMutelist( MM_Mutelist *pMsg )
+{
+#if defined( _X360 )
+	// local players
+	for( int i = 0; i < m_Local.m_cPlayers; ++i )
+	{
+		// remote players
+		for( int j = 0; j < pMsg->m_cPlayers; ++j )
+		{
+			m_MutedBy[i].FindAndRemove( pMsg->m_xuid[j] );
+
+			// players muted by remote player
+			for( int k = 0; k < pMsg->m_cMuted[j]; ++k )
+			{
+				if( m_Local.m_xuids[i] == pMsg->m_Muted[j][k] )
+				{
+					m_MutedBy[i].AddToTail( pMsg->m_xuid[j] );
+				}
+			}
+
+			BOOL bIsMuted = m_MutedBy[i].HasElement( pMsg->m_xuid[j] );
+			if ( !bIsMuted )
+			{
+				XUserMuteListQuery( m_Local.m_iControllers[i], pMsg->m_xuid[j], &bIsMuted );
+			}
+			if( bIsMuted )
+			{
+				Audio_GetXVoice()->SetPlaybackPriority( pMsg->m_xuid[j], m_Local.m_iControllers[i], XHV_PLAYBACK_PRIORITY_NEVER );
+			}
+			else
+			{
+				Audio_GetXVoice()->SetPlaybackPriority( pMsg->m_xuid[j], m_Local.m_iControllers[i], XHV_PLAYBACK_PRIORITY_MAX );
+			}
+		}
+	}
+
+	if ( m_Session.IsHost() )
+	{
+		// Pass this along to everyone else
+		SendToRemoteClients( pMsg );
+	}
+
+#endif
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A client is changing to another team
+//-----------------------------------------------------------------------------
+void CMatchmaking::ChangeTeam( const char *pTeamName )
+{
+	if ( !pTeamName )
+	{
+		// Automatic switch to next team
+		if ( m_Session.IsHost() )
+		{
+			if ( m_CurrentState == MMSTATE_ACCEPTING_CONNECTIONS )
+			{
+				// Put ourselves on another team and
+				// tell the other players
+				SwitchToNextOpenTeam( &m_Local );
+			}
+		}
+		else
+		{
+			// Send a request to the host
+			MM_Checkpoint msg;
+			msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_CHANGETEAM;
+			SendMessage( &msg, &m_Host );
+		}
+	}
+	else
+	{
+		// Find a team name that matches, and tell everyone our new team number
+		char szTeamName[32];
+		uint id = g_ClientDLL->GetPresenceID( "PROPERTY_TEAM" );
+
+		for ( int iTeam = 0; iTeam < m_nTotalTeams; ++iTeam )
+		{
+			g_ClientDLL->GetPropertyDisplayString( id, iTeam, szTeamName, sizeof( szTeamName ) );
+			if ( !Q_stricmp( szTeamName, pTeamName ) )
+			{
+				bool bChanged = false;
+				MM_ClientInfo info;
+				ClientInfoToNetMessage( &info, &m_Local );
+				for ( int i = 0; i < m_Local.m_cPlayers; ++i )
+				{
+					if ( info.m_iTeam[i] != iTeam )
+					{
+						bChanged = true;
+					}
+					info.m_iTeam[i] = iTeam;
+				}
+
+				if ( !bChanged )
+				{
+					return;
+				}
+
+				if ( m_Session.IsHost() )
+				{
+					ProcessClientInfo( &info );
+				}
+				else
+				{
+					SendMessage( &info, &m_Host );
+				}
+				break;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle various matchmaking checkpoint messages
+//-----------------------------------------------------------------------------
+bool CMatchmaking::ProcessCheckpoint( MM_Checkpoint *pMsg )
+{
+	switch( pMsg->m_Checkpoint )
+	{
+	case MM_Checkpoint::CHECKPOINT_CHANGETEAM:
+		if ( m_Session.IsHost() )
+		{
+			// if the countdown has started, deny
+			if ( m_CurrentState == MMSTATE_ACCEPTING_CONNECTIONS )
+			{
+				netadr_t adr = pMsg->GetNetChannel()->GetRemoteAddress();
+				CClientInfo *pClient = FindClient( &adr );
+				if ( pClient )
+				{
+					SwitchToNextOpenTeam( pClient );
+				}
+			}
+		}	
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_PREGAME:
+
+		if ( m_Session.IsArbitrated() && !m_Session.IsHost() )
+		{
+			m_Session.RegisterForArbitration();
+		}
+
+		// Start the countdown timer to map load
+		SwitchToState( MMSTATE_PREGAME );
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_GAME_LOBBY:
+		
+		// returning to game lobby, pregame canceled
+		// reset the countdown
+		SessionNotification( SESSION_NOTIFY_COUNTDOWN, -1 );
+		if ( m_Session.IsHost() )
+		{
+			SwitchToState( MMSTATE_ACCEPTING_CONNECTIONS );
+		}
+		else
+		{
+			SwitchToState( MMSTATE_SESSION_CONNECTED );
+		}
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_LOADING_COMPLETE:
+
+		if ( m_Session.IsHost() )
+		{
+			// Mark this client as loaded
+			netadr_t adr = pMsg->GetNetChannel()->GetRemoteAddress();
+			CClientInfo *pClient = FindClient( &adr );
+			if ( pClient )
+			{
+				pClient->m_bLoaded = true;
+
+				if ( GameIsActive() )
+				{
+					// Send a reply and reset the netchannel timeout
+					SendMessage( pMsg, pClient );
+					SetChannelTimeout( &pClient->m_adr, HEARTBEAT_TIMEOUT );
+				}
+			}
+		}
+		else
+		{
+			// The host is also loaded, so reset the netchannel timeout
+			SetChannelTimeout( &m_Host.m_adr, HEARTBEAT_TIMEOUT );
+		}
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_CONNECT:
+
+		// If we're already connected or in the game, don't connect again.
+		if ( m_CurrentState == MMSTATE_CONNECTED_TO_SERVER || 
+			 m_CurrentState == MMSTATE_INGAME )
+		{
+			break;
+		}
+
+		if ( m_Session.IsHost() )
+		{
+			// Send the message to everyone
+			SendToRemoteClients( pMsg );
+		}
+		else
+		{
+			// The host is asking us to connect to the game server
+			if ( m_CurrentState != MMSTATE_LOADING )
+			{
+				// Set the longer timeout for loading
+				SetChannelTimeout( &m_Host.m_adr, HEARTBEAT_TIMEOUT_LOADING );
+				SwitchToState( MMSTATE_LOADING );
+			}
+		}
+
+		// Make sure we're not preventing full startup
+		SetPreventFullServerStartup( false, "CHECKPOINT_CONNECT\n" );
+
+		if ( !IsServer() )
+		{
+			char cmd[MAX_PATH];
+			Q_snprintf( cmd, sizeof( cmd ), "connect %d.%d.%d.%d", m_Host.m_adr.ip[0], m_Host.m_adr.ip[1], m_Host.m_adr.ip[2], m_Host.m_adr.ip[3] );		
+			Cbuf_AddText( cmd );
+
+			SessionNotification( SESSION_NOTIFY_CONNECTED_TOSERVER );
+		}
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_SESSION_DISCONNECT:
+
+		PerformDisconnect();
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_REPORT_STATS:
+
+		// Start stats reporting
+		g_ClientDLL->StartStatsReporting( m_Session.GetSessionHandle(), m_Session.IsArbitrated() );
+		m_Local.m_bReportedStats = true;
+
+		m_fHeartbeatInterval = HEARTBEAT_INTERVAL_SHORT;
+
+		SwitchToState( MMSTATE_REPORTING_STATS );
+
+		// Host needs to wait for clients to finish reporting
+		if ( !m_Session.IsHost() )
+		{
+			EndStatsReporting();
+		}
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_REPORTING_COMPLETE:
+		{
+			// Mark this client as finished reporting stats
+			bool bFinished = false;
+			netadr_t adr = pMsg->GetNetChannel()->GetRemoteAddress();
+			for ( int i = 0; i < m_Remote.Count(); ++i )
+			{
+				CClientInfo *pClient = m_Remote[i];
+				if ( pClient->m_adr.CompareAdr( adr ) )
+				{
+					pClient->m_bReportedStats = true;
+				}
+
+				if ( !pClient->m_bReportedStats )
+				{
+					bFinished = false;
+				}
+			}
+
+			if ( bFinished && m_Local.m_bReportedStats )
+			{
+				EndStatsReporting();	
+			}
+		}
+		break;
+
+	case MM_Checkpoint::CHECKPOINT_POSTGAME:
+
+		g_pXboxSystem->SessionEnd( m_Session.GetSessionHandle(), false );
+
+		engineClient->ClientCmd( "disconnect" );
+
+		EngineVGui()->ActivateGameUI();
+
+		if ( m_Session.IsArbitrated() )
+		{
+			// Tell gameui to return to the main menu
+			SessionNotification( SESSION_NOTIFY_ENDGAME_RANKED );
+
+			SwitchToState( MMSTATE_INITIAL );
+		}
+		else
+		{
+			if ( m_Session.IsHost() )
+			{
+				// Make ourselves available to queries again
+				m_HostData.gameState = GAMESTATE_INLOBBY;
+				UpdateSessionReplyData( XNET_QOS_LISTEN_ENABLE|XNET_QOS_LISTEN_SET_DATA );
+			}
+
+			// Tell gameui to activate the lobby
+			SessionNotification( m_Session.IsHost() ? SESSION_NOTIFY_ENDGAME_HOST : SESSION_NOTIFY_ENDGAME_CLIENT );
+
+			// Fill the lobby with all of the clients
+			if ( !m_Session.IsHost() )
+			{
+				SendPlayerInfoToLobby( &m_Host, m_nHostOwnerId );
+				SendPlayerInfoToLobby( &m_Local );
+			}
+			else
+			{
+				SendPlayerInfoToLobby( &m_Local, 0 );
+			}
+
+			for ( int i = 0; i < m_Remote.Count(); ++i )
+			{
+				SendPlayerInfoToLobby( m_Remote[i] );
+			}
+
+			if ( m_Session.IsHost() )
+			{
+				SwitchToState( MMSTATE_ACCEPTING_CONNECTIONS );
+			}
+			else
+			{
+				SwitchToState( MMSTATE_SESSION_CONNECTED );
+			}
+		}
+		break;
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop any asynchronous operation that is currently running
+//-----------------------------------------------------------------------------
+void CMatchmaking::CancelCurrentOperation()
+{
+	switch( m_CurrentState )
+	{
+	case MMSTATE_CREATING:
+		m_Session.CancelCreateSession();
+		break;
+
+	case MMSTATE_SEARCHING:
+		CancelSearch();
+		break;
+
+	case MMSTATE_WAITING_QOS:
+		CancelQosLookup();
+		break;
+
+	case MMSTATE_SESSION_CONNECTING:
+		break;
+
+	default:
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Send player info to be displayed in the session lobby
+//-----------------------------------------------------------------------------
+void CMatchmaking::SendPlayerInfoToLobby( CClientInfo *pClient, int iHostIdx )
+{
+	for ( int i = 0; i < pClient->m_cPlayers; ++i )
+	{
+		EngineVGui()->UpdatePlayerInfo( pClient->m_xuids[i], pClient->m_szGamertags[i], pClient->m_iTeam[i], pClient->m_cVoiceState[i], GetPlayersNeeded(), iHostIdx == i );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update the start game countdown timer
+//-----------------------------------------------------------------------------
+void CMatchmaking::UpdatePregame()
+{
+	int elapsedTime = GetTime() - m_fCountdownStartTime;
+	if ( elapsedTime > REGISTRATION_MAXWAITTIME )
+	{
+		// Check the registration timer.
+		if ( m_Session.IsHost() && m_Session.IsArbitrated() && !m_Local.m_bRegistered )
+		{
+			// Time's up, register ourselves
+			m_Local.m_bRegistered = true;
+			m_Session.RegisterForArbitration();
+		}
+	}
+
+	// Check the countdown timer.  When it's zero, start the game.
+	if ( elapsedTime < STARTGAME_COUNTDOWN )
+	{
+		SessionNotification( SESSION_NOTIFY_COUNTDOWN, STARTGAME_COUNTDOWN - elapsedTime );
+		return;
+	}
+
+	// Send the zero count
+	SessionNotification( SESSION_NOTIFY_COUNTDOWN, 0 );
+
+	// Set a longer timeout for loading
+	if ( m_Session.IsHost() )
+	{
+		for ( int i = 0; i < m_Remote.Count(); ++i )
+		{
+			SetChannelTimeout( &m_Remote[i]->m_adr, HEARTBEAT_TIMEOUT_LOADING );
+		}
+
+		// Set commentary & cheats off
+		ConVarRef commentary( "commentary" );
+		commentary.SetValue( false );
+		ConVarRef sv_cheats( "sv_cheats" );
+		sv_cheats.SetValue( 0 );
+	}
+	else
+	{
+		SetChannelTimeout( &m_Host.m_adr, HEARTBEAT_TIMEOUT_LOADING );
+	}
+
+	g_pXboxSystem->SessionStart( m_Session.GetSessionHandle(), 0, false );
+
+	if ( !IsServer() )
+	{
+		SetPreventFullServerStartup( true, "SESSION_NOTIFY_COUNTDOWN == 0 and not the host\n" );
+	}
+
+	SwitchToState( MMSTATE_LOADING );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Receive notifications from the session
+//-----------------------------------------------------------------------------
+void CMatchmaking::SessionNotification( const SESSION_NOTIFY notification, const int param )
+{
+	// Notify GameUI
+	EngineVGui()->SessionNotification( notification, param );
+
+	switch( notification )
+	{
+	case SESSION_NOTIFY_CREATED_HOST:
+		m_bEnteredLobby = true;
+		OnHostSessionCreated();
+		break;
+
+	case SESSION_NOTIFY_CREATED_CLIENT:
+		Msg( "Client: CreateSession successful\n" );
+
+		// Session has been created according to the advertised specifications.
+		// Now send a connection request to the session host.
+		SwitchToState( MMSTATE_SESSION_CONNECTING );
+		break;
+
+	case SESSION_NOFIFY_MODIFYING_SESSION:
+		SwitchToState( MMSTATE_MODIFYING );
+		break;
+
+	case SESSION_NOTIFY_MODIFYING_COMPLETED_HOST:
+		SwitchToState( MMSTATE_ACCEPTING_CONNECTIONS );
+		break;
+
+	case SESSION_NOTIFY_MODIFYING_COMPLETED_CLIENT:
+		SwitchToState( MMSTATE_SESSION_CONNECTED );
+		break;
+
+	case SESSION_NOTIFY_SEARCH_COMPLETED:
+		// Waiting for the player to choose a session
+		SwitchToState( MMSTATE_BROWSING );
+		break;
+
+	case SESSION_NOTIFY_CONNECTED_TOSESSION:
+		m_bEnteredLobby = true;
+		SwitchToState( MMSTATE_SESSION_CONNECTED );
+		break;
+
+	case SESSION_NOTIFY_CONNECTED_TOSERVER:
+		SwitchToState( MMSTATE_CONNECTED_TO_SERVER );
+		break;
+
+	case SESSION_NOTIFY_MIGRATION_COMPLETED:
+		if ( !m_Session.IsHost() )
+		{
+			// Finished
+			EndMigration();
+		}
+		else
+		{
+			// Get ready to send join requests too peers
+			for ( int i = 0; i < m_Remote.Count(); ++i )
+			{
+				m_Remote[i]->m_bMigrated = false;
+
+				AddRemoteChannel( &m_Remote[i]->m_adr );
+			}
+
+			m_nSendCount = 0;
+			m_fSendTimer = 0;
+
+			SwitchToState( MMSTATE_HOSTMIGRATE_WAITINGFORCLIENTS );
+		}
+		break;
+
+	case SESSION_NOTIFY_FAIL_MIGRATE:
+		// X360TBD: How to handle this error?
+		Warning( "Migrate Failed\n" );
+		break;
+
+	case SESSION_NOTIFY_REGISTER_COMPLETED:
+		if( !m_Session.IsHost() )
+		{
+			// Tell the host we're registered
+			MM_RegisterResponse msg;
+			SendMessage( &msg, &m_Host.m_adr );
+		}
+		else
+		{
+			// Process the results of registration
+			ProcessRegistrationResults();
+		}
+		break;
+
+	case SESSION_NOTIFY_ENDGAME_HOST:
+	case SESSION_NOTIFY_ENDGAME_CLIENT:
+		m_fHeartbeatInterval = HEARTBEAT_INTERVAL_SHORT;
+		break;
+
+	case SESSION_NOTIFY_LOST_HOST:
+	case SESSION_NOTIFY_LOST_SERVER:
+		SwitchToState( MMSTATE_SESSION_DISCONNECTING );
+		break;
+
+	case SESSION_NOTIFY_FAIL_REGISTER:
+	case SESSION_NOTIFY_FAIL_CREATE:
+	case SESSION_NOTIFY_FAIL_SEARCH:
+	case SESSION_NOTIFY_CONNECT_SESSIONFULL:
+	case SESSION_NOTIFY_CONNECT_NOTAVAILABLE:
+	case SESSION_NOTIFY_CONNECT_FAILED:
+
+		// Reset the session
+		SwitchToState( MMSTATE_INITIAL );
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Switch between matchmaking states
+//-----------------------------------------------------------------------------
+void CMatchmaking::SwitchToState( int newState )
+{
+	// Clean up from the previous state
+	switch( m_CurrentState )
+	{
+	case MMSTATE_INITIAL:
+		break;
+
+	case MMSTATE_BROWSING:
+		// Clean up the search results
+		ClearSearchResults();
+		break;
+
+	default:
+		break;
+	}
+
+	// Initialize the next state
+	switch( newState )
+	{
+	case MMSTATE_INITIAL:
+		m_bCleanup = true;
+		break;
+
+	case MMSTATE_CREATING:
+	case MMSTATE_SEARCHING:
+	case MMSTATE_ACCEPTING_CONNECTIONS:
+		break;
+
+	case MMSTATE_MODIFYING:
+		m_fSendTimer = GetTime();
+		break;
+
+	case MMSTATE_WAITING_QOS:
+		m_fWaitTimer = GetTime();
+		break;
+
+	case MMSTATE_SESSION_CONNECTING:
+		ConnectToHost();
+		break;
+
+	case MMSTATE_PREGAME:
+		m_fCountdownStartTime = GetTime();
+		break;
+
+	case MMSTATE_LOADING:
+		m_fHeartbeatInterval = HEARTBEAT_INTERVAL_LONG;
+		break;
+
+	case MMSTATE_SESSION_DISCONNECTING:
+		m_fWaitTimer = GetTime();
+		break;
+
+	case MMSTATE_REPORTING_STATS:
+		m_fWaitTimer = GetTime();
+		break;
+
+	default:
+		break;
+	}
+
+	m_CurrentState = newState;
+}
+
+void CMatchmaking::UpdateVoiceStatus( void )
+{
+#if defined( _X360 )
+
+	if ( m_flVoiceBlinkTime > GetTime() )
+		return;
+
+	m_flVoiceBlinkTime = GetTime() + VOICE_ICON_BLINK_TIME;
+	CClientInfo *pClient = &m_Local;
+
+	bool bIsHost = m_Session.IsHost();
+	bool bShouldSendInfo = false;
+
+	if ( pClient )
+	{
+		for ( int i = 0; i < pClient->m_cPlayers; ++i )
+		{
+			if ( pClient->m_xuids[i] == 0 )
+				continue;
+
+			byte cOldVoiceState = pClient->m_cVoiceState[i];
+
+			if ( Audio_GetXVoice()->IsHeadsetPresent( pClient->m_iControllers[i] ) == false )
+			{
+				pClient->m_cVoiceState[i] = VOICE_STATUS_OFF;
+			}
+			else
+			{
+				if ( Audio_GetXVoice()->IsPlayerTalking( pClient->m_xuids[i], true ) )
+				{
+					pClient->m_cVoiceState[i] = VOICE_STATUS_TALKING;
+				}
+				else
+				{
+					pClient->m_cVoiceState[i] = VOICE_STATUS_IDLE;
+				}
+			}
+
+			if ( cOldVoiceState != pClient->m_cVoiceState[i] )
+			{
+				bShouldSendInfo = true;
+			}
+
+			if ( bShouldSendInfo == true )
+			{
+				EngineVGui()->UpdatePlayerInfo( pClient->m_xuids[i], pClient->m_szGamertags[i], pClient->m_iTeam[i], pClient->m_cVoiceState[i], GetPlayersNeeded(), bIsHost );
+			}
+		}
+
+
+		if ( bShouldSendInfo )
+		{
+			MM_ClientInfo info;
+			ClientInfoToNetMessage( &info, pClient );
+		
+			if ( bIsHost == true )
+			{
+				// Tell all the clients
+				ProcessClientInfo( &info );
+			}
+			else
+			{
+				// Tell all the clients
+				SendMessage( &info, &m_Host );
+			}
+		}
+	}
+
+#endif
+
+}
+
+//-----------------------------------------------------------------------------
+//	Update matchmaking and any active session 
+//-----------------------------------------------------------------------------
+void CMatchmaking::RunFrame()
+{
+	if ( !m_bInitialized )
+	{
+		RunFrameInvite();
+		return;
+	}
+
+	if ( NET_IsMultiplayer() )
+	{
+		NET_ProcessSocket( NS_MATCHMAKING, this );
+
+		if ( m_Session.IsSystemLink() )
+		{
+			NET_ProcessSocket( NS_SYSTEMLINK, this );
+		}
+	}
+
+#if defined( _X360 )
+	if ( Audio_GetXVoice() != NULL )
+	{
+		if ( !GameIsActive() )
+		{
+			if ( Audio_GetXVoice()->VoiceUpdateData() == true )
+			{
+				CLC_VoiceData voice;
+				Audio_GetXVoice()->GetVoiceData( &voice );
+
+				if ( m_Session.IsHost() )
+				{
+					// Send this message on to everyone else
+					SendToRemoteClients( &voice, true );
+				}
+				else
+				{
+					// Send to the host
+					SendMessage( &voice, &m_Host );
+				}
+
+				Audio_GetXVoice()->VoiceResetLocalData();
+			}
+
+			UpdateVoiceStatus();
+		}
+	}
+#endif
+
+	// Tell the session to run its update
+	m_Session.RunFrame();
+
+	// Check state:
+	switch( m_CurrentState )
+	{
+	case MMSTATE_CREATING:
+		// Waiting for success or failure from CreateSession()
+		// GameUI is displaying a "Creating Game" dialog.
+		break;
+
+	case MMSTATE_ACCEPTING_CONNECTIONS:
+		// Host is sitting in the Lobby waiting for connection requests. Once the game
+		// is full enough (player count >= min players) the host will be able to start the game.
+		UpdateAcceptingConnections();
+		break;
+
+	case MMSTATE_SEARCHING:
+		UpdateSearch();
+		break;
+
+	case MMSTATE_WAITING_QOS:
+		UpdateQosLookup();
+		break;
+
+	case MMSTATE_SESSION_CONNECTING:
+		UpdateConnecting();
+		break;
+
+	case MMSTATE_PREGAME:
+		UpdatePregame();
+		break;
+
+	case MMSTATE_MODIFYING:
+		UpdateSessionModify();
+		break;
+
+	case MMSTATE_HOSTMIGRATE_WAITINGFORCLIENTS:
+		if ( GetTime() - m_fSendTimer > HOSTMIGRATION_RETRYINTERVAL )
+		{
+			if ( m_nSendCount > HOSTMIGRATION_MAXRETRIES )
+			{
+				EndMigration();
+			}
+			else
+			{
+				TellClientsToMigrate();
+			}
+		}
+		break;
+
+	case MMSTATE_HOSTMIGRATE_WAITINGFORHOST:
+		if ( GetTime() - m_fWaitTimer > HOSTMIGRATION_MAXWAITTIME )
+		{
+			// Give up on that host and try the next one in the list
+			Msg( "Giving up on this host\n" );
+			ClientDropped( m_pNewHost );
+
+			StartHostMigration();
+		}
+		break;
+
+	case MMSTATE_SESSION_DISCONNECTING:
+		// Wait for the host reply, or timeout
+		if ( GetTime() - m_fWaitTimer > DISCONNECT_WAITTIME )
+		{
+			PerformDisconnect();
+		}
+		break;
+
+	case MMSTATE_REPORTING_STATS:
+		if ( GetTime() - m_fWaitTimer > REPORTSTATS_WAITTIME )
+		{
+			EndStatsReporting();
+		}
+		break;
+	}
+
+	CleanupMarkedChannels();
+	SendHeartbeat();
+
+	if ( m_bCleanup )
+	{
+		Cleanup();
+	}
+
+	RunFrameInvite();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Let the invite system determine a good moment to start connecting to inviter's host
+//-----------------------------------------------------------------------------
+void CMatchmaking::RunFrameInvite()
+{
+	if ( m_InviteState != INVITE_NONE )
+	{
+		JoinInviteSession( &m_InviteSessionInfo );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get Quality-of-Service with LIVE
+//-----------------------------------------------------------------------------
+MM_QOS_t CMatchmaking::GetQosWithLIVE()
+{
+	return MM_GetQos();
+}
+
+//-----------------------------------------------------------------------------
+// Debugging helpers 
+//-----------------------------------------------------------------------------
+void CMatchmaking::ShowSessionInfo()
+{
+	Msg( "[MM] Filled Slots:\n[MM] Public: %d of %d\n[MM] Private: %d of %d\n", 
+			m_Session.GetSessionSlots( SLOTS_FILLEDPUBLIC ), 
+			m_Session.GetSessionSlots( SLOTS_TOTALPUBLIC ),
+			m_Session.GetSessionSlots( SLOTS_FILLEDPRIVATE ),
+			m_Session.GetSessionSlots( SLOTS_TOTALPRIVATE ) );
+
+	Msg( "[MM] Current state: %d\n", m_CurrentState );
+	Msg( "[MM] Send timer: %f\n", GetTime() - m_fSendTimer );
+	Msg( "[MM] Wait timer: %f\n", GetTime() - m_fWaitTimer );
+	
+	int total = 0;
+	for ( int i = 0; i < m_nTotalTeams; ++i )
+	{
+		total += CountPlayersOnTeam( i );
+	}
+	Msg( "[MM] Total players: %d\n", total );
+
+	EngineVGui()->SessionNotification( SESSION_NOTIFY_DUMPSTATS );
+}
+
+//-----------------------------------------------------------------------------
+// Debugging helpers 
+//-----------------------------------------------------------------------------
+void CMatchmaking::TestSendMessage()
+{
+	for ( int i = 0; i < m_Remote.Count(); ++i )
+	{
+		AddRemoteChannel( &m_Remote[i]->m_adr );
+	}
+	NET_StringCmd msg;
+	SendToRemoteClients( &msg );
+}
+
+bool CMatchmaking::PreventFullServerStartup()
+{
+	return m_bPreventFullServerStartup;
+}
+
+void CMatchmaking::SetPreventFullServerStartup( bool bState, char const *fmt, ... )
+{
+	char desc[ 256 ];
+	va_list argptr;
+	va_start( argptr, fmt );
+	Q_vsnprintf( desc, sizeof( desc ), fmt, argptr );
+	va_end( argptr );
+
+	DevMsg( 1, "Setting state from prevent %s to prevent %s:  %s",
+		m_bPreventFullServerStartup ? "yes" : "no",
+		bState ? "yes" : "no",
+		desc );
+
+	m_bPreventFullServerStartup = bState;
+}
+
+CON_COMMAND( mm_session_info, "Dump session information" )
+{
+	if ( g_pMatchmaking )
+	{
+		g_pMatchmaking->ShowSessionInfo();
+	}
+}
+
+CON_COMMAND( mm_message, "Send a message to all remote clients" )
+{
+	if ( g_pMatchmaking )
+	{
+		g_pMatchmaking->TestSendMessage();
+	}
+}
+
+CON_COMMAND( mm_stats, "" )
+{
+	if ( g_pMatchmaking )
+	{
+		g_pMatchmaking->TestStats();
+	}
+}