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.
 
 
 
 
 
 

739 lines
20 KiB

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