1HEADmaster

1 files changed, 3005 insertions, 0 deletions

diff --git a/game/client/tf/tf_quickplay_ui.cpp b/game/client/tf/tf_quickplay_ui.cpp
new file mode 100644
index 0000000..59ccd10
--- /dev/null
+++ b/game/client/tf/tf_quickplay_ui.cpp
@@ -0,0 +1,3005 @@
+//========= 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." );