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.
3006 lines
100 KiB
3006 lines
100 KiB
5 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
|
//
|
||
|
|
// Purpose:
|
||
|
|
//
|
||
|
|
// $NoKeywords: $
|
||
|
|
//=============================================================================
|
||
|
|
#include "cbase.h"
|
||
|
|
|
||
|
|
// for messaging with the GC
|
||
|
|
#include "tf_gcmessages.h"
|
||
|
|
#include "tf_item_inventory.h"
|
||
|
|
#include "econ_game_account_server.h"
|
||
|
|
#include "gc_clientsystem.h"
|
||
|
|
#include "tf_quickplay.h"
|
||
|
|
|
||
|
|
// ui related
|
||
|
|
#include "filesystem.h"
|
||
|
|
#include "tf_controls.h"
|
||
|
|
#include "clientmode_tf.h"
|
||
|
|
#include "confirm_dialog.h"
|
||
|
|
#include "econ_controls.h"
|
||
|
|
#include "game/client/iviewport.h"
|
||
|
|
#include "ienginevgui.h"
|
||
|
|
#include "tf_hud_mainmenuoverride.h"
|
||
|
|
#include "tf_hud_statpanel.h"
|
||
|
|
#include "tf_mouseforwardingpanel.h"
|
||
|
|
#include "vgui/ILocalize.h"
|
||
|
|
#include "vgui/ISurface.h"
|
||
|
|
#include "vgui_controls/PanelListPanel.h"
|
||
|
|
#include "vgui_controls/ProgressBar.h"
|
||
|
|
#include "vgui_controls/RadioButton.h"
|
||
|
|
#include "ServerBrowser/blacklisted_server_manager.h"
|
||
|
|
#include "rtime.h"
|
||
|
|
|
||
|
|
#include "c_tf_gamestats.h"
|
||
|
|
#include "tf_gamerules.h"
|
||
|
|
#include "ServerBrowser/IServerBrowser.h"
|
||
|
|
|
||
|
|
// other
|
||
|
|
#include "tier1/netadr.h"
|
||
|
|
|
||
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
||
|
|
#include <tier0/memdbgon.h>
|
||
|
|
|
||
|
|
const char *COM_GetModDirectory();
|
||
|
|
extern int g_iQuickplaySessionIndex;
|
||
|
|
|
||
|
|
#include "tf_matchmaking_scoring.h"
|
||
|
|
|
||
|
|
ConVar tf_matchmaking_debug( "tf_matchmaking_spew_level",
|
||
|
|
#ifdef _DEBUG
|
||
|
|
"3",
|
||
|
|
#else
|
||
|
|
"1",
|
||
|
|
#endif
|
||
|
|
FCVAR_NONE, "Set to 1 for basic console spew of quickplay-related decisions. 4 for maximum verbosity." );
|
||
|
|
|
||
|
|
ConVar tf_quickplay_pref_community_servers( "tf_quickplay_pref_community_servers", "0", FCVAR_ARCHIVE, "0=Valve only, 1=Community only, 2=Either" );
|
||
|
|
|
||
|
|
#define TF_MATCHMAKING_SPEW( lvl, pStrFmt, ...) \
|
||
|
|
if ( tf_matchmaking_debug.GetInt() >= lvl ) \
|
||
|
|
{ \
|
||
|
|
Msg( pStrFmt, ##__VA_ARGS__ ); \
|
||
|
|
}
|
||
|
|
|
||
|
|
// Hack to force it to search for other app ID's for testing
|
||
|
|
static inline int GetTfMatchmakingAppID()
|
||
|
|
{
|
||
|
|
// !TEST!
|
||
|
|
#ifdef STAGING_ONLY
|
||
|
|
ConVarRef sb_fake_app_id( "sb_fake_app_id" );
|
||
|
|
if ( sb_fake_app_id.GetInt() != 0 )
|
||
|
|
return sb_fake_app_id.GetInt();
|
||
|
|
#endif
|
||
|
|
// return 440;
|
||
|
|
|
||
|
|
return engine->GetAppID();
|
||
|
|
}
|
||
|
|
|
||
|
|
// A server that we recently were matched to and attempted to join
|
||
|
|
struct RecentlyMatchedServer
|
||
|
|
{
|
||
|
|
uint32 m_ip;
|
||
|
|
uint16 m_port;
|
||
|
|
RTime32 m_timeMatched;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Just store them in a simple list. This will be small, and it won't hurt
|
||
|
|
// to scan the whole thing, so it won't do any good to do anything fancy
|
||
|
|
static CUtlVector<RecentlyMatchedServer> s_vecRecentlyMatchedServers;
|
||
|
|
|
||
|
|
// Search for a recently matched server. Also process cooldown expiry
|
||
|
|
static int FindRecentlyMatchedServer( uint32 ip, uint16 port )
|
||
|
|
{
|
||
|
|
RTime32 timeOfOldestEntryToKeep = CRTime::RTime32TimeCur() - tf_matchmaking_retry_cooldown_seconds.GetInt();
|
||
|
|
int i = 0;
|
||
|
|
int result = -1;
|
||
|
|
while ( i < s_vecRecentlyMatchedServers.Count() )
|
||
|
|
{
|
||
|
|
// Expire?
|
||
|
|
if ( s_vecRecentlyMatchedServers[i].m_timeMatched < timeOfOldestEntryToKeep )
|
||
|
|
{
|
||
|
|
DevLog(" Expiring quickplay recently joined server entry %08X:%d\n", s_vecRecentlyMatchedServers[i].m_ip, (int)s_vecRecentlyMatchedServers[i].m_port );
|
||
|
|
s_vecRecentlyMatchedServers.Remove( i );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Address match?
|
||
|
|
if ( s_vecRecentlyMatchedServers[i].m_ip == ip && s_vecRecentlyMatchedServers[i].m_port == port )
|
||
|
|
{
|
||
|
|
Assert( result < 0 ); // dups in the list?
|
||
|
|
result = i;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Record is still active. Keep it
|
||
|
|
++i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Return index of the entry we found, if any
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
ConVar tf_quickplay_pref_increased_maxplayers( "tf_quickplay_pref_increased_maxplayers", "0", FCVAR_ARCHIVE, "0=Default only, 1=Yes, 2=Don't care" );
|
||
|
|
ConVar tf_quickplay_pref_disable_random_crits( "tf_quickplay_pref_disable_random_crits", "0", FCVAR_ARCHIVE, "0=Random crits enabled, 1=Random crits disabled, 2=Don't care" );
|
||
|
|
ConVar tf_quickplay_pref_enable_damage_spread( "tf_quickplay_pref_enable_damage_spread", "0", FCVAR_ARCHIVE, "0=Damage spread disabled, 1=Damage spread enabled, 2=Don't care" );
|
||
|
|
ConVar tf_quickplay_pref_respawn_times( "tf_quickplay_pref_respawn_times", "0", FCVAR_ARCHIVE, "0=Default respawn times only, 1=Instant respawn times ('norespawn' tag), 2=Don't care" );
|
||
|
|
ConVar tf_quickplay_pref_advanced_view( "tf_quickplay_pref_advanced_view", "0", FCVAR_NONE, "0=Default to simplified view, 1=Default to more detailed options view" );
|
||
|
|
ConVar tf_quickplay_pref_beta_content( "tf_quickplay_pref_beta_content", "0", FCVAR_ARCHIVE, "0=No beta content, 1=Only beta content" );
|
||
|
|
|
||
|
|
|
||
|
|
static bool BHasTag( const CUtlStringList &TagList, const char *tag )
|
||
|
|
{
|
||
|
|
for ( int i = 0; i < TagList.Count(); i++ )
|
||
|
|
{
|
||
|
|
if ( !Q_stricmp( TagList[i], tag) )
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void GetQuickplayTags( const QuickplaySearchOptions &opt, CUtlStringList &requiredTags, CUtlStringList &illegalTags )
|
||
|
|
{
|
||
|
|
// Always required
|
||
|
|
requiredTags.CopyAndAddToTail( "_registered" );
|
||
|
|
|
||
|
|
// Always illegal
|
||
|
|
illegalTags.CopyAndAddToTail( "friendlyfire" );
|
||
|
|
illegalTags.CopyAndAddToTail( "highlander" );
|
||
|
|
illegalTags.CopyAndAddToTail( "noquickplay" );
|
||
|
|
illegalTags.CopyAndAddToTail( "trade" );
|
||
|
|
|
||
|
|
switch ( opt.m_eRespawnTimes )
|
||
|
|
{
|
||
|
|
case QuickplaySearchOptions::eRespawnTimesDefault:
|
||
|
|
illegalTags.CopyAndAddToTail( "respawntimes" );
|
||
|
|
illegalTags.CopyAndAddToTail( "norespawntime" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QuickplaySearchOptions::eRespawnTimesInstant:
|
||
|
|
requiredTags.CopyAndAddToTail( "norespawntime" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
case QuickplaySearchOptions::eRespawnTimesDontCare:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch ( opt.m_eRandomCrits )
|
||
|
|
{
|
||
|
|
case QuickplaySearchOptions::eRandomCritsYes:
|
||
|
|
illegalTags.CopyAndAddToTail( "nocrits" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QuickplaySearchOptions::eRandomCritsNo:
|
||
|
|
requiredTags.CopyAndAddToTail( "nocrits" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
case QuickplaySearchOptions::eRandomCritsDontCare:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch ( opt.m_eDamageSpread )
|
||
|
|
{
|
||
|
|
case QuickplaySearchOptions::eDamageSpreadYes:
|
||
|
|
requiredTags.CopyAndAddToTail( "dmgspread" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QuickplaySearchOptions::eDamageSpreadNo:
|
||
|
|
illegalTags.CopyAndAddToTail( "dmgspread" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
case QuickplaySearchOptions::eDamageSpreadDontCare:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch ( opt.m_eMaxPlayers )
|
||
|
|
{
|
||
|
|
case QuickplaySearchOptions::eMaxPlayers24:
|
||
|
|
illegalTags.CopyAndAddToTail( "increased_maxplayers" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QuickplaySearchOptions::eMaxPlayers30Plus:
|
||
|
|
requiredTags.CopyAndAddToTail( "increased_maxplayers" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
case QuickplaySearchOptions::eMaxPlayersDontCare:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch ( opt.m_eBetaContent )
|
||
|
|
{
|
||
|
|
case QuickplaySearchOptions::eBetaYes:
|
||
|
|
requiredTags.CopyAndAddToTail( "beta" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QuickplaySearchOptions::eBetaNo:
|
||
|
|
illegalTags.CopyAndAddToTail( "beta" );
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
static void OpenQuickplayDialogCallback( bool bConfirmed, void *pContext )
|
||
|
|
{
|
||
|
|
engine->ClientCmd_Unrestricted( "OpenQuickplayDialog" );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Why does it take so many lines of code to do stuff like this?
|
||
|
|
static CDllDemandLoader g_ServerBrowser( "ServerBrowser" );
|
||
|
|
static IServerBrowser *GetServerBrowser()
|
||
|
|
{
|
||
|
|
static IServerBrowser *pServerBrowser = NULL;
|
||
|
|
if ( pServerBrowser == NULL )
|
||
|
|
{
|
||
|
|
int iReturnCode;
|
||
|
|
pServerBrowser = (IServerBrowser *)g_ServerBrowser.GetFactory()( SERVERBROWSER_INTERFACE_VERSION, &iReturnCode );
|
||
|
|
Assert( pServerBrowser );
|
||
|
|
}
|
||
|
|
return pServerBrowser;
|
||
|
|
}
|
||
|
|
|
||
|
|
//=============================================================================
|
||
|
|
|
||
|
|
enum eGameServerFilter
|
||
|
|
{
|
||
|
|
kGameServerListFilter_Internet,
|
||
|
|
kGameServerListFilter_Favorites,
|
||
|
|
};
|
||
|
|
|
||
|
|
struct sortable_gameserveritem_t
|
||
|
|
{
|
||
|
|
sortable_gameserveritem_t()
|
||
|
|
{
|
||
|
|
m_bRegistered = false;
|
||
|
|
m_bValve = false;
|
||
|
|
m_bNewUserFriendly = false;
|
||
|
|
m_bMapIsQuickPlayOK = false;
|
||
|
|
userScore = -999.9f;
|
||
|
|
serverScore = -999.9f;
|
||
|
|
m_fRecentMatchPenalty = -999.9f;
|
||
|
|
m_fTotalScoreFromGC = -9999.9f;
|
||
|
|
m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_Invalid;
|
||
|
|
m_nOptionsScoreFromGC = INT_MAX;
|
||
|
|
}
|
||
|
|
|
||
|
|
gameserveritem_t server;
|
||
|
|
bool m_bRegistered;
|
||
|
|
bool m_bValve;
|
||
|
|
bool m_bNewUserFriendly;
|
||
|
|
bool m_bMapIsQuickPlayOK;
|
||
|
|
float userScore;
|
||
|
|
float serverScore;
|
||
|
|
float m_fRecentMatchPenalty;
|
||
|
|
float m_fTotalScoreFromGC;
|
||
|
|
TF_Gamestats_QuickPlay_t::eServerStatus m_eStatus;
|
||
|
|
int m_nOptionsScoreFromGC;
|
||
|
|
|
||
|
|
inline float TotalScore() const { return userScore + serverScore; }
|
||
|
|
};
|
||
|
|
|
||
|
|
// Store a server that has been scored by the GC and
|
||
|
|
// is ready to receive the final confirmation ping
|
||
|
|
struct gameserver_ping_queue_entry_t
|
||
|
|
{
|
||
|
|
float m_fTotalScore;
|
||
|
|
netadr_t m_adr;
|
||
|
|
};
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Score a game server based on number of players and ping
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
class CGameServerItemSort
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
bool Less( const sortable_gameserveritem_t *src1, const sortable_gameserveritem_t *src2, void *pCtx )
|
||
|
|
{
|
||
|
|
// we want higher scores sorted to the front
|
||
|
|
return src1->TotalScore() > src2->TotalScore();
|
||
|
|
}
|
||
|
|
bool Less( const gameserver_ping_queue_entry_t &src1, const gameserver_ping_queue_entry_t &src2, void *pCtx )
|
||
|
|
{
|
||
|
|
// we want higher scores sorted to the front
|
||
|
|
return src1.m_fTotalScore > src2.m_fTotalScore;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// !KLUDGE! This is duplicated from serverbrowserQuickListPanel.h
|
||
|
|
class CQuickListPanel : public vgui::EditablePanel
|
||
|
|
{
|
||
|
|
DECLARE_CLASS_SIMPLE( CQuickListPanel, vgui::EditablePanel );
|
||
|
|
|
||
|
|
public:
|
||
|
|
CQuickListPanel( vgui::Panel *parent, const char *panelName );
|
||
|
|
|
||
|
|
virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
|
||
|
|
void SetMapName( const char *pMapName );
|
||
|
|
void SetImage( const char *pMapName );
|
||
|
|
void SetGameType( const char *pGameType );
|
||
|
|
const char *GetMapName( void ) { return m_szMapName; }
|
||
|
|
void SetRefreshing( void );
|
||
|
|
|
||
|
|
virtual void OnMousePressed( vgui::MouseCode code );
|
||
|
|
virtual void OnMouseDoublePressed( vgui::MouseCode code );
|
||
|
|
void SetServerInfo ( KeyValues *pKV, int iListID, int iTotalServers );
|
||
|
|
int GetListID( void ) { return m_iListID; }
|
||
|
|
|
||
|
|
virtual void PerformLayout( void )
|
||
|
|
{
|
||
|
|
BaseClass::PerformLayout();
|
||
|
|
}
|
||
|
|
|
||
|
|
MESSAGE_FUNC_INT( OnPanelSelected, "PanelSelected", state )
|
||
|
|
{
|
||
|
|
if ( state )
|
||
|
|
{
|
||
|
|
vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
|
||
|
|
|
||
|
|
if ( pScheme && m_pBGroundPanel )
|
||
|
|
{
|
||
|
|
m_pBGroundPanel->SetBgColor( pScheme->GetColor("QuickListBGSelected", Color(255, 255, 255, 0 ) ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
|
||
|
|
|
||
|
|
if ( pScheme && m_pBGroundPanel )
|
||
|
|
{
|
||
|
|
m_pBGroundPanel->SetBgColor( pScheme->GetColor("QuickListBGDeselected", Color(255, 255, 255, 0 ) ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
PostMessage( GetParent()->GetVParent(), new KeyValues("PanelSelected") );
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
char m_szMapName[64];
|
||
|
|
|
||
|
|
vgui::ImagePanel *m_pLatencyImage;
|
||
|
|
vgui::Label *m_pLatencyLabel;
|
||
|
|
vgui::Label *m_pPlayerCountLabel;
|
||
|
|
vgui::Label *m_pOtherServersLabel;
|
||
|
|
vgui::Label *m_pServerNameLabel;
|
||
|
|
vgui::Panel *m_pBGroundPanel;
|
||
|
|
vgui::ImagePanel *m_pMapImage;
|
||
|
|
|
||
|
|
vgui::Panel *m_pListPanelParent;
|
||
|
|
vgui::Label *m_pGameTypeLabel;
|
||
|
|
vgui::Label *m_pMapNameLabel;
|
||
|
|
|
||
|
|
vgui::ImagePanel *m_pReplayImage;
|
||
|
|
|
||
|
|
int m_iListID;
|
||
|
|
};
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
CQuickListPanel::CQuickListPanel( vgui::Panel* pParent, const char *pElementName ) : BaseClass( pParent, pElementName )
|
||
|
|
{
|
||
|
|
SetParent( pParent );
|
||
|
|
|
||
|
|
m_pListPanelParent = pParent;
|
||
|
|
|
||
|
|
SetScheme( "SourceScheme" );
|
||
|
|
SetProportional( false );
|
||
|
|
|
||
|
|
CMouseMessageForwardingPanel *panel = new CMouseMessageForwardingPanel(this, NULL);
|
||
|
|
panel->SetZPos(3);
|
||
|
|
|
||
|
|
m_pLatencyImage = new ImagePanel( this, "latencyimage" );
|
||
|
|
m_pPlayerCountLabel = new Label( this, "playercount", "" );
|
||
|
|
m_pOtherServersLabel = new Label( this, "otherservercount", "" );
|
||
|
|
m_pServerNameLabel = new Label( this, "servername", "" );
|
||
|
|
m_pBGroundPanel = new Panel( this, "background" );
|
||
|
|
m_pMapImage = new ImagePanel( this, "mapimage" );
|
||
|
|
m_pGameTypeLabel = new Label( this, "gametype", "" );
|
||
|
|
m_pMapNameLabel = new Label( this, "mapname", "" );
|
||
|
|
m_pLatencyLabel = new Label( this, "latencytext", "" );
|
||
|
|
m_pReplayImage = new ImagePanel( this, "replayimage" );
|
||
|
|
|
||
|
|
const char *pPathID = "PLATFORM";
|
||
|
|
|
||
|
|
if ( g_pFullFileSystem->FileExists( "Servers/QuickListPanel.res", "MOD" ) )
|
||
|
|
{
|
||
|
|
pPathID = "MOD";
|
||
|
|
}
|
||
|
|
|
||
|
|
LoadControlSettings( "Servers/QuickListPanel.res", pPathID );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CQuickListPanel::ApplySchemeSettings(IScheme *pScheme)
|
||
|
|
{
|
||
|
|
BaseClass::ApplySchemeSettings(pScheme);
|
||
|
|
|
||
|
|
if ( pScheme && m_pBGroundPanel )
|
||
|
|
{
|
||
|
|
m_pBGroundPanel->SetBgColor( pScheme->GetColor("QuickListBGDeselected", Color(255, 255, 255, 0 ) ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CQuickListPanel::SetRefreshing( void )
|
||
|
|
{
|
||
|
|
if ( m_pServerNameLabel )
|
||
|
|
{
|
||
|
|
m_pServerNameLabel->SetText( g_pVGuiLocalize->Find("#ServerBrowser_QuickListRefreshing") );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pPlayerCountLabel )
|
||
|
|
{
|
||
|
|
m_pPlayerCountLabel->SetVisible( false );
|
||
|
|
}
|
||
|
|
if ( m_pOtherServersLabel )
|
||
|
|
{
|
||
|
|
m_pOtherServersLabel->SetVisible( false );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pLatencyImage )
|
||
|
|
{
|
||
|
|
m_pLatencyImage->SetVisible( false );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pReplayImage )
|
||
|
|
{
|
||
|
|
m_pReplayImage->SetVisible( false );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pLatencyLabel )
|
||
|
|
{
|
||
|
|
m_pLatencyLabel->SetVisible( false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CQuickListPanel::SetMapName( const char *pMapName )
|
||
|
|
{
|
||
|
|
Q_strncpy( m_szMapName, pMapName, sizeof( m_szMapName ) );
|
||
|
|
|
||
|
|
if ( m_pMapNameLabel )
|
||
|
|
{
|
||
|
|
m_pMapNameLabel->SetText( pMapName );
|
||
|
|
m_pMapNameLabel->SizeToContents();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CQuickListPanel::SetGameType( const char *pGameType )
|
||
|
|
{
|
||
|
|
if ( strlen ( pGameType ) == 0 )
|
||
|
|
{
|
||
|
|
m_pGameTypeLabel->SetVisible( false );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char gametype[ 512 ];
|
||
|
|
Q_snprintf( gametype, sizeof( gametype ), "(%s)", pGameType );
|
||
|
|
|
||
|
|
m_pGameTypeLabel->SetText( gametype );
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CQuickListPanel::SetServerInfo ( KeyValues *pKV, int iListID, int iTotalServers )
|
||
|
|
{
|
||
|
|
if ( pKV == NULL )
|
||
|
|
return;
|
||
|
|
|
||
|
|
m_iListID = iListID;
|
||
|
|
|
||
|
|
m_pServerNameLabel->SetText( pKV->GetString( "name", " " ) );
|
||
|
|
|
||
|
|
int iPing = pKV->GetInt( "ping", 0 );
|
||
|
|
|
||
|
|
if ( iPing <= 100 )
|
||
|
|
{
|
||
|
|
m_pLatencyImage->SetImage( "../vgui/icon_con_high.vmt" );
|
||
|
|
}
|
||
|
|
else if ( iPing <= 150 )
|
||
|
|
{
|
||
|
|
m_pLatencyImage->SetImage( "../vgui/icon_con_medium.vmt" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pLatencyImage->SetImage( "../vgui/icon_con_low.vmt" );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pLatencyImage->SetVisible( false );
|
||
|
|
|
||
|
|
//if ( GameSupportsReplay() )
|
||
|
|
{
|
||
|
|
m_pReplayImage->SetVisible( pKV->GetInt( "Replay", 0 ) > 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
char ping[ 512 ];
|
||
|
|
Q_snprintf( ping, sizeof( ping ), "%d ms", iPing );
|
||
|
|
|
||
|
|
m_pLatencyLabel->SetText( ping );
|
||
|
|
m_pLatencyLabel->SetVisible( true );
|
||
|
|
|
||
|
|
wchar_t players[ 512 ];
|
||
|
|
wchar_t playercount[16];
|
||
|
|
wchar_t *pwszPlayers = g_pVGuiLocalize->Find("#ServerBrowser_Players");
|
||
|
|
|
||
|
|
g_pVGuiLocalize->ConvertANSIToUnicode( pKV->GetString( "players", " " ), playercount, sizeof( playercount ) );
|
||
|
|
|
||
|
|
_snwprintf( players, ARRAYSIZE( players ), L"%ls %ls", playercount, pwszPlayers );
|
||
|
|
|
||
|
|
m_pPlayerCountLabel->SetText( players );
|
||
|
|
m_pPlayerCountLabel->SetVisible( true );
|
||
|
|
|
||
|
|
|
||
|
|
// Now setup the other server count
|
||
|
|
if ( iTotalServers == 2 )
|
||
|
|
{
|
||
|
|
m_pOtherServersLabel->SetText( g_pVGuiLocalize->Find("#ServerBrowser_QuickListOtherServer") );
|
||
|
|
m_pOtherServersLabel->SetVisible( true );
|
||
|
|
}
|
||
|
|
else if ( iTotalServers > 2 )
|
||
|
|
{
|
||
|
|
wchar_t *pwszServers = g_pVGuiLocalize->Find("#ServerBrowser_QuickListOtherServers");
|
||
|
|
_snwprintf( playercount, Q_ARRAYSIZE(playercount), L"%d", (iTotalServers-1) );
|
||
|
|
g_pVGuiLocalize->ConstructString_safe( players, pwszServers, 1, playercount );
|
||
|
|
m_pOtherServersLabel->SetText( players );
|
||
|
|
m_pOtherServersLabel->SetVisible( true );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_pOtherServersLabel->SetVisible( false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose:
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
void CQuickListPanel::SetImage( const char *pMapName )
|
||
|
|
{
|
||
|
|
char path[ 512 ];
|
||
|
|
Q_snprintf( path, sizeof( path ), "materials/vgui/maps/menu_thumb_%s.vmt", pMapName );
|
||
|
|
|
||
|
|
char map[ 512 ];
|
||
|
|
Q_snprintf( map, sizeof( map ), "maps/%s.bsp", pMapName );
|
||
|
|
|
||
|
|
if ( g_pFullFileSystem->FileExists( map, "MOD" ) == false )
|
||
|
|
{
|
||
|
|
pMapName = "default_download";
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if ( g_pFullFileSystem->FileExists( path, "MOD" ) == false )
|
||
|
|
{
|
||
|
|
pMapName = "default";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_pMapImage )
|
||
|
|
{
|
||
|
|
char imagename[ 512 ];
|
||
|
|
Q_snprintf( imagename, sizeof( imagename ), "..\\vgui\\maps\\menu_thumb_%s", pMapName );
|
||
|
|
|
||
|
|
m_pMapImage->SetImage ( imagename );
|
||
|
|
m_pMapImage->SetMouseInputEnabled( false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickListPanel::OnMousePressed( vgui::MouseCode code )
|
||
|
|
{
|
||
|
|
if ( m_pListPanelParent )
|
||
|
|
{
|
||
|
|
vgui::PanelListPanel *pParent = dynamic_cast < vgui::PanelListPanel *> ( m_pListPanelParent );
|
||
|
|
|
||
|
|
if ( pParent )
|
||
|
|
{
|
||
|
|
pParent->SetSelectedPanel( this );
|
||
|
|
m_pListPanelParent->CallParentFunction( new KeyValues("ItemSelected", "itemID", -1 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( code == MOUSE_RIGHT )
|
||
|
|
{
|
||
|
|
m_pListPanelParent->CallParentFunction( new KeyValues("OpenContextMenu", "itemID", -1 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickListPanel::OnMouseDoublePressed( vgui::MouseCode code )
|
||
|
|
{
|
||
|
|
if ( code == MOUSE_RIGHT )
|
||
|
|
return;
|
||
|
|
|
||
|
|
// call the panel
|
||
|
|
OnMousePressed( code );
|
||
|
|
|
||
|
|
m_pListPanelParent->CallParentFunction( new KeyValues("ConnectToServer", "code", code) );
|
||
|
|
}
|
||
|
|
|
||
|
|
CUtlString GetCommaDelimited( const CUtlStringList &list )
|
||
|
|
{
|
||
|
|
CUtlString sResult;
|
||
|
|
FOR_EACH_VEC( list, idx )
|
||
|
|
{
|
||
|
|
if ( idx != 0 )
|
||
|
|
sResult.Append( "," );
|
||
|
|
sResult.Append( list[idx] );
|
||
|
|
}
|
||
|
|
return sResult;
|
||
|
|
}
|
||
|
|
|
||
|
|
class CQuickplayWaitDialog;
|
||
|
|
static CQuickplayWaitDialog *s_pQuickPlayWaitingDialog;
|
||
|
|
|
||
|
|
// Busy indicator and also server list if the didn't use "I'm feeling lucky"
|
||
|
|
class CQuickplayWaitDialog : public CGenericWaitingDialog, public ISteamMatchmakingServerListResponse, public ISteamMatchmakingPingResponse
|
||
|
|
{
|
||
|
|
DECLARE_CLASS_SIMPLE( CQuickplayWaitDialog, CGenericWaitingDialog );
|
||
|
|
public:
|
||
|
|
CQuickplayWaitDialog( bool bFeelingLucky, const QuickplaySearchOptions &opt )
|
||
|
|
: CGenericWaitingDialog( NULL )
|
||
|
|
, m_options( opt )
|
||
|
|
, m_fHoursPlayed( 0 )
|
||
|
|
, m_nAppID( GetTfMatchmakingAppID() )
|
||
|
|
, m_hServerListRequest( NULL )
|
||
|
|
, m_hServerQueryRequest( HSERVERQUERY_INVALID )
|
||
|
|
, m_fPingA( tf_matchmaking_ping_a.GetFloat() )
|
||
|
|
, m_fPingAScore( tf_matchmaking_ping_a_score.GetFloat() )
|
||
|
|
, m_fPingB( tf_matchmaking_ping_b.GetFloat() )
|
||
|
|
, m_fPingBScore( tf_matchmaking_ping_b_score.GetFloat() )
|
||
|
|
, m_fPingC( tf_matchmaking_ping_c.GetFloat() )
|
||
|
|
, m_fPingCScore( tf_matchmaking_ping_c_score.GetFloat() )
|
||
|
|
, m_bFeelingLucky( bFeelingLucky )
|
||
|
|
, m_eCurrentStep( k_EStep_GMSQuery )
|
||
|
|
, m_timeGCScoreTimeout( 0.0 )
|
||
|
|
, m_timeGMSSearchStarted( 0.0 )
|
||
|
|
, m_timePingServerTimeout( 0.0 )
|
||
|
|
, m_pBusyContainer( NULL )
|
||
|
|
, m_pResultsContainer( NULL )
|
||
|
|
, m_pServerListPanel( NULL )
|
||
|
|
, m_pProgressBar( NULL )
|
||
|
|
, m_ScoringNumbers( steamapicontext ? steamapicontext->SteamUser()->GetSteamID() : CSteamID() )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Check the panel name since we are changing the resource
|
||
|
|
SetName("QuickPlayBusyDialog");
|
||
|
|
|
||
|
|
Assert( s_pQuickPlayWaitingDialog == NULL );
|
||
|
|
s_pQuickPlayWaitingDialog = this;
|
||
|
|
|
||
|
|
m_blackList.LoadServersFromFile( BLACKLIST_DEFAULT_SAVE_FILE, false );
|
||
|
|
|
||
|
|
m_fHoursPlayed = CTFStatPanel::GetTotalHoursPlayed();
|
||
|
|
m_Stats.m_fUserHoursPlayed = m_fHoursPlayed;
|
||
|
|
m_Stats.m_iExperimentGroup = m_ScoringNumbers.m_eExperimentGroup;
|
||
|
|
|
||
|
|
// Determine bonus we'll give to valve servers, using linear
|
||
|
|
// interpolation with clamped endpoints
|
||
|
|
float m_fValveBonusHrsA = tf_matchmaking_numbers_valve_bonus_hrs_a.GetFloat();
|
||
|
|
float m_fValveBonusPtsA = tf_matchmaking_numbers_valve_bonus_pts_a.GetFloat();
|
||
|
|
float m_fValveBonusHrsB = tf_matchmaking_numbers_valve_bonus_hrs_b.GetFloat();
|
||
|
|
float m_fValveBonusPtsB = tf_matchmaking_numbers_valve_bonus_pts_b.GetFloat();
|
||
|
|
Assert( m_fValveBonusHrsA < m_fValveBonusHrsB );
|
||
|
|
if ( m_fHoursPlayed < m_fValveBonusHrsA )
|
||
|
|
{
|
||
|
|
m_fValveBonus = m_fValveBonusPtsA;
|
||
|
|
}
|
||
|
|
else if ( m_fHoursPlayed < m_fValveBonusHrsB )
|
||
|
|
{
|
||
|
|
m_fValveBonus = lerp( m_fValveBonusHrsA, m_fValveBonusPtsA, m_fValveBonusHrsB, m_fValveBonusPtsB, m_fHoursPlayed );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_fValveBonus = m_fValveBonusPtsB;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Calc bonus given if the map is noob friendly
|
||
|
|
float fNoobTime = tf_matchmaking_noob_hours_played.GetFloat();
|
||
|
|
m_fNoobMapBonus = 0.0f;
|
||
|
|
if ( m_fHoursPlayed < fNoobTime )
|
||
|
|
{
|
||
|
|
float fNoobPct = 1.0f - ( fNoobTime / fNoobTime );
|
||
|
|
m_fNoobMapBonus = fNoobPct * tf_matchmaking_noob_map_score_boost.GetFloat();
|
||
|
|
}
|
||
|
|
|
||
|
|
switch ( m_options.m_eSelectedGameType )
|
||
|
|
{
|
||
|
|
case kGameCategory_Quickplay: m_Stats.m_sUserGameMode = "(any)"; break;
|
||
|
|
case kGameCategory_Escort: m_Stats.m_sUserGameMode = "escort"; break;
|
||
|
|
case kGameCategory_CTF: m_Stats.m_sUserGameMode = "ctf"; break;
|
||
|
|
case kGameCategory_AttackDefense: m_Stats.m_sUserGameMode = "attackdefense"; break;
|
||
|
|
case kGameCategory_Koth: m_Stats.m_sUserGameMode = "koth"; break;
|
||
|
|
case kGameCategory_CP: m_Stats.m_sUserGameMode = "cp"; break;
|
||
|
|
case kGameCategory_EscortRace: m_Stats.m_sUserGameMode = "escortrace"; break;
|
||
|
|
case kGameCategory_EventMix: m_Stats.m_sUserGameMode = "eventmix"; break;
|
||
|
|
case kGameCategory_Event247: m_Stats.m_sUserGameMode = "event247"; break;
|
||
|
|
case kGameCategory_SD: m_Stats.m_sUserGameMode = "sd"; break;
|
||
|
|
case kGameCategory_RobotDestruction: m_Stats.m_sUserGameMode = "rd"; break;
|
||
|
|
case kGameCategory_Powerup: m_Stats.m_sUserGameMode = "powerup"; break;
|
||
|
|
case kGameCategory_Featured: m_Stats.m_sUserGameMode = "featured"; break;
|
||
|
|
case kGameCategory_Passtime: m_Stats.m_sUserGameMode = "passtime"; break;
|
||
|
|
case kGameCategory_Community_Update: m_Stats.m_sUserGameMode = "community_update"; break;
|
||
|
|
case kGameCategory_Misc: m_Stats.m_sUserGameMode = "misc"; break;
|
||
|
|
//case kQuickplayGameType_Arena: stats.m_sUserGameMode = "arena"; break;
|
||
|
|
//case kQuickplayGameType_Specialty: stats.m_sUserGameMode = "specialty"; break;
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
m_Stats.m_sUserGameMode.Format( "%d", m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
SetDefLessFunc( m_mapServers );
|
||
|
|
|
||
|
|
// Sanity
|
||
|
|
Assert( 0.0 < m_fPingA ); Assert( m_fPingA < m_fPingB ); Assert( m_fPingB < m_fPingC );
|
||
|
|
Assert( 1.0 > m_fPingAScore ); Assert( m_fPingAScore > m_fPingBScore ); Assert( m_fPingBScore > m_fPingCScore );
|
||
|
|
|
||
|
|
// Setup search filters
|
||
|
|
CUtlVector<MatchMakingKeyValuePair_t> vecServerFilters;
|
||
|
|
AddFilter( vecServerFilters, "gamedir", COM_GetModDirectory() );
|
||
|
|
if ( GetUniverse() == k_EUniversePublic )
|
||
|
|
{
|
||
|
|
AddFilter( vecServerFilters, "secure", "1" );
|
||
|
|
AddFilter( vecServerFilters, "dedicated", "1" );
|
||
|
|
}
|
||
|
|
AddFilter( vecServerFilters, "full", "1" ); // actually means "not full"
|
||
|
|
|
||
|
|
GetQuickplayTags( m_options, m_vecStrRequiredTags, m_vecStrRejectTags );
|
||
|
|
|
||
|
|
// Specified map filter if one is specified
|
||
|
|
if ( !m_options.m_strMapName.IsEmpty() )
|
||
|
|
{
|
||
|
|
AddFilter( vecServerFilters, "map", m_options.m_strMapName );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Add filter for the game mode tag
|
||
|
|
switch ( m_options.m_eSelectedGameType )
|
||
|
|
{
|
||
|
|
case kGameCategory_Escort:
|
||
|
|
case kGameCategory_EscortRace:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "payload" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Koth:
|
||
|
|
case kGameCategory_AttackDefense:
|
||
|
|
case kGameCategory_CP:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "cp" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_CTF:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "ctf" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_EventMix:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "eventmix" );
|
||
|
|
m_vecStrRejectTags.CopyAndAddToTail( "event247" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Event247:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "event247" );
|
||
|
|
m_vecStrRejectTags.CopyAndAddToTail( "eventmix" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_SD:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "sd" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_RobotDestruction:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "rd" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Powerup:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "powerup" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Featured:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "featured" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Passtime:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "passtime" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Community_Update:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "community_update" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Misc:
|
||
|
|
m_vecStrRequiredTags.CopyAndAddToTail( "misc" );
|
||
|
|
AddMapsFilter( vecServerFilters, m_options.m_eSelectedGameType );
|
||
|
|
break;
|
||
|
|
case kGameCategory_Quickplay:
|
||
|
|
// Grrrrr. Anything we can do here?
|
||
|
|
// The list of all the maps won't fit. We do not yet have an "or" syntax.
|
||
|
|
// So we're stuck filtering them client side
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
AddFilter( vecServerFilters, "ngametype", GetCommaDelimited( m_vecStrRejectTags ) );
|
||
|
|
AddFilter( vecServerFilters, "gametype", GetCommaDelimited( m_vecStrRequiredTags ) );
|
||
|
|
AddFilter( vecServerFilters, "steamblocking", "1" );
|
||
|
|
|
||
|
|
if ( m_options.m_eServers == QuickplaySearchOptions::eServersOfficial )
|
||
|
|
{
|
||
|
|
AddFilter( vecServerFilters, "white", "1" );
|
||
|
|
}
|
||
|
|
else if ( m_options.m_eServers == QuickplaySearchOptions::eServersCommunity )
|
||
|
|
{
|
||
|
|
// community servers *ONLY*
|
||
|
|
AddFilter( vecServerFilters, "nor", "1" );
|
||
|
|
AddFilter( vecServerFilters, "white", "1" );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Remember when we started
|
||
|
|
m_timeGMSSearchStarted = Plat_FloatTime();
|
||
|
|
|
||
|
|
// Print for debugging
|
||
|
|
if ( tf_matchmaking_debug.GetInt() >= 2 )
|
||
|
|
{
|
||
|
|
CUtlString sFilter;
|
||
|
|
FOR_EACH_VEC( vecServerFilters, idx )
|
||
|
|
{
|
||
|
|
sFilter.Append( vecServerFilters[idx].m_szKey );
|
||
|
|
sFilter.Append( " - " );
|
||
|
|
sFilter.Append( vecServerFilters[idx].m_szValue );
|
||
|
|
sFilter.Append( "\n" );
|
||
|
|
}
|
||
|
|
Msg( "Using GMS filter: %s\n", sFilter.String() );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Initiate the search
|
||
|
|
MatchMakingKeyValuePair_t *pFilters = vecServerFilters.Base(); // <<<< Note, this is weird, but correct.
|
||
|
|
m_hServerListRequest = steamapicontext->SteamMatchmakingServers()->RequestInternetServerList( GetTfMatchmakingAppID(), &pFilters, vecServerFilters.Count(), this );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual ~CQuickplayWaitDialog()
|
||
|
|
{
|
||
|
|
Assert( s_pQuickPlayWaitingDialog == this );
|
||
|
|
s_pQuickPlayWaitingDialog = NULL;
|
||
|
|
|
||
|
|
DestroyServerQueryRequest();
|
||
|
|
DestroyServerListRequest();
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual const char* GetResFile() const { return "Resource/UI/QuickPlayBusyDialog.res"; }
|
||
|
|
|
||
|
|
void OnReceivedGCScores( CMsgTFQuickplay_ScoreServersResponse &msg )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Make sure we're expecting them
|
||
|
|
if ( m_eCurrentStep != k_EStep_GCScore )
|
||
|
|
{
|
||
|
|
Warning(" Received CGCTFQuickplay_ScoreServers_Response, but not expecting them (current step = %d)?\n", m_eCurrentStep );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_vecServerJoinQueue.RemoveAll();
|
||
|
|
|
||
|
|
// Do we have any GC scores?
|
||
|
|
if ( msg.servers_size() > 0 )
|
||
|
|
{
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "Received %d server scores from GC\n", msg.servers_size());
|
||
|
|
|
||
|
|
// Put them in a queue. We will try them in score order
|
||
|
|
TF_MATCHMAKING_SPEW( 2, "SteamID, IP, score\n" );
|
||
|
|
for ( int i = 0; i < msg.servers_size(); ++i )
|
||
|
|
{
|
||
|
|
const CMsgTFQuickplay_ScoreServersResponse_ServerInfo &info = msg.servers( i );
|
||
|
|
netadr_t adr( info.server_address(), info.server_port() );
|
||
|
|
CSteamID steamID( info.steam_id() );
|
||
|
|
|
||
|
|
TF_MATCHMAKING_SPEW( 2, "\"%s\", \"%s\", %.2f\n",
|
||
|
|
steamID.Render(), adr.ToString(), info.total_score() );
|
||
|
|
|
||
|
|
gameserver_ping_queue_entry_t item;
|
||
|
|
item.m_adr.SetIPAndPort( info.server_address(), info.server_port() );
|
||
|
|
item.m_fTotalScore = info.total_score();
|
||
|
|
int nOptionsScore = RemapValClamped( info.options_score(), 0.f, 30000.f, tf_mm_options_bonus.GetFloat(), tf_mm_options_penalty.GetFloat() );
|
||
|
|
item.m_fTotalScore += nOptionsScore;
|
||
|
|
m_vecServerJoinQueue.InsertNoSort( item );
|
||
|
|
|
||
|
|
// Locate the original entry. Try by IP first,
|
||
|
|
// and if that fails, try steam ID. (Can happen due
|
||
|
|
// to mismatch of public/private IP)
|
||
|
|
int idx = m_mapServers.Find( adr );
|
||
|
|
if ( m_mapServers.IsValidIndex( idx ) )
|
||
|
|
{
|
||
|
|
// Might actually fail in race condition, but should
|
||
|
|
// be extremely rare. If it's happening frequently,
|
||
|
|
// we probably have a bug or have misunderstood something
|
||
|
|
Assert( m_mapServers[idx].server.m_steamID == steamID );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bool bFound = false;
|
||
|
|
FOR_EACH_MAP_FAST( m_mapServers, j )
|
||
|
|
{
|
||
|
|
if ( m_mapServers[j].server.m_steamID == steamID )
|
||
|
|
{
|
||
|
|
Assert( !m_mapServers.IsValidIndex( idx ) ); // duplicate?
|
||
|
|
idx = j;
|
||
|
|
bFound = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( bFound )
|
||
|
|
{
|
||
|
|
// Remove it and re-insert, updating the address
|
||
|
|
// we got from the GC, which is probably the public IP.
|
||
|
|
// this IP is more useful for scoring purposes
|
||
|
|
sortable_gameserveritem_t temp = m_mapServers[idx];
|
||
|
|
temp.server.m_NetAdr.SetIP( info.server_address() );
|
||
|
|
m_mapServers.RemoveAt( idx );
|
||
|
|
idx = m_mapServers.InsertOrReplace( adr, temp );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_mapServers.IsValidIndex( idx ) )
|
||
|
|
{
|
||
|
|
m_mapServers[ idx ].m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_Scored;
|
||
|
|
m_mapServers[ idx ].m_fTotalScoreFromGC = info.total_score();
|
||
|
|
m_mapServers[ idx ].m_nOptionsScoreFromGC = info.options_score();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Warning( "Received score from GC for %s @ %s, but I didn't ask for that server!\n", steamID.Render(), adr.ToString() );
|
||
|
|
Assert( m_mapServers.IsValidIndex( idx ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
TF_MATCHMAKING_SPEW(1, "Using client-only scoring (no reputation data)\n" );
|
||
|
|
|
||
|
|
// Just add all of the servers that we thought were good enough to send to the GC
|
||
|
|
// to even request a score into the list of possible ones to join
|
||
|
|
FOR_EACH_MAP( m_mapServers, i )
|
||
|
|
{
|
||
|
|
sortable_gameserveritem_t &s = m_mapServers[i];
|
||
|
|
if ( s.m_eStatus >= TF_Gamestats_QuickPlay_t::k_Server_RequestedScore )
|
||
|
|
{
|
||
|
|
gameserver_ping_queue_entry_t item;
|
||
|
|
item.m_adr.SetIPAndPort( s.server.m_NetAdr.GetIP(), s.server.m_NetAdr.GetConnectionPort() );
|
||
|
|
item.m_fTotalScore = s.TotalScore(); // client-side score only, no reputation data
|
||
|
|
m_vecServerJoinQueue.InsertNoSort( item );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
m_vecServerJoinQueue.RedoSort();
|
||
|
|
|
||
|
|
if ( msg.servers_size() > 0 )
|
||
|
|
{
|
||
|
|
TF_MATCHMAKING_SPEW(1, "Best GC score was %.2f\n", m_vecServerJoinQueue[0].m_fTotalScore );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Show some UI
|
||
|
|
if ( !m_bFeelingLucky )
|
||
|
|
{
|
||
|
|
ShowSelectServerUI();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// OK, we have some candidates, but let's only try the first few.
|
||
|
|
// If they all fail, we probably have some bigger problem.
|
||
|
|
// !GAH! CUtlVector SetCount will not truncate an existing list,
|
||
|
|
// it will always fill the list with N dummy entries. I have
|
||
|
|
// no idea why.
|
||
|
|
while ( m_vecServerJoinQueue.Count() > 5 )
|
||
|
|
{
|
||
|
|
m_vecServerJoinQueue.Remove( m_vecServerJoinQueue.Count()-1 );
|
||
|
|
}
|
||
|
|
|
||
|
|
// OK, we have a server.
|
||
|
|
C_CTFGameStats::ImmediateWriteInterfaceEvent( "response(quickplay)", "gc_server_found" );
|
||
|
|
|
||
|
|
// // !FIXME! Server pinging not working for some reason.
|
||
|
|
// // Just try to connect to the best one.
|
||
|
|
// ConnectToServer( m_vecServerJoinQueue[0].m_adr.GetIP(), m_vecServerJoinQueue[0].m_adr.GetPort() );
|
||
|
|
// return;
|
||
|
|
|
||
|
|
// Allright, begin loop pinging servers in order
|
||
|
|
// until we find one that is still OK to join.
|
||
|
|
// Hopefully and usually, the first one will
|
||
|
|
// still be available. But we sometimes waited
|
||
|
|
// too long and something happened on that server
|
||
|
|
// during the search and we need to go with our
|
||
|
|
// 2nd choice
|
||
|
|
m_eCurrentStep = k_EStep_PingCheckNotFull;
|
||
|
|
PingNextBestServer();
|
||
|
|
}
|
||
|
|
|
||
|
|
void ShowSelectServerUI()
|
||
|
|
{
|
||
|
|
m_eCurrentStep = k_EStep_SelectServerUI;
|
||
|
|
|
||
|
|
if ( m_pBusyContainer )
|
||
|
|
m_pBusyContainer->SetVisible( false );
|
||
|
|
if ( m_pResultsContainer )
|
||
|
|
m_pResultsContainer->SetVisible( true );
|
||
|
|
m_adrCurrentPing.Clear();
|
||
|
|
|
||
|
|
if ( m_pServerListPanel )
|
||
|
|
{
|
||
|
|
FOR_EACH_VEC( m_vecServerJoinQueue, idxServer )
|
||
|
|
{
|
||
|
|
int idxMap = m_mapServers.Find( m_vecServerJoinQueue[ idxServer ].m_adr );
|
||
|
|
if ( idxMap < 0 )
|
||
|
|
continue;
|
||
|
|
sortable_gameserveritem_t &s = m_mapServers[ idxMap ];
|
||
|
|
CQuickListPanel *pServerPanel = new CQuickListPanel( m_pServerListPanel, "QuickListPanel" );
|
||
|
|
|
||
|
|
char szFriendlyName[MAX_MAP_NAME];
|
||
|
|
const char *pszFriendlyGameTypeName = GetServerBrowser()->GetMapFriendlyNameAndGameType( s.server.m_szMap, szFriendlyName, sizeof(szFriendlyName) );
|
||
|
|
|
||
|
|
pServerPanel->SetName( s.server.m_szMap );
|
||
|
|
pServerPanel->SetMapName( GetMapDisplayName( s.server.m_szMap ) );
|
||
|
|
pServerPanel->SetImage( s.server.m_szMap );
|
||
|
|
pServerPanel->SetGameType( pszFriendlyGameTypeName );
|
||
|
|
|
||
|
|
KeyValues *pKV = new KeyValues( "ServerInfo" );
|
||
|
|
|
||
|
|
pKV->SetInt( "ping", s.server.m_nPing );
|
||
|
|
pKV->SetString( "name", s.server.GetName() );
|
||
|
|
pKV->SetString( "players", CFmtStr( "%d/%d", s.server.m_nPlayers, s.server.m_nMaxPlayers ) );
|
||
|
|
pServerPanel->SetServerInfo( pKV, idxMap, 0 );
|
||
|
|
pKV->deleteThis();
|
||
|
|
pServerPanel->InvalidateLayout();
|
||
|
|
pServerPanel->SetVisible( true );
|
||
|
|
m_pServerListPanel->AddItem( NULL, pServerPanel );
|
||
|
|
|
||
|
|
// We need to reset the proportional flag again because the AddItem() call does a SetParent()
|
||
|
|
// call which copies the parent's proportional setting to the panel being added
|
||
|
|
pServerPanel->SetProportional( false );
|
||
|
|
}
|
||
|
|
m_pServerListPanel->InvalidateLayout( false, true );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ApplySchemeSettings( vgui::IScheme *pScheme )
|
||
|
|
{
|
||
|
|
CGenericWaitingDialog::ApplySchemeSettings( pScheme );
|
||
|
|
|
||
|
|
m_pBusyContainer = dynamic_cast< vgui::EditablePanel* >( FindChildByName( "BusyContainer" ) );
|
||
|
|
m_pResultsContainer = dynamic_cast< vgui::EditablePanel* >( FindChildByName( "ResultsContainer" ) );
|
||
|
|
if ( m_pBusyContainer == NULL || m_pResultsContainer == NULL )
|
||
|
|
{
|
||
|
|
Assert( m_pBusyContainer );
|
||
|
|
Assert( m_pResultsContainer );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
m_pBusyContainer->SetVisible( true );
|
||
|
|
m_pResultsContainer->SetVisible( false );
|
||
|
|
m_pServerListPanel = dynamic_cast< vgui::PanelListPanel* >( m_pResultsContainer->FindChildByName( "ServerList" ) ); Assert( m_pServerListPanel );
|
||
|
|
if ( m_pServerListPanel )
|
||
|
|
m_pServerListPanel->SetFirstColumnWidth( 0 );
|
||
|
|
m_pProgressBar = dynamic_cast< vgui::ProgressBar* >( m_pBusyContainer->FindChildByName( "Progress" ) ); Assert( m_pProgressBar );
|
||
|
|
|
||
|
|
vgui::Label *pTitle = dynamic_cast< vgui::Label* >( m_pBusyContainer->FindChildByName( "TitleLabel" ) ); Assert( pTitle );
|
||
|
|
if ( pTitle ) pTitle->SetText( m_bFeelingLucky ? "#TF_MM_WaitDialog_Title_FeelingLucky" : "#TF_MM_WaitDialog_Title_ShowServers" );
|
||
|
|
|
||
|
|
vgui::Panel *pPanel;
|
||
|
|
pPanel = m_pBusyContainer->FindChildByName( "CloseButton" ); Assert( pPanel );
|
||
|
|
if ( pPanel ) pPanel->AddActionSignalTarget( this );
|
||
|
|
pPanel = m_pResultsContainer->FindChildByName( "ConnectButton" ); Assert( pPanel );
|
||
|
|
if ( pPanel ) pPanel->AddActionSignalTarget( this );
|
||
|
|
pPanel = m_pResultsContainer->FindChildByName( "CancelButton" ); Assert( pPanel );
|
||
|
|
if ( pPanel ) pPanel->AddActionSignalTarget( this );
|
||
|
|
}
|
||
|
|
|
||
|
|
void ConnectToServer( uint32 iAddress, uint16 iPort )
|
||
|
|
{
|
||
|
|
|
||
|
|
SendStats( TF_Gamestats_QuickPlay_t::k_Result_TriedToConnect );
|
||
|
|
|
||
|
|
netadr_t address( iAddress, iPort );
|
||
|
|
Msg("Quickplay connecting to %s\n", address.ToString() );
|
||
|
|
|
||
|
|
// Close the window (and queue us for deletion), set our status
|
||
|
|
CloseMe();
|
||
|
|
|
||
|
|
// Find/add an entry in the list of recent servers
|
||
|
|
int iRecentIndex = FindRecentlyMatchedServer( iAddress, iPort );
|
||
|
|
if ( iRecentIndex < 0 )
|
||
|
|
{
|
||
|
|
iRecentIndex = s_vecRecentlyMatchedServers.AddToTail();
|
||
|
|
s_vecRecentlyMatchedServers[ iRecentIndex ].m_ip = iAddress;
|
||
|
|
s_vecRecentlyMatchedServers[ iRecentIndex ].m_port = iPort;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set time when we were matched to this server
|
||
|
|
s_vecRecentlyMatchedServers[ iRecentIndex ].m_timeMatched = CRTime::RTime32TimeCur();
|
||
|
|
|
||
|
|
const char *pszConnectCode = m_bFeelingLucky ? "quickplay" : "quickpick";
|
||
|
|
char command[256];
|
||
|
|
Q_snprintf( command, sizeof(command), "connect %s %s_%d\n", address.ToString(), pszConnectCode, g_iQuickplaySessionIndex );
|
||
|
|
engine->ClientCmd_Unrestricted( command );
|
||
|
|
}
|
||
|
|
|
||
|
|
void OnCommand( const char *pCommand )
|
||
|
|
{
|
||
|
|
if ( FStrEq( pCommand, "ConnectToServer" ) )
|
||
|
|
{
|
||
|
|
UserConnectToServer();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
BaseClass::OnCommand( pCommand );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void OnUserClose()
|
||
|
|
{
|
||
|
|
SendStats( TF_Gamestats_QuickPlay_t::k_Result_UserCancel );
|
||
|
|
BaseClass::OnUserClose();
|
||
|
|
}
|
||
|
|
|
||
|
|
protected:
|
||
|
|
|
||
|
|
enum EStep
|
||
|
|
{
|
||
|
|
k_EStep_GMSQuery, // We're waiting on the GMS to give us back some servers
|
||
|
|
k_EStep_GCScore, // We're waiting on the GC to send us back scores
|
||
|
|
k_EStep_SelectServerUI, // User wasn't feeling lucky, wanted to see his options first
|
||
|
|
k_EStep_PingCheckNotFull, // We're looking for the highest scores server that isn't full
|
||
|
|
k_EStep_Terminated, // We've been terminated and are waiting to die
|
||
|
|
};
|
||
|
|
EStep m_eCurrentStep;
|
||
|
|
bool m_bFeelingLucky;
|
||
|
|
|
||
|
|
CUtlMap< netadr_t, sortable_gameserveritem_t > m_mapServers;
|
||
|
|
HServerListRequest m_hServerListRequest;
|
||
|
|
HServerQuery m_hServerQueryRequest;
|
||
|
|
uint32 m_nAppID;
|
||
|
|
CBlacklistedServerManager m_blackList;
|
||
|
|
QuickplaySearchOptions m_options;
|
||
|
|
CUtlStringList m_vecStrRequiredTags;
|
||
|
|
CUtlStringList m_vecStrRejectTags;
|
||
|
|
float m_fHoursPlayed;
|
||
|
|
double m_timeGCScoreTimeout;
|
||
|
|
double m_timeGMSSearchStarted;
|
||
|
|
double m_timePingServerTimeout;
|
||
|
|
netadr_t m_adrCurrentPing;
|
||
|
|
vgui::EditablePanel *m_pBusyContainer;
|
||
|
|
vgui::EditablePanel *m_pResultsContainer;
|
||
|
|
vgui::PanelListPanel *m_pServerListPanel;
|
||
|
|
vgui::ProgressBar *m_pProgressBar;
|
||
|
|
|
||
|
|
// Piecewise linear data points for ping->score function
|
||
|
|
float m_fPingA, m_fPingAScore;
|
||
|
|
float m_fPingB, m_fPingBScore;
|
||
|
|
float m_fPingC, m_fPingCScore;
|
||
|
|
float m_fValveBonus;
|
||
|
|
float m_fNoobMapBonus;
|
||
|
|
|
||
|
|
// List of scores servers we will try to join (after confirming they are still
|
||
|
|
// OK), in order
|
||
|
|
CUtlSortVector<gameserver_ping_queue_entry_t, CGameServerItemSort> m_vecServerJoinQueue;
|
||
|
|
|
||
|
|
TF2ScoringNumbers_t m_ScoringNumbers;
|
||
|
|
|
||
|
|
TF_Gamestats_QuickPlay_t m_Stats;
|
||
|
|
|
||
|
|
void SendStats( TF_Gamestats_QuickPlay_t::eResult result )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Set final result code
|
||
|
|
m_Stats.m_eResultCode = result;
|
||
|
|
|
||
|
|
// Duration of total process
|
||
|
|
m_Stats.m_fSearchTime = Plat_FloatTime() - m_timeGMSSearchStarted;
|
||
|
|
|
||
|
|
// Populate the server list
|
||
|
|
FOR_EACH_MAP( m_mapServers, i )
|
||
|
|
{
|
||
|
|
sortable_gameserveritem_t &item = m_mapServers[i];
|
||
|
|
TF_Gamestats_QuickPlay_t::Server_t &s = m_Stats.m_vecServers[m_Stats.m_vecServers.AddToTail()];
|
||
|
|
Assert( item.m_eStatus != TF_Gamestats_QuickPlay_t::k_Server_Invalid );
|
||
|
|
s.m_eStatus = item.m_eStatus;
|
||
|
|
s.m_ip = item.server.m_NetAdr.GetIP();
|
||
|
|
s.m_port = item.server.m_NetAdr.GetConnectionPort();
|
||
|
|
s.m_bSecure = item.server.m_bSecure;
|
||
|
|
s.m_bRegistered = item.m_bRegistered;
|
||
|
|
s.m_bValve = item.m_bValve;
|
||
|
|
s.m_nPlayers = item.server.m_nPlayers;
|
||
|
|
s.m_nMaxPlayers = item.server.m_nMaxPlayers;
|
||
|
|
s.m_sMapName = item.server.m_szMap;
|
||
|
|
s.m_sTags = item.server.m_szGameTags;
|
||
|
|
s.m_iPing = item.server.m_nPing;
|
||
|
|
s.m_bMapIsQuickPlayOK = s.m_bMapIsQuickPlayOK;
|
||
|
|
s.m_bMapIsNewUserFriendly = item.m_bNewUserFriendly;
|
||
|
|
s.m_fScoreClient = item.userScore;
|
||
|
|
s.m_fScoreServer = item.serverScore;
|
||
|
|
s.m_fScoreGC = item.m_fTotalScoreFromGC;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Send em
|
||
|
|
C_CTF_GameStats.QuickplayResults( m_Stats );
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// ISteamMatchmakingServerListResponse overrides
|
||
|
|
//
|
||
|
|
|
||
|
|
virtual void ServerResponded( HServerListRequest hRequest, int iServer )
|
||
|
|
{
|
||
|
|
Assert( m_eCurrentStep == k_EStep_GMSQuery && m_hServerListRequest );
|
||
|
|
gameserveritem_t *server = steamapicontext->SteamMatchmakingServers()->GetServerDetails( hRequest, iServer );
|
||
|
|
if ( server )
|
||
|
|
{
|
||
|
|
ServerResponded( *server );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void ServerFailedToRespond( HServerListRequest hRequest, int iServer )
|
||
|
|
{
|
||
|
|
// Should only happen during server list process, in which case we don't
|
||
|
|
// care. (We just won't add it to our list.)
|
||
|
|
Assert( m_eCurrentStep == k_EStep_GMSQuery && m_hServerListRequest );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void RefreshComplete( HServerListRequest hRequest, EMatchMakingServerResponse response )
|
||
|
|
{
|
||
|
|
// Destroy our request. We'll pick up on this fact next time in Think()
|
||
|
|
// and send the best servers to the GC to be scored
|
||
|
|
Assert( m_eCurrentStep == k_EStep_GMSQuery && m_hServerListRequest );
|
||
|
|
DestroyServerListRequest();
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// ISteamMatchmakingPingResponse overrides
|
||
|
|
//
|
||
|
|
|
||
|
|
virtual void ServerResponded( gameserveritem_t &server )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Ignore servers with bogus addres. Is this possible?
|
||
|
|
if ( !server.m_NetAdr.GetIP() || !server.m_NetAdr.GetConnectionPort() )
|
||
|
|
{
|
||
|
|
Assert( server.m_NetAdr.GetIP() && server.m_NetAdr.GetConnectionPort() );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Bogus steam ID?
|
||
|
|
if ( !server.m_steamID.IsValid() || !server.m_steamID.BGameServerAccount() || server.m_steamID.GetAccountID() == 0 )
|
||
|
|
{
|
||
|
|
TF_MATCHMAKING_SPEW( 2, "Quickplay ignoring gameserver at %s with invalid Steam ID %s", server.m_NetAdr.GetQueryAddressString(), server.m_steamID.Render() );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Filter the server
|
||
|
|
//
|
||
|
|
sortable_gameserveritem_t item;
|
||
|
|
item.server = server;
|
||
|
|
item.m_bNewUserFriendly = false;
|
||
|
|
// XXX(JohnS): This function is no longer available to clients with the matchmaking re-work. If we start using
|
||
|
|
// this UI for valve servers again we will need to fix this somehow.
|
||
|
|
// BIsIPInValveAddressSpace( item.server.m_NetAdr.GetIP() );
|
||
|
|
item.m_bValve = false;
|
||
|
|
|
||
|
|
// Parse out tags
|
||
|
|
CUtlStringList TagList; // auto-deletes strings on scope exit
|
||
|
|
if ( item.server.m_szGameTags && item.server.m_szGameTags[0] )
|
||
|
|
{
|
||
|
|
V_SplitString( item.server.m_szGameTags, ",", TagList );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if the server is registered
|
||
|
|
item.m_bRegistered = BHasTag( TagList, "_registered" );
|
||
|
|
|
||
|
|
const SchemaMap_t *pMapInfo = GetItemSchema()->GetMapForName( item.server.m_szMap );
|
||
|
|
if ( pMapInfo != NULL )
|
||
|
|
{
|
||
|
|
item.m_bMapIsQuickPlayOK = true;
|
||
|
|
item.m_bNewUserFriendly = pMapInfo->eQuickplayType == kQuickplay_AllUsers;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
item.m_bMapIsQuickPlayOK = false;
|
||
|
|
item.m_bNewUserFriendly = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Joined recently?
|
||
|
|
CalculateRecentMatchPenalty( item );
|
||
|
|
|
||
|
|
// Do some basic filtering. We put an extremely low score in there if the server fails
|
||
|
|
// to match the criteria. The actual value isn't important here, but it's handy to have
|
||
|
|
// different values for different failure criteria for stats.
|
||
|
|
int failureCodes = 0;
|
||
|
|
if ( !PassesFilter( item.server ) ) failureCodes |= (1<<15);
|
||
|
|
if ( !HasAppropriateTags(TagList) ) failureCodes |= (1<<14);
|
||
|
|
if ( pMapInfo == NULL )
|
||
|
|
failureCodes |= (1<<13); // unknown map
|
||
|
|
else
|
||
|
|
{
|
||
|
|
|
||
|
|
// Map is known to us, make sure it matches search criteria
|
||
|
|
switch ( m_options.m_eSelectedGameType )
|
||
|
|
{
|
||
|
|
case kGameCategory_EventMix:
|
||
|
|
if ( pMapInfo->eGameCategory != kGameCategory_EventMix && pMapInfo->eGameCategory != kGameCategory_Event247 )
|
||
|
|
failureCodes |= (1<<12);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case kGameCategory_Quickplay:
|
||
|
|
// Any map that's in the list will do
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
// Must match requested game mode
|
||
|
|
if ( pMapInfo->eGameCategory != m_options.m_eSelectedGameType )
|
||
|
|
failureCodes |= (1<<12);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ( server.m_nPlayers >= server.m_nMaxPlayers ) failureCodes |= (1<<11);
|
||
|
|
if ( m_blackList.IsServerBlacklisted( server ) ) failureCodes |= (1<<10);
|
||
|
|
|
||
|
|
if ( failureCodes != 0 )
|
||
|
|
{
|
||
|
|
item.serverScore = item.userScore = -(float)failureCodes;
|
||
|
|
item.m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_Ineligible;
|
||
|
|
|
||
|
|
// Check for certain failures that a valve server should never have
|
||
|
|
if ( item.m_bValve && ( failureCodes & ( (1<<15) | (1<<14) | (1<<13) ) ) )
|
||
|
|
{
|
||
|
|
Warning( "Valve-hosted server '%s' does not meet quickplay criteria?\n", server.GetName() );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Server pases basic filters and should be scored
|
||
|
|
item.m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_Eligible;
|
||
|
|
|
||
|
|
// Start a score based only on the server, not on us
|
||
|
|
int nHumans = item.server.m_nPlayers - item.server.m_nBotPlayers;
|
||
|
|
int nNumInSearchParty = 1; // we are a party of 1
|
||
|
|
item.serverScore = QuickplayCalculateServerScore( nHumans, item.server.m_nBotPlayers, item.server.m_nMaxPlayers, nNumInSearchParty );
|
||
|
|
item.serverScore += 6.0f; // !KLUDGE! Add offset to keep score ranges comparable with historical norms. (We used to give bonuses for some things we now simply require.)
|
||
|
|
|
||
|
|
// Start calculating score based on our own data
|
||
|
|
item.userScore = 0.0f;
|
||
|
|
|
||
|
|
// Evaluate piecewise linear ping->score function
|
||
|
|
float fPing = (float)item.server.m_nPing;
|
||
|
|
float fPingScore = 0.0f;
|
||
|
|
if ( fPing < m_fPingA )
|
||
|
|
{
|
||
|
|
fPingScore = lerp( 0.0f, 1.0f, m_fPingA, m_fPingAScore, fPing );
|
||
|
|
}
|
||
|
|
else if ( fPing < m_fPingB )
|
||
|
|
{
|
||
|
|
fPingScore = lerp( m_fPingA, m_fPingAScore, m_fPingB, m_fPingCScore, fPing );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// note: This continues to get worse and worse if the ping > pingC
|
||
|
|
fPingScore = lerp( m_fPingB, m_fPingBScore, m_fPingC, m_fPingCScore, fPing );
|
||
|
|
}
|
||
|
|
item.userScore += fPingScore;
|
||
|
|
|
||
|
|
// Give a bonus to valve servers
|
||
|
|
if ( item.m_bValve )
|
||
|
|
{
|
||
|
|
item.userScore += m_fValveBonus;
|
||
|
|
}
|
||
|
|
|
||
|
|
// weight "newbie" servers a higher
|
||
|
|
if ( item.m_bNewUserFriendly )
|
||
|
|
{
|
||
|
|
item.userScore += m_fNoobMapBonus;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add in recently-joined cooldown factor
|
||
|
|
item.userScore -= item.m_fRecentMatchPenalty;
|
||
|
|
|
||
|
|
// Penalty for rule changes
|
||
|
|
//item.userScore -= QuickplayCalculateRuleChangePenalty( TagList );
|
||
|
|
|
||
|
|
//
|
||
|
|
// Experiment
|
||
|
|
//
|
||
|
|
switch ( m_ScoringNumbers.m_eExperimentGroup )
|
||
|
|
{
|
||
|
|
default:
|
||
|
|
Assert( !"Bogus experiment group" );
|
||
|
|
case TF2ScoringNumbers_t::k_ExperimentGroup_Experiment1_Control:
|
||
|
|
case TF2ScoringNumbers_t::k_ExperimentGroup_Experiment1_ValveBiasInactive:
|
||
|
|
case TF2ScoringNumbers_t::k_ExperimentGroup_Experiment1_CommunityBiasInactive:
|
||
|
|
// No modifications
|
||
|
|
break;
|
||
|
|
|
||
|
|
case TF2ScoringNumbers_t::k_ExperimentGroup_Experiment1_ValveBias:
|
||
|
|
|
||
|
|
// Give valve servers with a good ping a significant bonus
|
||
|
|
item.userScore -= 1.0f;
|
||
|
|
if ( item.m_bValve )
|
||
|
|
{
|
||
|
|
item.userScore += fPingScore;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case TF2ScoringNumbers_t::k_ExperimentGroup_Experiment1_CommunityBias:
|
||
|
|
|
||
|
|
// Give community servers with a good ping a significant bonus
|
||
|
|
item.userScore -= 1.0f;
|
||
|
|
if ( !item.m_bValve )
|
||
|
|
{
|
||
|
|
item.userScore += fPingScore;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
netadr_t netAdr( server.m_NetAdr.GetIP(), server.m_NetAdr.GetConnectionPort() );
|
||
|
|
|
||
|
|
// Are we still in the initial pass, or are we pinging servers?
|
||
|
|
if ( m_eCurrentStep == k_EStep_GMSQuery )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Insert/update our server map
|
||
|
|
m_mapServers.InsertOrReplace( netAdr, item );
|
||
|
|
}
|
||
|
|
else if ( m_eCurrentStep == k_EStep_PingCheckNotFull || m_eCurrentStep == k_EStep_SelectServerUI )
|
||
|
|
{
|
||
|
|
|
||
|
|
// It had better be from who we expect
|
||
|
|
if ( netAdr.GetIPNetworkByteOrder() != m_adrCurrentPing.GetIPNetworkByteOrder() || netAdr.GetPort() != m_adrCurrentPing.GetPort() )
|
||
|
|
{
|
||
|
|
// Of course, we could receive a packet on the network at any
|
||
|
|
// time. But we expect the steam API's to deal with that.
|
||
|
|
// But still, just in case....
|
||
|
|
Warning( "Received unexpected server ping from %s\n", netAdr.ToString() );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
|
||
|
|
// !TEST! Simulate server filling up
|
||
|
|
//failureCodes |= (1<<11);
|
||
|
|
|
||
|
|
// Find it in the server list; update the result
|
||
|
|
int iServerIndex = m_mapServers.Find( m_adrCurrentPing );
|
||
|
|
Assert( m_mapServers.IsValidIndex(iServerIndex) );
|
||
|
|
|
||
|
|
if ( failureCodes == 0 )
|
||
|
|
{
|
||
|
|
if ( m_mapServers.IsValidIndex(iServerIndex) )
|
||
|
|
{
|
||
|
|
Assert( m_mapServers[iServerIndex].m_eStatus == TF_Gamestats_QuickPlay_t::k_Server_Pinged );
|
||
|
|
m_mapServers[iServerIndex].m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_Connected;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Still joinable. JOIN IT!
|
||
|
|
TF_MATCHMAKING_SPEW(2, "Reply ping from %s. Client score is now %.02f.\n", netAdr.ToString(), item.TotalScore() );
|
||
|
|
ConnectToServer( netAdr.GetIPHostByteOrder(), netAdr.GetPort() );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if ( m_mapServers.IsValidIndex(iServerIndex) )
|
||
|
|
{
|
||
|
|
Assert( m_mapServers[iServerIndex].m_eStatus == TF_Gamestats_QuickPlay_t::k_Server_Pinged );
|
||
|
|
m_mapServers[iServerIndex].m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_PingIneligible;
|
||
|
|
}
|
||
|
|
|
||
|
|
// We missed the window of opportunity.
|
||
|
|
// Move on to our next best choice
|
||
|
|
TF_MATCHMAKING_SPEW(2, "Reply ping from %s, but no longer joinable!\n", netAdr.ToString() );
|
||
|
|
if ( m_eCurrentStep == k_EStep_SelectServerUI )
|
||
|
|
{
|
||
|
|
if ( failureCodes & (1<<11) )
|
||
|
|
QuickpickPingFailed( "#TF_Quickplay_SelectedServer_Full" );
|
||
|
|
else
|
||
|
|
QuickpickPingFailed( "#TF_Quickplay_SelectedServer_NoLongerMeetsCriteria" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
PingNextBestServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Eh?
|
||
|
|
Assert( false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void ServerFailedToRespond()
|
||
|
|
{
|
||
|
|
if ( m_eCurrentStep == k_EStep_PingCheckNotFull || m_eCurrentStep == k_EStep_SelectServerUI )
|
||
|
|
{
|
||
|
|
TF_MATCHMAKING_SPEW(2, "Timeout waiting on ping reply from %s.\n", m_adrCurrentPing.ToString() );
|
||
|
|
|
||
|
|
// Find it in the server list; record the failure result
|
||
|
|
int iServerIndex = m_mapServers.Find( m_adrCurrentPing );
|
||
|
|
if ( m_mapServers.IsValidIndex(iServerIndex) )
|
||
|
|
{
|
||
|
|
Assert( m_mapServers[iServerIndex].m_eStatus == TF_Gamestats_QuickPlay_t::k_Server_Pinged );
|
||
|
|
m_mapServers[iServerIndex].m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_PingTimedOut;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Wat.
|
||
|
|
Assert( m_mapServers.IsValidIndex(iServerIndex) );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( m_eCurrentStep == k_EStep_SelectServerUI )
|
||
|
|
{
|
||
|
|
QuickpickPingFailed( "#TF_Quickplay_SelectedServer_Timeout" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
PingNextBestServer();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// We can get some timeouts after we've finished, during cleanup.
|
||
|
|
// Just ignore it
|
||
|
|
Assert( m_eCurrentStep == k_EStep_Terminated );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Internal members
|
||
|
|
//
|
||
|
|
bool HasAppropriateTags( const CUtlStringList &TagList )
|
||
|
|
{
|
||
|
|
FOR_EACH_VEC( m_vecStrRequiredTags, idx )
|
||
|
|
{
|
||
|
|
if ( !BHasTag( TagList, m_vecStrRequiredTags[idx] ) )
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
FOR_EACH_VEC( m_vecStrRejectTags, idx )
|
||
|
|
{
|
||
|
|
if ( BHasTag( TagList, m_vecStrRejectTags[idx] ) )
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void DestroyServerListRequest()
|
||
|
|
{
|
||
|
|
if ( m_hServerListRequest )
|
||
|
|
{
|
||
|
|
steamapicontext->SteamMatchmakingServers()->ReleaseRequest( m_hServerListRequest );
|
||
|
|
m_hServerListRequest = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void DestroyServerQueryRequest()
|
||
|
|
{
|
||
|
|
if ( m_hServerQueryRequest != HSERVERQUERY_INVALID )
|
||
|
|
{
|
||
|
|
steamapicontext->SteamMatchmakingServers()->CancelServerQuery( m_hServerQueryRequest );
|
||
|
|
m_hServerQueryRequest = HSERVERQUERY_INVALID;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void AddFilter( CUtlVector<MatchMakingKeyValuePair_t> &vecServerFilters, const char *pchKey, const char *pchValue )
|
||
|
|
{
|
||
|
|
// @note Tom Bui: this is to get around the linker error where we don't like strncpy in MatchMakingKeyValuePair_t's constructor!
|
||
|
|
int idx = vecServerFilters.AddToTail();
|
||
|
|
MatchMakingKeyValuePair_t &keyvalue = vecServerFilters[idx];
|
||
|
|
Q_strncpy( keyvalue.m_szKey, pchKey, sizeof( keyvalue.m_szKey ) );
|
||
|
|
Q_strncpy( keyvalue.m_szValue, pchValue, sizeof( keyvalue.m_szValue ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
static void AddMapsFilter( CUtlVector<MatchMakingKeyValuePair_t> &vecServerFilters, EGameCategory t )
|
||
|
|
{
|
||
|
|
CUtlString sMapList;
|
||
|
|
for ( int i = 0 ; i < GetItemSchema()->GetMapCount() ; ++i )
|
||
|
|
{
|
||
|
|
const SchemaMap_t& map = GetItemSchema()->GetMapForIndex( i );
|
||
|
|
int mapType = map.eGameCategory;
|
||
|
|
if ( ( mapType == t ) || ( ( mapType == kGameCategory_Event247 ) && ( t == kGameCategory_EventMix ) ) )
|
||
|
|
{
|
||
|
|
if ( !sMapList.IsEmpty() )
|
||
|
|
{
|
||
|
|
sMapList.Append( "," );
|
||
|
|
}
|
||
|
|
sMapList.Append( map.pszMapName );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
MatchMakingKeyValuePair_t kludge;
|
||
|
|
if ( sMapList.Length() < sizeof( kludge.m_szValue ) )
|
||
|
|
{
|
||
|
|
AddFilter( vecServerFilters, "map", sMapList );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Warning( "List of map names too long for this game mode, cannot filter on server side!\n" );
|
||
|
|
Assert( false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool PassesFilter( const gameserveritem_t &server )
|
||
|
|
{
|
||
|
|
if ( server.m_nAppID != m_nAppID )
|
||
|
|
{
|
||
|
|
// This should be filtered by the steam matchmaking servers API
|
||
|
|
AssertMsg( server.m_nAppID == 0, "Got back server with wrong APP ID?" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( server.m_bPassword )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if ( GetUniverse() == k_EUniversePublic )
|
||
|
|
{
|
||
|
|
if ( server.m_bSecure == false )
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( server.m_nMaxPlayers > kTFQuickPlayMaxPlayers )
|
||
|
|
return false;
|
||
|
|
if ( server.m_nMaxPlayers < kTFQuickPlayMinMaxNumberOfPlayers )
|
||
|
|
return false;
|
||
|
|
switch ( m_options.m_eMaxPlayers )
|
||
|
|
{
|
||
|
|
case QuickplaySearchOptions::eMaxPlayers24:
|
||
|
|
if ( server.m_nMaxPlayers != 24 )
|
||
|
|
return false;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case QuickplaySearchOptions::eMaxPlayers30Plus:
|
||
|
|
if ( server.m_nMaxPlayers < 30 )
|
||
|
|
return false;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
case QuickplaySearchOptions::eMaxPlayersDontCare:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( server.m_steamID.BGameServerAccount() == false )
|
||
|
|
return false;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CalculateRecentMatchPenalty( sortable_gameserveritem_t &item )
|
||
|
|
{
|
||
|
|
// Hysteresis
|
||
|
|
int iRecentIndex = FindRecentlyMatchedServer( item.server.m_NetAdr.GetIP(), item.server.m_NetAdr.GetConnectionPort() );
|
||
|
|
item.m_fRecentMatchPenalty = 0.0f;
|
||
|
|
if ( iRecentIndex >= 0 )
|
||
|
|
{
|
||
|
|
float fAge = (float)(CRTime::RTime32TimeCur() - s_vecRecentlyMatchedServers[iRecentIndex].m_timeMatched);
|
||
|
|
if ( fAge < 0.0f )
|
||
|
|
{
|
||
|
|
// Time running in reverse?!
|
||
|
|
Assert( fAge >= 0.0f );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
float fCooldownTime = tf_matchmaking_retry_cooldown_seconds.GetFloat();
|
||
|
|
Assert( fCooldownTime > 0.0f );
|
||
|
|
if ( fCooldownTime > 0.0f ) // 0 can be used to turn this off, but then all the entries should immediately expire and we shouldn't be here...
|
||
|
|
{
|
||
|
|
float fAgePct = MIN( fAge / fCooldownTime, 1.0f );
|
||
|
|
item.m_fRecentMatchPenalty = (1.0f - fAgePct) * tf_matchmaking_retry_max_penalty.GetFloat();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void OnThink()
|
||
|
|
{
|
||
|
|
BaseClass::OnThink();
|
||
|
|
|
||
|
|
double currentTime = Plat_FloatTime();
|
||
|
|
|
||
|
|
// Do work, depending on the current step
|
||
|
|
switch ( m_eCurrentStep )
|
||
|
|
{
|
||
|
|
case k_EStep_GMSQuery:
|
||
|
|
CheckSendScoresToGC();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case k_EStep_GCScore:
|
||
|
|
// Check for timeout
|
||
|
|
Assert( m_timeGCScoreTimeout > 0.0 );
|
||
|
|
if ( currentTime > m_timeGCScoreTimeout )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Well, we never heard back from the GC. But we needn't let that stop us.
|
||
|
|
// We have quite a bit of data, let's just go with what we have, rather
|
||
|
|
// than totally failing
|
||
|
|
C_CTFGameStats::ImmediateWriteInterfaceEvent( "response(quickplay)", "gc_score_timeout" );
|
||
|
|
Warning( "Timed out waiting to get scores back from GC, proceding without reputation data.\n" );
|
||
|
|
|
||
|
|
CMsgTFQuickplay_ScoreServersResponse emptyMsg;
|
||
|
|
OnReceivedGCScores( emptyMsg );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case k_EStep_SelectServerUI:
|
||
|
|
// !FIXME! Ping servers every now and then and remove the full ones?
|
||
|
|
break;
|
||
|
|
|
||
|
|
case k_EStep_PingCheckNotFull:
|
||
|
|
|
||
|
|
// Do our own timeout processing
|
||
|
|
Assert( m_hServerQueryRequest != HSERVERQUERY_INVALID );
|
||
|
|
if ( currentTime > m_timePingServerTimeout || m_hServerQueryRequest == HSERVERQUERY_INVALID )
|
||
|
|
{
|
||
|
|
ServerFailedToRespond();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case k_EStep_Terminated:
|
||
|
|
// Just wait to die
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
Assert( false );
|
||
|
|
SendStats( TF_Gamestats_QuickPlay_t::k_Result_InternalError );
|
||
|
|
GenericFailure();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Called when we're done, just before we go on to wherever we're going next
|
||
|
|
void CloseMe()
|
||
|
|
{
|
||
|
|
m_eCurrentStep = k_EStep_Terminated;
|
||
|
|
DestroyServerListRequest();
|
||
|
|
DestroyServerQueryRequest();
|
||
|
|
CloseWaitingDialog();
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void GenericFailure()
|
||
|
|
{
|
||
|
|
CloseMe();
|
||
|
|
ShowMessageBox( "#TF_MM_GenericFailure_Title", "#TF_MM_GenericFailure", "#GameUI_OK", &OpenQuickplayDialogCallback );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void NoServersFoundFailure()
|
||
|
|
{
|
||
|
|
CloseMe();
|
||
|
|
ShowMessageBox( "#TF_MM_ResultsDialog_Title", "#TF_MM_ResultsDialog_ServerNotFound", "#GameUI_OK", &OpenQuickplayDialogCallback );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CheckSendScoresToGC()
|
||
|
|
{
|
||
|
|
|
||
|
|
// How long have we been searching?
|
||
|
|
Assert( m_timeGMSSearchStarted > 0.0 );
|
||
|
|
float fSearchDuration = Plat_FloatTime() - m_timeGMSSearchStarted;
|
||
|
|
|
||
|
|
// Get a list of all the servers worth joining, and sort them
|
||
|
|
float fScoreThreshold = 1.0f; // !FIXME! Put into convar
|
||
|
|
CUtlSortVector< sortable_gameserveritem_t *, CGameServerItemSort > vecGameServers;
|
||
|
|
FOR_EACH_MAP_FAST( m_mapServers, idx )
|
||
|
|
{
|
||
|
|
sortable_gameserveritem_t *pItem = &m_mapServers[idx];
|
||
|
|
if ( pItem->TotalScore() > fScoreThreshold )
|
||
|
|
{
|
||
|
|
vecGameServers.InsertNoSort( pItem );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
vecGameServers.RedoSort();
|
||
|
|
|
||
|
|
// See how long we've been searching, relative to the max time
|
||
|
|
Assert( tf_matchmaking_max_search_time.GetFloat() > 0.0 ); // don't be dumb
|
||
|
|
float fSearchTimePct = fSearchDuration / tf_matchmaking_max_search_time.GetFloat();
|
||
|
|
|
||
|
|
// Give up based on sheer timeout?
|
||
|
|
if ( fSearchTimePct > 1.0 )
|
||
|
|
{
|
||
|
|
// Time to give up
|
||
|
|
TF_MATCHMAKING_SPEW(1, "Quickplay GMS search timed out. We'll go with what we've found so far.\n" );
|
||
|
|
DestroyServerListRequest();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if we should keep searching
|
||
|
|
if ( m_hServerListRequest )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Determine "good enough" tolerances
|
||
|
|
float fScoreLo = Lerp( fSearchTimePct, tf_matchmaking_goodenough_score_start.GetFloat(), tf_matchmaking_goodenough_score_end.GetFloat() );
|
||
|
|
float fCountLo = Lerp( fSearchTimePct, tf_matchmaking_goodenough_count_start.GetFloat(), tf_matchmaking_goodenough_count_end.GetFloat() );
|
||
|
|
//float fScoreHi = Lerp( fSearchTimePct, tf_matchmaking_goodenough_hi_score_start.GetFloat(), tf_matchmaking_goodenough_hi_score_end.GetFloat() );
|
||
|
|
//float fCountHi = Lerp( fSearchTimePct, tf_matchmaking_goodenough_hi_count_start.GetFloat(), tf_matchmaking_goodenough_hi_count_end.GetFloat() );
|
||
|
|
|
||
|
|
// !TEST! Hack this to force us to just show some servers
|
||
|
|
//fScoreLo = 3.0f;
|
||
|
|
//fCountLo = 10.0f;
|
||
|
|
|
||
|
|
// Now scan list to see if we have enough results at this point
|
||
|
|
int iGoodEnoughCount = 0;
|
||
|
|
for ( iGoodEnoughCount = 0 ; iGoodEnoughCount < vecGameServers.Count() ; ++iGoodEnoughCount)
|
||
|
|
{
|
||
|
|
sortable_gameserveritem_t *pItem = vecGameServers[ iGoodEnoughCount ];
|
||
|
|
if ( pItem->TotalScore() < fScoreLo )
|
||
|
|
{
|
||
|
|
// This guy and all subsequent ones don't meet the criteria.
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
Assert( pItem->m_eStatus == TF_Gamestats_QuickPlay_t::k_Server_Eligible );
|
||
|
|
}
|
||
|
|
|
||
|
|
// See how many more are eligible, just not meeting our criteria to terminate the search
|
||
|
|
int iEligibleCount = iGoodEnoughCount;
|
||
|
|
while ( iEligibleCount < vecGameServers.Count() && vecGameServers[iEligibleCount]->m_eStatus > TF_Gamestats_QuickPlay_t::k_Server_Ineligible )
|
||
|
|
{
|
||
|
|
Assert( vecGameServers[iEligibleCount]->m_eStatus == TF_Gamestats_QuickPlay_t::k_Server_Eligible );
|
||
|
|
++iEligibleCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update the dialog
|
||
|
|
if ( m_pBusyContainer )
|
||
|
|
{
|
||
|
|
locchar_t wszValue[64];
|
||
|
|
locchar_t wszText[256];
|
||
|
|
loc_sprintf_safe( wszValue, LOCCHAR( "%u" ), iEligibleCount );
|
||
|
|
g_pVGuiLocalize->ConstructString_safe( wszText, g_pVGuiLocalize->Find( "#TF_Quickplay_NumGames" ), 1, wszValue );
|
||
|
|
m_pBusyContainer->SetDialogVariable( "numservers", wszText );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Found enough good servers to bail now?
|
||
|
|
if ( iGoodEnoughCount >= (int)(fCountLo + 0.5f) )
|
||
|
|
{
|
||
|
|
TF_MATCHMAKING_SPEW(1, "Quickplay initial search: %d servers with scores %.2f or better. Good enough...proceeding to backend scoring.\n", iGoodEnoughCount, fScoreLo );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// We haven't found enough good servers. Update progress indicator
|
||
|
|
// to show that we're doing something
|
||
|
|
if ( m_pProgressBar )
|
||
|
|
{
|
||
|
|
// Determine percentage completion based on "good enough" criteria.
|
||
|
|
float fGoodEnoughPct = (float)iGoodEnoughCount / (float)fCountLo;
|
||
|
|
|
||
|
|
// Use max of this indicator, or basic timeout. That way,
|
||
|
|
// there is always some motion on the progress bar
|
||
|
|
float fProgressPct = MAX( fGoodEnoughPct, fSearchTimePct );
|
||
|
|
|
||
|
|
// Set it
|
||
|
|
m_pProgressBar->SetProgress( fProgressPct );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Keep searching
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// OK, we think we've got enough decent servers to see what the GC thinks.
|
||
|
|
// No need to keep talking to the GMS
|
||
|
|
DestroyServerListRequest();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set progress bar to 100%
|
||
|
|
if ( m_pProgressBar )
|
||
|
|
{
|
||
|
|
m_pProgressBar->SetProgress( 1.0f );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decide how many to score.
|
||
|
|
const int iNumServersToScore = MIN( vecGameServers.Count(), kTFMaxQuickPlayServersToScore );
|
||
|
|
|
||
|
|
//
|
||
|
|
// Dump some debug stuff to the console
|
||
|
|
//
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "Quickplay client scoring\n" );
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "Selected game mode: %d\n", m_options.m_eSelectedGameType );
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "Hours played: %.1f\n", m_fHoursPlayed );
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "Valve server bonus: %.2f, noob map bonus: %.2f\n", m_fValveBonus, m_fNoobMapBonus );
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "Search duration: %.1f\n", fSearchDuration );
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "Found %d total servers, %d met minimum score threshold, %d will be sent to GC for scoring\n", m_mapServers.Count(), vecGameServers.Count(), iNumServersToScore );
|
||
|
|
CUtlSortVector< sortable_gameserveritem_t *, CGameServerItemSort > vecGameServersToPrint;
|
||
|
|
if ( tf_matchmaking_debug.GetInt() >= 4 )
|
||
|
|
{
|
||
|
|
FOR_EACH_MAP_FAST( m_mapServers, idx )
|
||
|
|
{
|
||
|
|
vecGameServersToPrint.InsertNoSort( &m_mapServers[idx] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if ( tf_matchmaking_debug.GetInt() >= 3 )
|
||
|
|
{
|
||
|
|
for ( int i = 0 ; i < vecGameServers.Count() ; ++i)
|
||
|
|
{
|
||
|
|
vecGameServersToPrint.InsertNoSort( vecGameServers[i] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if ( tf_matchmaking_debug.GetInt() >= 2 )
|
||
|
|
{
|
||
|
|
for ( int i = 0 ; i < iNumServersToScore ; ++i)
|
||
|
|
{
|
||
|
|
vecGameServersToPrint.InsertNoSort( vecGameServers[i] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ( vecGameServersToPrint.Count() > 0 )
|
||
|
|
{
|
||
|
|
vecGameServersToPrint.RedoSort();
|
||
|
|
Msg( "Name, address, numplayers, maxplayers, ping, new user friendly, registered, valve, recent match penalty, user score, server score, total score, steamID, map, tags\n" );
|
||
|
|
|
||
|
|
// Print in reverse order --- the bottom is the most interesting part and the log usually scrolls.
|
||
|
|
// Anybody looking at a file can pull it into excel and sort however they want
|
||
|
|
for ( int i = vecGameServersToPrint.Count()-1 ; i >=0 ; --i )
|
||
|
|
{
|
||
|
|
sortable_gameserveritem_t &item = *vecGameServersToPrint[i];
|
||
|
|
Msg( "\"%s\",\"%s\",%d,%d,%d,%d,%d,%d,%.2f,%7.4f,%7.4f,%7.4f,\"%s\",\"%s\",\"%s\"\n",
|
||
|
|
item.server.GetName(),
|
||
|
|
item.server.m_NetAdr.GetConnectionAddressString(),
|
||
|
|
item.server.m_nPlayers - item.server.m_nBotPlayers, item.server.m_nMaxPlayers, item.server.m_nPing,
|
||
|
|
item.m_bNewUserFriendly ? 1 : 0,
|
||
|
|
item.m_bRegistered ? 1 : 0,
|
||
|
|
item.m_bValve ? 1 : 0,
|
||
|
|
item.m_fRecentMatchPenalty,
|
||
|
|
item.userScore, item.serverScore, item.serverScore+item.userScore,
|
||
|
|
item.server.m_steamID.Render(),
|
||
|
|
item.server.m_szMap,
|
||
|
|
item.server.m_szGameTags
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// *NOW* Check for failure. (We waited until now, so we can properly log it.)
|
||
|
|
if ( iNumServersToScore <= 0 )
|
||
|
|
{
|
||
|
|
C_CTFGameStats::ImmediateWriteInterfaceEvent( "response(quickplay)", "servers_not_found" );
|
||
|
|
SendStats( m_mapServers.Count() > 0 ?
|
||
|
|
TF_Gamestats_QuickPlay_t::k_Result_NoServersMetCrtieria :
|
||
|
|
TF_Gamestats_QuickPlay_t::k_Result_NoServersFound );
|
||
|
|
NoServersFoundFailure();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// send message to GC
|
||
|
|
GCSDK::CProtoBufMsg< CMsgTFQuickplay_ScoreServers > msg( k_EMsgGC_QP_ScoreServers );
|
||
|
|
for ( int i = 0; i < iNumServersToScore; ++i )
|
||
|
|
{
|
||
|
|
sortable_gameserveritem_t *pItem = vecGameServers[i];
|
||
|
|
gameserveritem_t &server = pItem->server;
|
||
|
|
Assert( pItem->m_eStatus == TF_Gamestats_QuickPlay_t::k_Server_Eligible );
|
||
|
|
pItem->m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_RequestedScore;
|
||
|
|
CMsgTFQuickplay_ScoreServers_ServerInfo *pServerInfo = msg.Body().add_servers();
|
||
|
|
pServerInfo->set_server_address( server.m_NetAdr.GetIP() );
|
||
|
|
pServerInfo->set_server_port( server.m_NetAdr.GetConnectionPort() );
|
||
|
|
pServerInfo->set_num_users( server.m_nPlayers - server.m_nBotPlayers );
|
||
|
|
pServerInfo->set_max_users( server.m_nMaxPlayers );
|
||
|
|
pServerInfo->set_user_score( pItem->userScore );
|
||
|
|
pServerInfo->set_steam_id( server.m_steamID.ConvertToUint64() );
|
||
|
|
}
|
||
|
|
|
||
|
|
m_eCurrentStep = k_EStep_GCScore;
|
||
|
|
|
||
|
|
//// !TEST! Skip scoring
|
||
|
|
//CMsgTFQuickplay_ScoreServersResponse emptyMsg;
|
||
|
|
//OnReceivedGCScores( emptyMsg );
|
||
|
|
//return;
|
||
|
|
|
||
|
|
GCClientSystem()->BSendMessage( msg );
|
||
|
|
|
||
|
|
// Give the GC some time to respond. It usually wil respond very quickly
|
||
|
|
m_timeGCScoreTimeout = Plat_FloatTime() + 10.0f;
|
||
|
|
}
|
||
|
|
|
||
|
|
void UserConnectToServer()
|
||
|
|
{
|
||
|
|
Assert( m_eCurrentStep == k_EStep_SelectServerUI );
|
||
|
|
if ( m_adrCurrentPing.IsValid() )
|
||
|
|
return;
|
||
|
|
CQuickListPanel *pPanel = dynamic_cast<CQuickListPanel*>( m_pServerListPanel->GetSelectedPanel() );
|
||
|
|
if ( pPanel == NULL )
|
||
|
|
return;
|
||
|
|
int idx = pPanel->GetListID();
|
||
|
|
m_adrCurrentPing = m_mapServers.Key( idx );
|
||
|
|
PingServer();
|
||
|
|
}
|
||
|
|
|
||
|
|
void QuickpickPingFailed( const char *pszLocTok )
|
||
|
|
{
|
||
|
|
ShowMessageBox( "#TF_Quickplay_Error", pszLocTok, "#GameUI_OK" );
|
||
|
|
|
||
|
|
// Remove this guy
|
||
|
|
for ( int i = 0 ; i < m_vecServerJoinQueue.Count() ; ++i )
|
||
|
|
{
|
||
|
|
if ( m_vecServerJoinQueue[i].m_adr == m_adrCurrentPing )
|
||
|
|
{
|
||
|
|
m_vecServerJoinQueue.Remove(i);
|
||
|
|
if ( m_pServerListPanel )
|
||
|
|
m_pServerListPanel->RemoveItem(i);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_adrCurrentPing.Clear();
|
||
|
|
|
||
|
|
// !KLUDGE! If the list goes empty, then just act like they hit ESC.
|
||
|
|
if ( m_pServerListPanel && m_pServerListPanel->GetItemCount() == 0 )
|
||
|
|
OnCommand( "user_close" );
|
||
|
|
}
|
||
|
|
|
||
|
|
void PingNextBestServer()
|
||
|
|
{
|
||
|
|
Assert( m_eCurrentStep == k_EStep_PingCheckNotFull );
|
||
|
|
|
||
|
|
// If we already have any ping activity going, cancel it. (We shouldn't)
|
||
|
|
DestroyServerQueryRequest();
|
||
|
|
|
||
|
|
// Any more options to try?
|
||
|
|
if ( m_vecServerJoinQueue.Count() < 1 )
|
||
|
|
{
|
||
|
|
TF_MATCHMAKING_SPEW( 1, "No more scored servers left to ping. We failed!\n" );
|
||
|
|
SendStats( TF_Gamestats_QuickPlay_t::k_Result_FinalPingFailed );
|
||
|
|
NoServersFoundFailure();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Remove the next address from the queue
|
||
|
|
m_adrCurrentPing = m_vecServerJoinQueue[0].m_adr;
|
||
|
|
m_vecServerJoinQueue.Remove( 0 );
|
||
|
|
|
||
|
|
// Do it
|
||
|
|
PingServer();
|
||
|
|
}
|
||
|
|
|
||
|
|
void PingServer()
|
||
|
|
{
|
||
|
|
// If we already have any ping activity going, cancel it. (We shouldn't)
|
||
|
|
DestroyServerQueryRequest();
|
||
|
|
|
||
|
|
// Find it in the server list; mark it as being pinged
|
||
|
|
int iServerIndex = m_mapServers.Find( m_adrCurrentPing );
|
||
|
|
if ( m_mapServers.IsValidIndex(iServerIndex) )
|
||
|
|
{
|
||
|
|
Assert( m_mapServers[iServerIndex].m_eStatus >= TF_Gamestats_QuickPlay_t::k_Server_Eligible );
|
||
|
|
m_mapServers[iServerIndex].m_eStatus = TF_Gamestats_QuickPlay_t::k_Server_Pinged;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Wat.
|
||
|
|
Assert( m_mapServers.IsValidIndex(iServerIndex) );
|
||
|
|
}
|
||
|
|
|
||
|
|
// Send the ping
|
||
|
|
TF_MATCHMAKING_SPEW( 2, "Pinging %s\n", m_adrCurrentPing.ToString() );
|
||
|
|
m_hServerQueryRequest = steamapicontext->SteamMatchmakingServers()->PingServer( m_adrCurrentPing.GetIPHostByteOrder(), m_adrCurrentPing.GetPort(), this );
|
||
|
|
Assert( m_hServerQueryRequest != HSERVERQUERY_INVALID );
|
||
|
|
|
||
|
|
// Set timeout. Since we've already pinged them once
|
||
|
|
// fairly recently, and we are considering joining this
|
||
|
|
// server, we don't want to wait around forever. They
|
||
|
|
// should reply to the ping pretty quickly or let's
|
||
|
|
// not join them.
|
||
|
|
m_timePingServerTimeout = Plat_FloatTime() + 1.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void OnKeyCodeTyped( vgui::KeyCode code )
|
||
|
|
{
|
||
|
|
if( code == KEY_ESCAPE )
|
||
|
|
{
|
||
|
|
OnCommand( "user_close" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
BaseClass::OnKeyCodeTyped( code );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
class CStandaloneQuickplayMenu : public CQuickplayWaitDialog
|
||
|
|
{
|
||
|
|
DECLARE_CLASS_SIMPLE( CStandaloneQuickplayMenu, CQuickplayWaitDialog );
|
||
|
|
public:
|
||
|
|
CStandaloneQuickplayMenu( bool bFeelingLucky, const QuickplaySearchOptions &opt )
|
||
|
|
: BaseClass( bFeelingLucky, opt )
|
||
|
|
{}
|
||
|
|
|
||
|
|
virtual void GenericFailure() OVERRIDE
|
||
|
|
{
|
||
|
|
CloseMe();
|
||
|
|
ShowMessageBox( "#TF_MM_GenericFailure_Title", "#TF_MM_GenericFailure", "#GameUI_OK", NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void NoServersFoundFailure() OVERRIDE
|
||
|
|
{
|
||
|
|
CloseMe();
|
||
|
|
ShowMessageBox( "#TF_MM_ResultsDialog_Title", "#TF_MM_ResultsDialog_ServerNotFound", "#GameUI_OK", NULL );
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Quickplay Dialog
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
ConVar tf_quickplay_lastviewedmode( "tf_quickplay_lastviewedmode", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
|
||
|
|
|
||
|
|
CQuickplayPanelBase::CQuickplayPanelBase( vgui::Panel *parent, const char *name )
|
||
|
|
: vgui::EditablePanel( parent, name )
|
||
|
|
, m_iCurrentItem( 0 )
|
||
|
|
, m_pContainer( NULL )
|
||
|
|
, m_bSetInitialSelection( false )
|
||
|
|
, m_pPrevPageButton( NULL )
|
||
|
|
, m_pNextPageButton( NULL )
|
||
|
|
, m_bShowRandomOption( true )
|
||
|
|
, m_pSimplifiedOptionsContainer( NULL )
|
||
|
|
, m_pAdvOptionsContainer( NULL )
|
||
|
|
{
|
||
|
|
vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme" );
|
||
|
|
SetScheme(scheme);
|
||
|
|
SetProportional( true );
|
||
|
|
}
|
||
|
|
CQuickplayPanelBase::~CQuickplayPanelBase()
|
||
|
|
{
|
||
|
|
vgui::ivgui()->RemoveTickSignal( GetVPanel() );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::ShowItemByGameType( EGameCategory type )
|
||
|
|
{
|
||
|
|
for ( int i = 0 ; i < m_vecItems.Count() ; ++i )
|
||
|
|
{
|
||
|
|
if ( m_vecItems[i].gameType == type )
|
||
|
|
{
|
||
|
|
ShowItemByIndex( i );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
AssertMsg1( false, "Bogus quickplay type %d", type );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::ShowItemByIndex( int iItem )
|
||
|
|
{
|
||
|
|
Assert( iItem >= 0 );
|
||
|
|
Assert( iItem < m_vecItems.Size() );
|
||
|
|
m_iCurrentItem = iItem;
|
||
|
|
|
||
|
|
QuickplayItem &item = m_vecItems[ m_iCurrentItem ];
|
||
|
|
|
||
|
|
if ( m_pGameModeInfoContainer )
|
||
|
|
{
|
||
|
|
m_pGameModeInfoContainer->SetDialogVariable( "gametype", g_pVGuiLocalize->Find( item.pTitle ) );
|
||
|
|
m_pGameModeInfoContainer->SetDialogVariable( "description", g_pVGuiLocalize->Find( item.pDescription ) );
|
||
|
|
m_pGameModeInfoContainer->SetDialogVariable( "complexity", g_pVGuiLocalize->Find( item.pComplexity ) );
|
||
|
|
|
||
|
|
if ( m_pMoreInfoContainer )
|
||
|
|
m_pMoreInfoContainer->SetDialogVariable( "more_info", g_pVGuiLocalize->Find( item.pMoreInfo ) );
|
||
|
|
|
||
|
|
vgui::ImagePanel *pImage = dynamic_cast< vgui::ImagePanel* >( m_pGameModeInfoContainer->FindChildByName( "ModeImage" ) );
|
||
|
|
if ( pImage )
|
||
|
|
{
|
||
|
|
pImage->SetImage( GetItemImage( item ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
char szTmp[16];
|
||
|
|
Q_snprintf(szTmp, 16, "%d/%d", m_iCurrentItem + 1, m_vecItems.Size() );
|
||
|
|
if ( m_pSimplifiedOptionsContainer )
|
||
|
|
m_pSimplifiedOptionsContainer->SetDialogVariable( "page", szTmp );
|
||
|
|
|
||
|
|
if ( m_pGameModeCombo )
|
||
|
|
m_pGameModeCombo->SilentActivateItemByRow( iItem );
|
||
|
|
|
||
|
|
WriteOptionCombosAndSummary();
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *CQuickplayPanelBase::GetItemImage( const QuickplayItem& item ) const
|
||
|
|
{
|
||
|
|
return item.pImage;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::SetupActionTarget( const char *pPanelName )
|
||
|
|
{
|
||
|
|
vgui::Panel *pPanel = m_pContainer->FindChildByName( pPanelName, true );
|
||
|
|
if ( pPanel )
|
||
|
|
{
|
||
|
|
pPanel->AddActionSignalTarget( this );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::AddItem( EGameCategory gameType, const char *pTitle, const char *pDescription, const char *pMoreInfo, const char *pComplexity, const char *pImage, const char *pBetaImage )
|
||
|
|
{
|
||
|
|
int idx = m_vecAllItems.AddToTail();
|
||
|
|
QuickplayItem &item = m_vecAllItems[idx];
|
||
|
|
item.gameType = gameType;
|
||
|
|
item.pTitle = pTitle;
|
||
|
|
item.pDescription = pDescription;
|
||
|
|
item.pMoreInfo = pMoreInfo;
|
||
|
|
item.pComplexity = pComplexity;
|
||
|
|
item.pImage = pImage;
|
||
|
|
item.pBetaImage = pBetaImage;
|
||
|
|
|
||
|
|
if ( m_pGameModeCombo )
|
||
|
|
m_pGameModeCombo->AddItem( pTitle, NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::UpdateSelectableItems()
|
||
|
|
{
|
||
|
|
m_vecItems = m_vecAllItems;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::ApplySettings( KeyValues *pInResourceData )
|
||
|
|
{
|
||
|
|
BaseClass::ApplySettings( pInResourceData );
|
||
|
|
|
||
|
|
V_strcpy_safe( m_szEvent247Image, pInResourceData->GetString( "event247_image", "illustrations/gamemode_halloween" ) );
|
||
|
|
V_strcpy_safe( m_szCommunityUpdateImage, pInResourceData->GetString( "community_update_image", "illustrations/gamemode_cp" ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::ApplySchemeSettings( vgui::IScheme *pScheme )
|
||
|
|
{
|
||
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
||
|
|
|
||
|
|
m_pSimplifiedOptionsContainer = dynamic_cast< vgui::EditablePanel *>( FindChildByName( "SimplifiedOptionsContainer", true ) ); Assert( m_pSimplifiedOptionsContainer );
|
||
|
|
if ( m_pSimplifiedOptionsContainer )
|
||
|
|
{
|
||
|
|
m_pGameModeInfoContainer = dynamic_cast< vgui::EditablePanel *>( m_pSimplifiedOptionsContainer->FindChildByName( "ModeInfoContainer", true ) ); Assert( m_pGameModeInfoContainer );
|
||
|
|
}
|
||
|
|
if ( m_pGameModeInfoContainer )
|
||
|
|
{
|
||
|
|
m_pMoreInfoContainer = dynamic_cast< vgui::EditablePanel *>( m_pGameModeInfoContainer->FindChildByName( "MoreInfoContainer", true ) ); Assert( m_pMoreInfoContainer );
|
||
|
|
}
|
||
|
|
m_pPrevPageButton = dynamic_cast< vgui::Button *>( FindChildByName( "PrevPageButton", true ) ); Assert( m_pPrevPageButton );
|
||
|
|
m_pNextPageButton = dynamic_cast< vgui::Button *>( FindChildByName( "NextPageButton", true ) ); Assert( m_pNextPageButton );
|
||
|
|
m_pMoreOptionsButton = dynamic_cast< vgui::Button *>( FindChildByName( "OptionsButton", true ) );
|
||
|
|
m_pAdvOptionsContainer = dynamic_cast< vgui::EditablePanel *>( FindChildByName( "AdvOptionsContainer", true ) );
|
||
|
|
m_pGameModeCombo = NULL;
|
||
|
|
m_pOptionsSummaryLabel = NULL;
|
||
|
|
if ( m_pAdvOptionsContainer )
|
||
|
|
{
|
||
|
|
Panel *pGameModeOptionContainer = m_pAdvOptionsContainer->FindChildByName( "GameModeOptionContainer", true ); Assert( pGameModeOptionContainer );
|
||
|
|
|
||
|
|
if ( pGameModeOptionContainer )
|
||
|
|
{
|
||
|
|
m_pGameModeCombo = dynamic_cast< vgui::ComboBox *>( pGameModeOptionContainer->FindChildByName( "OptionCombo", true ) );
|
||
|
|
Assert( m_pGameModeCombo );
|
||
|
|
}
|
||
|
|
if ( m_pGameModeCombo )
|
||
|
|
m_pGameModeCombo->AddActionSignalTarget( this );
|
||
|
|
if ( m_pContainer )
|
||
|
|
{
|
||
|
|
m_pOptionsSummaryLabel = dynamic_cast< vgui::Label *>( m_pContainer->FindChildByName( "OptionsSummaryLabel", true ) );
|
||
|
|
Assert( m_pOptionsSummaryLabel );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//m_pFavoritesCheckButton = dynamic_cast< vgui::CheckButton *>( m_pContainer->FindChildByName( "FavoritesCheckButton" ) );
|
||
|
|
//m_pFavoritesCheckButton->AddActionSignalTarget( this );
|
||
|
|
//
|
||
|
|
//m_pRefreshButton = dynamic_cast< vgui::Button *>( m_pContainer->FindChildByName( "RefreshButton" ) );
|
||
|
|
//m_pRefreshButton->AddActionSignalTarget( this );
|
||
|
|
|
||
|
|
m_vecItems.RemoveAll();
|
||
|
|
m_vecAllItems.RemoveAll();
|
||
|
|
|
||
|
|
// listed in the order we want to show them
|
||
|
|
extern bool TF_IsHolidayActive( int eHoliday );
|
||
|
|
bool bHalloween = TF_IsHolidayActive( kHoliday_Halloween );
|
||
|
|
if ( bHalloween )
|
||
|
|
{
|
||
|
|
AddItem( kGameCategory_Event247, "#Gametype_Halloween247", "#TF_GameModeDesc_Halloween247", "#TF_GameModeDetail_Halloween247", "#TF_Quickplay_Complexity1", m_szEvent247Image, NULL );
|
||
|
|
AddItem( kGameCategory_EventMix, "#Gametype_HalloweenMix", "#TF_GameModeDesc_HalloweenMix", "#TF_GameModeDetail_HalloweenMix", "#TF_Quickplay_Complexity1", "illustrations/gamemode_halloween", NULL );
|
||
|
|
}
|
||
|
|
// AddItem( kGameType_Community_Update,"#GameType_Community_Update", "#TF_GameModeDesc_Community_Update", "#TF_GameModeDetail_Community_Update", "#TF_Quickplay_Complexity1", m_szCommunityUpdateImage, NULL );
|
||
|
|
// AddItem( kGameType_Featured, "#GameType_Featured", "#TF_GameModeDesc_Featured", "#TF_GameModeDetail_Featured", "#TF_Quickplay_Complexity1", "illustrations/gamemode_operation_tough_break", NULL );
|
||
|
|
AddItem( kGameCategory_Escort, "#Gametype_Escort", "#TF_GameModeDesc_Escort", "#TF_GameModeDetail_Escort", "#TF_Quickplay_Complexity1", "illustrations/gamemode_payload", "illustrations/gamemode_payload_beta" );
|
||
|
|
AddItem( kGameCategory_Koth, "#Gametype_Koth", "#TF_GameModeDesc_Koth", "#TF_GameModeDetail_Koth", "#TF_Quickplay_Complexity1", "illustrations/gamemode_koth", NULL );
|
||
|
|
AddItem( kGameCategory_AttackDefense, "#Gametype_AttackDefense", "#TF_GameModeDesc_AttackDefense", "#TF_GameModeDetail_AttackDefense", "#TF_Quickplay_Complexity1", "illustrations/gamemode_attackdefend", NULL );
|
||
|
|
AddItem( kGameCategory_EscortRace, "#Gametype_EscortRace", "#TF_GameModeDesc_EscortRace", "#TF_GameModeDetail_EscortRace", "#TF_Quickplay_Complexity2", "illustrations/gamemode_payloadrace", NULL );
|
||
|
|
AddItem( kGameCategory_CP, "#Gametype_CP", "#TF_GameModeDesc_CP", "#TF_GameModeDetail_CP", "#TF_Quickplay_Complexity2", "illustrations/gamemode_cp", NULL );
|
||
|
|
AddItem( kGameCategory_CTF, "#Gametype_CTF", "#TF_GameModeDesc_CTF", "#TF_GameModeDetail_CTF", "#TF_Quickplay_Complexity2", "illustrations/gamemode_ctf", NULL );
|
||
|
|
AddItem( kGameCategory_Misc, "#Gametype_Misc", "#TF_GameModeDesc_Misc", "#TF_GameModeDetail_Misc", "#TF_Quickplay_Complexity2", "illustrations/gamemode_sd", NULL );
|
||
|
|
AddItem( kGameCategory_Powerup, "#GameType_Powerup", "#TF_GameModeDesc_Powerup", "#TF_GameModeDetail_Powerup", "#TF_Quickplay_Complexity3", "illustrations/gamemode_powerup", "illustrations/gamemode_powerup_beta" ); // Fix beta image once Heather has the image
|
||
|
|
AddItem( kGameCategory_Passtime, "#GameType_Passtime", "#TF_GameModeDesc_Passtime", "#TF_GameModeDetail_Passtime", "#TF_Quickplay_Complexity2", "illustrations/gamemode_passtime", "illustrations/gamemode_passtime_beta" );
|
||
|
|
AddItem( kGameCategory_RobotDestruction,"#Gametype_RobotDestruction", "#TF_GameModeDesc_RobotDestruction", "#TF_GameModeDetail_RobotDestruction", "#TF_Quickplay_Complexity2", "illustrations/gamemode_sd", "illustrations/gamemode_robotdestruction_beta" );
|
||
|
|
if ( m_bShowRandomOption )
|
||
|
|
AddItem( kGameCategory_Quickplay, "#Gametype_Quickplay", "#TF_GameModeDesc_Quickplay", "#TF_GameModeDetail_Quickplay", "#TF_Quickplay_Complexity2", "illustrations/quickplay", "illustrations/quickplay_beta" );
|
||
|
|
|
||
|
|
// AddItem( kQuickplayGameType_Arena, "#Gametype_Arena", "#TF_GameModeDesc_Arena", "#TF_GameModeDetail_Arena", "#TF_Quickplay_Complexity3", "maps/menu_photos_cp_granary" );
|
||
|
|
// AddItem( kQuickplayGameType_Specialty, "#Gametype_Specialty", "#TF_GameModeDesc_Specialty", "#TF_GameModeDetail_Specialty", "#TF_Quickplay_Complexity3", "maps/menu_photos_cp_granary" );
|
||
|
|
|
||
|
|
UpdateSelectableItems();
|
||
|
|
SetupMoreOptions();
|
||
|
|
|
||
|
|
// set current, if we didn't already
|
||
|
|
if ( !m_bSetInitialSelection )
|
||
|
|
{
|
||
|
|
m_iCurrentItem = tf_quickplay_lastviewedmode.GetInt();
|
||
|
|
static bool bForcedOnce = false;
|
||
|
|
//tagES need to remove this when Operation Gun Mettle is finished
|
||
|
|
if ( /* bHalloween && */ !bForcedOnce )
|
||
|
|
{
|
||
|
|
m_iCurrentItem = 0;
|
||
|
|
bForcedOnce = true;
|
||
|
|
}
|
||
|
|
m_bSetInitialSelection = true;
|
||
|
|
}
|
||
|
|
m_iCurrentItem = Min( m_iCurrentItem, m_vecItems.Count()-1 );
|
||
|
|
m_iCurrentItem = Max( m_iCurrentItem, 0 );
|
||
|
|
ShowItemByIndex( m_iCurrentItem );
|
||
|
|
|
||
|
|
SetupActionTarget( "MoreInfoButton" );
|
||
|
|
SetupActionTarget( "PrevPageButton" );
|
||
|
|
SetupActionTarget( "NextPageButton" );
|
||
|
|
SetupActionTarget( "CancelButton" );
|
||
|
|
|
||
|
|
ShowSimplifiedOrAdvancedOptions();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::SetupMoreOptions()
|
||
|
|
{
|
||
|
|
SetupActionTarget( "OptionsButton" );
|
||
|
|
|
||
|
|
// Panel *pOptionTemplate = m_pMoreOptionsContainer->FindChildByName( "OptionContainerTemplate" );
|
||
|
|
// Assert( pOptionTemplate );
|
||
|
|
// KeyValues *pTemplateSettings = new KeyValues( "Template" );
|
||
|
|
// pOptionTemplate->GetSettings( pTemplateSettings );
|
||
|
|
// pOptionTemplate->SetVisible( false );
|
||
|
|
//
|
||
|
|
// new QuickplayOptionPanel( m_pMoreOptionsContainer, 0, pTemplateSettings );
|
||
|
|
// new QuickplayOptionPanel( m_pMoreOptionsContainer, 1, pTemplateSettings );
|
||
|
|
// new QuickplayOptionPanel( m_pMoreOptionsContainer, 2, pTemplateSettings );
|
||
|
|
//
|
||
|
|
// pTemplateSettings->deleteThis();
|
||
|
|
|
||
|
|
AdvOption *pOpt;
|
||
|
|
COMPILE_TIME_ASSERT( kEAdvOption_ServerHost == 0 );
|
||
|
|
pOpt = &m_vecAdvOptions[ m_vecAdvOptions.AddToTail() ];
|
||
|
|
pOpt->m_pszContainerName = "ValveServerOption";
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_ServerHost_Official" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_ServerHost_Official_Summary" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_ServerHost_Community" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_ServerHost_Community_Summary" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_ServerHost_DontCare" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_ServerHost_DontCare_Summary" );
|
||
|
|
pOpt->m_pConvar = &tf_quickplay_pref_community_servers;
|
||
|
|
|
||
|
|
COMPILE_TIME_ASSERT( kEAdvOption_MaxPlayers == 1 );
|
||
|
|
pOpt = &m_vecAdvOptions[ m_vecAdvOptions.AddToTail() ];
|
||
|
|
pOpt->m_pszContainerName = "IncreasedPlayerCountOption";
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_MaxPlayers_Default" ); pOpt->m_vecOptionSummaryNames.AddToTail( "" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_MaxPlayers_Increased" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_MaxPlayers_Increased_Summary" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_MaxPlayers_DontCare" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_MaxPlayers_DontCare_Summary" );
|
||
|
|
pOpt->m_pConvar = &tf_quickplay_pref_increased_maxplayers;
|
||
|
|
|
||
|
|
COMPILE_TIME_ASSERT( kEAdvOption_Respawn == 2 );
|
||
|
|
pOpt = &m_vecAdvOptions[ m_vecAdvOptions.AddToTail() ];
|
||
|
|
pOpt->m_pszContainerName = "RespawnTimesOption";
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_RespawnTimes_Default" ); pOpt->m_vecOptionSummaryNames.AddToTail( "" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_RespawnTimes_Instant" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_RespawnTimes_Instant_Summary" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_RespawnTimes_DontCare" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_RespawnTimes_DontCare_Summary" );
|
||
|
|
pOpt->m_pConvar = &tf_quickplay_pref_respawn_times;
|
||
|
|
|
||
|
|
COMPILE_TIME_ASSERT( kEAdvOption_RandomCrits == 3 );
|
||
|
|
pOpt = &m_vecAdvOptions[ m_vecAdvOptions.AddToTail() ];
|
||
|
|
pOpt->m_pszContainerName = "RandomCritsOption";
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_RandomCrits_Default" ); pOpt->m_vecOptionSummaryNames.AddToTail( "" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_RandomCrits_Disabled" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_RandomCrits_Disabled_Summary" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_RandomCrits_DontCare" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_RandomCrits_DontCare_Summary" );
|
||
|
|
pOpt->m_pConvar = &tf_quickplay_pref_disable_random_crits;
|
||
|
|
|
||
|
|
COMPILE_TIME_ASSERT( kEAdvOption_DamageSpread == 4 );
|
||
|
|
pOpt = &m_vecAdvOptions[ m_vecAdvOptions.AddToTail() ];
|
||
|
|
pOpt->m_pszContainerName = "DamageSpreadOption";
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_DamageSpread_Default" ); pOpt->m_vecOptionSummaryNames.AddToTail( "" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_DamageSpread_Enabled" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_DamageSpread_Enabled_Summary" );
|
||
|
|
pOpt->m_vecOptionNames.AddToTail( "#TF_Quickplay_DamageSpread_DontCare" ); pOpt->m_vecOptionSummaryNames.AddToTail( "#TF_Quickplay_DamageSpread_DontCare_Summary" );
|
||
|
|
pOpt->m_pConvar = &tf_quickplay_pref_enable_damage_spread;
|
||
|
|
|
||
|
|
FOR_EACH_VEC( m_vecAdvOptions, idxAdvOpt )
|
||
|
|
{
|
||
|
|
pOpt = &m_vecAdvOptions[ idxAdvOpt ];
|
||
|
|
EditablePanel *pContainer = dynamic_cast<EditablePanel*>( FindChildByName( pOpt->m_pszContainerName, true ) );
|
||
|
|
FOR_EACH_VEC( pOpt->m_vecOptionNames, idx )
|
||
|
|
{
|
||
|
|
vgui::RadioButton *pRadioButton = NULL;
|
||
|
|
if ( pContainer )
|
||
|
|
{
|
||
|
|
pRadioButton = dynamic_cast<vgui::RadioButton*>( pContainer->FindChildByName( VarArgs("RadioButton%d", idx ) ) );
|
||
|
|
Assert( pRadioButton );
|
||
|
|
}
|
||
|
|
if ( pRadioButton )
|
||
|
|
{
|
||
|
|
pRadioButton->AddActionSignalTarget( this );
|
||
|
|
pRadioButton->SetText( pOpt->m_vecOptionNames[idx] );
|
||
|
|
}
|
||
|
|
pOpt->m_vecRadioButtons.AddToTail( pRadioButton );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Populate choice from the convars
|
||
|
|
FOR_EACH_VEC( m_vecAdvOptions, idxAdvOpt )
|
||
|
|
{
|
||
|
|
AdvOption *pOpt = &m_vecAdvOptions[ idxAdvOpt ];
|
||
|
|
pOpt->m_nChoice = pOpt->m_pConvar->GetInt();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::ShowSimplifiedOrAdvancedOptions()
|
||
|
|
{
|
||
|
|
if ( m_pSimplifiedOptionsContainer )
|
||
|
|
m_pSimplifiedOptionsContainer->SetVisible( !tf_quickplay_pref_advanced_view.GetBool() );
|
||
|
|
if ( m_pAdvOptionsContainer )
|
||
|
|
m_pAdvOptionsContainer->SetVisible( tf_quickplay_pref_advanced_view.GetBool() );
|
||
|
|
}
|
||
|
|
|
||
|
|
const size_t kQuickplayOptionsSummaryLen = 1024;
|
||
|
|
static void AppendOptionInfo( wchar_t *wszText, const char *pszLocToken )
|
||
|
|
{
|
||
|
|
if ( pszLocToken == NULL || *pszLocToken == '\0' )
|
||
|
|
return;
|
||
|
|
const wchar_t *pwszLocalized = NULL;
|
||
|
|
if ( *pszLocToken == '#' )
|
||
|
|
pwszLocalized = g_pVGuiLocalize->Find( pszLocToken );
|
||
|
|
wchar_t wszTemp[ 1024 ];
|
||
|
|
if ( pwszLocalized == NULL )
|
||
|
|
{
|
||
|
|
V_UTF8ToUnicode( pszLocToken, wszTemp, sizeof(wszTemp) );
|
||
|
|
pwszLocalized = wszTemp;
|
||
|
|
}
|
||
|
|
if ( *wszText != '\0' )
|
||
|
|
V_wcsncat( wszText, L"; ", kQuickplayOptionsSummaryLen );
|
||
|
|
V_wcsncat( wszText, pwszLocalized, kQuickplayOptionsSummaryLen );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::WriteOptionCombosAndSummary()
|
||
|
|
{
|
||
|
|
wchar_t wszSmmary[ kQuickplayOptionsSummaryLen ] = {};
|
||
|
|
|
||
|
|
GetOptionsAndSummaryText( wszSmmary );
|
||
|
|
|
||
|
|
if ( m_pOptionsSummaryLabel )
|
||
|
|
m_pOptionsSummaryLabel->SetText( wszSmmary );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::GetOptionsAndSummaryText( wchar_t *pwszSummary )
|
||
|
|
{
|
||
|
|
if ( m_vecItems[m_iCurrentItem].gameType == kGameCategory_Quickplay )
|
||
|
|
AppendOptionInfo( pwszSummary, "#Gametype_AnyGameMode" ); // "random" looks weird here, use custom text
|
||
|
|
else
|
||
|
|
AppendOptionInfo( pwszSummary, m_vecItems[m_iCurrentItem].pTitle );
|
||
|
|
|
||
|
|
// Check if we need to force "community only" or "don't care" server host due to their options
|
||
|
|
FOR_EACH_VEC( m_vecAdvOptions, idxVecOpt )
|
||
|
|
{
|
||
|
|
if ( idxVecOpt == kEAdvOption_ServerHost )
|
||
|
|
continue;
|
||
|
|
if ( m_vecAdvOptions[idxVecOpt].m_nChoice == 1 )
|
||
|
|
{
|
||
|
|
m_vecAdvOptions[kEAdvOption_ServerHost].m_nChoice = QuickplaySearchOptions::eServersCommunity;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
FOR_EACH_VEC( m_vecAdvOptions, idxAdvOpt )
|
||
|
|
{
|
||
|
|
AdvOption *pOpt = &m_vecAdvOptions[ idxAdvOpt ];
|
||
|
|
|
||
|
|
FOR_EACH_VEC( pOpt->m_vecRadioButtons, idxRadButton )
|
||
|
|
{
|
||
|
|
if ( pOpt->m_vecRadioButtons[idxRadButton] )
|
||
|
|
{
|
||
|
|
//pOpt->m_vecRadioButtons[idxRadButton]->SetEnabled( idxRadButton == 0 || !bForceVanilla );
|
||
|
|
pOpt->m_vecRadioButtons[idxRadButton]->SilentSetSelected( pOpt->m_nChoice == idxRadButton );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int nChoice = ( tf_quickplay_pref_beta_content.GetBool() ? 0 : pOpt->m_nChoice );
|
||
|
|
AppendOptionInfo( pwszSummary, pOpt->m_vecOptionSummaryNames[nChoice] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::OnTextChanged( vgui::Panel *panel )
|
||
|
|
{
|
||
|
|
if ( panel == m_pGameModeCombo )
|
||
|
|
{
|
||
|
|
UserSelectItemByIndex( m_pGameModeCombo->GetActiveItem() );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::OnRadioButtonChecked( vgui::Panel *panel )
|
||
|
|
{
|
||
|
|
FOR_EACH_VEC( m_vecAdvOptions, idxAdvOpt )
|
||
|
|
{
|
||
|
|
AdvOption *pOpt = &m_vecAdvOptions[ idxAdvOpt ];
|
||
|
|
int idxBtn = pOpt->m_vecRadioButtons.Find( (vgui::RadioButton*)panel );
|
||
|
|
if ( idxBtn >= 0 )
|
||
|
|
{
|
||
|
|
pOpt->m_nChoice = idxBtn;
|
||
|
|
|
||
|
|
// Check if they change the server hosting to valve servers,
|
||
|
|
// then slam their choices to vanilla
|
||
|
|
if ( idxAdvOpt == kEAdvOption_ServerHost && idxBtn == QuickplaySearchOptions::eServersOfficial )
|
||
|
|
{
|
||
|
|
FOR_EACH_VEC( m_vecAdvOptions, idxSlam )
|
||
|
|
{
|
||
|
|
if ( idxSlam != kEAdvOption_ServerHost )
|
||
|
|
m_vecAdvOptions[idxSlam].m_nChoice = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
WriteOptionCombosAndSummary();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::SetPageScrollButtonsVisible( bool bFlag )
|
||
|
|
{
|
||
|
|
if ( m_pPrevPageButton )
|
||
|
|
m_pPrevPageButton->SetVisible( bFlag );
|
||
|
|
if ( m_pNextPageButton )
|
||
|
|
m_pNextPageButton->SetVisible( bFlag );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::SaveSettings()
|
||
|
|
{
|
||
|
|
tf_quickplay_lastviewedmode.SetValue( m_iCurrentItem );
|
||
|
|
FOR_EACH_VEC( m_vecAdvOptions, idxAdvOpt )
|
||
|
|
{
|
||
|
|
AdvOption *pOpt = &m_vecAdvOptions[ idxAdvOpt ];
|
||
|
|
pOpt->m_pConvar->SetValue( pOpt->m_nChoice );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::OnCommand( const char *pCommand )
|
||
|
|
{
|
||
|
|
if ( FStrEq( pCommand, "prevpage" ) )
|
||
|
|
{
|
||
|
|
UserSelectItemByIndex( ( m_iCurrentItem > 0 ) ? ( m_iCurrentItem - 1 ) : ( m_vecItems.Count() - 1 ) );
|
||
|
|
if ( m_pPrevPageButton )
|
||
|
|
m_pPrevPageButton->RequestFocus();
|
||
|
|
}
|
||
|
|
else if ( FStrEq( pCommand, "nextpage" ) )
|
||
|
|
{
|
||
|
|
UserSelectItemByIndex( ( m_iCurrentItem+1 < m_vecItems.Count() ) ? ( m_iCurrentItem+1 ) : 0 );
|
||
|
|
if ( m_pNextPageButton )
|
||
|
|
m_pNextPageButton->RequestFocus();
|
||
|
|
}
|
||
|
|
else if ( FStrEq( pCommand, "more_info" ) )
|
||
|
|
{
|
||
|
|
if ( m_pMoreInfoContainer && m_pGameModeInfoContainer )
|
||
|
|
{
|
||
|
|
m_pMoreInfoContainer->SetVisible( !m_pMoreInfoContainer->IsVisible() );
|
||
|
|
vgui::ImagePanel *pImage = dynamic_cast< vgui::ImagePanel* >( m_pGameModeInfoContainer->FindChildByName( "ModeImage" ) );
|
||
|
|
if ( pImage )
|
||
|
|
{
|
||
|
|
pImage->SetVisible( !m_pMoreInfoContainer->IsVisible() );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if ( FStrEq( pCommand, "ToggleShowOptions" ) )
|
||
|
|
{
|
||
|
|
tf_quickplay_pref_advanced_view.SetValue( !tf_quickplay_pref_advanced_view.GetBool() );
|
||
|
|
ShowSimplifiedOrAdvancedOptions();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
BaseClass::OnCommand( pCommand );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void CQuickplayPanelBase::UserSelectItemByIndex( int iNewItem )
|
||
|
|
{
|
||
|
|
ShowItemByIndex( iNewItem );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class CQuickplayDialog : public CQuickplayPanelBase
|
||
|
|
{
|
||
|
|
DECLARE_CLASS_SIMPLE( CQuickplayDialog, CQuickplayPanelBase );
|
||
|
|
public:
|
||
|
|
CQuickplayDialog( vgui::Panel *parent )
|
||
|
|
: CQuickplayPanelBase( parent, "QuickPlayDialog" )
|
||
|
|
{
|
||
|
|
m_pContainer = new vgui::EditablePanel( this, "Container" );
|
||
|
|
m_pBetaCheckButton = new vgui::CheckButton( m_pContainer, "BetaCheckButton", "BetaToggle" );
|
||
|
|
m_pBetaCheckButton->AddActionSignalTarget( this );
|
||
|
|
m_pBetaCheckButton->SetSelected( tf_quickplay_pref_beta_content.GetInt() == 1 );
|
||
|
|
m_pTauntsExplanationPopup = new CExplanationPopup( m_pContainer, "BetaExplanation" );
|
||
|
|
|
||
|
|
C_CTFGameStats::ImmediateWriteInterfaceEvent( "interface_open", "quickplay" );
|
||
|
|
|
||
|
|
LoadControlSettings( "Resource/ui/QuickplayDialog.res" );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual ~CQuickplayDialog()
|
||
|
|
{
|
||
|
|
|
||
|
|
C_CTFGameStats::ImmediateWriteInterfaceEvent( "interface_close", "quickplay" );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void ApplySchemeSettings( vgui::IScheme *pScheme ) OVERRIDE
|
||
|
|
{
|
||
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
||
|
|
|
||
|
|
Panel *pPanel;
|
||
|
|
pPanel = FindChildByName( "PlayNowButton", true ); Assert( pPanel );
|
||
|
|
if ( pPanel ) pPanel->AddActionSignalTarget( this );
|
||
|
|
pPanel = FindChildByName( "ShowServersButton", true ); Assert( pPanel );
|
||
|
|
if ( pPanel ) pPanel->AddActionSignalTarget( this );
|
||
|
|
pPanel = FindChildByName( "ExplainBetaButton", true ); Assert( pPanel );
|
||
|
|
if ( pPanel ) pPanel->AddActionSignalTarget( this );
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void PerformLayout() OVERRIDE
|
||
|
|
{
|
||
|
|
m_pBetaCheckButton->SizeToContents();
|
||
|
|
|
||
|
|
BaseClass::PerformLayout();
|
||
|
|
|
||
|
|
// Center it, keeping requested size
|
||
|
|
int x, y, ww, wt, wide, tall;
|
||
|
|
vgui::surface()->GetWorkspaceBounds( x, y, ww, wt );
|
||
|
|
GetSize(wide, tall);
|
||
|
|
SetPos(x + ((ww - wide) / 2), y + ((wt - tall) / 2));
|
||
|
|
|
||
|
|
m_pMoreOptionsButton->SetVisible( !m_pBetaCheckButton->IsSelected() );
|
||
|
|
tf_quickplay_pref_beta_content.SetValue( m_pBetaCheckButton->IsSelected() ? 1 : 0 );
|
||
|
|
// @todo setup
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void Show()
|
||
|
|
{
|
||
|
|
TFModalStack()->PushModal( this );
|
||
|
|
|
||
|
|
// Make sure we're signed on
|
||
|
|
if ( !CheckSteamSignOn() )
|
||
|
|
{
|
||
|
|
Close();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
SetVisible( true );
|
||
|
|
MakePopup();
|
||
|
|
MoveToFront();
|
||
|
|
SetKeyBoardInputEnabled( true );
|
||
|
|
SetMouseInputEnabled( true );
|
||
|
|
|
||
|
|
vgui::Panel *pPlayNowButton = FindChildByName( "PlayNowButton" );
|
||
|
|
if ( pPlayNowButton )
|
||
|
|
{
|
||
|
|
pPlayNowButton->RequestFocus();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CheckSteamSignOn()
|
||
|
|
{
|
||
|
|
// Make sure we are connected to steam, or they are going to be disappointed
|
||
|
|
if ( steamapicontext == NULL
|
||
|
|
|| steamapicontext->SteamUtils() == NULL
|
||
|
|
|| steamapicontext->SteamMatchmakingServers() == NULL
|
||
|
|
|| steamapicontext->SteamUser() == NULL
|
||
|
|
|| !steamapicontext->SteamUser()->BLoggedOn()
|
||
|
|
) {
|
||
|
|
Warning( "Steam not properly initialized or connected.\n" );
|
||
|
|
ShowMessageBox( "#TF_MM_GenericFailure_Title", "#TF_MM_GenericFailure", "#GameUI_OK" );
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void OnCommand( const char *pCommand )
|
||
|
|
{
|
||
|
|
C_CTFGameStats::ImmediateWriteInterfaceEvent( "on_command(quickplay)", pCommand );
|
||
|
|
|
||
|
|
if ( FStrEq( pCommand, "playnow" ) || FStrEq( pCommand, "show_servers" ) )
|
||
|
|
{
|
||
|
|
SaveSettings();
|
||
|
|
Close();
|
||
|
|
|
||
|
|
if ( !CheckSteamSignOn() )
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool bBetaContent = tf_quickplay_pref_beta_content.GetBool();
|
||
|
|
|
||
|
|
QuickplaySearchOptions opt;
|
||
|
|
opt.m_eSelectedGameType = m_vecItems[m_iCurrentItem].gameType;
|
||
|
|
opt.m_eServers = (QuickplaySearchOptions::EServers)( bBetaContent ?
|
||
|
|
#ifdef STAGING_ONLY
|
||
|
|
2 :
|
||
|
|
#else
|
||
|
|
0 :
|
||
|
|
#endif
|
||
|
|
tf_quickplay_pref_community_servers.GetInt() );
|
||
|
|
opt.m_eRandomCrits = (QuickplaySearchOptions::ERandomCrits)( bBetaContent ? 2 : tf_quickplay_pref_disable_random_crits.GetInt() );
|
||
|
|
opt.m_eDamageSpread = (QuickplaySearchOptions::EDamageSpread)( bBetaContent ? 2 : tf_quickplay_pref_enable_damage_spread.GetInt() );
|
||
|
|
opt.m_eRespawnTimes = (QuickplaySearchOptions::ERespawnTimes)( bBetaContent ? 2 : tf_quickplay_pref_respawn_times.GetInt() );
|
||
|
|
opt.m_eMaxPlayers = (QuickplaySearchOptions::EMaxPlayers)( bBetaContent ? 2 : tf_quickplay_pref_increased_maxplayers.GetInt() );
|
||
|
|
opt.m_eBetaContent = (QuickplaySearchOptions::EBetaContent)tf_quickplay_pref_beta_content.GetInt();
|
||
|
|
ShowWaitingDialog( new CQuickplayWaitDialog( FStrEq( pCommand, "playnow" ), opt ), NULL, true, true, 0.0f );
|
||
|
|
}
|
||
|
|
else if ( FStrEq( pCommand, "cancel" ) )
|
||
|
|
{
|
||
|
|
Close();
|
||
|
|
SaveSettings();
|
||
|
|
}
|
||
|
|
else if ( FStrEq( pCommand, "beta_toggle" ) )
|
||
|
|
{
|
||
|
|
UpdateSelectableItems();
|
||
|
|
|
||
|
|
if ( m_pMoreOptionsButton )
|
||
|
|
{
|
||
|
|
// Disable the advanced filtering if beta box is checked
|
||
|
|
m_pMoreOptionsButton->SetVisible( !m_pBetaCheckButton->IsSelected() );
|
||
|
|
tf_quickplay_pref_beta_content.SetValue( m_pBetaCheckButton->IsSelected() ? 1 : 0 );
|
||
|
|
|
||
|
|
WriteOptionCombosAndSummary();
|
||
|
|
|
||
|
|
tf_quickplay_pref_advanced_view.SetValue( 0 );
|
||
|
|
ShowSimplifiedOrAdvancedOptions();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if ( FStrEq( pCommand, "explain_beta" ) )
|
||
|
|
{
|
||
|
|
m_pTauntsExplanationPopup->Popup();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
BaseClass::OnCommand( pCommand );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void OnKeyCodePressed( vgui::KeyCode code )
|
||
|
|
{
|
||
|
|
vgui::KeyCode nButtonCode = GetBaseButtonCode( code );
|
||
|
|
if( nButtonCode == KEY_XBUTTON_B || nButtonCode == STEAMCONTROLLER_B || nButtonCode == STEAMCONTROLLER_START )
|
||
|
|
{
|
||
|
|
OnCommand( "cancel" );
|
||
|
|
}
|
||
|
|
else if ( nButtonCode == KEY_XBUTTON_A || nButtonCode == STEAMCONTROLLER_A )
|
||
|
|
{
|
||
|
|
OnCommand( "playnow" );
|
||
|
|
}
|
||
|
|
else if ( nButtonCode == KEY_XBUTTON_X || nButtonCode == STEAMCONTROLLER_X )
|
||
|
|
{
|
||
|
|
OnCommand( "more_info" );
|
||
|
|
}
|
||
|
|
else if ( nButtonCode == KEY_XBUTTON_LEFT ||
|
||
|
|
nButtonCode == KEY_XSTICK1_LEFT ||
|
||
|
|
nButtonCode == KEY_XSTICK2_LEFT ||
|
||
|
|
nButtonCode == STEAMCONTROLLER_DPAD_LEFT ||
|
||
|
|
code == KEY_LEFT )
|
||
|
|
{
|
||
|
|
OnCommand( "prevpage" );
|
||
|
|
}
|
||
|
|
else if ( nButtonCode == KEY_XBUTTON_RIGHT ||
|
||
|
|
nButtonCode == KEY_XSTICK1_RIGHT ||
|
||
|
|
nButtonCode == KEY_XSTICK2_RIGHT ||
|
||
|
|
nButtonCode == STEAMCONTROLLER_DPAD_RIGHT ||
|
||
|
|
code == KEY_RIGHT )
|
||
|
|
{
|
||
|
|
OnCommand( "nextpage" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
BaseClass::OnKeyCodeTyped( code );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void OnKeyCodeTyped( vgui::KeyCode code )
|
||
|
|
{
|
||
|
|
if( code == KEY_ESCAPE )
|
||
|
|
{
|
||
|
|
OnCommand( "cancel" );
|
||
|
|
}
|
||
|
|
else if ( code == KEY_ENTER || code == KEY_SPACE )
|
||
|
|
{
|
||
|
|
OnCommand( "playnow" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
BaseClass::OnKeyCodeTyped( code );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected:
|
||
|
|
|
||
|
|
virtual const char *GetItemImage( const QuickplayItem& item ) const OVERRIDE
|
||
|
|
{
|
||
|
|
if ( m_pBetaCheckButton->IsSelected() && item.pBetaImage )
|
||
|
|
{
|
||
|
|
return item.pBetaImage;
|
||
|
|
}
|
||
|
|
|
||
|
|
return item.pImage;
|
||
|
|
}
|
||
|
|
|
||
|
|
virtual void GetOptionsAndSummaryText( wchar_t *pwszSummary ) OVERRIDE
|
||
|
|
{
|
||
|
|
BaseClass::GetOptionsAndSummaryText( pwszSummary );
|
||
|
|
|
||
|
|
if ( m_pBetaCheckButton->IsSelected() )
|
||
|
|
{
|
||
|
|
AppendOptionInfo( pwszSummary, "#TF_Quickplay_Beta" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// called when the Cancel button is pressed
|
||
|
|
void Close()
|
||
|
|
{
|
||
|
|
SetVisible( false );
|
||
|
|
TFModalStack()->PopModal( this );
|
||
|
|
MarkForDeletion();
|
||
|
|
}
|
||
|
|
|
||
|
|
void UpdateSelectableItems() OVERRIDE
|
||
|
|
{
|
||
|
|
m_vecItems.Purge();
|
||
|
|
|
||
|
|
bool bBetaActive = m_pBetaCheckButton->IsSelected();
|
||
|
|
|
||
|
|
// Go through each of the modes
|
||
|
|
FOR_EACH_VEC( m_vecAllItems, i )
|
||
|
|
{
|
||
|
|
int nNumWithBetaContent = 0;
|
||
|
|
int nNumForThisMode = 0;
|
||
|
|
|
||
|
|
// Go through each of the modes
|
||
|
|
for ( int j = 0 ; j < GetItemSchema()->GetMapCount(); ++j )
|
||
|
|
{
|
||
|
|
const SchemaMap_t& map = GetItemSchema()->GetMapForIndex( j );
|
||
|
|
|
||
|
|
// Tally up maps for this mode
|
||
|
|
if ( map.eGameCategory == m_vecAllItems[i].gameType )
|
||
|
|
{
|
||
|
|
nNumForThisMode++;
|
||
|
|
|
||
|
|
// Check if any of the tags has "beta" as a tag, and tally that if so
|
||
|
|
for( int k = 0; k < map.vecTags.Count(); ++k )
|
||
|
|
{
|
||
|
|
if ( map.vecTags.HasElement( GetItemSchema()->GetHandleForTag( "beta" ) ) )
|
||
|
|
{
|
||
|
|
nNumWithBetaContent++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Only add the visible items if we're filtering for beta and this category has at least 1 beta map
|
||
|
|
// OR if we're not filtering for beta and we have at least 1 map that's not beta
|
||
|
|
const bool bBetaFilteringAndHasBetaContent = ( bBetaActive && nNumWithBetaContent > 0 );
|
||
|
|
const bool bNotBetaFilteringHasNonBetaContent = ( !bBetaActive && nNumForThisMode > nNumWithBetaContent );
|
||
|
|
const bool bIsRandom = m_vecAllItems[i].gameType == kGameCategory_Quickplay;
|
||
|
|
if ( ( bBetaFilteringAndHasBetaContent ) || ( bNotBetaFilteringHasNonBetaContent ) || bIsRandom )
|
||
|
|
{
|
||
|
|
m_vecItems.AddToTail( m_vecAllItems[i] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Go back to the first page
|
||
|
|
ShowItemByIndex( 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
vgui::CheckButton *m_pBetaCheckButton;
|
||
|
|
CExplanationPopup *m_pTauntsExplanationPopup;
|
||
|
|
};
|
||
|
|
static vgui::DHANDLE<CQuickplayDialog> g_pQuickplayDialog;
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
class CGCTFQuickplay_ScoreServers_Response : public GCSDK::CGCClientJob
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
CGCTFQuickplay_ScoreServers_Response( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
|
||
|
|
|
||
|
|
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
|
||
|
|
{
|
||
|
|
GCSDK::CProtoBufMsg<CMsgTFQuickplay_ScoreServersResponse> msg( pNetPacket );
|
||
|
|
|
||
|
|
if ( s_pQuickPlayWaitingDialog )
|
||
|
|
{
|
||
|
|
// !TEST! Forced failure
|
||
|
|
//Warning( "CMsgTFQuickplay_ScoreServersResponse received, but discarded to simulate failure!!\n" );
|
||
|
|
//return true;
|
||
|
|
|
||
|
|
s_pQuickPlayWaitingDialog->OnReceivedGCScores( msg.Body() );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Warning(" Received CGCTFQuickplay_ScoreServers_Response, but no quick play query in progress dialog to receive them?\n" );
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
GC_REG_JOB( GCSDK::CGCClient, CGCTFQuickplay_ScoreServers_Response, "CGCTFQuickplay_ScoreServers_Response", k_EMsgGC_QP_ScoreServersResponse, GCSDK::k_EServerTypeGCClient );
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// Purpose: Callback to open the game menus
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#ifdef ENABLE_GC_MATCHMAKING
|
||
|
|
ConVar tf_quickplay_beta_preference( "tf_quickplay_beta_preference", "-1", FCVAR_NONE, "Preference to participate in beta quickplay: -1 = no preference, 0 = opt out, 1 = opt in" );
|
||
|
|
ConVar tf_quickplay_beta_ask_percentage( "tf_quickplay_beta_ask_percentage", "0", FCVAR_NONE, "Percentage of people who will be prompted to participate in beta quickplay." );
|
||
|
|
|
||
|
|
|
||
|
|
void QuickplayBetaConfirmCallback( bool bConfirmed, void *pContext )
|
||
|
|
{
|
||
|
|
tf_quickplay_beta_preference.SetValue( bConfirmed ? 1 : 0 );
|
||
|
|
if ( bConfirmed )
|
||
|
|
{
|
||
|
|
engine->ClientCmd_Unrestricted( "OpenMatchmakingLobby quickplay" );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
engine->ClientCmd_Unrestricted( "OpenQuickplayDialog nobeta" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // #ifdef ENABLE_GC_MATCHMAKING
|
||
|
|
|
||
|
|
static void CL_OpenQuickplayDialog( const CCommand &args )
|
||
|
|
{
|
||
|
|
|
||
|
|
// Check for opting into beta quickplay
|
||
|
|
#ifdef ENABLE_GC_MATCHMAKING
|
||
|
|
if ( args.ArgC() < 2 && tf_quickplay_beta_preference.GetInt() != 0 )
|
||
|
|
{
|
||
|
|
if ( tf_quickplay_beta_preference.GetInt() > 0 )
|
||
|
|
{
|
||
|
|
engine->ClientCmd_Unrestricted( "OpenMatchmakingLobby quickplay" );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if ( steamapicontext && steamapicontext->SteamUser() && ( steamapicontext->SteamUser()->GetSteamID().GetAccountID() % 100U ) < (uint32)tf_quickplay_beta_ask_percentage.GetInt() )
|
||
|
|
{
|
||
|
|
ShowConfirmDialog( "#TF_QuickplayBeta_OptIn_Title", "#TF_QuickplayBeta_OptIn_Message", "#TF_QuickplayBeta_OptIn_YesButton", "#TF_QuickplayBeta_OptIn_NoButton", QuickplayBetaConfirmCallback );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
if ( g_pQuickplayDialog.Get() == NULL )
|
||
|
|
{
|
||
|
|
IViewPortPanel *pMMOverride = ( gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE ) );
|
||
|
|
g_pQuickplayDialog = vgui::SETUP_PANEL( new CQuickplayDialog( (CHudMainMenuOverride*)pMMOverride ) );
|
||
|
|
}
|
||
|
|
g_pQuickplayDialog->Show();
|
||
|
|
}
|
||
|
|
|
||
|
|
// the console commands
|
||
|
|
static ConCommand quickplaydialog( "OpenQuickplayDialog", &CL_OpenQuickplayDialog, "Displays the quickplay dialog." );
|
||
|
|
|
||
|
|
|
||
|
|
static void CL_OpenQuickplayDialogForMap( const CCommand &args )
|
||
|
|
{
|
||
|
|
if ( args.ArgC() != 2 )
|
||
|
|
return;
|
||
|
|
|
||
|
|
QuickplaySearchOptions opt;
|
||
|
|
opt.m_eServers = QuickplaySearchOptions::eServersOfficial; // Quests only work on official.
|
||
|
|
// Default settings
|
||
|
|
opt.m_eRandomCrits = QuickplaySearchOptions::ERandomCrits::eRandomCritsYes;
|
||
|
|
opt.m_eDamageSpread = QuickplaySearchOptions::EDamageSpread::eDamageSpreadNo;
|
||
|
|
opt.m_eRespawnTimes = QuickplaySearchOptions::ERespawnTimes::eRespawnTimesDefault;
|
||
|
|
opt.m_eMaxPlayers = QuickplaySearchOptions::EMaxPlayers::eMaxPlayers24;
|
||
|
|
opt.m_eBetaContent = QuickplaySearchOptions::EBetaContent::eBetaNo;
|
||
|
|
opt.m_strMapName = args.Arg(1); // Use the map name passed in
|
||
|
|
opt.m_eSelectedGameType = kGameCategory_Quickplay;
|
||
|
|
|
||
|
|
ShowWaitingDialog( new CStandaloneQuickplayMenu( false, opt ), NULL, true, true, 0.0f );
|
||
|
|
}
|
||
|
|
|
||
|
|
static ConCommand OpenQuickplayWaitDialogForMap( "OpenQuickplayWaitDialogForMap", &CL_OpenQuickplayDialogForMap, "Instantly starts a quickplay query for a map." );
|