d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/client/tf/tf_quickplay_ui.cpp

3005 lines
100 KiB
Raw Blame History

//========= 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." );