BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/client/tf/tf_quickplay_ui.cpp

3006 lines
100 KiB
C++
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." );
Reference in New Issue View Git Blame Copy Permalink