path: root/engine/matchmakinghost.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 "vstdlib/random.h"
#include "proto_oob.h"
#include "cdll_engine_int.h"
#include "matchmaking.h"
#include "Session.h"
#include "convar.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

static ConVar mm_minplayers( "mm_minplayers", "2", 0, "Number of players required to start an unranked game" );
static ConVar mm_max_spectators( "mm_max_spectators", "4", 0, "Max players allowed on the spectator team" );

//-----------------------------------------------------------------------------
// Purpose: Start a Matchmaking session as the host 
//-----------------------------------------------------------------------------
void CMatchmaking::StartHost( bool bSystemLink )
{
	NET_SetMutiplayer( true );

	InitializeLocalClient( true );

	// Set all of the session contexts and properties. These were filled
	// in by GameUI after the user set them in the game options menu
 	for ( int i = 0; i < m_SessionContexts.Count(); ++i )
 	{
 		XUSER_CONTEXT &ctx = m_SessionContexts[i];
 		m_Session.SetContext( ctx.dwContextId, ctx.dwValue, false );
 	}

	for ( int i = 0; i < m_SessionProperties.Count(); ++i )
	{
		XUSER_PROPERTY &prop = m_SessionProperties[i];
		m_Session.SetProperty( prop.dwPropertyId, prop.value.type, &prop.value.nData, false );
	}

	m_Session.SetSessionSlots( SLOTS_TOTALPUBLIC, m_nGameSize - m_nPrivateSlots );
	m_Session.SetSessionSlots( SLOTS_TOTALPRIVATE, m_nPrivateSlots );

	m_Session.SetIsSystemLink( bSystemLink );
	m_Session.SetIsHost( true );
	m_Session.SetOwnerId( XBX_GetPrimaryUserId() );

	// Session creation is asynchronous
	if ( !m_Session.CreateSession() )
	{
		SessionNotification( SESSION_NOTIFY_FAIL_CREATE );
		return;
	}

	// Waiting for session creation results
	SwitchToState( MMSTATE_CREATING );
}

//-----------------------------------------------------------------------------
// Purpose: Successfully created the session
//-----------------------------------------------------------------------------
void CMatchmaking::OnHostSessionCreated()
{
	Msg( "Host: CreateSession successful\n" );

	// Setup the game info that will be sent back to searching clients
	m_HostData.gameState = GAMESTATE_INLOBBY;
	KeyValues *pScenario = m_pSessionKeys->FindKey( "CONTEXT_SCENARIO" );
	if ( pScenario )
	{
		Q_strncpy( m_HostData.scenario, pScenario->GetString( "displaystring", "Unknown" ), sizeof( m_HostData.scenario ) );
	}
	KeyValues *pTime = m_pSessionKeys->FindKey( "PROPERTY_MAX_GAME_TIME" );
	if ( pTime )
	{
		m_HostData.gameTime = pTime->GetInt( "valuestring", 0 );
	}
	UpdateSessionReplyData( XNET_QOS_LISTEN_ENABLE|XNET_QOS_LISTEN_SET_DATA );

	int iTeam = ChooseTeam();
	for ( int i = 0; i < m_Local.m_cPlayers; ++i )
	{
		m_Local.m_iTeam[i] = iTeam;
	}

	AddPlayersToSession( &m_Local );
	SendPlayerInfoToLobby( &m_Local, 0 );

	// Send session properties to client.dll so it can properly
	// set up game rules, cvars, etc.
	g_ClientDLL->SetupGameProperties( m_SessionContexts, m_SessionProperties );

	// Session has been created and advertised. Start listening for connection requests.
	SwitchToState( MMSTATE_ACCEPTING_CONNECTIONS );
}

//-----------------------------------------------------------------------------
// Purpose: Handle queries for system link servers
//-----------------------------------------------------------------------------
void CMatchmaking::HandleSystemLinkSearch( netpacket_t *pPacket )
{
	// Should we respond to this probe?
	if ( !m_Session.IsSystemLink() || 
		 !m_Session.IsHost() ||
		  m_Session.IsFull() ||
		  m_CurrentState < MMSTATE_ACCEPTING_CONNECTIONS )
	{
		return;
	}

	uint64 nonce = pPacket->message.ReadLongLong();

	// Send back info about our session
	XSESSION_INFO info;
	m_Session.GetSessionInfo( &info );

	char msg_buffer[MAX_ROUTABLE_PAYLOAD];
	bf_write msg( msg_buffer, sizeof(msg_buffer) );

	msg.WriteLong( CONNECTIONLESS_HEADER );
	msg.WriteByte( HTP_SYSTEMLINK_REPLY );
	msg.WriteLongLong( nonce );
	msg.WriteBytes( &info, sizeof( info ) );
	msg.WriteByte( m_Session.GetSessionSlots( SLOTS_TOTALPUBLIC ) - m_Session.GetSessionSlots( SLOTS_FILLEDPUBLIC ) );
	msg.WriteByte( m_Session.GetSessionSlots( SLOTS_TOTALPRIVATE ) - m_Session.GetSessionSlots( SLOTS_FILLEDPRIVATE ) );
	msg.WriteByte( m_Session.GetSessionSlots( SLOTS_FILLEDPUBLIC ) );
	msg.WriteByte( m_Session.GetSessionSlots( SLOTS_FILLEDPRIVATE ) );
	msg.WriteByte( m_nTotalTeams );
	msg.WriteByte( m_HostData.gameState );
	msg.WriteByte( m_HostData.gameTime );
	msg.WriteBytes( m_Local.m_szGamertags[0], MAX_PLAYER_NAME_LENGTH );
	msg.WriteBytes( m_HostData.scenario, MAX_MAP_NAME );
	msg.WriteByte( m_SessionProperties.Count() );
	msg.WriteByte( m_SessionContexts.Count() );

	uint nScenarioId = g_ClientDLL->GetPresenceID( "CONTEXT_SCENARIO" );	
	uint nScenarioValue = 0;

	for ( int i = 0; i < m_SessionProperties.Count(); ++i )
	{
		XUSER_PROPERTY &prop = m_SessionProperties[i];
		msg.WriteBytes( &prop, sizeof( prop ) );
	}
	for ( int i = 0; i < m_SessionContexts.Count(); ++i )
	{
		XUSER_CONTEXT &ctx = m_SessionContexts[i];
		msg.WriteBytes( &ctx, sizeof( ctx ) );

		// Get the scenario id so the correct info can be displayed in the session browser
		if ( ctx.dwContextId == nScenarioId )
		{
			nScenarioValue = ctx.dwValue;
		}
	}
	msg.WriteByte( nScenarioValue );
	msg.WriteLongLong( m_HostData.xuid );

	netadr_t adr;
	adr.SetType( NA_BROADCAST );
	adr.SetPort( PORT_SYSTEMLINK );

	// Send message
	NET_SendPacket( NULL, NS_SYSTEMLINK, adr, msg.GetData(), msg.GetNumBytesWritten() );
}

//-----------------------------------------------------------------------------
// Purpose: Process a client request to join the matchmaking session. If the
//			request is accepted, transmit session info to the new client, and
//			notify all connected clients of the new addition.
//-----------------------------------------------------------------------------
void CMatchmaking::HandleJoinRequest( netpacket_t *pPacket )
{
	MM_JoinResponse joinResponse;
	CClientInfo tempClient;

	Msg( "Received a join request\n" );

	// Check the state
	if ( !IsAcceptingConnections() )
	{
		Msg( "State %d: Not accepting connections.\n", m_CurrentState );
		joinResponse.m_ResponseType = joinResponse.JOINRESPONSE_NOTHOSTING;
	}
	else
	{
		// Extract some packet data to see if this client was invited
		tempClient.m_id			= pPacket->message.ReadLongLong();	// 64 bit
		tempClient.m_cPlayers	= pPacket->message.ReadByte();
		tempClient.m_bInvited	= (pPacket->message.ReadOneBit() != 0);

		for ( int i = 0; i < m_Remote.Count(); i++ )
		{
			CClientInfo *pClient = m_Remote[i];

			if ( pClient )
			{
				if ( pClient->m_id == tempClient.m_id )
				{
					ClientDropped( pClient );
					break;
				}
			}
		}

		// Make sure there's room for new players
		int nSlotsOpen = m_Session.GetSessionSlots( SLOTS_TOTALPUBLIC ) - m_Session.GetSessionSlots( SLOTS_FILLEDPUBLIC );
		if ( tempClient.m_bInvited )
		{
			// Only invited clients can take private slots
			nSlotsOpen += m_Session.GetSessionSlots( SLOTS_TOTALPRIVATE ) - m_Session.GetSessionSlots( SLOTS_FILLEDPRIVATE );
		}

		if ( tempClient.m_cPlayers > nSlotsOpen )
		{
			Msg( "Session Full.\n" );
			joinResponse.m_ResponseType = joinResponse.JOINRESPONSE_SESSIONFULL;
		}
		else
		{
			// There is room for the new client - fill out the rest of the response fields
			joinResponse.m_ResponseType		= joinResponse.JOINRESPONSE_APPROVED;
			joinResponse.m_id				= m_Local.m_id;
			joinResponse.m_Nonce			= m_Session.GetSessionNonce();
			joinResponse.m_SessionFlags		= m_Session.GetSessionFlags();
			joinResponse.m_nOwnerId			= XBX_GetPrimaryUserId();
			joinResponse.m_nTotalTeams		= m_nTotalTeams;
			joinResponse.m_ContextCount		= m_SessionContexts.Count();
			joinResponse.m_PropertyCount	= m_SessionProperties.Count();

			for ( int i = 0; i < m_SessionContexts.Count(); ++i )
			{
				joinResponse.m_SessionContexts.AddToTail( m_SessionContexts[i] );
			}

			for ( int i = 0; i < m_SessionProperties.Count(); ++i )
			{
				joinResponse.m_SessionProperties.AddToTail( m_SessionProperties[i] );
			}

			if ( !GameIsActive() )
			{
				// If the game is in progress, the new client will choose a team after connecting
				joinResponse.m_iTeam = ChooseTeam(); 
			}
			else
			{
				// Tell the client to join the game in progress
				joinResponse.m_iTeam = -1;
				joinResponse.m_ResponseType = joinResponse.JOINRESPONSE_APPROVED_JOINGAME;
			}
		}
	}

	netadr_t *pFromAdr = &pPacket->from;

	// Create a network channel for this client
	INetChannel *pNetChannel = AddRemoteChannel( pFromAdr );
	if ( !pNetChannel )
	{
		// Handle the error
		return;
	}

	// Send the response
	SendMessage( &joinResponse, pFromAdr );

	if ( joinResponse.m_ResponseType == joinResponse.JOINRESPONSE_APPROVED ||
		joinResponse.m_ResponseType == joinResponse.JOINRESPONSE_APPROVED_JOINGAME )
	{
		Msg( "Join request approved\n" );

		// Create a new client
		CClientInfo *pNewClient = new CClientInfo();

		pNewClient->m_adr		= pPacket->from;
		pNewClient->m_id		= tempClient.m_id;			// 64 bit
		pNewClient->m_cPlayers	= tempClient.m_cPlayers;
		pNewClient->m_bInvited	= tempClient.m_bInvited;
		pPacket->message.ReadBytes( &pNewClient->m_xnaddr, sizeof( pNewClient->m_xnaddr ) );
		for ( int i = 0; i < tempClient.m_cPlayers; ++i )
		{
			pNewClient->m_xuids[i] = pPacket->message.ReadLongLong();	// 64 bit
			pPacket->message.ReadBytes( &pNewClient->m_cVoiceState, sizeof( pNewClient->m_cVoiceState ) );
			pNewClient->m_iTeam[i] = joinResponse.m_iTeam;
			pPacket->message.ReadString( pNewClient->m_szGamertags[i], sizeof( pNewClient->m_szGamertags[i] ), true );
		}

		// Tell everyone about the new client, and vice versa
		MM_ClientInfo newClientInfo;
		ClientInfoToNetMessage( &newClientInfo, pNewClient );

		for ( int i = 0; i < m_Remote.Count(); ++i )
		{
			CClientInfo *pRemote = m_Remote[i];

			MM_ClientInfo oldClientInfo;
			ClientInfoToNetMessage( &oldClientInfo, pRemote );

			SendMessage( &newClientInfo, pRemote );
			SendMessage( &oldClientInfo, pNewClient );
		}

		// Tell new client about the host (us)
		MM_ClientInfo hostInfo;
		ClientInfoToNetMessage( &hostInfo, &m_Local );
		SendMessage( &hostInfo, pNewClient );

		// Tell ourselves about the new client
		ProcessClientInfo( &newClientInfo );

		if ( GameIsActive() )
		{
			// Set a longer timeout for communication loss during loading
			SetChannelTimeout( &pNewClient->m_adr, HEARTBEAT_TIMEOUT_LOADING );

			// Tell the client to connect to the server
			MM_Checkpoint msg;
			msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_CONNECT;
			SendMessage( &msg, pNewClient );
		}
		else
		{
			// UpdateServerNegotiation();
		}
	}
	else
	{
		// Join request was denied - close the channel
		RemoveRemoteChannel( pFromAdr, "Join request denied" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Check the state of the lobby
//-----------------------------------------------------------------------------
void CMatchmaking::UpdateAcceptingConnections()
{
	// Update host status
	UpdateSessionReplyData( XNET_QOS_LISTEN_SET_DATA );

	// Do nothing else
}

//-----------------------------------------------------------------------------
// Purpose: Set the host data that gets sent in replies to client searches
//-----------------------------------------------------------------------------
void CMatchmaking::UpdateSessionReplyData( uint flags )
{
#if defined( _X360 )
	if ( m_Session.GetSessionHandle() == INVALID_HANDLE_VALUE )
		return;

	// Enable listening for client Quality Of Service probes
	XNKID id = m_Session.GetSessionId();
	uint ret = XNetQosListen( &id, (BYTE*)&m_HostData, sizeof( m_HostData ), 0, flags );
	if ( ret )
	{
		Warning( "Failed to update QOS Listener\n" );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Change properties of the current session
//-----------------------------------------------------------------------------
void CMatchmaking::ModifySession()
{
	// Notify all clients of the new settings and wait for replies
	for ( int i = 0; i < m_Remote.Count(); ++i )
	{
		m_Remote[i]->m_bModified = false;
	}

	SendModifySessionMessage();

	SessionNotification( SESSION_NOFIFY_MODIFYING_SESSION );
}

//-----------------------------------------------------------------------------
// Purpose: Send the new session properties to all clients
//-----------------------------------------------------------------------------
void CMatchmaking::SendModifySessionMessage()
{
	MM_JoinResponse msg;
	msg.m_ResponseType = MM_JoinResponse::JOINRESPONSE_MODIFY_SESSION;
	msg.m_ContextCount = m_SessionContexts.Count();
	msg.m_PropertyCount = m_SessionProperties.Count();

	for ( int i = 0; i < m_SessionProperties.Count(); ++i )
	{
		msg.m_SessionProperties.AddToTail( m_SessionProperties[i] );
	}
	for ( int i = 0; i < m_SessionContexts.Count(); ++i )
	{
		msg.m_SessionContexts.AddToTail( m_SessionContexts[i] );
	}

	SendToRemoteClients( &msg );

	// Wait for clients to respond before continuing
	m_fWaitTimer = GetTime();
}

//-----------------------------------------------------------------------------
// Purpose: Waiting for clients to modify their session properties
//-----------------------------------------------------------------------------
void CMatchmaking::UpdateSessionModify()
{
	if ( !m_Session.IsHost() )
		return;

	bool bFinished = true;

	if ( GetTime() - m_fWaitTimer < SESSIONMODIRY_MAXWAITTIME )
	{
		// Check if all clients have finished modifying the session
		for ( int i = 0; i < m_Remote.Count(); ++i )
		{
			if ( !m_Remote[i]->m_bModified )
			{
				bFinished = false;
			}
		}
	}

	if ( bFinished )
	{
		EndSessionModify();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Finish session modification
//-----------------------------------------------------------------------------
void CMatchmaking::EndSessionModify()
{
	// Drop any clients that didn't respond
	for ( int i = 0; i < m_Remote.Count(); ++i )
	{
		if ( !m_Remote[i]->m_bModified )
		{
			KickPlayerFromSession( m_Remote[i]->m_id );
		}
	}

	// Send session properties to client.dll so it can properly
	// set up game rules, cvars, etc.
	g_ClientDLL->SetupGameProperties( m_SessionContexts, m_SessionProperties );

	SessionNotification( SESSION_NOTIFY_MODIFYING_COMPLETED_HOST );
}

//-----------------------------------------------------------------------------
// Purpose: Handle a client registration response
//-----------------------------------------------------------------------------
bool CMatchmaking::ProcessRegisterResponse( MM_RegisterResponse *msg )
{
	// Check if all clients have registered
	bool bAllRegistered = true;
	INetChannel *pChannel = msg->GetNetChannel();
	for ( int i = 0; i < m_Remote.Count(); ++i )
	{
		CClientInfo *pClient = m_Remote[i];
		if ( pClient->m_adr.CompareAdr( pChannel->GetRemoteAddress() ) )
		{
			pClient->m_bRegistered = true;
		}

		if ( !pClient->m_bRegistered )
		{
			bAllRegistered = false;
		}
	}

	if ( bAllRegistered )
	{
		// Everyone's registered, register ourselves
		m_Local.m_bRegistered = true;
		m_Session.RegisterForArbitration();
	}
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Find out if all clients registered for arbitration
//-----------------------------------------------------------------------------
void CMatchmaking::ProcessRegistrationResults()
{
	// Clear all the client registration flags
	for ( int i = 0; i < m_Remote.Count(); ++i )
	{
		m_Remote[i]->m_bRegistered = false;
	}

	XSESSION_REGISTRATION_RESULTS *pResults = m_Session.GetRegistrationResults();
	Assert( pResults );

	int numRegistrants = pResults->wNumRegistrants;
	Msg( "%d players registered for arbitration\n", numRegistrants );

	for ( int i = 0; i < numRegistrants; ++i )
	{
		for ( int j = 0; j < m_Remote.Count(); ++j )
		{
			if ( m_Remote[j]->m_id == pResults->rgRegistrants[i].qwMachineID )
			{
				m_Remote[j]->m_bRegistered = true;
			}
		}
	}

	// Now drop any clients that didn't register
	for ( int i = m_Remote.Count()-1; i >= 0; --i )
	{
		if ( !m_Remote[i]->m_bRegistered )
		{
			ClientDropped( m_Remote[i] );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: All clients are in the lobby and ready - perform pre-game setup
//-----------------------------------------------------------------------------
bool CMatchmaking::StartGame()
{
	if ( !m_Session.IsHost() )
		return false;

	if ( GetPlayersNeeded() != 0 )
		return false;

	StartCountdown();

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: All clients are in the lobby and ready - perform pre-game setup
//-----------------------------------------------------------------------------
bool CMatchmaking::CancelStartGame()
{
	if ( !m_Session.IsHost() )
		return false;

	CancelCountdown();

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Start the countdown timer for game start
//-----------------------------------------------------------------------------
void CMatchmaking::StartCountdown()
{
	if ( m_Session.IsArbitrated() )
	{
		// Initialize the client flags
		for ( int i = 0; i < m_Remote.Count(); ++i )
		{
			m_Remote[i]->m_bRegistered = false;
		}
		m_Local.m_bRegistered = false;
	}

	// Block searches while we're loading the game, because we can't reply anyway
	UpdateSessionReplyData( XNET_QOS_LISTEN_DISABLE );

	// Send the start game message to everyone
	MM_Checkpoint msg;
	msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_PREGAME;
	SendToRemoteClients( &msg );
	ProcessCheckpoint( &msg );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMatchmaking::CancelCountdown()
{
	// Accept searches again
	UpdateSessionReplyData( XNET_QOS_LISTEN_ENABLE|XNET_QOS_LISTEN_SET_DATA );

	MM_Checkpoint msg;
	msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_GAME_LOBBY;
	SendToRemoteClients( &msg );
	ProcessCheckpoint( &msg );
}

//-----------------------------------------------------------------------------
// Purpose: Tell the clients to connect to the server
//-----------------------------------------------------------------------------
void CMatchmaking::TellClientsToConnect()
{
	if ( IsServer() )
	{
		MM_Checkpoint msg;
		msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_CONNECT;
		if ( m_Session.IsHost() )
		{
			ProcessCheckpoint( &msg );
		}
		else
		{
			SendMessage( &msg, &m_Host );
		}

		SwitchToState( MMSTATE_CONNECTED_TO_SERVER );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Tell the clients the game is over
//-----------------------------------------------------------------------------
void CMatchmaking::EndGame()
{
	if ( m_Session.IsHost() && GameIsActive() )
	{
		MM_Checkpoint msg;
		if ( !m_Session.IsSystemLink() )
		{
			// Tell clients to report stats to live.
			for ( int i = 0; i < m_Remote.Count(); ++i )
			{
				m_Remote[i]->m_bReportedStats = false;
			}
			m_Local.m_bReportedStats = false;

			msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_REPORT_STATS;
		}
		else
		{
			msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_POSTGAME;
		}

		SendToRemoteClients( &msg );
		ProcessCheckpoint( &msg );
	}
}

//-----------------------------------------------------------------------------
// Purpose: End the stats reporting phase
//-----------------------------------------------------------------------------
void CMatchmaking::EndStatsReporting()
{
	if ( m_CurrentState == MMSTATE_REPORTING_STATS )
	{
		if ( !m_Session.IsHost() )
		{
			// Notify the host that we've finished reporting stats
			MM_Checkpoint msg;
			msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_REPORTING_COMPLETE;
			SendMessage( &msg, &m_Host );
		}
		else
		{
			// Remove anyone who didn't report stats
			// Drop any clients that didn't respond
			for ( int i = 0; i < m_Remote.Count(); ++i )
			{
				if ( !m_Remote[i]->m_bReportedStats )
				{
					KickPlayerFromSession( m_Remote[i]->m_id );
				}
			}

			// Everyone has reported stats
			MM_Checkpoint msg;
			msg.m_Checkpoint = MM_Checkpoint::CHECKPOINT_POSTGAME;
			SendToRemoteClients( &msg );
			ProcessCheckpoint( &msg );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Count players on a given team
//-----------------------------------------------------------------------------
int CMatchmaking::CountPlayersOnTeam( int idxTeam )
{
	int numPlayers = 0;
	for ( int i = 0; i < m_Remote.Count(); ++i )
	{
		if ( !m_Remote[i] )
			continue;

		CClientInfo &ciRemote = *m_Remote[i];

		for ( int jp = 0; jp < ciRemote.m_cPlayers; ++ jp )
		{
			if ( ciRemote.m_iTeam[jp] == idxTeam )
			{
				++ numPlayers;
			}
		}
	}
	for ( int jp = 0; jp < m_Local.m_cPlayers; ++ jp )
	{
		if ( m_Local.m_iTeam[jp] == idxTeam )
		{
			++ numPlayers;
		}
	}
	if ( !m_Session.IsHost() )
	{
		for ( int jp = 0; jp < m_Host.m_cPlayers; ++ jp )
		{
			if ( m_Host.m_iTeam[jp] == idxTeam )
			{
				++ numPlayers;
			}
		}
	}
	return numPlayers;
}

//-----------------------------------------------------------------------------
// Purpose: Auto-assign players as they first enter the lobby
//-----------------------------------------------------------------------------
int CMatchmaking::ChooseTeam()
{
	int iTeam = -1;
	for ( int i = 0; i < m_nTotalTeams - 1; ++i )
	{
		int numI = CountPlayersOnTeam( i ), numIp1 = CountPlayersOnTeam( i + 1 );

		if ( numI < numIp1 )
		{
			iTeam = i;
		}
		else if ( numI > numIp1 )
		{
			iTeam = i + 1;
		}
	}

	if ( iTeam == -1 )
	{
		iTeam = RandomInt( 0, m_nTotalTeams - 1 );
	}

	return iTeam;
}

//-----------------------------------------------------------------------------
// Purpose: Switch this client to the next team with open slots
//-----------------------------------------------------------------------------
void CMatchmaking::SwitchToNextOpenTeam( CClientInfo *pClient )
{
	int oldTeam = pClient->m_iTeam[0];
	int maxPlayersPerTeam = m_nGameSize / m_nTotalTeams + 3;

	// Choose the next team for this client
	int iTeam = oldTeam;
	do
	{
		iTeam = (iTeam + 1) % m_nTotalTeams;
		if ( CountPlayersOnTeam( iTeam ) < maxPlayersPerTeam )
			break;

	} while( iTeam != oldTeam );

	MM_ClientInfo info;
	ClientInfoToNetMessage( &info, pClient );
	for ( int i = 0; i < pClient->m_cPlayers; ++i )
	{
		info.m_iTeam[i] = iTeam;
	}

	// Send to ourselves and everyone else
	ProcessClientInfo( &info );
}

//-----------------------------------------------------------------------------
// Purpose: Check if the teams are full enough to start
//-----------------------------------------------------------------------------
int CMatchmaking::GetPlayersNeeded()
{
	// System link can always be started
	if ( m_Session.IsSystemLink() )
		return 0;

	// check if we can start the game
	int total = 0;
	
	for ( int i = 0; i < m_nTotalTeams; ++i )
	{
		total += CountPlayersOnTeam( i );
	}


	return max( 0, mm_minplayers.GetInt() - max( 0, total ) );
}