diff options
Diffstat (limited to 'game/client/tf/tf_quickplay_ui.cpp')
| -rw-r--r-- | game/client/tf/tf_quickplay_ui.cpp | 3005 |
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." ); |