d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
source-engine/gameui/matchmaking/sessionlobbydialog.cpp

739 lines
20 KiB
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "sessionlobbydialog.h"
#include "engine/imatchmaking.h"
#include "GameUI_Interface.h"
#include "EngineInterface.h"
#include "vgui/ISurface.h"
#include "vgui_controls/ImagePanel.h"
#include "vgui/ILocalize.h"
#include "BasePanel.h"
#include "matchmakingbasepanel.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
CSessionLobbyDialog *g_pLobbyDialog;
//--------------------------------
// CSessionLobbyDialog
//--------------------------------
CSessionLobbyDialog::CSessionLobbyDialog( vgui::Panel *pParent ) : BaseClass( pParent, "SessionLobbyDialog" )
{
m_Menus[0].SetParent( this );
m_Menus[0].SetName( "BluePlayers" );
m_Menus[1].SetParent( this );
m_Menus[1].SetName( "RedPlayers" );
m_iLocalTeam = -1;
m_iActiveMenu = -1;
m_nHostId = 0;
m_bHostLobby = false;
m_bCenterOnScreen = true;
m_pLobbyStateBg = new vgui::Panel( this, "LobbyStateBg" );
m_pLobbyStateLabel = new CPropertyLabel( this, "LobbyStateLabel", "" );
m_pLobbyStateIcon = new CPropertyLabel( this, "LobbyStateIcon", "" );
m_pHostLabel = new CPropertyLabel( this, "HostLabel", "" );
m_pHostOptionsPanel = new vgui::EditablePanel( this, "HostOptions" );
m_pScenarioInfo = new CScenarioInfoPanel( this, "GameScenario" );
m_pTeamInfos[BLUE_TEAM_LOBBY] = new CScenarioInfoPanel( this, "BlueTeamDescription" );
m_pTeamInfos[RED_TEAM_LOBBY] = new CScenarioInfoPanel( this, "RedTeamDescription" );
m_pDialogKeys = NULL;
g_pLobbyDialog = this;
m_bStartingGame = false;
m_nLastPlayersNeeded = 0;
m_nMinInfoHeight[BLUE_TEAM_LOBBY] = 0;
m_nMinInfoHeight[RED_TEAM_LOBBY] = 0;
}
CSessionLobbyDialog::~CSessionLobbyDialog()
{
delete m_pLobbyStateBg;
delete m_pLobbyStateLabel;
delete m_pLobbyStateIcon;
delete m_pHostLabel;
delete m_pHostOptionsPanel;
delete m_pScenarioInfo;
for ( int i = 0; i < TOTAL_LOBBY_TEAMS; ++i )
{
delete m_pTeamInfos[i];
}
}
//---------------------------------------------------------------------
// Purpose: Dialog keys contain session contexts and properties
//---------------------------------------------------------------------
void CSessionLobbyDialog::SetDialogKeys( KeyValues *pKeys )
{
m_pDialogKeys = pKeys;
InvalidateLayout();
}
//---------------------------------------------------------------------
// Purpose: Helper to set label text from keyvalues
//---------------------------------------------------------------------
void CSessionLobbyDialog::SetTextFromKeyvalues( CPropertyLabel *pLabel )
{
KeyValues *pKey = m_pDialogKeys->FindKey( pLabel->m_szPropertyString );
if ( pKey )
{
const char *pString = pKey->GetString( "displaystring", NULL );
if ( pString )
{
pLabel->SetText( pString );
}
}
}
//---------------------------------------------------------------------
// Purpose: Center the dialog on the screen
//---------------------------------------------------------------------
void CSessionLobbyDialog::PerformLayout()
{
BaseClass::PerformLayout();
if ( !m_pDialogKeys )
return;
// Set the label strings according to the keyvalues passed in
SetTextFromKeyvalues( m_pScenarioInfo->m_pTitle );
SetTextFromKeyvalues( m_pScenarioInfo->m_pDescOne );
SetTextFromKeyvalues( m_pScenarioInfo->m_pDescTwo );
SetTextFromKeyvalues( m_pScenarioInfo->m_pDescThree );
SetTextFromKeyvalues( m_pScenarioInfo->m_pValueTwo );
SetTextFromKeyvalues( m_pScenarioInfo->m_pValueThree );
const char *pDiskName = "unknown";
KeyValues *pName = m_pDialogKeys->FindKey( "MapDiskNames" );
if ( pName )
{
KeyValues *pScenario = m_pDialogKeys->FindKey( "CONTEXT_SCENARIO" );
if ( pScenario )
{
pDiskName = pName->GetString( pScenario->GetString( "displaystring" ), "unknown" );
}
}
// find the scenario type
KeyValues *pType = m_pDialogKeys->FindKey( "ScenarioTypes" );
if ( pType )
{
const char *pString = pType->GetString( pDiskName, NULL );
if ( pString )
{
m_pScenarioInfo->m_pSubtitle->SetText( pString );
}
}
// Set the team goals
KeyValues *pGoals = m_pDialogKeys->FindKey( "TeamGoals" );
if ( pGoals )
{
KeyValues *pTeam = pGoals->FindKey( "Blue" );
if ( pTeam )
{
m_pTeamInfos[BLUE_TEAM_LOBBY]->m_pDescOne->SetText( pTeam->GetString( pDiskName, "" ) );
}
pTeam = pGoals->FindKey( "Red" );
if ( pTeam )
{
m_pTeamInfos[RED_TEAM_LOBBY]->m_pDescOne->SetText( pTeam->GetString( pDiskName, "" ) );
}
}
for ( int i = 0; i < TOTAL_LOBBY_TEAMS; ++i )
{
UpdatePlayerCountDisplay( i );
}
if ( m_bCenterOnScreen )
{
MoveToCenterOfScreen();
}
// Don't allow player reviews in system link games
CMatchmakingBasePanel *pBase = dynamic_cast< CMatchmakingBasePanel* >( m_pParent );
if ( pBase )
{
pBase->SetFooterButtonVisible( "#GameUI_PlayerReview", pBase->GetGameType() != GAMETYPE_SYSTEMLINK_MATCH );
// hide the settings changing if we're in a ranked game
if ( m_pHostOptionsPanel )
{
bool bVisible = pBase->GetGameType() != GAMETYPE_RANKED_MATCH;
vgui::Label *pSettingsLabel = (vgui::Label *)m_pHostOptionsPanel->FindChildByName("ChangeSettingsButton",true);
if ( pSettingsLabel )
{
pSettingsLabel->SetVisible( bVisible );
}
pSettingsLabel = (vgui::Label *)m_pHostOptionsPanel->FindChildByName("ChangeSettingsText",true);
if ( pSettingsLabel )
{
pSettingsLabel->SetVisible( bVisible );
}
}
}
}
//---------------------------------------------------------------------
// Purpose: Parse session properties and contexts from the resource file
//---------------------------------------------------------------------
void CSessionLobbyDialog::ApplySettings( KeyValues *pResourceData )
{
BaseClass::ApplySettings( pResourceData );
m_nImageBorderWidth = pResourceData->GetInt( "imageborderwidth", 15 );
m_nTeamspacing = pResourceData->GetInt( "teamspacing", 0 );
m_bHostLobby = pResourceData->GetInt( "hostlobby", 0 ) != 0;
m_bCenterOnScreen = pResourceData->GetInt( "center", 1 ) == 1;
Q_strncpy( m_szCommand, pResourceData->GetString( "commandstring", "NULL" ), sizeof( m_szCommand ) );
}
//---------------------------------------------------------------------
// Purpose: Set up colors and other such stuff
//---------------------------------------------------------------------
void CSessionLobbyDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
Color cLabelColor = pScheme->GetColor( "MatchmakingDialogTitleColor", Color( 0, 0, 0, 255 ) );
m_pLobbyStateLabel->SetFgColor( cLabelColor );
m_pHostLabel->SetFgColor( cLabelColor );
m_pLobbyStateBg->SetBgColor( pScheme->GetColor( "TanDarker", Color( 0, 0, 0, 255 ) ) );
m_pLobbyStateBg->SetPaintBackgroundType( 2 );
m_pHostOptionsPanel->SetBgColor( pScheme->GetColor( "TanDarker", Color( 0, 0, 0, 255 ) ) );
m_pHostOptionsPanel->SetPaintBackgroundType( 2 );
m_pScenarioInfo->SetBgColor( pScheme->GetColor( "TanDarker", Color( 0, 0, 0, 255 ) ) );
m_pTeamInfos[BLUE_TEAM_LOBBY]->SetBgColor( pScheme->GetColor( "HudBlueTeam", Color( 0, 0, 0, 255 ) ) );
m_pTeamInfos[RED_TEAM_LOBBY]->SetBgColor( pScheme->GetColor( "HudRedTeam", Color( 0, 0, 0, 255 ) ) );
// Cache of these heights so we never go below them when resizing
m_nMinInfoHeight[BLUE_TEAM_LOBBY] = m_pTeamInfos[BLUE_TEAM_LOBBY]->GetTall();
m_nMinInfoHeight[RED_TEAM_LOBBY] = m_pTeamInfos[RED_TEAM_LOBBY]->GetTall();
//Lets set all the labels this panel owns to be the right fgcolor. hooray vgui!
int iChildren = m_pHostOptionsPanel->GetChildCount();
for ( int i=0;i<iChildren;i++ )
{
vgui::Label *pLabel = dynamic_cast< vgui::Label * >( m_pHostOptionsPanel->GetChild(i) );
if ( pLabel )
{
SETUP_PANEL( pLabel );
pLabel->SetFgColor( cLabelColor );
}
}
vgui::Label *pPlayerReviewLabel = (vgui::Label *)FindChildByName("PlayerReviewLabel" );
if ( pPlayerReviewLabel )
{
SETUP_PANEL( pPlayerReviewLabel );
pPlayerReviewLabel->SetFgColor( cLabelColor );
}
SetLobbyReadyState( m_nLastPlayersNeeded );
}
void CSessionLobbyDialog::PositionTeamInfos()
{
// Line up the team info panels and menus
int x, y;
int menux, menuy;
m_pTeamInfos[0]->GetPos( x, y );
m_Menus[0].GetPos( menux, menuy );
for ( int i = 1; i < TOTAL_LOBBY_TEAMS; ++i )
{
y += m_pTeamInfos[i - 1]->GetTall() + m_nTeamspacing;
m_pTeamInfos[i]->SetPos( x, y );
m_Menus[i].SetPos( menux, y );
}
}
void CSessionLobbyDialog::ActivateNextMenu()
{
int startIndex = m_iActiveMenu;
m_Menus[m_iActiveMenu].SetFocus( -1 );
do
{
m_iActiveMenu = (m_iActiveMenu + 1) % TOTAL_LOBBY_TEAMS;
} while ( m_Menus[m_iActiveMenu].GetItemCount() == 0 && m_iActiveMenu != startIndex );
m_Menus[m_iActiveMenu].SetFocus( 0 );
}
void CSessionLobbyDialog::ActivatePreviousMenu()
{
int startIndex = m_iActiveMenu;
m_Menus[m_iActiveMenu].SetFocus( -1 );
do
{
m_iActiveMenu = m_iActiveMenu ? m_iActiveMenu - 1 : TOTAL_LOBBY_TEAMS - 1;
} while ( m_Menus[m_iActiveMenu].GetItemCount() == 0 && m_iActiveMenu != startIndex );
m_Menus[m_iActiveMenu].SetFocus( m_Menus[m_iActiveMenu].GetItemCount() - 1 );
}
void CSessionLobbyDialog::UpdatePlayerCountDisplay( int iTeam )
{
int ct = m_Menus[iTeam].GetItemCount();
wchar_t wszString[32];
wchar_t *wzPlayersFmt = g_pVGuiLocalize->Find( ct != 1 ? "#TF_ScoreBoard_Players" : "#TF_ScoreBoard_Player" );
wchar_t wzPlayerCt[8];
V_snwprintf( wzPlayerCt, ARRAYSIZE( wzPlayerCt ), L"%d", ct );
g_pVGuiLocalize->ConstructString( wszString, sizeof( wszString ), wzPlayersFmt, 1, wzPlayerCt );
m_pTeamInfos[iTeam]->m_pSubtitle->SetText( wszString );
if ( m_nMinInfoHeight[iTeam] == 0 )
{
m_nMinInfoHeight[iTeam] = m_pTeamInfos[iTeam]->GetTall();
}
int height = max( m_nMinInfoHeight[iTeam], m_Menus[iTeam].GetTall() );
m_pTeamInfos[iTeam]->SetTall( height );
PositionTeamInfos();
}
void CSessionLobbyDialog::UpdatePlayerInfo( uint64 nPlayerId, const char *pName, int iTeam, byte cVoiceState, int nPlayersNeeded, bool bHost )
{
if ( m_iLocalTeam == -1 )
{
m_iLocalTeam = iTeam;
}
bool bReady = ( nPlayersNeeded == 0 );
// Look for the player
int iFoundTeam = -1;
int iFoundItem = -1;
CPlayerItem *pFound = NULL;
for ( int iMenu = 0; iMenu < TOTAL_LOBBY_TEAMS && !pFound; ++iMenu )
{
CDialogMenu &menu = m_Menus[iMenu];
if ( menu.GetItemCount() == 0 )
continue;
for ( int idx = 0; idx < menu.GetItemCount(); ++idx )
{
CPlayerItem *pPlayerItem = dynamic_cast< CPlayerItem* >( menu.GetItem( idx ) );
if ( pPlayerItem && pPlayerItem->m_nId == nPlayerId )
{
pFound = pPlayerItem;
iFoundTeam = iMenu;
iFoundItem = idx;
break;
}
}
}
// Update menu and item focus if the player changed teams
if ( iFoundTeam != iTeam )
{
if ( pFound )
{
// Remove the player from the current team
m_Menus[iFoundTeam].RemovePlayerItem( iFoundItem );
UpdatePlayerCountDisplay( iFoundTeam );
}
if ( 0 <= iTeam && iTeam < TOTAL_LOBBY_TEAMS )
{
// Add the player to the new team
m_Menus[iTeam].AddPlayerItem( pName, nPlayerId, cVoiceState, bReady );
UpdatePlayerCountDisplay( iTeam );
}
// if the player joined an empty lobby, set the active team
if ( m_iActiveMenu == -1 )
{
m_iActiveMenu = iTeam;
m_Menus[m_iActiveMenu].SetFocus( 0 );
}
// update the highlight position
if ( iFoundTeam == m_iActiveMenu )
{
CDialogMenu &activeMenu = m_Menus[m_iActiveMenu];
int iActive = activeMenu.GetActiveItemIndex();
if ( iActive == iFoundItem )
{
// The changed player was also the highlighted player
if ( iTeam >= 0 )
{
// Move the highlight to the player's new position
activeMenu.SetFocus( -1 );
m_iActiveMenu = iTeam;
m_Menus[m_iActiveMenu].SetFocus( m_Menus[m_iActiveMenu].GetItemCount() - 1 );
}
else
{
// player left the game, move the highlight to the next filled slot
if ( iActive >= activeMenu.GetItemCount() )
{
ActivateNextMenu();
}
}
}
else if ( iActive > iFoundItem )
{
// Need to drop the highlighted index one slot
m_Menus[m_iActiveMenu].SetFocus( iActive - 1 );
}
}
}
else
{
if ( pFound )
{
if ( pFound->m_bVoice != cVoiceState )
{
pFound->m_bVoice = cVoiceState;
pFound->InvalidateLayout();
}
}
}
if ( bHost )
{
wchar_t wszString[MAX_PATH];
wchar_t wszHostname[MAX_PATH];
wchar_t *wzHostFmt = g_pVGuiLocalize->Find( "#TF_Lobby_Host" );
g_pVGuiLocalize->ConvertANSIToUnicode( pName, wszHostname, sizeof( wszHostname ) );
V_snwprintf( wszString, ARRAYSIZE(wszString), L"%s\n%s", wzHostFmt, wszHostname );
m_pHostLabel->SetText( wszString );
m_nHostId = nPlayerId;
}
int iPlayersNeeded = ( bReady ) ? 0 : nPlayersNeeded;
SetLobbyReadyState( iPlayersNeeded );
m_nLastPlayersNeeded = iPlayersNeeded;
InvalidateLayout( true, false );
}
void CSessionLobbyDialog::SetLobbyReadyState( int nPlayersNeeded )
{
// check if the host is allowed to start the game
if ( nPlayersNeeded <= 0 )
{
if ( m_bHostLobby )
{
m_pLobbyStateLabel->SetText( "#TF_PressStart" );
m_pLobbyStateIcon->SetText( "#GameUI_Icons_START" );
}
else
{
m_pLobbyStateLabel->SetText( "#TF_WaitingForHost" );
m_pLobbyStateIcon->SetText( "#TF_Icon_Alert" );
m_bStartingGame = false; // client guesses that they can change teams
}
}
else
{
wchar_t wszWaiting[64];
wchar_t *wzWaitingFmt;
if ( nPlayersNeeded == 1 )
{
wzWaitingFmt = g_pVGuiLocalize->Find( "#TF_WaitingForPlayerFmt" );
}
else
{
wzWaitingFmt = g_pVGuiLocalize->Find( "#TF_WaitingForPlayersFmt" );
}
wchar_t wzPlayers[8];
V_snwprintf( wzPlayers, ARRAYSIZE( wzPlayers ), L"%d", nPlayersNeeded );
g_pVGuiLocalize->ConstructString( wszWaiting, sizeof( wszWaiting ), wzWaitingFmt, 1, wzPlayers );
m_pLobbyStateLabel->SetText( wszWaiting );
m_pLobbyStateIcon->SetText( "#TF_Icon_Alert" );
// If we were starting and dropped below min players, cancel
SetStartGame( false );
}
}
void CSessionLobbyDialog::UpdateCountdown( int seconds )
{
if ( seconds == -1 )
{
// countdown was canceled
SetLobbyReadyState( 0 );
return;
}
// Set the text in the countdown label
wchar_t wszCountdown[MAX_PATH];
wchar_t wszSeconds[MAX_PATH];
wchar_t *wzCountdownFmt;
if ( seconds != 1 )
{
wzCountdownFmt = g_pVGuiLocalize->Find( "#TF_StartingInSecs" );
}
else
{
wzCountdownFmt = g_pVGuiLocalize->Find( "#TF_StartingInSec" );
}
V_snwprintf( wszSeconds, ARRAYSIZE( wszSeconds ), L"%d", seconds );
g_pVGuiLocalize->ConstructString( wszCountdown, sizeof( wszCountdown ), wzCountdownFmt, 1, wszSeconds );
m_pLobbyStateLabel->SetText( wszCountdown );
if ( !m_bHostLobby )
{
m_bStartingGame = true; // client guesses that they can't change teams
}
}
//-----------------------------------------------------------------
// Purpose: Send key presses to the dialog's menu
//-----------------------------------------------------------------
void CSessionLobbyDialog::OnKeyCodePressed( vgui::KeyCode code )
{
CDialogMenu *pMenu = &m_Menus[m_iActiveMenu];
if ( !pMenu )
return;
int idx = pMenu->GetActiveItemIndex();
int itemCt = pMenu->GetItemCount();
CPlayerItem *pItem = dynamic_cast< CPlayerItem* >( pMenu->GetItem( idx ) );
if ( !pItem )
return;
SetDeleteSelfOnClose( true );
switch( code )
{
case KEY_XBUTTON_DOWN:
case KEY_XSTICK1_DOWN:
case STEAMCONTROLLER_DPAD_DOWN:
if ( idx >= itemCt - 1 )
{
ActivateNextMenu();
}
else
{
pMenu->HandleKeyCode( code );
}
break;
case KEY_XBUTTON_UP:
case KEY_XSTICK1_UP:
case STEAMCONTROLLER_DPAD_UP:
if ( idx <= 0 )
{
ActivatePreviousMenu();
}
else
{
pMenu->HandleKeyCode( code );
}
break;
case KEY_XBUTTON_A:
case STEAMCONTROLLER_A:
#ifdef _X360
XShowGamerCardUI( XBX_GetPrimaryUserId(), pItem->m_nId );
#endif
break;
case KEY_XBUTTON_RIGHT_SHOULDER:
#ifdef _X360
{
// Don't allow player reviews in system link games
CMatchmakingBasePanel *pBase = dynamic_cast< CMatchmakingBasePanel* >( m_pParent );
if ( pBase && pBase->GetGameType() == GAMETYPE_SYSTEMLINK_MATCH )
break;
}
XShowPlayerReviewUI( XBX_GetPrimaryUserId(), pItem->m_nId );
#endif
break;
case KEY_XBUTTON_LEFT_SHOULDER:
{
// Don't kick ourselves
if ( m_bHostLobby )
{
if ( pItem && ((CPlayerItem*)pItem)->m_nId != m_nHostId )
{
GameUI().ShowMessageDialog( MD_KICK_CONFIRMATION, this );
}
else
{
vgui::surface()->PlaySound( "player/suit_denydevice.wav" );
}
}
}
break;
case KEY_XBUTTON_B:
case STEAMCONTROLLER_B:
GameUI().ShowMessageDialog( MD_EXIT_SESSION_CONFIRMATION, this );
if ( m_bHostLobby )
{
SetStartGame( false );
}
break;
case KEY_XBUTTON_X:
case STEAMCONTROLLER_X:
if ( m_bStartingGame )
{
// We think we're loading the game, so play deny sound
vgui::surface()->PlaySound( "player/suit_denydevice.wav" );
}
else
{
matchmaking->ChangeTeam( NULL );
}
break;
case KEY_XBUTTON_Y:
case STEAMCONTROLLER_Y:
if ( m_bHostLobby )
{
// Don't allow settings changes in ranked games
CMatchmakingBasePanel *pBase = dynamic_cast< CMatchmakingBasePanel* >( m_pParent );
if ( pBase && pBase->GetGameType() == GAMETYPE_RANKED_MATCH )
break;
SetDeleteSelfOnClose( false );
OnCommand( "SessionOptions_Modify" );
SetStartGame( false );
}
break;
case KEY_XBUTTON_START:
SetStartGame( !m_bStartingGame );
break;
default:
pMenu->HandleKeyCode( code );
break;
}
}
//---------------------------------------------------------------------
// Purpose: start and stop the countdown
//---------------------------------------------------------------------
void CSessionLobbyDialog::SetStartGame( bool bStartGame )
{
if ( !m_bHostLobby )
return;
bool bCanStart = true;
if ( m_bStartingGame != bStartGame )
{
if ( bStartGame )
{
m_bStartingGame = matchmaking->StartGame();
bCanStart = m_bStartingGame;
}
else
{
if ( matchmaking->CancelStartGame() )
{
m_bStartingGame = false;
}
}
// If we can start the game but haven't started yet, show the "Start Game" label
bool bShowStartGame = bCanStart && !m_bStartingGame;
// show/hide the "start game" and countdown hint label based on state
vgui::Label *pStartGame = (vgui::Label *)m_pHostOptionsPanel->FindChildByName("StartGameText" );
if ( pStartGame )
{
pStartGame->SetVisible( m_bStartingGame == false );
}
vgui::Label *pCancelCountdown = (vgui::Label *)m_pHostOptionsPanel->FindChildByName("CancelGameText" );
if ( pCancelCountdown )
{
pCancelCountdown->SetVisible( m_bStartingGame == true );
}
if ( bShowStartGame )
{
m_pLobbyStateLabel->SetText( "#TF_PressStart" );
m_pLobbyStateIcon->SetText( "#GameUI_Icons_START" );
}
}
}
//---------------------------------------------------------------------
// Purpose: Handle menu commands
//---------------------------------------------------------------------
void CSessionLobbyDialog::OnCommand( const char *pCommand )
{
if ( !Q_stricmp( pCommand, "ReturnToMainMenu" ) )
{
matchmaking->KickPlayerFromSession( 0 );
}
else if ( !Q_stricmp( pCommand, "KickPlayer" ) )
{
CDialogMenu *pMenu = &m_Menus[m_iActiveMenu];
CPlayerItem *pItem = (CPlayerItem*)pMenu->GetItem( pMenu->GetActiveItemIndex() );
if ( pItem )
{
matchmaking->KickPlayerFromSession( pItem->m_nId );
}
}
GetParent()->OnCommand( pCommand );
}
static int pnum = 1;
CON_COMMAND( mm_add_player, "Add a player" )
{
if ( args.ArgC() >= 5 )
{
int team = atoi( args[1] );
const char *pName = args[2];
uint32 id = atoi( args[3] );
byte cVoiceState = atoi( args[4] ) != 0;
int nPlayersNeeded = atoi( args[5] );
g_pLobbyDialog->UpdatePlayerInfo( id, pName, team, cVoiceState, nPlayersNeeded, false );
}
else if ( args.ArgC() >= 1 )
{
char name[ 32 ];
int team = pnum & 0x1;
int id = pnum++;
if ( args.ArgC() >= 2 )
{
team = atoi( args[ 1 ] );
if ( args.ArgC() >= 3 )
{
id = atoi( args[2] );
}
}
Q_snprintf( name, sizeof( name ), "Player%d", pnum );
g_pLobbyDialog->UpdatePlayerInfo( id, name, team, true, 0, false );
}
}