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.
2385 lines
72 KiB
2385 lines
72 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
//============================================================================= |
|
|
|
#include "pch_serverbrowser.h" |
|
|
|
#if defined( _X360 ) |
|
#include "xbox/xbox_win32stubs.h" |
|
#endif |
|
|
|
using namespace vgui; |
|
|
|
#define FILTER_ALLSERVERS 0 |
|
#define FILTER_SECURESERVERSONLY 1 |
|
#define FILTER_INSECURESERVERSONLY 2 |
|
|
|
#define UNIVERSE_OFFICIAL 0 |
|
#define UNIVERSE_CUSTOMGAMES 1 |
|
#define QUICKLIST_FILTER_MIN_PING 0 |
|
|
|
#define MAX_MAP_NAME 128 |
|
const char *COM_GetModDirectory(); |
|
|
|
#undef wcscat |
|
|
|
ConVar sb_mod_suggested_maxplayers( "sb_mod_suggested_maxplayers", "0", FCVAR_HIDDEN ); |
|
ConVar sb_filter_incompatible_versions( "sb_filter_incompatible_versions", |
|
#ifdef STAGING_ONLY |
|
"0", |
|
#else |
|
"1", |
|
#endif |
|
0, "Hides servers running incompatible versions from the server browser. (Internet tab only.)" ); |
|
|
|
bool GameSupportsReplay() |
|
{ |
|
extern IEngineReplay *g_pEngineReplay; |
|
return g_pEngineReplay && g_pEngineReplay->IsSupportedModAndPlatform(); |
|
} |
|
|
|
#ifdef STAGING_ONLY |
|
ConVar sb_fake_app_id( "sb_fake_app_id", "0", 0, "If nonzero, then server browser requests will use this App ID instead" ); |
|
#endif |
|
|
|
//-------------------------------------------------------------------------------------------------------- |
|
bool IsReplayServer( gameserveritem_t &server ) |
|
{ |
|
bool bReplay = false; |
|
|
|
if ( GameSupportsReplay() ) |
|
{ |
|
if ( server.m_szGameTags && server.m_szGameTags[0] ) |
|
{ |
|
CUtlVector<char*> TagList; |
|
V_SplitString( server.m_szGameTags, ",", TagList ); |
|
for ( int i = 0; i < TagList.Count(); i++ ) |
|
{ |
|
if ( Q_stricmp( TagList[i], "replays" ) == 0 ) |
|
{ |
|
bReplay = true; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return bReplay; |
|
} |
|
|
|
//-------------------------------------------------------------------------------------------------------- |
|
inline char *CloneString( const char *str ) |
|
{ |
|
char *cloneStr = new char [ strlen(str)+1 ]; |
|
strcpy( cloneStr, str ); |
|
return cloneStr; |
|
} |
|
|
|
const char *COM_GetModDirectory() |
|
{ |
|
static char modDir[MAX_PATH]; |
|
if ( Q_strlen( modDir ) == 0 ) |
|
{ |
|
const char *gamedir = CommandLine()->ParmValue("-game", CommandLine()->ParmValue( "-defaultgamedir", "hl2" ) ); |
|
Q_strncpy( modDir, gamedir, sizeof(modDir) ); |
|
if ( strchr( modDir, '/' ) || strchr( modDir, '\\' ) ) |
|
{ |
|
Q_StripLastDir( modDir, sizeof(modDir) ); |
|
int dirlen = Q_strlen( modDir ); |
|
Q_strncpy( modDir, gamedir + dirlen, sizeof(modDir) - dirlen ); |
|
} |
|
} |
|
|
|
return modDir; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
CGameListPanel::CGameListPanel( CBaseGamesPage *pOuter, const char *pName ) : |
|
BaseClass( pOuter, pName ) |
|
{ |
|
m_pOuter = pOuter; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Forward KEY_ENTER to the CBaseGamesPage. |
|
//----------------------------------------------------------------------------- |
|
void CGameListPanel::OnKeyCodePressed(vgui::KeyCode code) |
|
{ |
|
// Let the outer class handle it. |
|
if ( code == KEY_ENTER && m_pOuter->OnGameListEnterPressed() ) |
|
return; |
|
|
|
BaseClass::OnKeyCodePressed( code ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
CBaseGamesPage::CBaseGamesPage( vgui::Panel *parent, const char *name, EPageType eType, const char *pCustomResFilename) |
|
: PropertyPage(parent, name), |
|
m_CallbackFavoritesMsg( this, &CBaseGamesPage::OnFavoritesMsg ), |
|
m_hRequest( NULL ), |
|
m_pCustomResFilename( pCustomResFilename ) |
|
{ |
|
SetSize( 624, 278 ); |
|
m_szGameFilter[0] = 0; |
|
m_szMapFilter[0] = 0; |
|
m_iMaxPlayerFilter = 0; |
|
m_iPingFilter = 0; |
|
m_iServerRefreshCount = 0; |
|
m_bFilterNoFullServers = false; |
|
m_bFilterNoEmptyServers = false; |
|
m_bFilterNoPasswordedServers = false; |
|
m_iSecureFilter = FILTER_ALLSERVERS; |
|
m_hFont = NULL; |
|
m_eMatchMakingType = eType; |
|
m_bFilterReplayServers = false; |
|
SetDefLessFunc( m_mapServers ); |
|
SetDefLessFunc( m_mapServerIP ); |
|
SetDefLessFunc( m_mapGamesFilterItem ); |
|
|
|
// Not always loaded |
|
m_pWorkshopFilter = NULL; |
|
|
|
bool bRunningTF2 = GameSupportsReplay(); |
|
|
|
// get the 'all' text |
|
wchar_t *all = g_pVGuiLocalize->Find("ServerBrowser_All"); |
|
Q_UnicodeToUTF8(all, m_szComboAllText, sizeof(m_szComboAllText)); |
|
|
|
// Init UI |
|
m_pConnect = new Button(this, "ConnectButton", "#ServerBrowser_Connect"); |
|
m_pConnect->SetEnabled(false); |
|
m_pRefreshAll = new Button(this, "RefreshButton", "#ServerBrowser_Refresh"); |
|
m_pRefreshQuick = new Button(this, "RefreshQuickButton", "#ServerBrowser_RefreshQuick"); |
|
m_pAddServer = new Button(this, "AddServerButton", "#ServerBrowser_AddServer"); |
|
m_pAddCurrentServer = new Button(this, "AddCurrentServerButton", "#ServerBrowser_AddCurrentServer"); |
|
m_pGameList = new CGameListPanel(this, "gamelist"); |
|
m_pGameList->SetAllowUserModificationOfColumns(true); |
|
|
|
m_pQuickList = new PanelListPanel(this, "quicklist"); |
|
m_pQuickList->SetFirstColumnWidth( 0 ); |
|
|
|
m_pAddToFavoritesButton = new vgui::Button( this, "AddToFavoritesButton", "" ); |
|
m_pAddToFavoritesButton->SetEnabled( false ); |
|
m_pAddToFavoritesButton->SetVisible( false ); |
|
|
|
// Increment this number if columns are added / removed or some other change is done that requires |
|
// tossing out old saved user configs. |
|
m_pGameList->m_nUserConfigFileVersion = 2; |
|
|
|
// Add the column headers |
|
m_pGameList->AddColumnHeader( k_nColumn_Password, "Password", "#ServerBrowser_Password", 16, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_IMAGE); |
|
m_pGameList->AddColumnHeader( k_nColumn_Secure, "Secure", "#ServerBrowser_Secure", 16, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_IMAGE); |
|
|
|
int nReplayWidth = 16; |
|
if ( !bRunningTF2 ) |
|
{ |
|
nReplayWidth = 0; |
|
} |
|
|
|
m_pGameList->AddColumnHeader( k_nColumn_Replay, "Replay", "#ServerBrowser_Replay", nReplayWidth, ListPanel::COLUMN_FIXEDSIZE | ListPanel::COLUMN_IMAGE); |
|
m_pGameList->AddColumnHeader( k_nColumn_Name, "Name", "#ServerBrowser_Servers", 50, ListPanel::COLUMN_RESIZEWITHWINDOW | ListPanel::COLUMN_UNHIDABLE); |
|
m_pGameList->AddColumnHeader( k_nColumn_IPAddr, "IPAddr", "#ServerBrowser_IPAddress", 64, ListPanel::COLUMN_HIDDEN); |
|
m_pGameList->AddColumnHeader( k_nColumn_GameDesc, "GameDesc", "#ServerBrowser_Game", 112, |
|
112, // minwidth |
|
300, // maxwidth |
|
0 // flags |
|
); |
|
m_pGameList->AddColumnHeader( k_nColumn_Players, "Players", "#ServerBrowser_Players", 55, ListPanel::COLUMN_FIXEDSIZE); |
|
m_pGameList->AddColumnHeader( k_nColumn_Bots, "Bots", "#ServerBrowser_Bots", 40, ListPanel::COLUMN_FIXEDSIZE); |
|
m_pGameList->AddColumnHeader( k_nColumn_Map, "Map", "#ServerBrowser_Map", 90, |
|
90, // minwidth |
|
300, // maxwidth |
|
0 // flags |
|
); |
|
m_pGameList->AddColumnHeader( k_nColumn_Ping, "Ping", "#ServerBrowser_Latency", 55, ListPanel::COLUMN_FIXEDSIZE); |
|
|
|
m_pGameList->SetColumnHeaderTooltip( k_nColumn_Password, "#ServerBrowser_PasswordColumn_Tooltip"); |
|
m_pGameList->SetColumnHeaderTooltip( k_nColumn_Bots, "#ServerBrowser_BotColumn_Tooltip"); |
|
m_pGameList->SetColumnHeaderTooltip( k_nColumn_Secure, "#ServerBrowser_SecureColumn_Tooltip"); |
|
|
|
if ( bRunningTF2 ) |
|
{ |
|
m_pGameList->SetColumnHeaderTooltip( k_nColumn_Replay, "#ServerBrowser_ReplayColumn_Tooltip"); |
|
} |
|
|
|
// setup fast sort functions |
|
m_pGameList->SetSortFunc( k_nColumn_Password, PasswordCompare); |
|
m_pGameList->SetSortFunc( k_nColumn_Bots, BotsCompare); |
|
m_pGameList->SetSortFunc( k_nColumn_Secure, SecureCompare); |
|
|
|
if ( bRunningTF2 ) |
|
{ |
|
m_pGameList->SetSortFunc( k_nColumn_Replay, ReplayCompare); |
|
} |
|
|
|
m_pGameList->SetSortFunc( k_nColumn_Name, ServerNameCompare); |
|
m_pGameList->SetSortFunc( k_nColumn_IPAddr, IPAddressCompare); |
|
m_pGameList->SetSortFunc( k_nColumn_GameDesc, GameCompare); |
|
m_pGameList->SetSortFunc( k_nColumn_Players, PlayersCompare); |
|
m_pGameList->SetSortFunc( k_nColumn_Map, MapCompare); |
|
m_pGameList->SetSortFunc( k_nColumn_Ping, PingCompare); |
|
|
|
// Sort by ping time by default |
|
m_pGameList->SetSortColumn( k_nColumn_Ping ); |
|
|
|
CreateFilters(); |
|
LoadFilterSettings(); |
|
|
|
m_bAutoSelectFirstItemInGameList = false; |
|
|
|
// In TF2, fill out the max player count so that we sort all >24 player servers below the rest. |
|
if ( bRunningTF2 ) |
|
{ |
|
sb_mod_suggested_maxplayers.SetValue( 24 ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Destructor |
|
//----------------------------------------------------------------------------- |
|
CBaseGamesPage::~CBaseGamesPage() |
|
{ |
|
if ( m_hRequest ) |
|
{ |
|
steamapicontext->SteamMatchmakingServers()->ReleaseRequest( m_hRequest ); |
|
m_hRequest = NULL; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CBaseGamesPage::GetInvalidServerListID() |
|
{ |
|
return m_pGameList->InvalidItemID(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::PerformLayout() |
|
{ |
|
BaseClass::PerformLayout(); |
|
|
|
if ( GetSelectedServerID() == -1 ) |
|
{ |
|
m_pConnect->SetEnabled(false); |
|
} |
|
else |
|
{ |
|
m_pConnect->SetEnabled(true); |
|
} |
|
|
|
|
|
if (SupportsItem(IGameList::GETNEWLIST)) |
|
{ |
|
m_pRefreshQuick->SetVisible(true); |
|
m_pRefreshAll->SetText("#ServerBrowser_RefreshAll"); |
|
} |
|
else |
|
{ |
|
m_pRefreshQuick->SetVisible(false); |
|
m_pRefreshAll->SetText("#ServerBrowser_Refresh"); |
|
} |
|
|
|
if ( SupportsItem(IGameList::ADDSERVER) ) |
|
{ |
|
// m_pFilterString->SetWide( 90 ); // shrink the filter label to fix the add current server button |
|
m_pAddServer->SetVisible(true); |
|
} |
|
else |
|
{ |
|
m_pAddServer->SetVisible(false); |
|
} |
|
|
|
if ( SupportsItem(IGameList::ADDCURRENTSERVER) ) |
|
{ |
|
m_pAddCurrentServer->SetVisible(true); |
|
} |
|
else |
|
{ |
|
m_pAddCurrentServer->SetVisible(false); |
|
} |
|
|
|
if ( IsRefreshing() ) |
|
{ |
|
m_pRefreshAll->SetText( "#ServerBrowser_StopRefreshingList" ); |
|
} |
|
|
|
if (m_pGameList->GetItemCount() > 0) |
|
{ |
|
m_pRefreshQuick->SetEnabled(true); |
|
} |
|
else |
|
{ |
|
m_pRefreshQuick->SetEnabled(false); |
|
} |
|
|
|
/* if ( !steamapicontext->SteamMatchmakingServers() || !steamapicontext->SteamMatchmaking() ) |
|
{ |
|
m_pAddCurrentServer->SetVisible( false ); |
|
m_pRefreshQuick->SetEnabled( false ); |
|
m_pAddServer->SetEnabled( false ); |
|
m_pConnect->SetEnabled( false ); |
|
m_pRefreshAll->SetEnabled( false ); |
|
m_pAddToFavoritesButton->SetEnabled( false ); |
|
m_pGameList->SetEmptyListText( "#ServerBrowser_SteamRunning" ); |
|
}*/ |
|
|
|
Repaint(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::ApplySchemeSettings(IScheme *pScheme) |
|
{ |
|
BaseClass::ApplySchemeSettings(pScheme); |
|
|
|
// load the password icon |
|
ImageList *imageList = new ImageList(false); |
|
m_nImageIndexPassword = imageList->AddImage(scheme()->GetImage("servers/icon_password", false)); |
|
//imageList->AddImage(scheme()->GetImage("servers/icon_bots", false)); |
|
m_nImageIndexSecure = imageList->AddImage(scheme()->GetImage("servers/icon_robotron", false)); |
|
m_nImageIndexSecureVacBanned = imageList->AddImage(scheme()->GetImage("servers/icon_secure_deny", false)); |
|
m_nImageIndexReplay = imageList->AddImage(scheme()->GetImage("servers/icon_replay", false)); |
|
int passwordColumnImage = imageList->AddImage(scheme()->GetImage("servers/icon_password_column", false)); |
|
//int botColumnImage = imageList->AddImage(scheme()->GetImage("servers/icon_bots_column", false)); |
|
int secureColumnImage = imageList->AddImage(scheme()->GetImage("servers/icon_robotron_column", false)); |
|
int replayColumnImage = imageList->AddImage(scheme()->GetImage("servers/icon_replay_column", false)); |
|
|
|
m_pGameList->SetImageList(imageList, true); |
|
m_hFont = pScheme->GetFont( "ListSmall", IsProportional() ); |
|
if ( !m_hFont ) |
|
m_hFont = pScheme->GetFont( "DefaultSmall", IsProportional() ); |
|
|
|
m_pGameList->SetFont( m_hFont ); |
|
m_pGameList->SetColumnHeaderImage( k_nColumn_Password, passwordColumnImage); |
|
//m_pGameList->SetColumnHeaderImage( k_nColumn_Bots, botColumnImage); |
|
m_pGameList->SetColumnHeaderImage( k_nColumn_Secure, secureColumnImage); |
|
m_pGameList->SetColumnHeaderImage( k_nColumn_Replay, replayColumnImage); |
|
} |
|
|
|
struct serverqualitysort_t |
|
{ |
|
int iIndex; |
|
int iPing; |
|
int iPlayerCount; |
|
int iMaxPlayerCount; |
|
}; |
|
|
|
int ServerQualitySort( const serverqualitysort_t *pSQ1, const serverqualitysort_t *pSQ2 ) |
|
{ |
|
int iMaxP = sb_mod_suggested_maxplayers.GetInt(); |
|
if ( iMaxP && pSQ1->iMaxPlayerCount != pSQ2->iMaxPlayerCount ) |
|
{ |
|
if ( pSQ1->iMaxPlayerCount > iMaxP ) |
|
return 1; |
|
if ( pSQ2->iMaxPlayerCount > iMaxP ) |
|
return -1; |
|
} |
|
|
|
if ( pSQ1->iPing <= 100 && pSQ2->iPing <= 100 && pSQ1->iPlayerCount != pSQ2->iPlayerCount ) |
|
{ |
|
return pSQ2->iPlayerCount - pSQ1->iPlayerCount; |
|
} |
|
|
|
return pSQ1->iPing - pSQ2->iPing; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::SelectQuickListServers( void ) |
|
{ |
|
int iIndex = m_pQuickList->FirstItem(); |
|
|
|
while ( iIndex != m_pQuickList->InvalidItemID() ) |
|
{ |
|
CQuickListPanel *pQuickListPanel = dynamic_cast< CQuickListPanel *> ( m_pQuickList->GetItemPanel( iIndex ) ); |
|
|
|
if ( pQuickListPanel ) |
|
{ |
|
CUtlVector< serverqualitysort_t > vecServerQuality; |
|
|
|
int iElement = m_quicklistserverlist.Find( pQuickListPanel->GetName() ); |
|
|
|
if ( iElement != m_quicklistserverlist.InvalidIndex() ) |
|
{ |
|
CQuickListMapServerList *vecMapServers = &m_quicklistserverlist[iElement]; |
|
|
|
if ( vecMapServers ) |
|
{ |
|
for ( int i =0; i < vecMapServers->Count(); i++ ) |
|
{ |
|
int iListID = vecMapServers->Element( i ); |
|
|
|
serverqualitysort_t serverquality; |
|
|
|
serverquality.iIndex = iListID; |
|
|
|
KeyValues *kv = NULL; |
|
if ( m_pGameList->IsValidItemID( iListID ) ) |
|
{ |
|
kv = m_pGameList->GetItem( iListID ); |
|
} |
|
|
|
if ( kv ) |
|
{ |
|
serverquality.iPing = kv->GetInt( "ping", 0 ); |
|
serverquality.iPlayerCount = kv->GetInt( "PlayerCount", 0 ); |
|
serverquality.iMaxPlayerCount = kv->GetInt( "MaxPlayerCount", 0 ); |
|
} |
|
|
|
vecServerQuality.AddToTail( serverquality ); |
|
} |
|
|
|
vecServerQuality.Sort( ServerQualitySort ); |
|
|
|
serverqualitysort_t bestserver = vecServerQuality.Head(); |
|
|
|
if ( m_pGameList->IsValidItemID( bestserver.iIndex ) ) |
|
{ |
|
pQuickListPanel->SetServerInfo( m_pGameList->GetItem( bestserver.iIndex ), bestserver.iIndex, vecServerQuality.Count() ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
iIndex = m_pQuickList->NextItem( iIndex ); |
|
} |
|
|
|
//Force the connect button to recalculate its state. |
|
OnItemSelected(); |
|
} |
|
|
|
int ServerMapnameSortFunc( const servermaps_t *p1, const servermaps_t *p2 ) |
|
{ |
|
//If they're both on disc OR both missing then sort them alphabetically |
|
if ( (p1->bOnDisk && p2->bOnDisk) || (!p1->bOnDisk && !p2->bOnDisk ) ) |
|
return Q_strcmp( p1->pFriendlyName, p2->pFriendlyName ); |
|
|
|
//Otherwise maps you have show up first |
|
return p2->bOnDisk - p1->bOnDisk; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: prepares all the QuickListPanel map panels... |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::PrepareQuickListMap( const char *pMapName, int iListID ) |
|
{ |
|
char szMapName[ 512 ]; |
|
Q_snprintf( szMapName, sizeof( szMapName ), "%s", pMapName ); |
|
|
|
Q_strlower( szMapName ); |
|
|
|
char path[ 512 ]; |
|
Q_snprintf( path, sizeof( path ), "maps/%s.bsp", szMapName ); |
|
|
|
int iIndex = m_quicklistserverlist.Find( szMapName ); |
|
|
|
if ( m_quicklistserverlist.IsValidIndex( iIndex ) == false ) |
|
{ |
|
CQuickListMapServerList vecMapServers; |
|
iIndex = m_quicklistserverlist.Insert( szMapName, vecMapServers ); |
|
|
|
char szFriendlyName[MAX_MAP_NAME]; |
|
const char *pszFriendlyGameTypeName = ServerBrowser().GetMapFriendlyNameAndGameType( szMapName, szFriendlyName, sizeof(szFriendlyName) ); |
|
|
|
//Add the map to our list of panels. |
|
if ( m_pQuickList ) |
|
{ |
|
servermaps_t servermap; |
|
|
|
servermap.pFriendlyName = CloneString( szFriendlyName ); |
|
servermap.pOriginalName = CloneString( szMapName ); |
|
|
|
char path[ 512 ]; |
|
Q_snprintf( path, sizeof( path ), "maps/%s.bsp", szMapName ); |
|
|
|
servermap.bOnDisk = g_pFullFileSystem->FileExists( path, "MOD" ); |
|
|
|
CQuickListPanel *pQuickListPanel = new CQuickListPanel( m_pQuickList, "QuickListPanel"); |
|
|
|
if ( pQuickListPanel ) |
|
{ |
|
pQuickListPanel->InvalidateLayout(); |
|
pQuickListPanel->SetName( servermap.pOriginalName ); |
|
pQuickListPanel->SetMapName( servermap.pFriendlyName ); |
|
pQuickListPanel->SetImage( servermap.pOriginalName ); |
|
pQuickListPanel->SetGameType( pszFriendlyGameTypeName ); |
|
pQuickListPanel->SetVisible( true ); |
|
pQuickListPanel->SetRefreshing(); |
|
|
|
servermap.iPanelIndex = m_pQuickList->AddItem( NULL, pQuickListPanel ); |
|
} |
|
|
|
m_vecMapNamesFound.AddToTail( servermap ); |
|
m_vecMapNamesFound.Sort( ServerMapnameSortFunc ); |
|
} |
|
|
|
//Now make sure that list is sorted. |
|
CUtlVector<int> *pPanelSort = m_pQuickList->GetSortedVector(); |
|
|
|
if ( pPanelSort ) |
|
{ |
|
pPanelSort->RemoveAll(); |
|
|
|
for ( int i = 0; i < m_vecMapNamesFound.Count(); i++ ) |
|
{ |
|
pPanelSort->AddToTail( m_vecMapNamesFound[i].iPanelIndex ); |
|
} |
|
} |
|
} |
|
|
|
if ( iIndex != m_quicklistserverlist.InvalidIndex() ) |
|
{ |
|
CQuickListMapServerList *vecMapServers = &m_quicklistserverlist[iIndex]; |
|
|
|
if ( vecMapServers ) |
|
{ |
|
if ( vecMapServers->Find( iListID ) == vecMapServers->InvalidIndex() ) |
|
{ |
|
vecMapServers->AddToTail( iListID ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: gets information about specified server |
|
//----------------------------------------------------------------------------- |
|
gameserveritem_t *CBaseGamesPage::GetServer( unsigned int serverID ) |
|
{ |
|
if ( !steamapicontext->SteamMatchmakingServers() ) |
|
return NULL; |
|
|
|
// No point checking for >= 0 when serverID is unsigned. |
|
//if ( serverID >= 0 ) |
|
{ |
|
return steamapicontext->SteamMatchmakingServers()->GetServerDetails( m_hRequest, serverID ); |
|
} |
|
//else |
|
//{ |
|
// Assert( !"Unable to return a useful entry" ); |
|
// return NULL; // bugbug Alfred: temp Favorites/History objects won't return a good value here... |
|
//} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
bool CBaseGamesPage::TagsExclude( void ) |
|
{ |
|
if ( m_pTagsIncludeFilter == NULL ) |
|
return false; |
|
|
|
return m_pTagsIncludeFilter->GetActiveItem(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: What mode the workshop selection is in for pages that use it |
|
//----------------------------------------------------------------------------- |
|
CBaseGamesPage::eWorkshopMode CBaseGamesPage::WorkshopMode() |
|
{ |
|
if ( !m_pWorkshopFilter || !ServerBrowser().IsWorkshopEnabled() ) |
|
{ |
|
return eWorkshop_None; |
|
} |
|
|
|
return (eWorkshopMode)m_pWorkshopFilter->GetActiveItem(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::HideReplayFilter( void ) |
|
{ |
|
if ( m_pReplayFilterCheck && m_pReplayFilterCheck->IsVisible() ) |
|
{ |
|
m_pReplayFilterCheck->SetVisible( false ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::CreateFilters() |
|
{ |
|
m_pFilter = new ToggleButton(this, "Filter", "#ServerBrowser_Filters"); |
|
m_pFilterString = new Label(this, "FilterString", ""); |
|
|
|
if ( Q_stricmp( COM_GetModDirectory(), "cstrike" ) == 0 ) |
|
{ |
|
m_pFilter->SetSelected( false ); |
|
m_bFiltersVisible = false; |
|
} |
|
else |
|
{ |
|
m_pFilter->SetSelected( true ); |
|
m_bFiltersVisible = true; |
|
} |
|
|
|
// filter controls |
|
m_pGameFilter = new ComboBox(this, "GameFilter", 6, false); |
|
|
|
m_pLocationFilter = new ComboBox(this, "LocationFilter", 6, false); |
|
m_pLocationFilter->AddItem("", NULL); |
|
|
|
m_pMapFilter = new TextEntry(this, "MapFilter"); |
|
m_pMaxPlayerFilter = new TextEntry(this, "MaxPlayerFilter"); |
|
m_pPingFilter = new ComboBox(this, "PingFilter", 6, false); |
|
m_pPingFilter->AddItem("#ServerBrowser_All", NULL); |
|
m_pPingFilter->AddItem("#ServerBrowser_LessThan50", NULL); |
|
m_pPingFilter->AddItem("#ServerBrowser_LessThan100", NULL); |
|
m_pPingFilter->AddItem("#ServerBrowser_LessThan150", NULL); |
|
m_pPingFilter->AddItem("#ServerBrowser_LessThan250", NULL); |
|
m_pPingFilter->AddItem("#ServerBrowser_LessThan350", NULL); |
|
m_pPingFilter->AddItem("#ServerBrowser_LessThan600", NULL); |
|
|
|
m_pSecureFilter = new ComboBox(this, "SecureFilter", 3, false); |
|
m_pSecureFilter->AddItem("#ServerBrowser_All", NULL); |
|
m_pSecureFilter->AddItem("#ServerBrowser_SecureOnly", NULL); |
|
m_pSecureFilter->AddItem("#ServerBrowser_InsecureOnly", NULL); |
|
|
|
m_pTagsIncludeFilter = new ComboBox(this, "TagsInclude", 2, false); |
|
m_pTagsIncludeFilter->AddItem("#ServerBrowser_TagsInclude", NULL); |
|
m_pTagsIncludeFilter->AddItem("#ServerBrowser_TagsDoNotInclude", NULL); |
|
m_pTagsIncludeFilter->SetVisible( false ); |
|
|
|
if ( ServerBrowser().IsWorkshopEnabled() ) |
|
{ |
|
m_pWorkshopFilter = new ComboBox(this, "WorkshopFilter", 3, false); |
|
m_pWorkshopFilter->AddItem("#ServerBrowser_All", NULL); |
|
m_pWorkshopFilter->AddItem("#ServerBrowser_WorkshopFilterWorkshopOnly", NULL); |
|
m_pWorkshopFilter->AddItem("#ServerBrowser_WorkshopFilterSubscribed", NULL); |
|
m_pWorkshopFilter->SetVisible( false ); |
|
} |
|
|
|
m_pNoEmptyServersFilterCheck = new CheckButton(this, "ServerEmptyFilterCheck", ""); |
|
m_pNoFullServersFilterCheck = new CheckButton(this, "ServerFullFilterCheck", ""); |
|
m_pNoPasswordFilterCheck = new CheckButton(this, "NoPasswordFilterCheck", ""); |
|
m_pQuickListCheckButton = new CCheckBoxWithStatus(this, "QuickListCheck", ""); |
|
m_pReplayFilterCheck = new CheckButton(this, "ReplayFilterCheck", ""); |
|
|
|
KeyValues *pkv = new KeyValues("mod", "gamedir", "", "appid", NULL ); |
|
m_pGameFilter->AddItem("#ServerBrowser_All", pkv); |
|
|
|
for (int i = 0; i < ModList().ModCount(); i++) |
|
{ |
|
pkv->SetString("gamedir", ModList().GetModDir(i)); |
|
pkv->SetUint64("appid", ModList().GetAppID(i).ToUint64() ); |
|
int iItemID = m_pGameFilter->AddItem(ModList().GetModName(i), pkv); |
|
m_mapGamesFilterItem.Insert( ModList().GetAppID(i).ToUint64(), iItemID ); |
|
} |
|
pkv->deleteThis(); |
|
|
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: loads filter settings from the keyvalues |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::LoadFilterSettings() |
|
{ |
|
KeyValues *filter = ServerBrowserDialog().GetFilterSaveData(GetName()); |
|
|
|
if (ServerBrowserDialog().GetActiveModName()) |
|
{ |
|
Q_strncpy(m_szGameFilter, ServerBrowserDialog().GetActiveModName(), sizeof(m_szGameFilter)); |
|
m_iLimitToAppID = ServerBrowserDialog().GetActiveAppID(); |
|
} |
|
else |
|
{ |
|
Q_strncpy(m_szGameFilter, filter->GetString("game"), sizeof(m_szGameFilter)); |
|
m_iLimitToAppID = CGameID( filter->GetUint64( "appid", 0 ) ); |
|
} |
|
|
|
Q_strncpy(m_szMapFilter, filter->GetString("map"), sizeof(m_szMapFilter)); |
|
m_iMaxPlayerFilter = filter->GetInt("MaxPlayerCount"); |
|
m_iPingFilter = filter->GetInt("ping"); |
|
m_bFilterNoFullServers = filter->GetInt("NoFull"); |
|
m_bFilterNoEmptyServers = filter->GetInt("NoEmpty"); |
|
m_bFilterNoPasswordedServers = filter->GetInt("NoPassword"); |
|
m_bFilterReplayServers = filter->GetInt("Replay"); |
|
m_pQuickListCheckButton->SetSelected( filter->GetInt( "QuickList", 0 ) ); |
|
|
|
int secureFilter = filter->GetInt("Secure"); |
|
m_pSecureFilter->ActivateItem(secureFilter); |
|
|
|
int tagsinclude = filter->GetInt("tagsinclude"); |
|
m_pTagsIncludeFilter->ActivateItem( tagsinclude ); |
|
|
|
if ( m_pWorkshopFilter ) |
|
{ |
|
int workshopFilter = filter->GetInt("workshopfilter"); |
|
m_pWorkshopFilter->ActivateItem( workshopFilter ); |
|
} |
|
|
|
// apply to the controls |
|
UpdateGameFilter(); |
|
m_pMapFilter->SetText(m_szMapFilter); |
|
m_pLocationFilter->ActivateItem(filter->GetInt("location")); |
|
|
|
if (m_iMaxPlayerFilter) |
|
{ |
|
char buf[32]; |
|
Q_snprintf(buf, sizeof(buf), "%d", m_iMaxPlayerFilter); |
|
m_pMaxPlayerFilter->SetText(buf); |
|
} |
|
|
|
if (m_iPingFilter) |
|
{ |
|
char buf[32]; |
|
Q_snprintf(buf, sizeof(buf), "< %d", m_iPingFilter); |
|
m_pPingFilter->SetText(buf); |
|
} |
|
|
|
m_pNoFullServersFilterCheck->SetSelected(m_bFilterNoFullServers); |
|
m_pNoEmptyServersFilterCheck->SetSelected(m_bFilterNoEmptyServers); |
|
m_pNoPasswordFilterCheck->SetSelected(m_bFilterNoPasswordedServers); |
|
m_pReplayFilterCheck->SetSelected(m_bFilterReplayServers); |
|
|
|
OnLoadFilter( filter ); |
|
UpdateFilterSettings(); |
|
|
|
UpdateFilterAndQuickListVisibility(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sets the game filter combo box to be the saved setting |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::UpdateGameFilter() |
|
{ |
|
bool bFound = false; |
|
for (int i = 0; i < m_pGameFilter->GetItemCount(); i++) |
|
{ |
|
KeyValues *kv = m_pGameFilter->GetItemUserData(i); |
|
CGameID gameID( kv->GetUint64( "appID", 0 ) ); |
|
const char *pchGameDir = kv->GetString( "gamedir" ); |
|
if ( ( gameID == m_iLimitToAppID || m_iLimitToAppID.AppID() == 0 ) && ( !m_szGameFilter[0] || |
|
( pchGameDir && pchGameDir[0] && !Q_strncmp( pchGameDir, m_szGameFilter, Q_strlen( pchGameDir ) ) ) ) ) |
|
{ |
|
if ( i != m_pGameFilter->GetActiveItem() ) |
|
{ |
|
m_pGameFilter->ActivateItem(i); |
|
} |
|
bFound = true; |
|
break; |
|
} |
|
} |
|
if (!bFound) |
|
{ |
|
// default to empty |
|
if ( 0 != m_pGameFilter->GetActiveItem() ) |
|
{ |
|
m_pGameFilter->ActivateItem(0); |
|
} |
|
} |
|
|
|
// only one mod is allowed in the game |
|
if ( ServerBrowserDialog().GetActiveModName() ) |
|
{ |
|
m_pGameFilter->SetEnabled( false ); |
|
m_pGameFilter->SetText( ServerBrowserDialog().GetActiveGameName() ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handles incoming server refresh data |
|
// updates the server browser with the refreshed information from the server itself |
|
//----------------------------------------------------------------------------- |
|
/*void CBaseGamesPage::ServerResponded( gameserveritem_t &server ) |
|
{ |
|
int nIndex = -1; // start at -1 and work backwards to find the next free slot for this adhoc query |
|
while ( m_mapServers.Find( nIndex ) != m_mapServers.InvalidIndex() ) |
|
nIndex--; |
|
ServerResponded( nIndex, &server ); |
|
}*/ |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Callback for ISteamMatchmakingServerListResponse |
|
//----------------------------------------------------------------------------- |
|
/*void CBaseGamesPage::ServerResponded( HServerListRequest hReq, int iServer ) |
|
{ |
|
gameserveritem_t *pServerItem = steamapicontext->SteamMatchmakingServers()->GetServerDetails( hReq, iServer ); |
|
if ( !pServerItem ) |
|
{ |
|
Assert( !"Missing server response" ); |
|
return; |
|
} |
|
|
|
// FIXME(johns): This is a workaround for a steam bug, where it inproperly reads signed bytes out of the |
|
// message. Once the upstream fix makes it into our SteamSDK, this block can be removed. |
|
pServerItem->m_nPlayers = (uint8)(int8)pServerItem->m_nPlayers; |
|
pServerItem->m_nBotPlayers = (uint8)(int8)pServerItem->m_nBotPlayers; |
|
pServerItem->m_nMaxPlayers = (uint8)(int8)pServerItem->m_nMaxPlayers; |
|
|
|
ServerResponded( iServer, pServerItem ); |
|
}*/ |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handles incoming server refresh data |
|
// updates the server browser with the refreshed information from the server itself |
|
//----------------------------------------------------------------------------- |
|
|
|
void CBaseGamesPage::ServerResponded( int iServer, gameserveritem_t *pServerItem ) |
|
{ |
|
#if 0 |
|
int iServerMap = m_mapServers.Find( iServer ); |
|
if ( iServerMap == m_mapServers.InvalidIndex() ) |
|
{ |
|
netadr_t netAdr( pServerItem->m_NetAdr.GetIP(), pServerItem->m_NetAdr.GetConnectionPort() ); |
|
int iServerIP = m_mapServerIP.Find( netAdr ); |
|
if ( iServerIP != m_mapServerIP.InvalidIndex() ) |
|
{ |
|
// if we already had this entry under another index remove the old entry |
|
int iServerMap = m_mapServers.Find( m_mapServerIP[ iServerIP ] ); |
|
if ( iServerMap != m_mapServers.InvalidIndex() ) |
|
{ |
|
serverdisplay_t &server = m_mapServers[ iServerMap ]; |
|
if ( m_pGameList->IsValidItemID( server.m_iListID ) ) |
|
m_pGameList->RemoveItem( server.m_iListID ); |
|
m_mapServers.RemoveAt( iServerMap ); |
|
} |
|
m_mapServerIP.RemoveAt( iServerIP ); |
|
} |
|
|
|
serverdisplay_t serverFind; |
|
serverFind.m_iListID = -1; |
|
serverFind.m_bDoNotRefresh = false; |
|
iServerMap = m_mapServers.Insert( iServer, serverFind ); |
|
m_mapServerIP.Insert( netAdr, iServer ); |
|
} |
|
|
|
serverdisplay_t *pServer = &m_mapServers[ iServerMap ]; |
|
pServer->m_iServerID = iServer; |
|
Assert( pServerItem->m_NetAdr.GetIP() != 0 ); |
|
|
|
// check filters |
|
bool removeItem = false; |
|
if ( !CheckPrimaryFilters( *pServerItem ) ) |
|
{ |
|
// server has been filtered at a primary level |
|
// remove from lists |
|
pServer->m_bDoNotRefresh = true; |
|
|
|
// remove from UI list |
|
removeItem = true; |
|
|
|
if ( m_pGameList->IsValidItemID( pServer->m_iListID ) ) |
|
{ |
|
m_pGameList->RemoveItem( pServer->m_iListID ); |
|
pServer->m_iListID = GetInvalidServerListID(); |
|
} |
|
|
|
return; |
|
} |
|
else if (!CheckSecondaryFilters( *pServerItem )) |
|
{ |
|
// we still ping this server in the future; however it is removed from UI list |
|
removeItem = true; |
|
} |
|
|
|
// update UI |
|
KeyValues *kv; |
|
if ( m_pGameList->IsValidItemID( pServer->m_iListID ) ) |
|
{ |
|
// we're updating an existing entry |
|
kv = m_pGameList->GetItem( pServer->m_iListID ); |
|
m_pGameList->SetUserData( pServer->m_iListID, pServer->m_iServerID ); |
|
} |
|
else |
|
{ |
|
// new entry |
|
kv = new KeyValues("Server"); |
|
} |
|
|
|
kv->SetString("name", pServerItem->GetName()); |
|
kv->SetString("map", pServerItem->m_szMap); |
|
kv->SetString("GameDir", pServerItem->m_szGameDir); |
|
kv->SetString("GameDesc", pServerItem->m_szGameDescription); |
|
kv->SetInt("password", pServerItem->m_bPassword ? m_nImageIndexPassword : 0); |
|
|
|
if ( pServerItem->m_nBotPlayers > 0 ) |
|
kv->SetInt("bots", pServerItem->m_nBotPlayers); |
|
else |
|
kv->SetString("bots", ""); |
|
|
|
if ( pServerItem->m_bSecure ) |
|
{ |
|
// show the denied icon if banned from secure servers, the secure icon otherwise |
|
kv->SetInt("secure", ServerBrowser().IsVACBannedFromGame( pServerItem->m_nAppID ) ? m_nImageIndexSecureVacBanned : m_nImageIndexSecure ); |
|
} |
|
else |
|
{ |
|
kv->SetInt("secure", 0); |
|
} |
|
|
|
kv->SetString( "IPAddr", pServerItem->m_NetAdr.GetConnectionAddressString() ); |
|
|
|
int nAdjustedForBotsPlayers = max( 0, pServerItem->m_nPlayers - pServerItem->m_nBotPlayers ); |
|
|
|
char buf[32]; |
|
Q_snprintf(buf, sizeof(buf), "%d / %d", nAdjustedForBotsPlayers, pServerItem->m_nMaxPlayers ); |
|
kv->SetString("Players", buf); |
|
|
|
kv->SetInt("PlayerCount", nAdjustedForBotsPlayers ); |
|
kv->SetInt("MaxPlayerCount", pServerItem->m_nMaxPlayers ); |
|
|
|
kv->SetInt("Ping", pServerItem->m_nPing); |
|
|
|
kv->SetString("Tags", pServerItem->m_szGameTags ); |
|
|
|
kv->SetInt("Replay", IsReplayServer( *pServerItem ) ? m_nImageIndexReplay : 0); |
|
|
|
if ( pServerItem->m_ulTimeLastPlayed ) |
|
{ |
|
// construct a time string for last played time |
|
struct tm *now; |
|
now = localtime( (time_t*)&pServerItem->m_ulTimeLastPlayed ); |
|
|
|
if ( now ) |
|
{ |
|
char buf[64]; |
|
strftime(buf, sizeof(buf), "%a %d %b %I:%M%p", now); |
|
Q_strlower(buf + strlen(buf) - 4); |
|
kv->SetString("LastPlayed", buf); |
|
} |
|
} |
|
|
|
if ( pServer->m_bDoNotRefresh ) |
|
{ |
|
// clear out the vars |
|
kv->SetString("Ping", ""); |
|
kv->SetWString("GameDesc", g_pVGuiLocalize->Find("#ServerBrowser_NotResponding")); |
|
kv->SetString("Players", ""); |
|
kv->SetString("map", ""); |
|
} |
|
|
|
if ( !m_pGameList->IsValidItemID( pServer->m_iListID ) ) |
|
{ |
|
// new server, add to list |
|
pServer->m_iListID = m_pGameList->AddItem(kv, pServer->m_iServerID, false, false); |
|
if ( m_bAutoSelectFirstItemInGameList && m_pGameList->GetItemCount() == 1 ) |
|
{ |
|
m_pGameList->AddSelectedItem( pServer->m_iListID ); |
|
} |
|
|
|
m_pGameList->SetItemVisible( pServer->m_iListID, !removeItem ); |
|
|
|
kv->deleteThis(); |
|
} |
|
else |
|
{ |
|
// tell the list that we've changed the data |
|
m_pGameList->ApplyItemChanges( pServer->m_iListID ); |
|
m_pGameList->SetItemVisible( pServer->m_iListID, !removeItem ); |
|
} |
|
|
|
PrepareQuickListMap( pServerItem->m_szMap, pServer->m_iListID ); |
|
UpdateStatus(); |
|
m_iServerRefreshCount++; |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::UpdateFilterAndQuickListVisibility() |
|
{ |
|
bool showQuickList = m_pQuickListCheckButton->IsSelected(); |
|
bool showFilter = m_pFilter->IsSelected(); |
|
|
|
m_bFiltersVisible = !showQuickList && !m_pCustomResFilename && showFilter; |
|
|
|
int wide, tall; |
|
GetSize( wide, tall ); |
|
SetSize( 624, 278 ); |
|
|
|
UpdateDerivedLayouts(); |
|
UpdateGameFilter(); |
|
|
|
if ( m_hFont ) |
|
{ |
|
SETUP_PANEL( m_pGameList ); |
|
m_pGameList->SetFont( m_hFont ); |
|
} |
|
|
|
SetSize( wide, tall ); |
|
|
|
|
|
m_pQuickList->SetVisible( showQuickList ); |
|
m_pGameList->SetVisible( !showQuickList ); |
|
m_pFilter->SetVisible( !showQuickList ); |
|
m_pFilterString->SetVisible ( !showQuickList ); |
|
|
|
|
|
InvalidateLayout(); |
|
|
|
UpdateFilterSettings(); |
|
ApplyGameFilters(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::SetQuickListEnabled( bool bEnabled ) |
|
{ |
|
m_pQuickListCheckButton->SetSelected( bEnabled ); |
|
|
|
m_pQuickList->SetVisible( m_pQuickListCheckButton->IsSelected() ); |
|
m_pGameList->SetVisible( !m_pQuickListCheckButton->IsSelected() ); |
|
|
|
m_pFilter->SetVisible( !m_pQuickListCheckButton->IsSelected() ); |
|
m_pFilterString->SetVisible( !m_pQuickListCheckButton->IsSelected() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::SetFiltersVisible( bool bVisible ) |
|
{ |
|
if ( bVisible == m_pFilter->IsSelected() ) |
|
return; |
|
|
|
m_pFilter->SetSelected( bVisible ); |
|
OnButtonToggled( m_pFilter, bVisible ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handles filter dropdown being toggled |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnButtonToggled( Panel *panel, int state ) |
|
{ |
|
UpdateFilterAndQuickListVisibility(); |
|
|
|
|
|
if (panel == m_pNoFullServersFilterCheck || panel == m_pNoEmptyServersFilterCheck || panel == m_pNoPasswordFilterCheck || panel == m_pReplayFilterCheck) |
|
{ |
|
// treat changing these buttons like any other filter has changed |
|
OnTextChanged(panel, ""); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::UpdateDerivedLayouts( void ) |
|
{ |
|
char rgchControlSettings[MAX_PATH]; |
|
if ( m_pCustomResFilename ) |
|
{ |
|
Q_snprintf( rgchControlSettings, sizeof( rgchControlSettings ), "%s", m_pCustomResFilename ); |
|
} |
|
else |
|
{ |
|
if ( m_pFilter->IsSelected() && !m_pQuickListCheckButton->IsSelected() ) |
|
{ |
|
// drop down |
|
V_strncpy( rgchControlSettings, "servers/InternetGamesPage_Filters.res", sizeof( rgchControlSettings ) ); |
|
} |
|
else |
|
{ |
|
// hide filter area |
|
V_strncpy( rgchControlSettings, "servers/InternetGamesPage.res", sizeof( rgchControlSettings ) ); |
|
} |
|
} |
|
|
|
const char *pPathID = "PLATFORM"; |
|
|
|
if ( g_pFullFileSystem->FileExists( rgchControlSettings, "MOD" ) ) |
|
{ |
|
pPathID = "MOD"; |
|
} |
|
|
|
LoadControlSettings( rgchControlSettings, pPathID ); |
|
|
|
if ( !GameSupportsReplay() ) |
|
{ |
|
HideReplayFilter(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when the game dir combo box is changed |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnTextChanged(Panel *panel, const char *text) |
|
{ |
|
if (!Q_stricmp(text, m_szComboAllText)) |
|
{ |
|
ComboBox *box = dynamic_cast<ComboBox *>(panel); |
|
if (box) |
|
{ |
|
box->SetText(""); |
|
text = ""; |
|
} |
|
} |
|
|
|
// get filter settings from controls |
|
UpdateFilterSettings(); |
|
|
|
// apply settings |
|
ApplyGameFilters(); |
|
|
|
if ( m_bFiltersVisible && ( panel == m_pGameFilter || panel == m_pLocationFilter ) && ServerBrowserDialog().IsVisible() ) |
|
{ |
|
// if they changed games and/or region then cancel the refresh because the old list they are getting |
|
// will be for the wrong game, so stop and start a refresh |
|
StopRefresh(); |
|
GetNewServerList(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: applies only the game filter to the current list |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::ApplyGameFilters() |
|
{ |
|
#if 0 |
|
if ( !steamapicontext->SteamMatchmakingServers() ) |
|
return; |
|
|
|
// loop through all the servers checking filters |
|
FOR_EACH_MAP_FAST( m_mapServers, i ) |
|
{ |
|
serverdisplay_t &server = m_mapServers[ i ]; |
|
gameserveritem_t *pServer = steamapicontext->SteamMatchmakingServers()->GetServerDetails( m_hRequest, server.m_iServerID ); |
|
if ( !pServer ) |
|
continue; |
|
|
|
if (!CheckPrimaryFilters( *pServer ) || !CheckSecondaryFilters( *pServer )) |
|
{ |
|
// server failed filtering, remove it |
|
server.m_bDoNotRefresh = true; |
|
if ( m_pGameList->IsValidItemID( server.m_iListID) ) |
|
{ |
|
// don't remove the server from list, just hide since this is a lot faster |
|
m_pGameList->SetItemVisible( server.m_iListID, false ); |
|
} |
|
} |
|
else if ( BShowServer( server ) ) |
|
{ |
|
// server passed filters, so it can be refreshed again |
|
server.m_bDoNotRefresh = false; |
|
|
|
// re-add item to list |
|
if ( !m_pGameList->IsValidItemID( server.m_iListID ) ) |
|
{ |
|
KeyValues *kv = new KeyValues("Server"); |
|
kv->SetString("name", pServer->GetName()); |
|
kv->SetString("map", pServer->m_szMap); |
|
kv->SetString("GameDir", pServer->m_szGameDir); |
|
kv->SetString( "GameTags", pServer->m_szGameTags ); |
|
if ( pServer->m_szGameDescription[0] ) |
|
{ |
|
kv->SetString("GameDesc", pServer->m_szGameDescription ); |
|
} |
|
else |
|
{ |
|
kv->SetWString("GameDesc", g_pVGuiLocalize->Find("#ServerBrowser_PendingPing")); |
|
} |
|
|
|
int nAdjustedForBotsPlayers = max( 0, pServer->m_nPlayers - pServer->m_nBotPlayers ); |
|
|
|
char buf[256]; |
|
Q_snprintf(buf, sizeof(buf), "%d / %d", nAdjustedForBotsPlayers, pServer->m_nMaxPlayers ); |
|
kv->SetString( "Players", buf); |
|
kv->SetInt( "Ping", pServer->m_nPing ); |
|
kv->SetInt( "password", pServer->m_bPassword ? m_nImageIndexPassword : 0); |
|
if ( pServer->m_nBotPlayers > 0 ) |
|
kv->SetInt("bots", pServer->m_nBotPlayers); |
|
else |
|
kv->SetString("bots", ""); |
|
|
|
kv->SetInt("Replay", IsReplayServer( *pServer ) ? m_nImageIndexReplay : 0); |
|
|
|
server.m_iListID = m_pGameList->AddItem(kv, server.m_iServerID, false, false); |
|
kv->deleteThis(); |
|
} |
|
|
|
// make sure the server is visible |
|
m_pGameList->SetItemVisible( server.m_iListID, true ); |
|
} |
|
} |
|
|
|
UpdateStatus(); |
|
m_pGameList->SortList(); |
|
InvalidateLayout(); |
|
Repaint(); |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Resets UI server count |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::UpdateStatus() |
|
{ |
|
if (m_pGameList->GetItemCount() > 1) |
|
{ |
|
wchar_t msg[256]; |
|
|
|
_snwprintf( msg, Q_ARRAYSIZE(msg), L"%S( %d )", g_pVGuiLocalize->Find( "#ServerBrowser_Servers"), m_pGameList->GetItemCount() ); |
|
m_pGameList->SetColumnHeaderText( k_nColumn_Name, msg); |
|
} |
|
else |
|
{ |
|
m_pGameList->SetColumnHeaderText( k_nColumn_Name, g_pVGuiLocalize->Find("#ServerBrowser_Servers")); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: gets filter settings from controls |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::UpdateFilterSettings() |
|
{ |
|
// game |
|
if ( ServerBrowserDialog().GetActiveModName() ) |
|
{ |
|
// overriding the game filter |
|
Q_strncpy(m_szGameFilter, ServerBrowserDialog().GetActiveModName(), sizeof(m_szGameFilter)); |
|
m_iLimitToAppID = ServerBrowserDialog().GetActiveAppID(); |
|
|
|
|
|
#ifdef STAGING_ONLY |
|
if ( sb_fake_app_id.GetInt() != 0 ) |
|
m_iLimitToAppID = CGameID( sb_fake_app_id.GetInt() ); |
|
#endif |
|
|
|
|
|
RecalculateFilterString(); |
|
UpdateGameFilter(); |
|
} |
|
else |
|
{ |
|
KeyValues *data = m_pGameFilter->GetActiveItemUserData(); |
|
if (data && Q_strlen( data->GetString( "gamedir" ) ) > 0 ) |
|
{ |
|
Q_strncpy( m_szGameFilter, data->GetString( "gamedir" ), sizeof( m_szGameFilter ) ); |
|
if ( Q_strlen( m_szGameFilter ) > 0 ) // if there is a gamedir |
|
{ |
|
m_iLimitToAppID = CGameID( data->GetUint64( "appid", 0 ) ); |
|
} |
|
else |
|
{ |
|
m_iLimitToAppID.Reset(); |
|
} |
|
} |
|
else |
|
{ |
|
m_iLimitToAppID.Reset(); |
|
m_szGameFilter[0] = 0; |
|
} |
|
m_pGameFilter->SetEnabled(true); |
|
} |
|
Q_strlower(m_szGameFilter); |
|
|
|
// map |
|
m_pMapFilter->GetText(m_szMapFilter, sizeof(m_szMapFilter) - 1); |
|
Q_strlower(m_szMapFilter); |
|
|
|
// max player |
|
char buf[256]; |
|
m_pMaxPlayerFilter->GetText(buf, sizeof(buf)); |
|
if (buf[0]) |
|
{ |
|
m_iMaxPlayerFilter = atoi(buf); |
|
} |
|
else |
|
{ |
|
m_iMaxPlayerFilter = 0; |
|
} |
|
|
|
// ping |
|
m_pPingFilter->GetText(buf, sizeof(buf)); |
|
if (buf[0]) |
|
{ |
|
m_iPingFilter = atoi(buf + 2); |
|
} |
|
else |
|
{ |
|
m_iPingFilter = 0; |
|
} |
|
|
|
// players |
|
m_bFilterNoFullServers = m_pNoFullServersFilterCheck->IsSelected(); |
|
m_bFilterNoEmptyServers = m_pNoEmptyServersFilterCheck->IsSelected(); |
|
m_bFilterNoPasswordedServers = m_pNoPasswordFilterCheck->IsSelected(); |
|
m_iSecureFilter = m_pSecureFilter->GetActiveItem(); |
|
|
|
if ( GameSupportsReplay() ) |
|
{ |
|
m_bFilterReplayServers = m_pReplayFilterCheck->IsSelected(); |
|
} |
|
else |
|
{ |
|
m_bFilterReplayServers = false; |
|
} |
|
|
|
m_vecServerFilters.RemoveAll(); |
|
|
|
bool bFilterNoEmpty = m_bFilterNoEmptyServers; |
|
bool bFilterNoFull = m_bFilterNoFullServers; |
|
bool bFilterNoPassword = m_bFilterNoPasswordedServers; |
|
int iFilterSecure = m_iSecureFilter; |
|
|
|
if ( m_pQuickList->IsVisible() == true ) |
|
{ |
|
bFilterNoEmpty = true; |
|
bFilterNoFull = true; |
|
bFilterNoPassword = true; |
|
iFilterSecure = FILTER_SECURESERVERSONLY; |
|
} |
|
|
|
extern IRunGameEngine *g_pRunGameEngine; |
|
if ( sb_filter_incompatible_versions.GetBool() && g_pRunGameEngine != NULL ) |
|
{ |
|
const char *pszVersion = g_pRunGameEngine->GetProductVersionString(); |
|
const char k_VersionFromP4[] = "2000"; // magic version string we use when we're running from P4 |
|
if ( pszVersion && *pszVersion && ( V_strcmp( pszVersion, k_VersionFromP4 ) != 0 ) ) |
|
{ |
|
m_vecServerFilters.AddToTail( MatchMakingKeyValuePair_t( "version_match", pszVersion ) ); |
|
} |
|
} |
|
|
|
// update master filter string text |
|
if (m_szGameFilter[0] && m_iLimitToAppID.AppID() != 1002 ) // HACKHACK: Alfred - don't use a dir filter for RDKF |
|
{ |
|
m_vecServerFilters.AddToTail( MatchMakingKeyValuePair_t( "gamedir", m_szGameFilter ) ); |
|
} |
|
if (bFilterNoEmpty) |
|
{ |
|
m_vecServerFilters.AddToTail( MatchMakingKeyValuePair_t( "empty", "1" ) ); |
|
} |
|
if (bFilterNoFull) |
|
{ |
|
m_vecServerFilters.AddToTail( MatchMakingKeyValuePair_t( "full", "1" ) ); |
|
} |
|
if (iFilterSecure == FILTER_SECURESERVERSONLY) |
|
{ |
|
m_vecServerFilters.AddToTail( MatchMakingKeyValuePair_t( "secure", "1" ) ); |
|
} |
|
int regCode = GetRegionCodeToFilter(); |
|
if ( ( regCode >= 0 ) && ( regCode < 255 ) ) |
|
{ |
|
char szRegCode[ 32 ]; |
|
Q_snprintf( szRegCode, sizeof(szRegCode), "%i", regCode ); |
|
m_vecServerFilters.AddToTail( MatchMakingKeyValuePair_t( "region", szRegCode ) ); |
|
} |
|
|
|
// copy filter settings into filter file |
|
KeyValues *filter = ServerBrowserDialog().GetFilterSaveData(GetName()); |
|
|
|
// only save the game filter if we're not overriding it |
|
if (!ServerBrowserDialog().GetActiveModName()) |
|
{ |
|
filter->SetString("game", m_szGameFilter); |
|
filter->SetUint64( "appid", m_iLimitToAppID.ToUint64() ); |
|
} |
|
|
|
filter->SetString("map", m_szMapFilter); |
|
filter->SetInt("MaxPlayerCount", m_iMaxPlayerFilter); |
|
filter->SetInt("ping", m_iPingFilter); |
|
|
|
if ( m_pLocationFilter->GetItemCount() > 1 ) |
|
{ |
|
// only save this if there are options to choose from |
|
filter->SetInt("location", m_pLocationFilter->GetActiveItem()); |
|
} |
|
|
|
filter->SetInt("NoFull", m_bFilterNoFullServers); |
|
filter->SetInt("NoEmpty", m_bFilterNoEmptyServers); |
|
filter->SetInt("NoPassword", m_bFilterNoPasswordedServers); |
|
filter->SetInt("Secure", m_iSecureFilter); |
|
filter->SetInt("QuickList", m_pQuickListCheckButton->IsSelected() ); |
|
filter->SetInt("tagsinclude", m_pTagsIncludeFilter->GetActiveItem() ); |
|
if ( m_pWorkshopFilter ) |
|
{ |
|
filter->SetInt("workshopfilter", m_pWorkshopFilter->GetActiveItem() ); |
|
} |
|
filter->SetInt("Replay", m_bFilterReplayServers); |
|
|
|
OnSaveFilter(filter); |
|
|
|
RecalculateFilterString(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: allow derived classes access to the saved filter string |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnSaveFilter(KeyValues *filter) |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: allow derived classes access to the saved filter string |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnLoadFilter(KeyValues *filter) |
|
{ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: reconstructs the filter description string from the current filter settings |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::RecalculateFilterString() |
|
{ |
|
wchar_t unicode[2048], tempUnicode[128], spacerUnicode[8]; |
|
unicode[0] = 0; |
|
int iTempUnicodeSize = sizeof( tempUnicode ); |
|
|
|
Q_UTF8ToUnicode( "; ", spacerUnicode, sizeof( spacerUnicode ) ); |
|
|
|
if (m_szGameFilter[0]) |
|
{ |
|
Q_UTF8ToUnicode( ModList().GetModNameForModDir( m_iLimitToAppID ), tempUnicode, iTempUnicodeSize ); |
|
wcscat( unicode, tempUnicode ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_iSecureFilter == FILTER_SECURESERVERSONLY) |
|
{ |
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescSecureOnly" ) ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
else if (m_iSecureFilter == FILTER_INSECURESERVERSONLY) |
|
{ |
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescInsecureOnly" ) ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_pLocationFilter->GetActiveItem() > 0) |
|
{ |
|
m_pLocationFilter->GetText(tempUnicode, sizeof(tempUnicode)); |
|
wcscat( unicode, tempUnicode ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_iPingFilter) |
|
{ |
|
char tmpBuf[16]; |
|
_snprintf( tmpBuf, sizeof(tmpBuf), "%d", m_iPingFilter ); |
|
|
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescLatency" ) ); |
|
Q_UTF8ToUnicode( " < ", tempUnicode, iTempUnicodeSize ); |
|
wcscat( unicode, tempUnicode ); |
|
Q_UTF8ToUnicode(tmpBuf, tempUnicode, iTempUnicodeSize ); |
|
wcscat( unicode, tempUnicode ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if ( m_iMaxPlayerFilter ) |
|
{ |
|
char tmpBuf[16]; |
|
_snprintf( tmpBuf, sizeof(tmpBuf), "%d", m_iMaxPlayerFilter ); |
|
|
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescMaxPlayers" ) ); |
|
Q_UTF8ToUnicode( " <= ", tempUnicode, iTempUnicodeSize ); |
|
wcscat( unicode, tempUnicode ); |
|
Q_UTF8ToUnicode(tmpBuf, tempUnicode, iTempUnicodeSize ); |
|
wcscat( unicode, tempUnicode ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_bFilterNoFullServers) |
|
{ |
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescNotFull" ) ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_bFilterNoEmptyServers) |
|
{ |
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescNotEmpty" ) ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_bFilterNoPasswordedServers) |
|
{ |
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescNoPassword" ) ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_bFilterReplayServers) |
|
{ |
|
wcscat( unicode, g_pVGuiLocalize->Find( "#ServerBrowser_FilterDescReplays" ) ); |
|
wcscat( unicode, spacerUnicode ); |
|
} |
|
|
|
if (m_szMapFilter[0]) |
|
{ |
|
Q_UTF8ToUnicode( m_szMapFilter, tempUnicode, iTempUnicodeSize ); |
|
wcscat( unicode, tempUnicode ); |
|
} |
|
|
|
m_pFilterString->SetText(unicode); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Checks to see if the server passes the primary filters |
|
// if the server fails the filters, it will not be refreshed again |
|
//----------------------------------------------------------------------------- |
|
bool CBaseGamesPage::CheckPrimaryFilters( newgameserver_t &server ) |
|
{ |
|
if (m_szGameFilter[0] && server.m_szGameDir[0] && Q_stricmp(m_szGameFilter, server.m_szGameDir ) ) |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Checks to see if a server passes the secondary set of filters |
|
// server will be continued to be pinged if it fails the filter, since |
|
// the relvent server data is dynamic |
|
//----------------------------------------------------------------------------- |
|
bool CBaseGamesPage::CheckSecondaryFilters( newgameserver_t &server ) |
|
{ |
|
bool bFilterNoEmpty = m_bFilterNoEmptyServers; |
|
bool bFilterNoFull = m_bFilterNoFullServers; |
|
int iFilterPing = m_iPingFilter; |
|
int iFilterMaxPlayerCount = m_iMaxPlayerFilter; |
|
bool bFilterNoPassword = m_bFilterNoPasswordedServers; |
|
int iFilterSecure = m_iSecureFilter; |
|
|
|
if ( m_pQuickList->IsVisible() == true ) |
|
{ |
|
bFilterNoEmpty = true; |
|
bFilterNoFull = true; |
|
iFilterPing = QUICKLIST_FILTER_MIN_PING; |
|
bFilterNoPassword = true; |
|
iFilterSecure = FILTER_SECURESERVERSONLY; |
|
iFilterMaxPlayerCount = sb_mod_suggested_maxplayers.GetInt(); |
|
} |
|
|
|
if ( bFilterNoEmpty && (server.m_nPlayers - server.m_nBotPlayers) < 1 ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( bFilterNoFull && server.m_nPlayers >= server.m_nMaxPlayers ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( iFilterPing && server.m_nPing > iFilterPing ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( iFilterMaxPlayerCount && server.m_nMaxPlayers > iFilterMaxPlayerCount ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( bFilterNoPassword && server.m_bPassword ) |
|
{ |
|
return false; |
|
} |
|
|
|
/*if ( iFilterSecure == FILTER_SECURESERVERSONLY && !server.m_bSecure ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( iFilterSecure == FILTER_INSECURESERVERSONLY && server.m_bSecure ) |
|
{ |
|
return false; |
|
} |
|
|
|
if ( m_bFilterReplayServers && !IsReplayServer( server ) ) |
|
{ |
|
return false; |
|
}*/ |
|
|
|
if ( m_pQuickList->IsVisible() == false ) |
|
{ |
|
// compare the first few characters of the filter name |
|
int count = Q_strlen( m_szMapFilter ); |
|
if ( count && Q_strnicmp( server.m_szMap, m_szMapFilter, count ) ) |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
return CheckTagFilter( server ) && CheckWorkshopFilter( server ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
uint32 CBaseGamesPage::GetServerFilters( MatchMakingKeyValuePair_t **pFilters ) |
|
{ |
|
*pFilters = m_vecServerFilters.Base(); |
|
return m_vecServerFilters.Count(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: call to let the UI now whether the game list is currently refreshing |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::SetRefreshing(bool state) |
|
{ |
|
if (state) |
|
{ |
|
ServerBrowserDialog().UpdateStatusText("#ServerBrowser_RefreshingServerList"); |
|
|
|
// clear message in panel |
|
m_pGameList->SetEmptyListText(""); |
|
m_pRefreshAll->SetText("#ServerBrowser_StopRefreshingList"); |
|
m_pRefreshAll->SetCommand("stoprefresh"); |
|
m_pRefreshQuick->SetEnabled(false); |
|
} |
|
else |
|
{ |
|
ServerBrowserDialog().UpdateStatusText(""); |
|
if (SupportsItem(IGameList::GETNEWLIST)) |
|
{ |
|
m_pRefreshAll->SetText("#ServerBrowser_RefreshAll"); |
|
} |
|
else |
|
{ |
|
m_pRefreshAll->SetText("#ServerBrowser_Refresh"); |
|
} |
|
m_pRefreshAll->SetCommand("GetNewList"); |
|
|
|
// 'refresh quick' button is only enabled if there are servers in the list |
|
if (m_pGameList->GetItemCount() > 0) |
|
{ |
|
m_pRefreshQuick->SetEnabled(true); |
|
} |
|
else |
|
{ |
|
m_pRefreshQuick->SetEnabled(false); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnCommand(const char *command) |
|
{ |
|
if (!Q_stricmp(command, "Connect")) |
|
{ |
|
OnBeginConnect(); |
|
} |
|
else if (!Q_stricmp(command, "stoprefresh")) |
|
{ |
|
// cancel the existing refresh |
|
StopRefresh(); |
|
} |
|
else if ( !Q_stricmp(command, "refresh") ) |
|
{ |
|
if ( steamapicontext->SteamMatchmakingServers() ) |
|
steamapicontext->SteamMatchmakingServers()->RefreshQuery( m_hRequest ); |
|
SetRefreshing( true ); |
|
m_iServerRefreshCount = 0; |
|
ClearQuickList(); |
|
} |
|
else if (!Q_stricmp(command, "GetNewList")) |
|
{ |
|
GetNewServerList(); |
|
} |
|
else |
|
{ |
|
BaseClass::OnCommand(command); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: called when a row gets selected in the list |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnItemSelected() |
|
{ |
|
if ( GetSelectedServerID() == -1 ) |
|
{ |
|
m_pConnect->SetEnabled(false); |
|
} |
|
else |
|
{ |
|
m_pConnect->SetEnabled(true); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: refreshes server list on F5 |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnKeyCodePressed(vgui::KeyCode code) |
|
{ |
|
if ( code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A ) |
|
{ |
|
m_pConnect->DoClick(); |
|
} |
|
else if ( code == KEY_F5 || code == KEY_XBUTTON_X || code == STEAMCONTROLLER_X ) |
|
{ |
|
StartRefresh(); |
|
} |
|
else if ( m_pGameList->GetItemCount() > 0 && |
|
( code == KEY_XBUTTON_UP || code == KEY_XSTICK1_UP || code == KEY_XSTICK2_UP || code == STEAMCONTROLLER_DPAD_UP || |
|
code == KEY_XBUTTON_DOWN || code == KEY_XSTICK1_DOWN || code == KEY_XSTICK2_DOWN || code == STEAMCONTROLLER_DPAD_DOWN ) ) |
|
{ |
|
m_pGameList->RequestFocus(); |
|
} |
|
else |
|
{ |
|
BaseClass::OnKeyCodePressed(code); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handle enter pressed in the games list page. Return true |
|
// to intercept the message instead of passing it on through vgui. |
|
//----------------------------------------------------------------------------- |
|
bool CBaseGamesPage::OnGameListEnterPressed() |
|
{ |
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the # items selected in the game list. |
|
//----------------------------------------------------------------------------- |
|
int CBaseGamesPage::GetSelectedItemsCount() |
|
{ |
|
return m_pGameList->GetSelectedItemsCount(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: adds a server to the favorites |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnAddToFavorites() |
|
{ |
|
if ( !steamapicontext->SteamMatchmakingServers() ) |
|
return; |
|
|
|
// loop through all the selected favorites |
|
for (int i = 0; i < m_pGameList->GetSelectedItemsCount(); i++) |
|
{ |
|
int serverID = m_pGameList->GetItemUserData(m_pGameList->GetSelectedItem(i)); |
|
|
|
gameserveritem_t *pServer = steamapicontext->SteamMatchmakingServers()->GetServerDetails( m_hRequest, serverID ); |
|
if ( pServer ) |
|
{ |
|
// add to favorites list |
|
ServerBrowserDialog().AddServerToFavorites(*pServer); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
#if 0 |
|
void CBaseGamesPage::ServerFailedToRespond( HServerListRequest hReq, int iServer ) |
|
{ |
|
ServerResponded( hReq, iServer ); |
|
} |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: removes the server from the UI list |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::RemoveServer( serverdisplay_t &server ) |
|
{ |
|
if ( m_pGameList->IsValidItemID( server.m_iListID ) ) |
|
{ |
|
// don't remove the server from list, just hide since this is a lot faster |
|
m_pGameList->SetItemVisible( server.m_iListID, false ); |
|
|
|
// find the row in the list and kill |
|
// m_pGameList->RemoveItem(server.listEntryID); |
|
// server.listEntryID = GetInvalidServerListID(); |
|
} |
|
|
|
UpdateStatus(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: refreshes a single server |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnRefreshServer( int serverID ) |
|
{ |
|
if ( !steamapicontext->SteamMatchmakingServers() ) |
|
return; |
|
|
|
// walk the list of selected servers refreshing them |
|
for (int i = 0; i < m_pGameList->GetSelectedItemsCount(); i++) |
|
{ |
|
int serverID = m_pGameList->GetItemUserData(m_pGameList->GetSelectedItem(i)); |
|
|
|
// refresh this server |
|
steamapicontext->SteamMatchmakingServers()->RefreshServer( m_hRequest, serverID ); |
|
} |
|
|
|
SetRefreshing(IsRefreshing()); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: starts the servers refreshing |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::StartRefresh() |
|
{ |
|
ClearServerList(); |
|
MatchMakingKeyValuePair_t *pFilters; |
|
int nFilters = GetServerFilters( &pFilters ); |
|
|
|
/* if ( m_hRequest ) |
|
{ |
|
steamapicontext->SteamMatchmakingServers()->ReleaseRequest( m_hRequest ); |
|
m_hRequest = NULL; |
|
}*/ |
|
switch ( m_eMatchMakingType ) |
|
{ |
|
/* case eFavoritesServer: |
|
m_hRequest = steamapicontext->SteamMatchmakingServers()->RequestFavoritesServerList( GetFilterAppID().AppID(), &pFilters, nFilters, this ); |
|
break; |
|
case eHistoryServer: |
|
m_hRequest = steamapicontext->SteamMatchmakingServers()->RequestHistoryServerList( GetFilterAppID().AppID(), &pFilters, nFilters, this ); |
|
break;*/ |
|
case eInternetServer: |
|
Msg("RequestInternetServerList\n"); |
|
g_pServersInfo->RequestInternetServerList(COM_GetModDirectory(), this); |
|
//m_hRequest = steamapicontext->SteamMatchmakingServers()->RequestInternetServerList( GetFilterAppID().AppID(), &pFilters, nFilters, this ); |
|
break; |
|
/* case eSpectatorServer: |
|
m_hRequest = steamapicontext->SteamMatchmakingServers()->RequestSpectatorServerList( GetFilterAppID().AppID(), &pFilters, nFilters, this ); |
|
break; |
|
case eLANServer: |
|
m_hRequest = steamapicontext->SteamMatchmakingServers()->RequestLANServerList( GetFilterAppID().AppID(), this ); |
|
break; |
|
default: |
|
Assert( !"Unknown server type" ); |
|
break;*/ |
|
} |
|
|
|
SetRefreshing( true ); |
|
|
|
m_iServerRefreshCount = 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::ClearQuickList( void ) |
|
{ |
|
m_pQuickList->DeleteAllItems(); |
|
m_vecMapNamesFound.RemoveAll(); |
|
|
|
int iIndex = m_quicklistserverlist.First(); |
|
|
|
while ( iIndex != m_quicklistserverlist.InvalidIndex() ) |
|
{ |
|
CQuickListMapServerList *vecMapServers = &m_quicklistserverlist[iIndex]; |
|
|
|
vecMapServers->RemoveAll(); |
|
|
|
iIndex = m_quicklistserverlist.Next( iIndex ); |
|
} |
|
|
|
m_quicklistserverlist.RemoveAll(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Remove all the servers we currently have |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::ClearServerList() |
|
{ |
|
m_mapServers.RemoveAll(); |
|
m_mapServerIP.RemoveAll(); |
|
m_pGameList->RemoveAll(); |
|
|
|
ClearQuickList(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: get a new list of servers from the backend |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::GetNewServerList() |
|
{ |
|
StartRefresh(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: stops current refresh/GetNewServerList() |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::StopRefresh() |
|
{ |
|
// clear update states |
|
m_iServerRefreshCount = 0; |
|
|
|
// Stop the server list refreshing |
|
if ( steamapicontext->SteamMatchmakingServers() ) |
|
steamapicontext->SteamMatchmakingServers()->CancelQuery( m_hRequest ); |
|
|
|
// update UI |
|
RefreshComplete( nServerResponded ); |
|
|
|
// apply settings |
|
ApplyGameFilters(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::RefreshComplete( NServerResponse response ) |
|
{ |
|
SelectQuickListServers(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: returns true if the list is currently refreshing servers |
|
//----------------------------------------------------------------------------- |
|
bool CBaseGamesPage::IsRefreshing() |
|
{ |
|
return steamapicontext->SteamMatchmakingServers() && steamapicontext->SteamMatchmakingServers()->IsRefreshing( m_hRequest ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Activates the page, starts refresh |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnPageShow() |
|
{ |
|
StartRefresh(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called on page hide, stops any refresh |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnPageHide() |
|
{ |
|
StopRefresh(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
vgui::Panel *CBaseGamesPage::GetActiveList( void ) |
|
{ |
|
if ( m_pQuickList->IsVisible() ) |
|
return m_pQuickList; |
|
|
|
return m_pGameList; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
int CBaseGamesPage::GetSelectedServerID( KeyValues **pKV ) |
|
{ |
|
int serverID = -1; |
|
if ( pKV ) |
|
{ |
|
*pKV = NULL; |
|
} |
|
|
|
if ( m_pQuickList->IsVisible() == true ) |
|
{ |
|
if ( IsRefreshing() == true ) |
|
return -1; |
|
|
|
if ( m_pQuickList->GetSelectedPanel() ) |
|
{ |
|
CQuickListPanel *pQuickPanel = dynamic_cast<CQuickListPanel*>( m_pQuickList->GetSelectedPanel() ); |
|
|
|
if ( pQuickPanel ) |
|
{ |
|
serverID = m_pGameList->GetItemUserData( pQuickPanel->GetListID() ); |
|
if ( pKV ) |
|
{ |
|
*pKV = m_pGameList->GetItem( pQuickPanel->GetListID() ); |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if (!m_pGameList->GetSelectedItemsCount()) |
|
return -1; |
|
|
|
// get the server |
|
serverID = m_pGameList->GetItemUserData( m_pGameList->GetSelectedItem(0) ); |
|
|
|
if ( pKV ) |
|
{ |
|
*pKV = m_pGameList->GetItem( m_pGameList->GetSelectedItem(0) ); |
|
} |
|
} |
|
|
|
return serverID; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Dialog which warns the user about the server they're joining |
|
//----------------------------------------------------------------------------- |
|
class CDialogServerWarning : public vgui::Frame |
|
{ |
|
DECLARE_CLASS_SIMPLE( CDialogServerWarning, vgui::Frame ); |
|
public: |
|
CDialogServerWarning(vgui::Panel *parent, IGameList *gameList, int serverID ); |
|
|
|
virtual void ApplySchemeSettings( vgui::IScheme *pScheme ); |
|
virtual void OnCommand(const char *command); |
|
|
|
MESSAGE_FUNC_PTR_INT( OnButtonToggled, "ButtonToggled", panel, state ); |
|
|
|
private: |
|
IGameList *m_pGameList; |
|
int m_iServerID; |
|
vgui::CheckButton *m_pDontShowThisAgainCheckButton; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
// Input : *gameList - game list to add specified server to |
|
//----------------------------------------------------------------------------- |
|
CDialogServerWarning::CDialogServerWarning(vgui::Panel *parent, IGameList *gameList, int serverID ) : Frame(parent, "DialogServerWarning") |
|
{ |
|
m_pGameList = gameList; |
|
m_iServerID = serverID; |
|
|
|
m_pDontShowThisAgainCheckButton = new CheckButton(this, "DontShowThisAgainCheckbutton", ""); |
|
|
|
SetDeleteSelfOnClose(true); |
|
SetSizeable( false ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CDialogServerWarning::ApplySchemeSettings( IScheme *pScheme ) |
|
{ |
|
BaseClass::ApplySchemeSettings( pScheme ); |
|
|
|
LoadControlSettings("Servers/DialogServerWarning.res"); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: button command handler |
|
//----------------------------------------------------------------------------- |
|
void CDialogServerWarning::OnCommand(const char *command) |
|
{ |
|
if ( Q_stricmp(command, "OK") == 0 ) |
|
{ |
|
// mark ourselves to be closed |
|
PostMessage(this, new KeyValues("Close")); |
|
|
|
// join the game |
|
//ServerBrowserDialog().JoinGame( m_pGameList, m_iServerID ); |
|
} |
|
else |
|
{ |
|
BaseClass::OnCommand(command); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Handles filter dropdown being toggled |
|
//----------------------------------------------------------------------------- |
|
void CDialogServerWarning::OnButtonToggled(Panel *panel, int state) |
|
{ |
|
ConVarRef sb_dontshow_maxplayer_warning( "sb_dontshow_maxplayer_warning", true ); |
|
if ( sb_dontshow_maxplayer_warning.IsValid() ) |
|
{ |
|
sb_dontshow_maxplayer_warning.SetValue( state ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: initiates server connection |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnBeginConnect() |
|
{ |
|
KeyValues *pKV = NULL; |
|
int iServerIndex = GetSelectedServerID( &pKV ); |
|
|
|
if ( iServerIndex == -1 ) |
|
return; |
|
|
|
// Stop the current refresh |
|
StopRefresh(); |
|
|
|
ConVarRef sb_dontshow_maxplayer_warning( "sb_dontshow_maxplayer_warning", true ); |
|
/* if ( sb_dontshow_maxplayer_warning.IsValid() ) |
|
{ |
|
// If the server is above the suggested maxplayers, warn the player |
|
int iMaxP = sb_mod_suggested_maxplayers.GetInt(); |
|
if ( iMaxP && pKV && !sb_dontshow_maxplayer_warning.GetBool() ) |
|
{ |
|
int iMaxCount = pKV->GetInt( "MaxPlayerCount", 0 ); |
|
if ( iMaxCount > iMaxP ) |
|
{ |
|
CDialogServerWarning *dlg = vgui::SETUP_PANEL( new CDialogServerWarning( this, this, serverID ) ); |
|
dlg->MoveToCenterOfScreen(); |
|
dlg->DoModal(); |
|
|
|
wchar_t wszWarning[512]; |
|
wchar_t wszServerMaxPlayers[12]; |
|
wchar_t wszDesignedMaxPlayers[12]; |
|
wchar_t wszGameName[256]; |
|
_snwprintf( wszServerMaxPlayers, Q_ARRAYSIZE(wszServerMaxPlayers), L"%d", iMaxCount ); |
|
_snwprintf( wszDesignedMaxPlayers, Q_ARRAYSIZE(wszDesignedMaxPlayers), L"%d", iMaxP ); |
|
Q_UTF8ToUnicode( ModList().GetModNameForModDir( m_iLimitToAppID ), wszGameName, Q_ARRAYSIZE(wszGameName) ); |
|
g_pVGuiLocalize->ConstructString( wszWarning, sizeof( wszWarning ), g_pVGuiLocalize->Find( "#ServerBrowser_ServerWarning_MaxPlayers"), 4, wszServerMaxPlayers, wszGameName, wszDesignedMaxPlayers, wszDesignedMaxPlayers ); |
|
dlg->SetDialogVariable( "warning", wszWarning ); |
|
|
|
return; |
|
} |
|
} |
|
}*/ |
|
|
|
// join the game |
|
ServerBrowserDialog().JoinGame(this, &m_serversInfo[iServerIndex]); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Displays the current game info without connecting |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnViewGameInfo() |
|
{ |
|
int serverID = GetSelectedServerID(); |
|
|
|
if ( serverID == -1 ) |
|
return; |
|
|
|
// Stop the current refresh |
|
StopRefresh(); |
|
|
|
// join the game |
|
//ServerBrowserDialog().OpenGameInfoDialog(this, serverID); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Return code to use for tracking how people are connecting to servers |
|
//----------------------------------------------------------------------------- |
|
const char *CBaseGamesPage::GetConnectCode() |
|
{ |
|
// Determine code to use, for the "connect" command. |
|
// |
|
// E.g.: "connect serverbrowser" (This command primarily exists so i can grep the code....) |
|
|
|
const char *pszConnectCode = "serverbrowser"; |
|
switch ( m_eMatchMakingType ) |
|
{ |
|
default: |
|
AssertMsg1( false, "Unknown matchmaking type %d", m_eMatchMakingType ); |
|
break; |
|
|
|
case eInternetServer: |
|
pszConnectCode = "serverbrowser_internet"; |
|
break; |
|
case eLANServer: |
|
pszConnectCode = "serverbrowser_lan"; |
|
break; |
|
case eFavoritesServer: |
|
pszConnectCode = "serverbrowser_favorites"; |
|
break; |
|
case eHistoryServer: |
|
pszConnectCode = "serverbrowser_history"; |
|
break; |
|
case eSpectatorServer: |
|
pszConnectCode = "serverbrowser_spectator"; |
|
break; |
|
}; |
|
|
|
return pszConnectCode; |
|
} |
|
|
|
void CBaseGamesPage::ServerResponded( newgameserver_t &server ) |
|
{ |
|
Assert( server.m_NetAdr.GetIPHostByteOrder() != 0 ); |
|
|
|
newgameserver_t *pServerItem = &server; |
|
|
|
// check filters |
|
bool removeItem = false; |
|
#if 0 |
|
if ( !CheckPrimaryFilters( server ) ) |
|
{ |
|
// server has been filtered at a primary level |
|
// remove from lists |
|
//pServer->m_bDoNotRefresh = true; |
|
|
|
// remove from UI list |
|
//removeItem = true; |
|
return; |
|
} |
|
else if (!CheckSecondaryFilters( server )) |
|
{ |
|
// we still ping this server in the future; however it is removed from UI list |
|
return; |
|
} |
|
#endif |
|
|
|
// new entry |
|
KeyValues *kv = new KeyValues("Server"); |
|
|
|
kv->SetString("name", pServerItem->m_szServerName); |
|
kv->SetString("map", pServerItem->m_szMap); |
|
kv->SetString("GameDir", pServerItem->m_szGameDir); |
|
kv->SetString("GameDesc", pServerItem->m_szGameDescription); |
|
kv->SetInt("password", pServerItem->m_bPassword ? m_nImageIndexPassword : 0); |
|
|
|
if ( pServerItem->m_nBotPlayers > 0 ) |
|
kv->SetInt("bots", pServerItem->m_nBotPlayers); |
|
else |
|
kv->SetString("bots", ""); |
|
|
|
|
|
kv->SetInt("secure", 0); |
|
|
|
kv->SetString( "IPAddr", pServerItem->m_NetAdr.ToString() ); |
|
|
|
int nAdjustedForBotsPlayers = max( 0, pServerItem->m_nPlayers - pServerItem->m_nBotPlayers ); |
|
|
|
char buf[32]; |
|
Q_snprintf(buf, sizeof(buf), "%d / %d", nAdjustedForBotsPlayers, pServerItem->m_nMaxPlayers ); |
|
kv->SetString("Players", buf); |
|
|
|
kv->SetInt("PlayerCount", nAdjustedForBotsPlayers ); |
|
kv->SetInt("MaxPlayerCount", pServerItem->m_nMaxPlayers ); |
|
|
|
kv->SetInt("Ping", pServerItem->m_nPing); |
|
|
|
kv->SetString("Tags", ""); |
|
|
|
kv->SetInt("Replay", 0); |
|
|
|
/* if ( pServerItem->m_ulTimeLastPlayed ) |
|
{ |
|
// construct a time string for last played time |
|
struct tm *now; |
|
now = localtime( (time_t*)&pServerItem->m_ulTimeLastPlayed ); |
|
|
|
if ( now ) |
|
{ |
|
char buf[64]; |
|
strftime(buf, sizeof(buf), "%a %d %b %I:%M%p", now); |
|
Q_strlower(buf + strlen(buf) - 4); |
|
kv->SetString("LastPlayed", buf); |
|
} |
|
}*/ |
|
|
|
int iServerIndex = m_serversInfo.AddToTail( server ); |
|
|
|
//if ( !m_pGameList->IsValidItemID( pServer->m_iListID ) ) |
|
|
|
// new server, add to list |
|
int iListID = m_pGameList->AddItem(kv, iServerIndex, false, false); |
|
/*if ( m_bAutoSelectFirstItemInGameList && m_pGameList->GetItemCount() == 1 ) |
|
{ |
|
m_pGameList->AddSelectedItem( pServer->m_iListID ); |
|
}*/ |
|
|
|
m_pGameList->SetItemVisible( iListID, true ); |
|
|
|
kv->deleteThis(); |
|
|
|
/* else |
|
{ |
|
// tell the list that we've changed the data |
|
m_pGameList->ApplyItemChanges( pServer->m_iListID ); |
|
m_pGameList->SetItemVisible( pServer->m_iListID, !removeItem ); |
|
}*/ |
|
|
|
PrepareQuickListMap( pServerItem->m_szMap, iListID ); |
|
UpdateStatus(); |
|
m_iServerRefreshCount++; |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Refresh if our favorites list changed |
|
//----------------------------------------------------------------------------- |
|
void CBaseGamesPage::OnFavoritesMsg( FavoritesListChanged_t *pFavListChanged ) |
|
{ |
|
if ( !pFavListChanged->m_nIP ) // a zero for IP means the whole list was reloaded and we need to reload |
|
{ |
|
switch ( m_eMatchMakingType ) |
|
{ |
|
case eInternetServer: |
|
case eLANServer: |
|
case eSpectatorServer: |
|
case eFavoritesServer: |
|
case eHistoryServer: |
|
// check containing property sheet to see if the page is visible. |
|
// if not, don't bother initiating a server list grab right now - |
|
// it will happen when the dialog is activated later. |
|
if ( reinterpret_cast< PropertySheet* >( GetParent() )->GetActivePage() == this && |
|
GetParent()->IsVisible() && ServerBrowserDialog().IsVisible() ) |
|
{ |
|
GetNewServerList(); |
|
} |
|
return; |
|
default: |
|
Assert( !"unknown matchmaking type" ); |
|
} |
|
return; |
|
} |
|
|
|
switch ( m_eMatchMakingType ) |
|
{ |
|
case eInternetServer: |
|
case eLANServer: |
|
case eSpectatorServer: |
|
case eFavoritesServer: |
|
case eHistoryServer: |
|
{ |
|
int iIPServer = m_mapServerIP.Find( netadr_t( pFavListChanged->m_nIP, pFavListChanged->m_nConnPort ) ); |
|
if ( iIPServer == m_mapServerIP.InvalidIndex() ) |
|
{ |
|
if ( pFavListChanged->m_bAdd ) |
|
{ |
|
|
|
// TODO(nillerusr): implement this |
|
// if ( steamapicontext->SteamMatchmakingServers() ) |
|
// steamapicontext->SteamMatchmakingServers()->PingServer( pFavListChanged->m_nIP, pFavListChanged->m_nQueryPort, this ); |
|
} |
|
// ignore deletes of fav's we didn't have |
|
} |
|
else |
|
{ |
|
if ( pFavListChanged->m_bAdd ) |
|
{ |
|
// if ( m_mapServerIP[ iIPServer ] > 0 ) |
|
// ServerResponded( m_hRequest, m_mapServerIP[ iIPServer ] ); |
|
} |
|
else |
|
{ |
|
int iServer = m_mapServers.Find( m_mapServerIP[ iIPServer ] ); |
|
serverdisplay_t &server = m_mapServers[ iServer ]; |
|
RemoveServer( server ); |
|
} |
|
} |
|
} |
|
break; |
|
default: |
|
Assert( !"unknown matchmaking type" ); |
|
}; |
|
} |
|
|
|
void CCheckBoxWithStatus::OnCursorEntered() |
|
{ |
|
ServerBrowserDialog().UpdateStatusText("#ServerBrowser_QuickListExplanation"); |
|
} |
|
|
|
void CCheckBoxWithStatus::OnCursorExited() |
|
{ |
|
ServerBrowserDialog().UpdateStatusText(""); |
|
}
|
|
|