tf2/tf2_src/engine/matchmakingshared.cpp

//========= 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();
	}
}