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

1506 lines
50 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include <vgui_controls/Label.h>
#include <vgui_controls/Button.h>
#include <vgui_controls/ComboBox.h>
#include <vgui_controls/ImagePanel.h>
#include <vgui_controls/RichText.h>
#include <vgui_controls/Frame.h>
#include <vgui_controls/QueryBox.h>
#include <vgui/IScheme.h>
#include <vgui/ILocalize.h>
#include <vgui/ISurface.h>
#include "ienginevgui.h"
#include <game/client/iviewport.h>
#include "tf_tips.h"
#include "tf_mapinfo.h"
#include "vgui_avatarimage.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "tf_statsummary.h"
#include <convar.h>
#include "fmtstr.h"
#include "tf_gamerules.h"
#include "tf_gc_client.h"
using namespace vgui;
#if defined( REPLAY_ENABLED )
extern bool g_bIsReplayRewinding;
#else
bool g_bIsReplayRewinding = false;
#endif
const char *g_pszTipsClassImages[] =
{
"", // TF_CLASS_UNDEFINED = 0,
"class_portraits/scout", // TF_CLASS_SCOUT,
"class_portraits/sniper",// TF_CLASS_SNIPER,
"class_portraits/soldier", // TF_CLASS_SOLDIER,
"class_portraits/demoman", // TF_CLASS_DEMOMAN,
"class_portraits/medic", // TF_CLASS_MEDIC,
"class_portraits/heavy", // TF_CLASS_HEAVYWEAPONS,
"class_portraits/pyro", // TF_CLASS_PYRO,
"class_portraits/spy", // TF_CLASS_SPY,
"class_portraits/engineer", // TF_CLASS_ENGINEER,
};
ClassDetails_t g_PerClassStatDetails[15] =
{
{ TFSTAT_POINTSSCORED, ALL_CLASSES, "#TF_ClassRecord_MostPoints", "#TF_ClassRecord_Alt_MostPoints" },
{ TFSTAT_KILLS, ALL_CLASSES, "#TF_ClassRecord_MostKills", "#TF_ClassRecord_Alt_MostKills" },
{ TFSTAT_KILLASSISTS, ALL_CLASSES, "#TF_ClassRecord_MostAssists", "#TF_ClassRecord_Alt_MostAssists" },
{ TFSTAT_CAPTURES, ALL_CLASSES, "#TF_ClassRecord_MostCaptures", "#TF_ClassRecord_Alt_MostCaptures" },
{ TFSTAT_DEFENSES, ALL_CLASSES, "#TF_ClassRecord_MostDefenses", "#TF_ClassRecord_Alt_MostDefenses" },
{ TFSTAT_DAMAGE, ALL_CLASSES, "#TF_ClassRecord_MostDamage", "#TF_ClassRecord_Alt_MostDamage" },
{ TFSTAT_BUILDINGSDESTROYED, ALL_CLASSES, "#TF_ClassRecord_MostDestruction", "#TF_ClassRecord_Alt_MostDestruction" },
{ TFSTAT_DOMINATIONS, ALL_CLASSES, "#TF_ClassRecord_MostDominations", "#TF_ClassRecord_Alt_MostDominations" },
{ TFSTAT_PLAYTIME, ALL_CLASSES, "#TF_ClassRecord_LongestLife", "#TF_ClassRecord_Alt_LongestLife" },
{ TFSTAT_HEALING, MAKESTATFLAG(TF_CLASS_MEDIC) | MAKESTATFLAG(TF_CLASS_ENGINEER) | MAKESTATFLAG(TF_CLASS_HEAVYWEAPONS), "#TF_ClassRecord_MostHealing", "#TF_ClassRecord_Alt_MostHealing" },
{ TFSTAT_INVULNS, MAKESTATFLAG(TF_CLASS_MEDIC), "#TF_ClassRecord_MostInvulns", "#TF_ClassRecord_Alt_MostInvulns" },
{ TFSTAT_MAXSENTRYKILLS, MAKESTATFLAG(TF_CLASS_ENGINEER), "#TF_ClassRecord_MostSentryKills", "#TF_ClassRecord_Alt_MostSentryKills" },
{ TFSTAT_TELEPORTS, MAKESTATFLAG(TF_CLASS_ENGINEER), "#TF_ClassRecord_MostTeleports", "#TF_ClassRecord_Alt_MostTeleports" },
{ TFSTAT_HEADSHOTS, MAKESTATFLAG(TF_CLASS_SNIPER) | MAKESTATFLAG(TF_CLASS_SPY), "#TF_ClassRecord_MostHeadshots", "#TF_ClassRecord_Alt_MostHeadshots" },
{ TFSTAT_BACKSTABS, MAKESTATFLAG(TF_CLASS_SPY), "#TF_ClassRecord_MostBackstabs", "#TF_ClassRecord_Alt_MostBackstabs" },
};
ClassDetails_t g_PerClassMVMStatDetails[12] =
{
{ TFSTAT_POINTSSCORED, ALL_CLASSES, "#TF_ClassRecord_MostPoints", "#TF_ClassRecord_Alt_MostPoints" },
{ TFSTAT_KILLS, ALL_CLASSES, "#TF_ClassRecord_MostKills", "#TF_ClassRecord_Alt_MostKills" },
{ TFSTAT_KILLASSISTS, ALL_CLASSES, "#TF_ClassRecord_MostAssists", "#TF_ClassRecord_Alt_MostAssists" },
{ TFSTAT_DEFENSES, ALL_CLASSES, "#TF_ClassRecord_MostDefenses", "#TF_ClassRecord_Alt_MostDefenses" },
{ TFSTAT_DAMAGE, ALL_CLASSES, "#TF_ClassRecord_MostDamage", "#TF_ClassRecord_Alt_MostDamage" },
{ TFSTAT_PLAYTIME, ALL_CLASSES, "#TF_ClassRecord_LongestLife", "#TF_ClassRecord_Alt_LongestLife" },
{ TFSTAT_HEALING, MAKESTATFLAG(TF_CLASS_MEDIC) | MAKESTATFLAG(TF_CLASS_ENGINEER) | MAKESTATFLAG(TF_CLASS_HEAVYWEAPONS), "#TF_ClassRecord_MostHealing", "#TF_ClassRecord_Alt_MostHealing" },
{ TFSTAT_INVULNS, MAKESTATFLAG(TF_CLASS_MEDIC), "#TF_ClassRecord_MostInvulns", "#TF_ClassRecord_Alt_MostInvulns" },
{ TFSTAT_MAXSENTRYKILLS, MAKESTATFLAG(TF_CLASS_ENGINEER), "#TF_ClassRecord_MostSentryKills", "#TF_ClassRecord_Alt_MostSentryKills" },
{ TFSTAT_TELEPORTS, MAKESTATFLAG(TF_CLASS_ENGINEER), "#TF_ClassRecord_MostTeleports", "#TF_ClassRecord_Alt_MostTeleports" },
{ TFSTAT_HEADSHOTS, MAKESTATFLAG(TF_CLASS_SNIPER) | MAKESTATFLAG(TF_CLASS_SPY), "#TF_ClassRecord_MostHeadshots", "#TF_ClassRecord_Alt_MostHeadshots" },
{ TFSTAT_BACKSTABS, MAKESTATFLAG(TF_CLASS_SPY), "#TF_ClassRecord_MostBackstabs", "#TF_ClassRecord_Alt_MostBackstabs" },
};
CTFStatsSummaryPanel *g_pTFStatsSummaryPanel = NULL;
CUtlVector<CTFStatsSummaryPanel *> g_vecStatPanels;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void UpdateStatSummaryPanels( CUtlVector<ClassStats_t> &vecClassStats )
{
for ( int i = 0; i < g_vecStatPanels.Count(); i++ )
{
g_vecStatPanels[i]->SetStats( vecClassStats );
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns the global stats summary panel
//-----------------------------------------------------------------------------
CTFStatsSummaryPanel *GStatsSummaryPanel()
{
if ( NULL == g_pTFStatsSummaryPanel )
{
g_pTFStatsSummaryPanel = new CTFStatsSummaryPanel();
}
return g_pTFStatsSummaryPanel;
}
//-----------------------------------------------------------------------------
// Purpose: Destroys the global stats summary panel
//-----------------------------------------------------------------------------
void DestroyStatsSummaryPanel()
{
if ( NULL != g_pTFStatsSummaryPanel )
{
g_pTFStatsSummaryPanel->MarkForDeletion();
g_pTFStatsSummaryPanel = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFStatsSummaryPanel::CTFStatsSummaryPanel()
: BaseClass( NULL, "TFStatsSummary", vgui::scheme()->LoadSchemeFromFile( "Resource/ClientScheme.res", "ClientScheme" ) )
, m_bShowingLeaderboard( false )
, m_bLoadingCommunityMap( false )
{
Init();
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::Init( void )
{
m_bControlsLoaded = false;
m_bInteractive = false;
m_bEmbedded = false;
m_xStartLHBar = 0;
m_xStartRHBar = 0;
m_iBarHeight = 1;
m_iBarMaxWidth = 1;
m_pPlayerData = new vgui::EditablePanel( this, "statdata" );
m_pInteractiveHeaders = new vgui::EditablePanel( m_pPlayerData, "InteractiveHeaders" );
m_pNonInteractiveHeaders = new vgui::EditablePanel( m_pPlayerData, "NonInteractiveHeaders" );
m_pBarChartComboBoxA = new vgui::ComboBox( m_pInteractiveHeaders, "BarChartComboA", 10, false );
m_pBarChartComboBoxB = new vgui::ComboBox( m_pInteractiveHeaders, "BarChartComboB", 10, false );
m_pClassComboBox = new vgui::ComboBox( m_pInteractiveHeaders, "ClassCombo", 10, false );
m_pTipImage = new CTFImagePanel( this, "TipImage" );
m_pTipText = new vgui::Label( this, "TipText", "" );
m_pMapInfoPanel = NULL;
m_pMainBackground = NULL;
m_pLeaderboardTitle = NULL;
m_pContributedPanel = NULL;
#ifdef _X360
m_pFooter = new CTFFooter( this, "Footer" );
m_bShowBackButton = false;
#else
m_pNextTipButton = new vgui::Button( this, "NextTipButton", "" );
m_pResetStatsButton = new vgui::Button( this, "ResetStatsButton", "" );
m_pCloseButton = new vgui::Button( this, "CloseButton", "" );
#endif
m_pBarChartComboBoxA->AddActionSignalTarget( this );
m_pBarChartComboBoxB->AddActionSignalTarget( this );
m_pClassComboBox->AddActionSignalTarget( this );
ListenForGameEvent( "server_spawn" );
Reset();
g_vecStatPanels.AddToTail( this );
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFStatsSummaryPanel::CTFStatsSummaryPanel( vgui::Panel *parent ) : BaseClass( parent, "TFStatsSummary",
vgui::scheme()->LoadSchemeFromFile( "Resource/ClientScheme.res", "ClientScheme" ) )
{
Init();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFStatsSummaryPanel::~CTFStatsSummaryPanel()
{
g_vecStatPanels.FindAndRemove( this );
}
//-----------------------------------------------------------------------------
// Purpose: Shows this dialog as a modal dialog
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::ShowModal()
{
#ifdef _X360
m_bInteractive = false;
m_bShowBackButton = true;
#else
// we are in interactive mode, enable controls
m_bInteractive = true;
#endif
SetParent( enginevgui->GetPanel( PANEL_GAMEUIDLL ) );
UpdateDialog();
SetVisible( true );
MoveToFront();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::SetupForEmbedded( void )
{
m_bInteractive = true;
m_bEmbedded = true;
UpdateDialog();
InvalidateLayout( true, true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::PerformLayout()
{
BaseClass::PerformLayout();
#ifndef _X360
if ( m_pTipImage && m_pTipText )
{
int iX,iY;
m_pTipImage->GetPos(iX,iY);
int iTX, iTY;
m_pTipText->GetPos(iTX, iTY);
m_pTipText->SetPos( iX + m_pTipImage->GetWide() + XRES(8), iTY );
}
if ( m_pNextTipButton )
{
m_pNextTipButton->SizeToContents();
}
if ( m_pResetStatsButton )
{
m_pResetStatsButton->SizeToContents();
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::OnThink()
{
BaseClass::OnThink();
if ( m_bShowingLeaderboard )
{
UpdateLeaderboard();
}
}
//-----------------------------------------------------------------------------
// Purpose: Command handler
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::OnCommand( const char *command )
{
if ( 0 == Q_stricmp( command, "vguicancel" ) )
{
m_bInteractive = false;
UpdateDialog();
SetVisible( false );
SetParent( (VPANEL) NULL );
#ifdef _X360
SetDefaultSelections();
m_bShowBackButton = true;
#endif
}
#ifndef _X360
else if ( 0 == Q_stricmp( command, "resetstatsbutton" ) )
{
QueryBox *qb = new QueryBox( "#GameUI_Confirm", "#TF_ConfirmResetStats" );
if (qb != NULL)
{
qb->SetOKCommand(new KeyValues("DoResetStats") );
qb->AddActionSignalTarget(this);
qb->MoveToFront();
qb->DoModal();
}
}
#endif
else if ( 0 == Q_stricmp( command, "nexttip" ) )
{
UpdateTip();
}
BaseClass::OnCommand( command );
}
//-----------------------------------------------------------------------------
// Purpose: Resets the dialog
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::Reset()
{
m_aClassStats.RemoveAll();
SetDefaultSelections();
}
//-----------------------------------------------------------------------------
// Purpose: Sets all user-controllable dialog settings to default values
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::SetDefaultSelections()
{
m_iSelectedClass = TF_CLASS_UNDEFINED;
m_statBarGraph[0] = TFSTAT_POINTSSCORED;
m_displayBarGraph[0]= SHOW_MAX;
m_statBarGraph[1] = TFSTAT_PLAYTIME;
m_displayBarGraph[1] = SHOW_TOTAL;
m_pBarChartComboBoxA->ActivateItemByRow( 0 );
m_pBarChartComboBoxB->ActivateItemByRow( 10 );
}
//-----------------------------------------------------------------------------
// Purpose: Set the background image based on the current mode
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::UpdateMainBackground( void )
{
if ( IsPC() )
{
m_pMainBackground = dynamic_cast<ImagePanel *>( FindChildByName( "MainBackground" ) );
if ( m_pMainBackground )
{
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GTFGCClientSystem()->GetLiveMatchGroup() );
// determine if we're in widescreen or not and select the appropriate image
int screenWide, screenTall;
surface()->GetScreenSize( screenWide, screenTall );
float aspectRatio = (float)screenWide/(float)screenTall;
bool bIsWidescreen = aspectRatio >= 1.5999f;
if ( g_bIsReplayRewinding )
{
m_pMainBackground->SetImage( bIsWidescreen ? "../console/rewind_background_widescreen" : "../console/rewind_background" );
}
else if ( engine->IsLoadingDemo() || engine->IsPlayingDemo() || engine->IsSkippingPlayback() )
{
m_pMainBackground->SetImage( bIsWidescreen ? "../console/replay_loading_widescreen" : "../console/replay_loading" );
}
else if ( pMatchDesc && pMatchDesc->GetMapLoadBackgroundOverride( bIsWidescreen ) ) // Use match override if we have one
{
m_pMainBackground->SetImage( pMatchDesc->GetMapLoadBackgroundOverride( bIsWidescreen ) );
}
else
{
m_pMainBackground->SetImage( bIsWidescreen ? "../console/background01_widescreen" : "../console/background01" );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Applies scheme settings
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::ApplySchemeSettings(vgui::IScheme *pScheme)
{
BaseClass::ApplySchemeSettings( pScheme );
SetProportional( true );
if ( m_bEmbedded )
{
LoadControlSettings( "Resource/UI/StatSummary_Embedded.res" );
}
else
{
LoadControlSettings( "Resource/UI/StatSummary.res" );
}
m_bControlsLoaded = true;
// set the background image
UpdateMainBackground();
m_pMapInfoPanel = dynamic_cast< EditablePanel *>( FindChildByName( "MapInfo" ) );
m_vecLeaderboardEntries.RemoveAll();
if ( m_pMapInfoPanel )
{
for ( int i = 0; i < 10; ++ i )
{
vgui::EditablePanel *pEntryUI = new vgui::EditablePanel( m_pMapInfoPanel, "LeaderboardEntry" );
pEntryUI->ApplySchemeSettings( pScheme );
pEntryUI->LoadControlSettings( "Resource/UI/LeaderboardEntry.res" );
m_vecLeaderboardEntries.AddToTail( pEntryUI );
}
}
// get the dimensions and position of a left-hand bar and a right-hand bar so we can do bar sizing later
Panel *pLHBar = m_pPlayerData->FindChildByName( "ClassBar1A" );
Panel *pRHBar = m_pPlayerData->FindChildByName( "ClassBar1B" );
if ( pLHBar && pRHBar )
{
int y;
pLHBar->GetBounds( m_xStartLHBar, y, m_iBarMaxWidth, m_iBarHeight );
pRHBar->GetBounds( m_xStartRHBar, y, m_iBarMaxWidth, m_iBarHeight );
}
// fill the combo box selections appropriately
InitBarChartComboBox( m_pBarChartComboBoxA );
InitBarChartComboBox( m_pBarChartComboBoxB );
// fill the class names in the class combo box
HFont hFont = scheme()->GetIScheme( GetScheme() )->GetFont( "ScoreboardSmall", true );
m_pClassComboBox->SetFont( hFont );
m_pClassComboBox->RemoveAll();
KeyValues *pKeyValues = new KeyValues( "data" );
pKeyValues->SetInt( "class", TF_CLASS_UNDEFINED );
m_pClassComboBox->AddItem( "#StatSummary_Label_AsAnyClass", pKeyValues );
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass <= TF_LAST_NORMAL_CLASS; iClass++ )
{
if ( iClass == TF_CLASS_CIVILIAN )
continue;
pKeyValues = new KeyValues( "data" );
pKeyValues->SetInt( "class", iClass );
m_pClassComboBox->AddItem( g_aPlayerClassNames[iClass], pKeyValues );
}
m_pClassComboBox->ActivateItemByRow( 0 );
if ( m_pMapInfoPanel )
{
m_pContributedPanel = dynamic_cast< vgui::EditablePanel* >( m_pMapInfoPanel->FindChildByName( "ContributedLabel" ) );
}
SetDefaultSelections();
UpdateDialog();
if ( !m_bEmbedded )
{
SetVisible( false );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::OnKeyCodePressed( KeyCode code )
{
if ( IsX360() )
{
if ( code == KEY_XBUTTON_A || code == STEAMCONTROLLER_A )
{
OnCommand( "nexttip" ) ;
}
else if ( code == KEY_XBUTTON_B || code == STEAMCONTROLLER_B )
{
OnCommand( "vguicancel" );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets stats to use
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::SetStats( CUtlVector<ClassStats_t> &vecClassStats )
{
m_aClassStats = vecClassStats;
if ( m_bControlsLoaded )
{
UpdateDialog();
}
}
//-----------------------------------------------------------------------------
// Purpose: Updates the dialog
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::ClearMapLabel()
{
SetDialogVariable( "maplabel", "" );
SetDialogVariable( "maptype", "" );
vgui::Label *pLabel = dynamic_cast<Label *>( FindChildByName( "OnYourWayLabel" ) );
if ( pLabel && pLabel->IsVisible() )
{
pLabel->SetVisible( false );
}
pLabel = dynamic_cast<Label *>( FindChildByName( "MapType" ) );
if ( pLabel && pLabel->IsVisible() )
{
pLabel->SetVisible( false );
}
if ( m_pContributedPanel )
{
m_pContributedPanel->SetVisible( false );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::ShowMapInfo( bool bShowMapInfo, bool bIsMVM /*= false*/, bool bBackgroundOverride /*= false*/ )
{
if ( m_pMainBackground )
{
m_pMainBackground->SetVisible( !bShowMapInfo );
}
m_pPlayerData->SetVisible( bIsMVM || !bShowMapInfo );
m_pNextTipButton->SetVisible( m_bInteractive && !bShowMapInfo );
m_pResetStatsButton->SetVisible( m_bInteractive && !bShowMapInfo );
if ( m_pMapInfoPanel )
{
m_pMapInfoPanel->SetVisible( bShowMapInfo );
vgui::Panel* pInfoBG = m_pMapInfoPanel->FindChildByName( "InfoBG" );
if ( pInfoBG )
{
pInfoBG->SetVisible( bShowMapInfo && !bIsMVM && !bBackgroundOverride );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::OnMapLoad( const char *pMapName )
{
if ( g_bIsReplayRewinding || engine->IsLoadingDemo() || engine->IsPlayingDemo() || engine->IsSkippingPlayback() )
return;
bool bWidescreenBackground = false;
bool bIsMVM = ( pMapName && !Q_strncmp( pMapName, "mvm_", 4 ) );
const char *pszBackgroundOverride = NULL;
const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GTFGCClientSystem()->GetLiveMatchGroup() );
if ( pMatchDesc )
{
int screenWide, screenTall;
surface()->GetScreenSize( screenWide, screenTall );
float aspectRatio = (float)screenWide/(float)screenTall;
bool bWideScreen = aspectRatio >= 1.5999f;
// Check if there's a widescreen override
if( bWideScreen )
{
pszBackgroundOverride = pMatchDesc->GetMapLoadBackgroundOverride( true );
if ( pszBackgroundOverride )
{
// Success! We're done
bWidescreenBackground = true;
}
}
if ( !bWideScreen && !pszBackgroundOverride )
{
pszBackgroundOverride = pMatchDesc->GetMapLoadBackgroundOverride( false );
}
}
else if ( bIsMVM )
{
// this will preserve the current behavior for non-matchmaking servers
pszBackgroundOverride = "mvm_background_map";
}
bool bIsCommunityMap = false;
const char *pAuthors = NULL;
const MapDef_t *pMapInfo = GetItemSchema()->GetMasterMapDefByName( pMapName );
if ( pMapInfo )
{
bIsCommunityMap = pMapInfo->IsCommunityMap();
pAuthors = pMapInfo->pszAuthorsLocKey;
}
ShowMapInfo( true, bIsMVM, ( pszBackgroundOverride != NULL ) );
m_xStartLeaderboard = 0;
m_yStartLeaderboard = 0;
// If we're loading a background map, don't display anything
// HACK: Client doesn't get gpGlobals->eLoadType, so just do string compare for now.
if ( Q_stristr( pMapName, "background") )
{
ClearMapLabel();
}
else
{
// set the map name in the UI
wchar_t wzMapName[255]=L"";
g_pVGuiLocalize->ConvertANSIToUnicode( GetMapDisplayName( pMapName ), wzMapName, sizeof( wzMapName ) );
SetDialogVariable( "maplabel", wzMapName );
SetDialogVariable( "maptype", g_pVGuiLocalize->Find( GetMapType( pMapName ) ) );
vgui::Label *pLabel = dynamic_cast<Label *>( FindChildByName( "OnYourWayLabel" ) );
if ( pLabel && !pLabel->IsVisible() )
{
pLabel->SetVisible( true );
}
pLabel = dynamic_cast<Label *>( FindChildByName( "MapType" ) );
if ( pLabel && !pLabel->IsVisible() )
{
pLabel->SetVisible( true );
}
ImagePanel *pMapImage = m_pMapInfoPanel ? dynamic_cast< ImagePanel *>( m_pMapInfoPanel->FindChildByName( "MapImage" ) ) : NULL;
if ( pMapImage )
{
// load the map image (if it exists for the current map)
char szMapImage[ MAX_PATH ];
Q_snprintf( szMapImage, sizeof( szMapImage ), "VGUI/maps/menu_photos_%s", pMapName );
Q_strlower( szMapImage );
IMaterial *pMapMaterial = materials->FindMaterial( szMapImage, TEXTURE_GROUP_VGUI, false );
if ( pMapMaterial && !IsErrorMaterial( pMapMaterial ) && !pszBackgroundOverride )
{
// take off the vgui/ at the beginning when we set the image
Q_snprintf( szMapImage, sizeof( szMapImage ), "maps/menu_photos_%s", pMapName );
Q_strlower( szMapImage );
pMapImage->SetImage( szMapImage );
pMapImage->SetVisible( true );
}
else
{
pMapImage->SetVisible( false );
}
}
ImagePanel *pBackgroundImage = m_pMapInfoPanel ? dynamic_cast< ImagePanel *>( m_pMapInfoPanel->FindChildByName( "Background" ) ) : NULL;
if ( pBackgroundImage )
{
const char* pszBackgroundImage = pszBackgroundOverride ? pszBackgroundOverride : "stamp_background_map";
pBackgroundImage->SetImage( pszBackgroundImage );
// Resize to accomodate the background image coming in
if ( bWidescreenBackground )
{
pBackgroundImage->SetWide( GetWide() );
}
else
{
pBackgroundImage->SetWide( GetTall() * ( 4.f / 3.f ) );
}
}
if ( bIsMVM )
{
UpdateClassDetails( true );
m_pMapInfoPanel->SetDialogVariable( "map_leaderboard_title", "" );
m_pMapInfoPanel->SetDialogVariable( "title", "" );
m_pMapInfoPanel->SetDialogVariable( "authors", "" );
FOR_EACH_VEC( m_vecLeaderboardEntries, i )
{
EditablePanel *pContainer = dynamic_cast< EditablePanel* >( m_vecLeaderboardEntries[i] );
if ( pContainer )
{
pContainer->SetVisible( false );
}
}
}
else
{
m_pLeaderboardTitle = NULL;
// add authors
if ( m_pMapInfoPanel )
{
if ( bIsCommunityMap )
{
m_pMapInfoPanel->SetDialogVariable( "title", g_pVGuiLocalize->Find( "#TF_MapAuthors_Community_Title" ) );
m_pMapInfoPanel->SetDialogVariable( "map_leaderboard_title", "" );
m_pMapInfoPanel->SetDialogVariable( "authors", g_pVGuiLocalize->Find( pAuthors ) );
m_pLeaderboardTitle = m_pMapInfoPanel->FindChildByName( "MapLeaderboardTitle" );
}
else
{
m_pMapInfoPanel->SetDialogVariable( "title", g_pVGuiLocalize->Find( "#TF_DuelLeaderboard_Title" ) );
m_pMapInfoPanel->SetDialogVariable( "map_leaderboard_title", "" );
m_pMapInfoPanel->SetDialogVariable( "authors", "" );
m_pLeaderboardTitle = m_pMapInfoPanel->FindChildByName( "Title" );
}
}
if ( m_pLeaderboardTitle )
{
m_pLeaderboardTitle->GetPos( m_xStartLeaderboard, m_yStartLeaderboard );
m_yStartLeaderboard += m_pLeaderboardTitle->GetTall();
}
// request leaderboard data
m_bShowingLeaderboard = true;
if ( bIsCommunityMap )
{
MapInfo_RefreshLeaderboard( pMapName );
}
else
{
Leaderboards_Refresh();
}
m_bLoadingCommunityMap = bIsCommunityMap;
if ( m_pContributedPanel && steamapicontext && steamapicontext->SteamUser() && steamapicontext->SteamFriends() )
{
int iDonationAmount = MapInfo_GetDonationAmount( steamapicontext->SteamUser()->GetSteamID().GetAccountID(), pMapName );
m_pContributedPanel->SetVisible( iDonationAmount != 0 );
if ( iDonationAmount != 0 )
{
m_pContributedPanel->SetDialogVariable( "playername", steamapicontext->SteamFriends()->GetPersonaName() );
}
}
UpdateLeaderboard();
}
}
}
void CTFStatsSummaryPanel::UpdateLeaderboard()
{
if ( m_pMapInfoPanel == NULL || steamapicontext == NULL || steamapicontext->SteamUserStats() == NULL || steamapicontext->SteamUser() == NULL )
return;
const int kMaxVisible_Supporters = 5;
const int kIdeallyNumVisible_Supporters = 3;
const int kMaxVisible_DuelWins = 10;
const int kIdeallyNumVisible_DuelWins = 5;
// retrieve scores
CUtlVector< LeaderboardEntry_t* > scores;
bool bVisible = true;
int iNumLeaderboardEntries = 0;
if ( m_bLoadingCommunityMap )
{
bVisible = MapInfo_GetLeaderboardInfo( engine->GetLevelName(), scores, iNumLeaderboardEntries, kIdeallyNumVisible_Supporters );
wchar_t wzNumEntriesString[256];
_snwprintf( wzNumEntriesString, ARRAYSIZE( wzNumEntriesString ), L"%i", iNumLeaderboardEntries );
wchar_t wzTitle[256];
g_pVGuiLocalize->ConstructString_safe( wzTitle, g_pVGuiLocalize->Find( "#TF_MapDonators_Title" ), 1, wzNumEntriesString );
m_pMapInfoPanel->SetDialogVariable( "map_leaderboard_title", wzTitle );
}
else
{
bVisible = Leaderboards_GetDuelWins( scores, false );
if ( bVisible && scores.Count() < kIdeallyNumVisible_DuelWins )
{
bVisible = Leaderboards_GetDuelWins( scores, true ) && scores.Count() > 0;
}
// show old stats
m_pPlayerData->SetVisible( bVisible == false );
if ( m_pMapInfoPanel )
{
vgui::Panel* pInfoBG = m_pMapInfoPanel->FindChildByName( "InfoBG" );
if ( pInfoBG )
{
pInfoBG->SetVisible( bVisible );
}
}
}
const int kMaxVisible = m_bLoadingCommunityMap ? kMaxVisible_Supporters : kMaxVisible_DuelWins;
// try to show local player in relation to the people in the list
if ( bVisible && scores.Count() > 0 && steamapicontext && steamapicontext->SteamUser() && steamapicontext->SteamUserStats() )
{
int iLocalPlayerIdx = -1;
CSteamID localSteamID = steamapicontext->SteamUser()->GetSteamID();
FOR_EACH_VEC( scores, i )
{
const LeaderboardEntry_t *leaderboardEntry = scores[i];
if ( leaderboardEntry->m_steamIDUser == localSteamID )
{
iLocalPlayerIdx = i;
break;
}
}
// local player is in the list, but is outside the visible range
// so we want to move them to the last spot
// and move the closest person above them as well
if ( iLocalPlayerIdx >= kMaxVisible )
{
LeaderboardEntry_t *entryLocalPlayer = scores[iLocalPlayerIdx];
LeaderboardEntry_t *closestPlayer = scores[iLocalPlayerIdx - 1];
scores[kMaxVisible - 1] = entryLocalPlayer;
scores[kMaxVisible - 2] = closestPlayer;
}
}
// set avatars and names
int x = m_xStartLeaderboard;
int y = m_yStartLeaderboard;
FOR_EACH_VEC( m_vecLeaderboardEntries, i )
{
EditablePanel *pContainer = dynamic_cast< EditablePanel* >( m_vecLeaderboardEntries[i] );
if ( pContainer )
{
bool bIsEntryVisible = bVisible && i < scores.Count() && i < kMaxVisible;
pContainer->SetVisible( bIsEntryVisible );
pContainer->SetPos( x, y );
y += pContainer->GetTall();
if ( bIsEntryVisible )
{
const LeaderboardEntry_t *leaderboardEntry = scores[i];
const CSteamID &steamID = leaderboardEntry->m_steamIDUser;
pContainer->SetDialogVariable( "username", CFmtStr( "%d. %s - %d", leaderboardEntry->m_nGlobalRank, InventoryManager()->PersonaName_Get( steamID.GetAccountID() ), leaderboardEntry->m_nScore ) );
CAvatarImagePanel *pAvatar = dynamic_cast< CAvatarImagePanel* >( pContainer->FindChildByName( "AvatarImage" ) );
if ( pAvatar )
{
pAvatar->SetShouldDrawFriendIcon( false );
pAvatar->SetPlayer( steamID, k_EAvatarSize32x32 );
}
}
}
}
if ( m_pLeaderboardTitle )
{
bool bShowTitle = bVisible && scores.Count() > 0;
if ( m_pLeaderboardTitle->IsVisible() != bShowTitle )
{
m_pLeaderboardTitle->SetVisible( bShowTitle );
}
}
m_bShowingLeaderboard = bVisible;
}
//-----------------------------------------------------------------------------
// Purpose: Updates the dialog
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::UpdateDialog()
{
UpdateMainBackground();
if ( g_bIsReplayRewinding || engine->IsLoadingDemo() || engine->IsPlayingDemo() || engine->IsSkippingPlayback() )
{
// hide all of the various panels for the other loadscreen modes
if ( IsPC() )
{
ClearMapLabel();
m_pPlayerData->SetVisible( false );
m_pNextTipButton->SetVisible( false );
m_pResetStatsButton->SetVisible( false );
m_pInteractiveHeaders->SetVisible( false );
m_pNonInteractiveHeaders->SetVisible( false );
m_pTipText->SetVisible( false );
m_pTipImage->SetVisible( false );
if ( m_pMapInfoPanel )
{
m_pMapInfoPanel->SetVisible( false );
vgui::Panel* pInfoBG = m_pMapInfoPanel->FindChildByName( "InfoBG" );
if ( pInfoBG )
{
pInfoBG->SetVisible( false );
}
}
}
return;
}
RandomSeed( Plat_MSTime() );
m_iTotalSpawns = 0;
// if we don't have stats for any class, add empty stat entries for them
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass <= TF_LAST_NORMAL_CLASS; iClass++ )
{
if ( iClass == TF_CLASS_CIVILIAN )
continue; // Ignore the civilian.
int j;
for ( j = 0; j < m_aClassStats.Count(); j++ )
{
if ( m_aClassStats[j].iPlayerClass == iClass )
{
m_iTotalSpawns += m_aClassStats[j].iNumberOfRounds;
break;
}
}
if ( j == m_aClassStats.Count() )
{
ClassStats_t stats;
stats.iPlayerClass = iClass;
m_aClassStats.AddToTail( stats );
}
}
ClearMapLabel();
#ifdef _X360
if ( m_pFooter )
{
m_pFooter->ShowButtonLabel( "nexttip", m_bShowBackButton );
m_pFooter->ShowButtonLabel( "back", m_bShowBackButton );
}
#endif
// fill out bar charts
UpdateBarCharts();
// fill out class details
UpdateClassDetails();
// update the tip
UpdateTip();
// show or hide controls depending on if we're interactive or not
UpdateControls();
}
//-----------------------------------------------------------------------------
// Purpose: Updates bar charts
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::UpdateBarCharts()
{
// sort the class stats by the selected stat for right-hand bar chart
m_aClassStats.Sort( &CTFStatsSummaryPanel::CompareClassStats );
// loop for left & right hand charts
for ( int iChart = 0; iChart < 2; iChart++ )
{
float flMax = 0;
for ( int i = 0; i < m_aClassStats.Count(); i++ )
{
// get max value of stat being charted so we know how to scale the graph
float flVal = GetDisplayValue( m_aClassStats[i], m_statBarGraph[iChart], m_displayBarGraph[iChart] );
flMax = MAX( flVal, flMax );
}
// draw the bar chart value for each player class
// TODO: Fix up after the civilian becomes playable.
int iChartBar = 0;
for ( int i = 0; i < m_aClassStats.Count(); i++ )
{
int iClass = m_aClassStats[i].iPlayerClass;
if ( iClass == TF_CLASS_CIVILIAN )
{
continue;
}
if ( 0 == iChart )
{
// if this is the first chart, set the class label for each class
m_pPlayerData->SetDialogVariable( CFmtStr( "class%d", iChartBar+1 ), g_pVGuiLocalize->Find( g_aPlayerClassNames[iClass] ) );
}
// draw the bar for this class
DisplayBarValue( iChart, iChartBar++, m_aClassStats[i], m_statBarGraph[iChart], m_displayBarGraph[iChart], flMax );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Updates class details
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::UpdateClassDetails( bool bIsMVM )
{
vgui::Label *pTitle = assert_cast< vgui::Label* >( FindChildByName( "RecordsLabel1", true ) );
if ( pTitle )
{
pTitle->SetText( bIsMVM ? "#StatSummary_Label_BestMVMMoments" : "#StatSummary_Label_BestMoments" );
}
const wchar_t *wzWithClassFmt = g_pVGuiLocalize->Find( "#StatSummary_ScoreAsClassFmt" );
const wchar_t *wzWithoutClassFmt = L"%s1";
ClassDetails_t *pStatDetails = ( bIsMVM ? g_PerClassMVMStatDetails : g_PerClassStatDetails );
int nArraySize = ( bIsMVM ? ARRAYSIZE( g_PerClassMVMStatDetails ) : ARRAYSIZE( g_PerClassStatDetails ) );
// display the record for each stat
int iRow = 0;
for ( int i = 0; i < nArraySize; i++ )
{
TFStatType_t statType = pStatDetails[i].statType;
int iClass = TF_CLASS_UNDEFINED;
int iMaxVal = 0;
// if there is a selected class, and if this stat should not be shown for this class, skip this stat
if ( m_iSelectedClass != TF_CLASS_UNDEFINED && ( 0 == ( pStatDetails[i].iFlagsClass & MAKESTATFLAG( m_iSelectedClass ) ) ) )
continue;
if ( m_iSelectedClass == TF_CLASS_UNDEFINED )
{
// if showing best from any class, look through all player classes to determine the max value of this stat
for ( int j = 0; j < m_aClassStats.Count(); j++ )
{
RoundStats_t *pRoundStats = &( bIsMVM ? m_aClassStats[j].maxMVM : m_aClassStats[j].max );
if ( pRoundStats->m_iStat[statType] > iMaxVal )
{
// remember max value and class that has max value
iMaxVal = pRoundStats->m_iStat[statType];
iClass = m_aClassStats[j].iPlayerClass;
}
}
}
else
{
// show best from selected class
iClass = m_iSelectedClass;
for ( int j = 0; j < m_aClassStats.Count(); j++ )
{
if ( m_aClassStats[j].iPlayerClass == iClass )
{
RoundStats_t *pRoundStats = &( bIsMVM ? m_aClassStats[j].maxMVM : m_aClassStats[j].max );
iMaxVal = pRoundStats->m_iStat[statType];
break;
}
}
}
wchar_t wzStatNum[32];
wchar_t wzStatVal[128];
if ( TFSTAT_PLAYTIME == statType )
{
// playtime gets displayed as a time string
g_pVGuiLocalize->ConvertANSIToUnicode( FormatSeconds( iMaxVal ), wzStatNum, sizeof( wzStatNum ) );
}
else
{
// all other stats are just shown as a #
swprintf_s( wzStatNum, ARRAYSIZE( wzStatNum ), L"%d", iMaxVal );
}
if ( TF_CLASS_UNDEFINED == m_iSelectedClass && iMaxVal > 0 )
{
// if we are doing a cross-class view (no single selected class) and the max value is non-zero, show "# (as <class>)"
wchar_t *wzLocalizedClassName = g_pVGuiLocalize->Find( g_aPlayerClassNames[iClass] );
g_pVGuiLocalize->ConstructString_safe( wzStatVal, wzWithClassFmt, 2, wzStatNum, wzLocalizedClassName );
}
else
{
// just show the value
g_pVGuiLocalize->ConstructString_safe( wzStatVal, wzWithoutClassFmt, 1, wzStatNum );
}
// set the label
m_pPlayerData->SetDialogVariable( CFmtStr( "classrecord%dlabel", iRow+1 ), g_pVGuiLocalize->Find( pStatDetails[i].szResourceName ) );
// set the value
m_pPlayerData->SetDialogVariable( CFmtStr( "classrecord%dvalue", iRow+1 ), wzStatVal );
iRow++;
}
// if there are any leftover rows for the selected class, fill out the remaining rows with blank labels and values
for ( ; iRow < 15; iRow ++ )
{
m_pPlayerData->SetDialogVariable( CFmtStr( "classrecord%dlabel", iRow+1 ), "" );
m_pPlayerData->SetDialogVariable( CFmtStr( "classrecord%dvalue", iRow+1 ), "" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Updates the tip
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::UpdateTip()
{
int iTipClass = TF_CLASS_UNDEFINED;
SetDialogVariable( "tiptext", g_TFTips.GetRandomTip( iTipClass ) );
if ( m_pTipImage )
{
if ( iTipClass > TF_CLASS_UNDEFINED && iTipClass <= TF_CLASS_ENGINEER )
{
m_pTipImage->SetVisible( true );
m_pTipImage->SetImage( g_pszTipsClassImages[iTipClass] );
}
else
{
m_pTipImage->SetVisible( false );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Shows or hides controls
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::UpdateControls()
{
// show or hide controls depending on what mode we're in
#ifndef _X360
bool bShowPlayerData = ( m_bInteractive || m_iTotalSpawns > 0 );
#else
bool bShowPlayerData = ( m_bInteractive || m_bShowBackButton || m_iTotalSpawns > 0 );
#endif
m_pPlayerData->SetVisible( bShowPlayerData );
m_pInteractiveHeaders->SetVisible( m_bInteractive );
m_pNonInteractiveHeaders->SetVisible( !m_bInteractive );
m_pTipText->SetVisible( bShowPlayerData );
m_pTipImage->SetVisible( bShowPlayerData );
if ( !IsX360() )
{
if ( !m_bInteractive )
{
char szTemp[128];
// update our non-interactive headers to match the current combo box selections
Label *pLabel = dynamic_cast<Label *>( m_pNonInteractiveHeaders->FindChildByName( "BarChartLabelA" ) );
if ( pLabel && m_pBarChartComboBoxA )
{
m_pBarChartComboBoxA->GetItemText( m_pBarChartComboBoxA->GetActiveItem(), szTemp, sizeof( szTemp ) );
pLabel->SetText( szTemp );
}
pLabel = dynamic_cast<Label *>( m_pNonInteractiveHeaders->FindChildByName( "BarChartLabelB" ) );
if ( pLabel && m_pBarChartComboBoxB )
{
m_pBarChartComboBoxB->GetItemText( m_pBarChartComboBoxB->GetActiveItem(), szTemp, sizeof( szTemp ) );
pLabel->SetText( szTemp );
}
pLabel = dynamic_cast<Label *>( m_pNonInteractiveHeaders->FindChildByName( "OverallRecordLabel" ) );
if ( pLabel && m_pClassComboBox )
{
m_pClassComboBox->GetItemText( m_pClassComboBox->GetActiveItem(), szTemp, sizeof( szTemp ) );
pLabel->SetText( szTemp );
}
}
}
#ifndef _X360
m_pNextTipButton->SetVisible( m_bInteractive );
m_pResetStatsButton->SetVisible( m_bInteractive );
m_pCloseButton->SetVisible( m_bInteractive && !m_bEmbedded );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Initializes a bar chart combo box
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::InitBarChartComboBox( ComboBox *pComboBox )
{
struct BarChartComboInit_t
{
TFStatType_t statType;
StatDisplay_t statDisplay;
const char *szName;
};
BarChartComboInit_t initData[] =
{
{ TFSTAT_POINTSSCORED, SHOW_MAX, "#StatSummary_StatTitle_MostPoints" },
{ TFSTAT_POINTSSCORED, SHOW_AVG, "#StatSummary_StatTitle_AvgPoints" },
{ TFSTAT_KILLS, SHOW_MAX, "#StatSummary_StatTitle_MostKills" },
{ TFSTAT_KILLS, SHOW_AVG, "#StatSummary_StatTitle_AvgKills" },
{ TFSTAT_CAPTURES, SHOW_MAX, "#StatSummary_StatTitle_MostCaptures" },
{ TFSTAT_CAPTURES, SHOW_AVG, "#StatSummary_StatTitle_AvgCaptures" },
{ TFSTAT_KILLASSISTS, SHOW_MAX, "#StatSummary_StatTitle_MostAssists" },
{ TFSTAT_KILLASSISTS, SHOW_AVG, "#StatSummary_StatTitle_AvgAssists" },
{ TFSTAT_DAMAGE, SHOW_MAX, "#StatSummary_StatTitle_MostDamage" },
{ TFSTAT_DAMAGE, SHOW_AVG, "#StatSummary_StatTitle_AvgDamage" },
{ TFSTAT_PLAYTIME, SHOW_TOTAL, "#StatSummary_StatTitle_TotalPlaytime" },
{ TFSTAT_PLAYTIME, SHOW_MAX, "#StatSummary_StatTitle_LongestLife" },
};
// set the font
HFont hFont = scheme()->GetIScheme( GetScheme() )->GetFont( "ScoreboardVerySmall", true );
pComboBox->SetFont( hFont );
pComboBox->RemoveAll();
// add all the options to the combo box
for ( int i=0; i < ARRAYSIZE( initData ); i++ )
{
KeyValues *pKeyValues = new KeyValues( "data" );
pKeyValues->SetInt( "stattype", initData[i].statType );
pKeyValues->SetInt( "statdisplay", initData[i].statDisplay );
pComboBox->AddItem( g_pVGuiLocalize->Find( initData[i].szName ), pKeyValues );
}
pComboBox->SetNumberOfEditLines( ARRAYSIZE( initData ) );
}
//-----------------------------------------------------------------------------
// Purpose: Helper function that sets the specified dialog variable to
// "<value> (as <localized class name>)"
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::SetValueAsClass( const char *pDialogVariable, int iValue, int iPlayerClass )
{
if ( iValue > 0 )
{
wchar_t *wzScoreAsClassFmt = g_pVGuiLocalize->Find( "#StatSummary_ScoreAsClassFmt" );
wchar_t *wzLocalizedClassName = g_pVGuiLocalize->Find( g_aPlayerClassNames[iPlayerClass] );
wchar_t wzVal[16];
wchar_t wzMsg[128];
swprintf( wzVal, ARRAYSIZE( wzVal ), L"%d", iValue );
g_pVGuiLocalize->ConstructString_safe( wzMsg, wzScoreAsClassFmt, 2, wzVal, wzLocalizedClassName );
m_pPlayerData->SetDialogVariable( pDialogVariable, wzMsg );
}
else
{
m_pPlayerData->SetDialogVariable( pDialogVariable, "0" );
}
}
//-----------------------------------------------------------------------------
// Purpose: Sets the specified bar chart item to the specified value, in range 0->1
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::DisplayBarValue( int iChart, int iBar, ClassStats_t &stats, TFStatType_t statType, StatDisplay_t statDisplay, float flMaxValue )
{
const char *szControlSuffix = ( 0 == iChart ? "A" : "B" );
Panel *pBar = m_pPlayerData->FindChildByName( CFmtStr( "ClassBar%d%s", iBar+1, szControlSuffix ) );
Label *pLabel = dynamic_cast<Label*>( m_pPlayerData->FindChildByName( CFmtStr( "classbarlabel%d%s", iBar+1, szControlSuffix ) ) );
if ( !pBar || !pLabel )
return;
// get the stat value
float flValue = GetDisplayValue( stats, statType, statDisplay );
// calculate the bar size to draw, in the range of 0.0->1.0
float flBarRange = SafeCalcFraction( flValue, flMaxValue );
// calculate the # of pixels of bar width to draw
int iBarWidth = MAX( (int) ( flBarRange * (float) m_iBarMaxWidth ), 1 );
// Get the text label to draw for this bar. For values of 0, draw nothing, to minimize clutter
const char *szLabel = ( flValue > 0 ? RenderValue( flValue, statType, statDisplay ) : "" );
// draw the label outside the bar if there's room
bool bLabelOutsideBar = true;
const int iLabelSpacing = 4;
HFont hFont = pLabel->GetFont();
int iLabelWidth = UTIL_ComputeStringWidth( hFont, szLabel );
if ( iBarWidth + iLabelWidth + iLabelSpacing > m_iBarMaxWidth )
{
// if there's not room outside the bar for the label, draw it inside the bar
bLabelOutsideBar = false;
}
int xBar,yBar,xLabel,yLabel;
pBar->GetPos( xBar,yBar );
pLabel->GetPos( xLabel,yLabel );
m_pPlayerData->SetDialogVariable( CFmtStr( "classbarlabel%d%s", iBar+1, szControlSuffix ), szLabel );
if ( 1 == iChart )
{
// drawing code for RH bar chart
xBar = m_xStartRHBar;
pBar->SetBounds( xBar, yBar, iBarWidth, m_iBarHeight );
if ( bLabelOutsideBar )
{
pLabel->SetPos( xBar + iBarWidth + iLabelSpacing, yLabel );
}
else
{
pLabel->SetPos( xBar + iBarWidth - ( iLabelWidth + iLabelSpacing ), yLabel );
}
}
else
{
// drawing code for LH bar chart
xBar = m_xStartLHBar + m_iBarMaxWidth - iBarWidth;
pBar->SetBounds( xBar, yBar, iBarWidth, m_iBarHeight );
if ( bLabelOutsideBar )
{
pLabel->SetPos( xBar - ( iLabelWidth + iLabelSpacing ), yLabel );
}
else
{
pLabel->SetPos( xBar + iLabelSpacing, yLabel );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Calculates a fraction and guards from divide by 0. (Returns 0 if
// denominator is 0.)
//-----------------------------------------------------------------------------
float CTFStatsSummaryPanel::SafeCalcFraction( float flNumerator, float flDemoninator )
{
if ( 0 == flDemoninator )
return 0;
return flNumerator / flDemoninator;
}
//-----------------------------------------------------------------------------
// Purpose: Formats # of seconds into a string
//-----------------------------------------------------------------------------
const char *FormatSeconds( int seconds )
{
static char string[64];
int hours = 0;
int minutes = seconds / 60;
if ( minutes > 0 )
{
seconds -= (minutes * 60);
hours = minutes / 60;
if ( hours > 0 )
{
minutes -= (hours * 60);
}
}
if ( hours > 0 )
{
Q_snprintf( string, sizeof(string), "%2i:%02i:%02i", hours, minutes, seconds );
}
else
{
Q_snprintf( string, sizeof(string), "%02i:%02i", minutes, seconds );
}
return string;
}
//-----------------------------------------------------------------------------
// Purpose: Static sort function that sorts in descending order by play time
//-----------------------------------------------------------------------------
int __cdecl CTFStatsSummaryPanel::CompareClassStats( const ClassStats_t *pStats0, const ClassStats_t *pStats1 )
{
// sort stats first by right-hand bar graph
TFStatType_t statTypePrimary = GStatsSummaryPanel()->m_statBarGraph[1];
StatDisplay_t statDisplayPrimary = GStatsSummaryPanel()->m_displayBarGraph[1];
// then by left-hand bar graph
TFStatType_t statTypeSecondary = GStatsSummaryPanel()->m_statBarGraph[0];
StatDisplay_t statDisplaySecondary = GStatsSummaryPanel()->m_displayBarGraph[0];
float flValPrimary0 = GetDisplayValue( (ClassStats_t &) *pStats0, statTypePrimary, statDisplayPrimary );
float flValPrimary1 = GetDisplayValue( (ClassStats_t &) *pStats1, statTypePrimary, statDisplayPrimary );
float flValSecondary0 = GetDisplayValue( (ClassStats_t &) *pStats0, statTypeSecondary, statDisplaySecondary );
float flValSecondary1 = GetDisplayValue( (ClassStats_t &) *pStats1, statTypeSecondary, statDisplaySecondary );
// sort in descending order by primary stat value
if ( flValPrimary1 > flValPrimary0 )
return 1;
if ( flValPrimary1 < flValPrimary0 )
return -1;
// if primary stat values are equal, sort in descending order by secondary stat value
if ( flValSecondary1 > flValSecondary0 )
return 1;
if ( flValSecondary1 < flValSecondary0 )
return -1;
// if primary & secondary stats are equal, sort by class for consistent sort order
return ( pStats1->iPlayerClass - pStats0->iPlayerClass );
}
//-----------------------------------------------------------------------------
// Purpose: Called when text changes in combo box
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::OnTextChanged( KeyValues *data )
{
Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
vgui::ComboBox *pComboBox = dynamic_cast<vgui::ComboBox *>( pPanel );
if ( m_pBarChartComboBoxA == pComboBox || m_pBarChartComboBoxB == pComboBox )
{
// a bar chart combo box changed, update the bar charts
KeyValues *pUserDataA = m_pBarChartComboBoxA->GetActiveItemUserData();
KeyValues *pUserDataB = m_pBarChartComboBoxB->GetActiveItemUserData();
if ( !pUserDataA || !pUserDataB )
return;
m_statBarGraph[0] = (TFStatType_t) pUserDataA->GetInt( "stattype" );
m_displayBarGraph[0] = (StatDisplay_t) pUserDataA->GetInt( "statdisplay" );
m_statBarGraph[1] = (TFStatType_t) pUserDataB->GetInt( "stattype" );
m_displayBarGraph[1] = (StatDisplay_t) pUserDataB->GetInt( "statdisplay" );
UpdateBarCharts();
}
else if ( m_pClassComboBox == pComboBox )
{
// the class selection combo box changed, update class details
KeyValues *pUserData = m_pClassComboBox->GetActiveItemUserData();
if ( !pUserData )
return;
m_iSelectedClass = pUserData->GetInt( "class", TF_CLASS_UNDEFINED );
UpdateClassDetails();
}
}
//-----------------------------------------------------------------------------
// Purpose: Command target handler called from reset stats confirmation query box
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::DoResetStats()
{
#ifndef _X360
// reset the stats
engine->ClientCmd( "resetplayerstats" );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Returns the stat value for specified display type
//-----------------------------------------------------------------------------
float CTFStatsSummaryPanel::GetDisplayValue( ClassStats_t &stats, TFStatType_t statType, StatDisplay_t statDisplay )
{
switch ( statDisplay )
{
case SHOW_MAX:
return stats.max.m_iStat[statType];
break;
case SHOW_TOTAL:
return stats.accumulated.m_iStat[statType];
break;
case SHOW_AVG:
return SafeCalcFraction( stats.accumulated.m_iStat[statType], stats.iNumberOfRounds );
break;
default:
AssertOnce( false );
return 0;
}
}
//-----------------------------------------------------------------------------
// Purpose: Gets the text representation of this value
//-----------------------------------------------------------------------------
const char *CTFStatsSummaryPanel::RenderValue( float flValue, TFStatType_t statType, StatDisplay_t statDisplay )
{
static char szValue[64];
if ( TFSTAT_PLAYTIME == statType )
{
// the playtime stat is shown in seconds
return FormatSeconds( (int) flValue );
}
else if ( SHOW_AVG == statDisplay )
{
// if it's an average, render as a float w/2 decimal places
Q_snprintf( szValue, ARRAYSIZE( szValue ), "%.2f", flValue );
}
else
{
// otherwise, render as an integer
Q_snprintf( szValue, ARRAYSIZE( szValue ), "%d", (int) flValue );
}
return szValue;
}
//-----------------------------------------------------------------------------
// Purpose: Event handler
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::FireGameEvent( IGameEvent *event )
{
const char *pEventName = event->GetName();
// when we are changing levels and
if ( 0 == Q_strcmp( pEventName, "server_spawn" ) )
{
if ( !m_bInteractive )
{
const char *pMapName = event->GetString( "mapname" );
if ( pMapName )
{
OnMapLoad( pMapName );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when we are activated during level load
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::OnActivate()
{
ClearMapLabel();
m_bShowingLeaderboard = false;
m_bLoadingCommunityMap = false;
ShowMapInfo( false );
#ifdef _X360
m_bShowBackButton = false;
#endif
UpdateDialog();
}
//-----------------------------------------------------------------------------
// Purpose: Called when we are deactivated at end of level load
//-----------------------------------------------------------------------------
void CTFStatsSummaryPanel::OnDeactivate()
{
ClearMapLabel();
}
CON_COMMAND( showstatsdlg, "Shows the player stats dialog" )
{
#ifdef _DEBUG
GStatsSummaryPanel()->InvalidateLayout( false, true );
#endif
GStatsSummaryPanel()->ShowModal();
#ifdef _DEBUG
GStatsSummaryPanel()->OnMapLoad( "cp_coldfront" );
#endif
}