mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 06:36:54 +00:00
739 lines
20 KiB
C++
739 lines
20 KiB
C++
//========= 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 );
|
|
}
|
|
} |