tf2/tf2_src/game/client/tf/vgui/tf_match_summary.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "cbase.h"

#include "hud.h"
#include "tf_match_summary.h"
#include "tf_hud_statpanel.h"
#include "tf_spectatorgui.h"
#include "vgui_controls/AnimationController.h"
#include "iclientmode.h"
#include "engine/IEngineSound.h"
#include "c_tf_playerresource.h"
#include "c_team.h"
#include "tf_clientscoreboard.h"
#include <vgui_controls/Label.h>
#include <vgui_controls/ImagePanel.h>
#include <vgui/ILocalize.h>
#include <vgui/ISurface.h>
#include "vgui_avatarimage.h"
#include "fmtstr.h"
#include "teamplayroundbased_gamerules.h"
#include "tf_gamerules.h"
#include "tf_logic_halloween_2014.h"
#include "tf_playermodelpanel.h"
#include "tf_mapinfo.h"
#include "c_tf_team.h"
#include "tf_pvp_rank_panel.h"
#include "tf_badge_panel.h"
#include "tf_survey_questions.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

void AddSubKeyNamed( KeyValues *pKeys, const char *pszName );
extern ISoundEmitterSystemBase *soundemitterbase;

#define MAX_PLAYER_MODELS	6

#define MS_STATE_TRANSITION_TO_STATS					17.0f
#define MS_STATE_TRANSITION_TO_MEDALS					3.0f
#define MS_STATE_TIME_BETWEEN_MEDALS					0.1f
#define MS_STATE_TIME_BETWEEN_MEDALS_CATEGORIES			0.1f

extern ConVar tf_scoreboard_alt_class_icons;

DECLARE_BUILD_FACTORY( TFSectionedListPanel );

DECLARE_HUDELEMENT( CTFMatchSummary );

#ifdef STAGING_ONLY
static void cc_tf_restart_match_summary()
{
	CTFMatchSummary *pMatchSummary = GET_HUDELEMENT( CTFMatchSummary );
	if (pMatchSummary)
	{
		pMatchSummary->InvalidateLayout(true, true);
		pMatchSummary->SetVisible( false );
		pMatchSummary->SetVisible( true );
	}
}
ConCommand tf_restart_match_summary("tf_restart_match_summary", cc_tf_restart_match_summary);
#endif

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFMatchSummary::CTFMatchSummary( const char *pElementName ) 
	: CHudElement( pElementName )
	, EditablePanel( NULL, "MatchSummary" )
	, m_bXPShown( false )
{
	vgui::Panel *pParent = g_pClientMode->GetViewport();
	SetParent( pParent );

	m_pMainStatsContainer = new EditablePanel( this, "MainStatsContainer" );
	m_pDrawingPanel = new CDrawingPanel( this, "DrawingPanel" );
	m_pStatsBgPanel = new EditablePanel( this, "StatsBgPanel" );

	m_pTeamScoresPanel = new EditablePanel( m_pMainStatsContainer, "TeamScoresPanel" );
	m_pParticlePanel = new CTFParticlePanel( m_pMainStatsContainer, "ParticlePanel" );
	m_pStatsLabelPanel = new EditablePanel( m_pMainStatsContainer, "StatsLabelPanel" );

	m_pBlueTeamPanel = new EditablePanel( m_pTeamScoresPanel, "BlueTeamPanel" );
	m_pRedTeamPanel = new EditablePanel( m_pTeamScoresPanel, "RedTeamPanel" );

	m_pPlayerListBlueParent = new EditablePanel( m_pBlueTeamPanel, "BluePlayerListParent" );
	m_pPlayerListBlue = new TFSectionedListPanel( m_pPlayerListBlueParent, "BluePlayerList" );
	m_pPlayerListRedParent = new EditablePanel( m_pRedTeamPanel, "RedPlayerListParent" );
	m_pPlayerListRed = new TFSectionedListPanel( m_pPlayerListRedParent, "RedPlayerList" );

	m_pBlueTeamScore = new CExLabel( m_pBlueTeamPanel, "BlueTeamScore", "" );
	m_pBlueTeamScoreDropshadow = new CExLabel( m_pBlueTeamPanel, "BlueTeamScoreDropshadow", "" );
	m_pBlueTeamScoreBG = new EditablePanel( m_pBlueTeamPanel, "BlueTeamScoreBG" );
	m_pBluePlayerListBG = new EditablePanel( m_pBlueTeamPanel, "BluePlayerListBG" );
	m_pRedTeamScore = new CExLabel( m_pRedTeamPanel, "RedTeamScore", "" );
	m_pRedTeamScoreDropshadow = new CExLabel( m_pRedTeamPanel, "RedTeamScoreDropshadow", "" );
	m_pRedTeamScoreBG = new EditablePanel( m_pRedTeamPanel, "RedTeamScoreBG" );
	m_pRedPlayerListBG = new EditablePanel( m_pRedTeamPanel, "RedPlayerListBG" );
	m_pBlueMedalsPanel = new EditablePanel( m_pTeamScoresPanel, "BlueMedals" );
	m_pRedMedalsPanel = new EditablePanel( m_pTeamScoresPanel, "RedMedals" );
	m_pRedTeamImage = new vgui::ImagePanel( m_pRedTeamPanel, "RedTeamImage" );
	m_pBlueTeamImage = new vgui::ImagePanel( m_pBlueTeamPanel, "BlueTeamImage" );
	m_pRedLeaderAvatarImage = new CAvatarImagePanel( m_pRedTeamPanel, "RedLeaderAvatar" );
	m_pBlueLeaderAvatarImage = new CAvatarImagePanel( m_pBlueTeamPanel, "BlueLeaderAvatar" );
	m_pRedLeaderAvatarBG = new EditablePanel( m_pRedTeamPanel, "RedLeaderAvatarBG" );
	m_pBlueLeaderAvatarBG = new EditablePanel( m_pBlueTeamPanel, "BlueLeaderAvatarBG" );
	m_pStatsAndMedals = new CExLabel( m_pStatsLabelPanel, "StatsAndMedals", "" );
	m_pStatsAndMedalsShadow = new CExLabel( m_pStatsLabelPanel, "StatsAndMedalsShadow", "" );
	m_pRedTeamName = new CExLabel( m_pRedTeamPanel, "RedTeamLabel", "" );
	m_pBlueTeamName = new CExLabel( m_pBlueTeamPanel, "BlueTeamLabel", "" );
	m_pRedTeamWinner = new CExLabel( m_pRedTeamPanel, "RedTeamWinner", "" );
	m_pRedTeamWinnerDropshadow = new CExLabel( m_pRedTeamPanel, "RedTeamWinnerDropshadow", "" );
	m_pBlueTeamWinner = new CExLabel( m_pBlueTeamPanel, "BlueTeamWinner", "" );
	m_pBlueTeamWinnerDropshadow = new CExLabel( m_pBlueTeamPanel, "BlueTeamWinnerDropshadow", "" );

	m_pImageList = NULL;

	m_mapAvatarsToImageList.SetLessFunc( DefLessFunc( CSteamID ) );
	m_mapAvatarsToImageList.RemoveAll();

	Q_memset( m_SkillRatings, 0, sizeof( m_SkillRatings ) );

	m_iCurrentState = MS_STATE_INITIAL;
	m_flNextActionTime = -1;

	m_nMedalsToAward_Bronze_Blue = 0;
	m_nMedalsToAward_Silver_Blue = 0;
	m_nMedalsToAward_Gold_Blue = 0;
	m_nMedalsToAward_Bronze_Red = 0;
	m_nMedalsToAward_Silver_Red = 0;
	m_nMedalsToAward_Gold_Red = 0;
	
	m_nMedalsRevealed = 0;
	m_nNumMedalsThisUpdate = 0;

	m_bBlueGoldValueRevealed = false;
	m_bBlueSilverValueRevealed = false;
	m_bBlueBronzeValueRevealed = false;
	m_bRedGoldValueRevealed = false;
	m_bRedSilverValueRevealed = false;
	m_bRedBronzeValueRevealed = false;
	m_bPlayerAbandoned = false;

	m_flMedalSoundTime = -1.f;

	m_bLargeMatchGroup = false;

	Q_memset( m_iImageClass, NULL, sizeof( m_iImageClass ) );
	Q_memset( m_iImageClassAlt, NULL, sizeof( m_iImageClassAlt ) );

	ListenForGameEvent( "competitive_victory" );
	ListenForGameEvent( "competitive_stats_update" );
	ListenForGameEvent( "player_abandoned_match" );
	ListenForGameEvent( "client_disconnect" );
	ListenForGameEvent( "show_match_summary" );

	vgui::ivgui()->AddTickSignal( GetVPanel(), 50 );
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFMatchSummary::~CTFMatchSummary()
{
	if ( NULL != m_pImageList )
	{
		delete m_pImageList;
		m_pImageList = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Applies scheme settings
//-----------------------------------------------------------------------------
void CTFMatchSummary::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	m_bLargeMatchGroup = false;

	KeyValues *pConditions = NULL;
	if ( TFGameRules() )
	{
		const IMatchGroupDescription* pMatch = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
		if ( pMatch )
		{
			if ( pMatch->m_params.m_pmm_match_group_size->GetInt() > 12 )
			{
				pConditions = new KeyValues( "conditions" );
				AddSubKeyNamed( pConditions, "if_large" );

				m_bLargeMatchGroup = true;
			}
		}
	}

	LoadControlSettings( "resource/UI/HudMatchSummary.res", NULL, NULL, pConditions );

	if ( pConditions )
	{
		pConditions->deleteThis();
	}

	if ( m_pDrawingPanel )
	{
		m_pDrawingPanel->ClearAllLines();
		m_pDrawingPanel->SetType( DRAWING_PANEL_TYPE_MATCH_SUMMARY );
		m_pDrawingPanel->MakePopup();
	}


	if ( m_pImageList )
		delete m_pImageList;
	m_pImageList = new ImageList( false );

	m_mapAvatarsToImageList.RemoveAll();

	for ( int i = 1; i < (int)StatMedal_Max; i++ )
	{
		m_iImageMedals[i] = m_pImageList->AddImage( scheme()->GetImage( g_pszCompetitiveMedalImages[i], true ) );
	}

	for ( int i = 1; i < SCOREBOARD_CLASS_ICONS; i++ )
	{
		m_iImageClass[i] = m_pImageList->AddImage( scheme()->GetImage( g_pszClassIcons[i], true ) );
		m_iImageClassAlt[i] = m_pImageList->AddImage( scheme()->GetImage( g_pszClassIconsAlt[i], true ) );
	}

	int iCurrentCount = m_pImageList->GetImageCount();

	// resize the images to our resolution
	for ( int i = 0; i < iCurrentCount; i++ )
	{
		int wide = 13, tall = 13;
		m_pImageList->GetImage( i )->SetSize( scheme()->GetProportionalScaledValueEx( GetScheme(), wide ), scheme()->GetProportionalScaledValueEx( GetScheme(), tall ) );
	}

	// resize the images to our resolution
	for ( int i = iCurrentCount; i < m_pImageList->GetImageCount(); i++ )
	{
		int wide = 26, tall = 26;
		m_pImageList->GetImage( i )->SetSize( scheme()->GetProportionalScaledValueEx( GetScheme(), wide ), scheme()->GetProportionalScaledValueEx( GetScheme(), tall ) );
	}

	SetPaintBackgroundEnabled( false );
	m_pTeamScoresPanel->SetPaintBackgroundEnabled( false );
	m_pPlayerListBlueParent->SetPaintBackgroundEnabled( false );
	m_pPlayerListRedParent->SetPaintBackgroundEnabled( false );
	m_pPlayerListBlue->SetPaintBackgroundEnabled( false );
	m_pPlayerListRed->SetPaintBackgroundEnabled( false );

	m_pPlayerListBlue->SetImageList( m_pImageList, false );
	m_pPlayerListBlue->SetVisible( true );

	m_pPlayerListRed->SetImageList( m_pImageList, false );
	m_pPlayerListRed->SetVisible( true );

	InitPlayerList( m_pPlayerListBlue, TF_TEAM_BLUE );
	InitPlayerList( m_pPlayerListRed, TF_TEAM_RED );

	m_hFont = pScheme->GetFont( "ScoreboardVerySmall", true );

	m_iCurrentState = MS_STATE_INITIAL;
	m_flNextActionTime = -1;

	RecalculateMedalCounts();

	m_nMedalsRevealed = 0;

	m_bBlueGoldValueRevealed = false;
	m_bBlueSilverValueRevealed = false;
	m_bBlueBronzeValueRevealed = false;
	m_bRedGoldValueRevealed = false;
	m_bRedSilverValueRevealed = false;
	m_bRedBronzeValueRevealed = false;

	m_flMedalSoundTime = -1.f;
	m_flDrawingPanelTime = -1.f;

	m_pBlueMedalsPanel->SetDialogVariable( "blueteammedals_gold", "?" );
	m_pBlueMedalsPanel->SetDialogVariable( "blueteammedals_silver", "?" );
	m_pBlueMedalsPanel->SetDialogVariable( "blueteammedals_bronze", "?" );
	m_pRedMedalsPanel->SetDialogVariable( "redteammedals_gold", "?" );
	m_pRedMedalsPanel->SetDialogVariable( "redteammedals_silver", "?" );
	m_pRedMedalsPanel->SetDialogVariable( "redteammedals_bronze", "?" );

	Update();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::PerformLayout()
{
	BaseClass::PerformLayout();

	EditablePanel* pStatsContainer = FindControl< EditablePanel >( "MainStatsContainer" );
	if ( pStatsContainer && m_bLargeMatchGroup )
	{
		pStatsContainer->SetPos( pStatsContainer->GetXPos(), m_iAnimStatsContainer12v12YPos );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFMatchSummary::ShouldDraw( void )
{
	return IsVisible();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::SetVisible( bool state )
{
	int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "mid" );

	if ( state )
	{
		gHUD.LockRenderGroup( iRenderGroup );

		InvalidateLayout( true, true );

		m_iCurrentState = MS_STATE_INITIAL;

		m_flDrawingPanelTime = gpGlobals->curtime + 4.5f;

		CPvPRankPanel* pPvPRankPanel = FindControl< CPvPRankPanel >( "RankPanel" );
		if ( pPvPRankPanel )
		{
			pPvPRankPanel->SetMatchGroup( TFGameRules()->GetCurrentMatchGroup() );
		}

		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "CompetitiveGame_LowerChatWindow", false );
	}
	else
	{
		gHUD.UnlockRenderGroup( iRenderGroup );
	}

	BaseClass::SetVisible( state );
}

//-----------------------------------------------------------------------------
// Purpose: Used for sorting players
//-----------------------------------------------------------------------------
bool CTFMatchSummary::TFPlayerSortFunc( vgui::SectionedListPanel *list, int itemID1, int itemID2 )
{
	KeyValues *it1 = list->GetItemData( itemID1 );
	KeyValues *it2 = list->GetItemData( itemID2 );
	Assert( it1 && it2 );

	// first compare score
	int v1 = it1->GetInt( "score" );
	int v2 = it2->GetInt( "score" );
	if ( v1 > v2 )
		return true;
	else if ( v1 < v2 )
		return false;

	// if score is the same, use player index to get deterministic sort
	int iPlayerIndex1 = it1->GetInt( "playerIndex" );
	int iPlayerIndex2 = it2->GetInt( "playerIndex" );
	return ( iPlayerIndex1 > iPlayerIndex2 );
}

//-----------------------------------------------------------------------------
// Purpose: Inits the player list in a list panel
//-----------------------------------------------------------------------------
void CTFMatchSummary::InitPlayerList( TFSectionedListPanel *pPlayerList, int nTeam )
{
	float flAspectRatio = engine->GetScreenAspectRatio();
	bool bStandard = flAspectRatio < 1.6f;

	pPlayerList->SetVerticalScrollbar( false );
	pPlayerList->RemoveAll();
	pPlayerList->RemoveAllSections();
	pPlayerList->AddSection( 0, "Players", TFPlayerSortFunc );
	pPlayerList->SetSectionAlwaysVisible( 0, true );
	pPlayerList->SetSectionDrawDividerBar( 0, false );
	pPlayerList->SetBorder( NULL );
	pPlayerList->SetMouseInputEnabled( false );
	pPlayerList->SetClickable( false );

	pPlayerList->AddColumnToSection( 0, "medal", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_CENTER, pPlayerList->m_iMedalWidth );
	pPlayerList->AddColumnToSection( 0, "avatar", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iAvatarWidth );
	pPlayerList->AddColumnToSection( 0, "spacer", "", 0, pPlayerList->m_iSpacerWidth );
	pPlayerList->AddColumnToSection( 0, "name", "", 0, pPlayerList->m_iNameWidth );
	pPlayerList->AddColumnToSection( 0, "class", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iClassWidth );
	pPlayerList->AddColumnToSection( 0, "score", bStandard ? "#TF_Comp_Scoreboard_Score_Standard" : "#TF_Comp_Scoreboard_Score", SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iStatsWidth );
	pPlayerList->AddColumnToSection( 0, "score_medal", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iAwardWidth );
	pPlayerList->AddColumnToSection( 0, "kills", bStandard ? "#TF_Comp_Scoreboard_Kills_Standard" : "#TF_Comp_Scoreboard_Kills", SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iStatsWidth );
	pPlayerList->AddColumnToSection( 0, "kills_medal", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iAwardWidth );
	pPlayerList->AddColumnToSection( 0, "damage", bStandard ? "#TF_Comp_Scoreboard_Damage_Standard" : "#TF_Comp_Scoreboard_Damage", SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iStatsWidth );
	pPlayerList->AddColumnToSection( 0, "damage_medal", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iAwardWidth );
	pPlayerList->AddColumnToSection( 0, "healing", bStandard ? "#TF_Comp_Scoreboard_Healing_Standard" : "#TF_Comp_Scoreboard_Healing", SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iStatsWidth );
	pPlayerList->AddColumnToSection( 0, "healing_medal", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iAwardWidth );
	pPlayerList->AddColumnToSection( 0, "support", bStandard ? "#TF_Comp_Scoreboard_Support_Standard" : "#TF_Comp_Scoreboard_Support", SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iStatsWidth );
	pPlayerList->AddColumnToSection( 0, "support_medal", "", SectionedListPanel::COLUMN_IMAGE | SectionedListPanel::COLUMN_RIGHT, pPlayerList->m_iAwardWidth );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::Update( void )
{
	UpdateTeamInfo();
	UpdatePlayerList();
	UpdateBadgePanels( m_pRedBadgePanels, m_pPlayerListRed );
	UpdateBadgePanels( m_pBlueBadgePanels, m_pPlayerListBlue );
}

//-----------------------------------------------------------------------------
// Purpose: Updates information about teams
//-----------------------------------------------------------------------------
void CTFMatchSummary::UpdateTeamInfo()
{
	bool bUseWinnerLabel = false;
	if ( GetGlobalTFTeam( TF_TEAM_RED ) && GetGlobalTFTeam( TF_TEAM_BLUE ) )
	{
		if ( GetGlobalTFTeam( TF_TEAM_RED )->Get_Score() == GetGlobalTFTeam( TF_TEAM_BLUE )->Get_Score() )
		{
			bUseWinnerLabel = true;
		}
	}

	int nWinningTeam = TEAM_INVALID;
	if ( TFGameRules() )
	{
		nWinningTeam = TFGameRules()->GetWinningTeam();
	}

	for ( int teamIndex = TF_TEAM_RED; teamIndex <= TF_TEAM_BLUE; teamIndex++ )
	{
		C_TFTeam *team = GetGlobalTFTeam( teamIndex );
		if ( team )
		{
			// choose dialog variables to set depending on team
			const char *pDialogVarTeamName = "";
			const char *pDialogVarTeamScore = "";
			const char *pDialogVarWinner = "";
			vgui::EditablePanel *pOwner = NULL;

			switch ( teamIndex )
			{
			case TF_TEAM_RED:
				pDialogVarTeamName = "redteamname";
				pDialogVarTeamScore = "redteamscore";
				pDialogVarWinner = "redteamwinner";
				pOwner = m_pRedTeamPanel;
				break;
			case TF_TEAM_BLUE:
				pDialogVarTeamName = "blueteamname";
				pDialogVarTeamScore = "blueteamscore";
				pDialogVarWinner = "blueteamwinner";
				pOwner = m_pBlueTeamPanel;
				break;
			default:
				Assert( false );
				break;
			}

			if ( !pOwner )
				return;

			// set the team name
			pOwner->SetDialogVariable( pDialogVarTeamName, team->Get_Localized_Name() );

			if ( bUseWinnerLabel )
			{
				const char *pszLabel = "";
				if ( teamIndex == nWinningTeam ) 
				{
					if ( team->GetNumPlayers() > 1 )
					{
						pszLabel = "#TF_Winners";
					}
					else
					{
						pszLabel = "#TF_Winner";
					}
				}

				pOwner->SetDialogVariable( pDialogVarTeamScore, "" );
				pOwner->SetDialogVariable( pDialogVarWinner, g_pVGuiLocalize->Find( pszLabel ) );
			}
			else
			{
				pOwner->SetDialogVariable( pDialogVarTeamScore, team->Get_Score() );
				pOwner->SetDialogVariable( pDialogVarWinner, "" );
			}
		}
	}

	bool bShowAvatars = g_TF_PR && g_TF_PR->HasPremadeParties();

	if ( bShowAvatars )
	{
		m_pRedLeaderAvatarImage->SetPlayer( GetSteamIDForPlayerIndex( g_TF_PR->GetPartyLeaderRedTeamIndex() ), k_EAvatarSize64x64 );
		m_pRedLeaderAvatarImage->SetShouldDrawFriendIcon( false );
		m_pBlueLeaderAvatarImage->SetPlayer( GetSteamIDForPlayerIndex( g_TF_PR->GetPartyLeaderBlueTeamIndex() ), k_EAvatarSize64x64 );
		m_pBlueLeaderAvatarImage->SetShouldDrawFriendIcon( false );
	}

	m_pRedLeaderAvatarImage->SetVisible( bShowAvatars );
	m_pRedLeaderAvatarBG->SetVisible( bShowAvatars );
	m_pRedTeamName->SetVisible( bShowAvatars );
	m_pRedTeamImage->SetVisible( !bShowAvatars );

	m_pBlueLeaderAvatarImage->SetVisible( bShowAvatars );
	m_pBlueLeaderAvatarBG->SetVisible( bShowAvatars );
	m_pBlueTeamName->SetVisible( bShowAvatars );
	m_pBlueTeamImage->SetVisible( !bShowAvatars );
}

//-----------------------------------------------------------------------------
// Purpose: Returns the last medal (column) added so we can display some effects
//-----------------------------------------------------------------------------
matchsummary_columns_t CTFMatchSummary::InternalAddMedalKeyValues( int iIndex, StatMedal_t eMedal, KeyValues *pKeyValues, int nTotalMedals /*= -1*/ )
{
	int nMedal = (int)eMedal;
	matchsummary_columns_t retVal = MS_COLUMN_INVALID;

	if ( ( nTotalMedals < 0 ) || ( m_nNumMedalsThisUpdate <= nTotalMedals ) )
	{
		if ( m_SkillRatings[iIndex].nScoreRank == nMedal )
		{
			pKeyValues->SetInt( "score_medal", m_iImageMedals[nMedal] );
			if ( nTotalMedals >= 0 )
			{
				m_nNumMedalsThisUpdate++;
			}

			if ( ( nTotalMedals >= 0 ) && ( m_nNumMedalsThisUpdate > nTotalMedals ) )
			{
				retVal = MS_COLUMN_SCORE_MEDAL;
			}
		}
	}

	if ( ( nTotalMedals < 0 ) || ( m_nNumMedalsThisUpdate <= nTotalMedals ) )
	{
		if ( m_SkillRatings[iIndex].nKillsRank == nMedal )
		{
			pKeyValues->SetInt( "kills_medal", m_iImageMedals[nMedal] );
			if ( nTotalMedals >= 0 )
			{
				m_nNumMedalsThisUpdate++;
			}

			if ( ( nTotalMedals >= 0 ) && ( m_nNumMedalsThisUpdate > nTotalMedals ) )
			{
				retVal = MS_COLUMN_KILLS_MEDAL;
			}
		}
	}

	if ( ( nTotalMedals < 0 ) || ( m_nNumMedalsThisUpdate <= nTotalMedals ) )
	{
		if ( m_SkillRatings[iIndex].nDamageRank == nMedal )
		{
			pKeyValues->SetInt( "damage_medal", m_iImageMedals[nMedal] );
			if ( nTotalMedals >= 0 )
			{
				m_nNumMedalsThisUpdate++;
			}

			if ( ( nTotalMedals >= 0 ) && ( m_nNumMedalsThisUpdate > nTotalMedals ) )
			{
				retVal = MS_COLUMN_DAMAGE_MEDAL;
			}
		}
	}

	if ( ( nTotalMedals < 0 ) || ( m_nNumMedalsThisUpdate <= nTotalMedals ) )
	{
		if ( m_SkillRatings[iIndex].nHealingRank == nMedal )
		{
			pKeyValues->SetInt( "healing_medal", m_iImageMedals[nMedal] );
			if ( nTotalMedals >= 0 )
			{
				m_nNumMedalsThisUpdate++;
			}

			if ( ( nTotalMedals >= 0 ) && ( m_nNumMedalsThisUpdate > nTotalMedals ) )
			{
				retVal = MS_COLUMN_HEALING_MEDAL;
			}
		}
	}

	if ( ( nTotalMedals < 0 ) || ( m_nNumMedalsThisUpdate <= nTotalMedals ) )
	{
		if ( m_SkillRatings[iIndex].nSupportRank == nMedal )
		{
			pKeyValues->SetInt( "support_medal", m_iImageMedals[nMedal] );
			if ( nTotalMedals >= 0 )
			{
				m_nNumMedalsThisUpdate++;
			}

			if ( ( nTotalMedals >= 0 ) && ( m_nNumMedalsThisUpdate > nTotalMedals ) )
			{
				retVal = MS_COLUMN_SUPPORT_MEDAL;
			}
		}
	}

	return retVal;
}

//-----------------------------------------------------------------------------
// Purpose: Updates the player list
//-----------------------------------------------------------------------------
void CTFMatchSummary::UpdatePlayerList()
{
	m_pPlayerListRed->RemoveAll();
	m_pPlayerListRed->ClearAllColorOverrideForCell();

	m_pPlayerListBlue->RemoveAll();
	m_pPlayerListBlue->ClearAllColorOverrideForCell();

	if ( !g_TF_PR )
		return;

	m_nNumMedalsThisUpdate = 0;

	for ( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
	{
		if ( g_PR->IsConnected( playerIndex ) || g_PR->IsValid( playerIndex ) )
		{
			TFSectionedListPanel *pPlayerList = NULL;
			int nTeam = g_PR->GetTeam( playerIndex );
			switch ( nTeam )
			{
			case TF_TEAM_BLUE:
				pPlayerList = m_pPlayerListBlue;
				break;
			case TF_TEAM_RED:
				pPlayerList = m_pPlayerListRed;
				break;
			}
			if ( null == pPlayerList )
				continue;

			KeyValues *pKeyValues = new KeyValues( "data" );
			pKeyValues->SetInt( "playerIndex", playerIndex );

			// this is just a placeholder in the sectioned list panel
			pKeyValues->SetInt( "medal", 0 ); 

			pKeyValues->SetString( "name", g_TF_PR->GetPlayerName( playerIndex ) );
			pKeyValues->SetInt( "score", g_TF_PR->GetTotalScore( playerIndex ) );

			int iClass = g_TF_PR->GetPlayerClass( playerIndex );
			if ( iClass >= TF_FIRST_NORMAL_CLASS && iClass <= TF_LAST_NORMAL_CLASS )
			{
				pKeyValues->SetInt( "class", tf_scoreboard_alt_class_icons.GetBool() ? m_iImageClassAlt[iClass] : m_iImageClass[iClass] );
			}
			else
			{
				pKeyValues->SetInt( "class", 0 );
			}

			pKeyValues->SetInt( "kills", g_TF_PR->GetPlayerScore( playerIndex ) );
			pKeyValues->SetInt( "damage", g_TF_PR->GetDamage( playerIndex ) );
			pKeyValues->SetInt( "healing", g_TF_PR->GetHealing( playerIndex ) );

			int nSupport = g_TF_PR->GetDamageAssist( playerIndex ) +
				g_TF_PR->GetHealingAssist( playerIndex ) +
				g_TF_PR->GetDamageBlocked( playerIndex ) +
				( g_TF_PR->GetBonusPoints( playerIndex ) * 25 );
			pKeyValues->SetInt( "support", nSupport );

			matchsummary_columns_t eParticleColumn = MS_COLUMN_INVALID;
			StatMedal_t eParticleMedal = StatMedal_None;

			if ( m_iCurrentState == MS_STATE_GOLD_MEDALS )
			{
				// we can add the bronze and silver since we've already processed those
				InternalAddMedalKeyValues( playerIndex, StatMedal_Bronze, pKeyValues );
				InternalAddMedalKeyValues( playerIndex, StatMedal_Silver, pKeyValues );
				eParticleColumn = InternalAddMedalKeyValues( playerIndex, StatMedal_Gold, pKeyValues, m_nMedalsRevealed );
				eParticleMedal = StatMedal_Gold;
			}
			else if ( m_iCurrentState == MS_STATE_SILVER_MEDALS )
			{
				// we can add the bronze since we've already processed those
				InternalAddMedalKeyValues( playerIndex, StatMedal_Bronze, pKeyValues );
				eParticleColumn = InternalAddMedalKeyValues( playerIndex, StatMedal_Silver, pKeyValues, m_nMedalsRevealed );
				eParticleMedal = StatMedal_Silver;
			}
			else if ( m_iCurrentState == MS_STATE_BRONZE_MEDALS )
			{
				eParticleColumn = InternalAddMedalKeyValues( playerIndex, StatMedal_Bronze, pKeyValues, m_nMedalsRevealed );
				eParticleMedal = StatMedal_Bronze;
			}

			UpdatePlayerAvatar( playerIndex, pKeyValues );

			int itemID = pPlayerList->AddItem( 0, pKeyValues );
			pPlayerList->SetItemFgColor( itemID, g_PR->GetTeamColor( nTeam ) );
			// Green background for rematch folks
			pPlayerList->SetItemBgColor( itemID, Color( 80, 80, 80, 80 ) );
			pPlayerList->SetItemBgHorizFillInset( itemID, pPlayerList->m_iHorizFillInset );
			pPlayerList->SetItemFont( itemID, m_hFont );

			// This highlights the local player in grey
			if ( playerIndex == GetLocalPlayerIndex() )
			{
				pPlayerList->SetSelectedItem( itemID );
			}

			// loop through and setup our medal color overrides
			KeyValues *pKey = pKeyValues->FindKey( "score_medal" );
			if ( pKey && pKey->GetInt() )
			{
				int nMedal = pKey->GetInt();
				pPlayerList->SetColorOverrideForCell( 0, itemID, MS_COLUMN_SCORE, ( nMedal == (int)StatMedal_Bronze ) ? m_clrBronzeMedal : ( nMedal == (int)StatMedal_Silver ) ?  m_clrSilverMedal : m_clrGoldMedal );
			}
			pKey = pKeyValues->FindKey( "kills_medal" );
			if ( pKey && pKey->GetInt() )
			{
				int nMedal = pKey->GetInt();
				pPlayerList->SetColorOverrideForCell( 0, itemID, MS_COLUMN_KILLS, ( nMedal == (int)StatMedal_Bronze ) ? m_clrBronzeMedal : ( nMedal == (int)StatMedal_Silver ) ? m_clrSilverMedal : m_clrGoldMedal );
			}
			pKey = pKeyValues->FindKey( "damage_medal" );
			if ( pKey && pKey->GetInt() )
			{
				int nMedal = pKey->GetInt();
				pPlayerList->SetColorOverrideForCell( 0, itemID, MS_COLUMN_DAMAGE, ( nMedal == (int)StatMedal_Bronze ) ? m_clrBronzeMedal : ( nMedal == (int)StatMedal_Silver ) ? m_clrSilverMedal : m_clrGoldMedal );
			}
			pKey = pKeyValues->FindKey( "healing_medal" );
			if ( pKey && pKey->GetInt() )
			{
				int nMedal = pKey->GetInt();
				pPlayerList->SetColorOverrideForCell( 0, itemID, MS_COLUMN_HEALING, ( nMedal == (int)StatMedal_Bronze ) ? m_clrBronzeMedal : ( nMedal == (int)StatMedal_Silver ) ? m_clrSilverMedal : m_clrGoldMedal );
			}
			pKey = pKeyValues->FindKey( "support_medal" );
			if ( pKey && pKey->GetInt() )
			{
				int nMedal = pKey->GetInt();
				pPlayerList->SetColorOverrideForCell( 0, itemID, MS_COLUMN_SUPPORT, ( nMedal == (int)StatMedal_Bronze ) ? m_clrBronzeMedal : ( nMedal == (int)StatMedal_Silver ) ? m_clrSilverMedal : m_clrGoldMedal );
			}

			pKeyValues->deleteThis();

			if ( ( eParticleColumn > MS_COLUMN_INVALID ) && ( eParticleMedal > StatMedal_None ) )
			{
				int nPanelXPos, nPanelYPos, nPanelWide, nPanelTall;
				pPlayerList->GetMaxCellBounds( itemID, eParticleColumn, nPanelXPos, nPanelYPos, nPanelWide, nPanelTall );

				FireMedalEffects( pPlayerList, nPanelXPos, nPanelYPos, nPanelWide, nPanelTall, eParticleMedal );
			}
		}
	}

	m_pPlayerListRed->SetSectionFgColor( 0, g_PR->GetTeamColor( TF_TEAM_RED ) );
	m_pPlayerListBlue->SetSectionFgColor( 0, g_PR->GetTeamColor( TF_TEAM_BLUE ) );

	// force the lists to PerformLayout() now so we can update our rank images after we return
	m_pPlayerListRed->InvalidateLayout( true );
	m_pPlayerListBlue->InvalidateLayout( true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::FireMedalEffects( Panel *pPanel, int nPanelXPos, int nPanelYPos, int nPanelWide, int nPanelTall, StatMedal_t eParticleMedal )
{
	if ( !pPanel )
		return;

	int nPanelCenterX = nPanelXPos + ( nPanelWide / 2 );
	int nPanelCenterY = nPanelYPos + ( nPanelTall / 2 );

	int iItemAbsX, iItemAbsY;
	vgui::ipanel()->GetAbsPos( pPanel->GetParent()->GetVPanel(), iItemAbsX, iItemAbsY );

	int x = iItemAbsX + nPanelCenterX;
	int y = iItemAbsY + nPanelCenterY;

	const char *pszSoundEffect = "MatchMaking.None";
	const char *pszParticleEffect = "mvm_loot_smoke";
	if ( eParticleMedal == StatMedal_Bronze )
	{
		pszSoundEffect = "MatchMaking.Bronze";
		pszParticleEffect = "mvm_loot_explosion";
	}
	else if ( eParticleMedal == StatMedal_Silver )
	{
		pszSoundEffect = "MatchMaking.Silver";
		pszParticleEffect = "mvm_loot_explosion";
	}
	else if ( eParticleMedal == StatMedal_Gold )
	{
		pszSoundEffect = "MatchMaking.Gold";
		pszParticleEffect = "mvm_pow_gold_seq_firework_mid";
	}

	m_pParticlePanel->FireParticleEffect( pszParticleEffect, x, y, 0.2f, false );

	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
	if ( pLocalPlayer )
	{
		pLocalPlayer->EmitSound( pszSoundEffect );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::UpdateBadgePanels( CUtlVector<CTFBadgePanel*> &pBadgePanels, TFSectionedListPanel *pPlayerList )
{
	if ( !TFGameRules() )
		return;

	const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
	const IProgressionDesc *pProgressionDesc = pMatchDesc ? pMatchDesc->m_pProgressionDesc : NULL; 
	if ( pProgressionDesc )
	{
		if ( pPlayerList )
		{
			int iNumPanels = 0;
			int parentTall = pPlayerList->GetTall();
			CTFBadgePanel *pPanel = NULL;

			for ( int i = 0; i < pPlayerList->GetItemCount(); i++ )
			{
				KeyValues *pKeyValues = pPlayerList->GetItemData( i );
				if ( !pKeyValues )
					continue;

				const CSteamID steamID = GetSteamIDForPlayerIndex( pKeyValues->GetInt( "playerIndex" ) );
#ifdef STAGING_ONLY
				if ( steamID.IsValid() || tf_test_match_summary.GetBool() )
#else
				if ( steamID.IsValid() )
#endif // STAGING_ONLY
				{
					if ( iNumPanels >= pBadgePanels.Count() )
					{
						pPanel = new CTFBadgePanel( m_pMainStatsContainer, "BadgePanel" );
						pPanel->MakeReadyForUse();
						pPanel->SetVisible( true );
						pPanel->SetZPos( 9999 );
						pBadgePanels.AddToTail( pPanel );
					}
					else
					{
						pPanel = pBadgePanels[iNumPanels];
					}

					int x, y, wide, tall;
					pPlayerList->GetMaxCellBounds( i, 0, x, y, wide, tall );

					if ( y + tall > parentTall )
						continue;

					if ( !pPanel->IsVisible() )
					{
						pPanel->SetVisible( true );
					}

					int xParent = 0, yParent = 0;
					if ( pPlayerList->GetParent() )
					{
						pPlayerList->GetParent()->GetPos( xParent, yParent );
					}

					int xGrandParent = 0, yGrandParent = 0;
					if ( pPlayerList->GetParent()->GetParent() )
					{
						pPlayerList->GetParent()->GetParent()->GetPos( xGrandParent, yGrandParent );
					}

					int nPanelXPos, nPanelYPos, nPanelWide, nPanelTall;
					pPanel->GetBounds( nPanelXPos, nPanelYPos, nPanelWide, nPanelTall );

					if ( ( nPanelXPos != xGrandParent + xParent + x )
						|| ( nPanelYPos != yGrandParent + yParent + y )
						|| ( nPanelWide != wide )
						|| ( nPanelTall != tall ) )
					{
						pPanel->SetBounds( xGrandParent + xParent + x, yGrandParent + yParent + y, wide, tall );
						pPanel->InvalidateLayout( true, true );
					}

					pPanel->SetupBadge( pProgressionDesc, steamID );
					iNumPanels++;
				}
			}

			// hide any unused images
			for ( int i = iNumPanels; i < pBadgePanels.Count(); i++ )
			{
				if ( pBadgePanels[i]->IsVisible() )
				{
					pBadgePanels[i]->SetVisible( false );
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::UpdatePlayerAvatar( int playerIndex, KeyValues *kv )
{
	if ( !g_PR )
		return;

	uint32 iAccountID = g_PR->GetAccountID( playerIndex );
	if ( iAccountID > 0 )
	{
		// Update their avatar
		if ( kv && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() )
		{
			CSteamID steamIDForPlayer( iAccountID, 1, GetUniverse(), k_EAccountTypeIndividual );

			// See if we already have that avatar in our list
			int iMapIndex = m_mapAvatarsToImageList.Find( steamIDForPlayer );
			int iImageIndex;
			if ( iMapIndex == m_mapAvatarsToImageList.InvalidIndex() )
			{
				CAvatarImage *pImage = new CAvatarImage();
				pImage->SetAvatarSteamID( steamIDForPlayer );
				pImage->SetAvatarSize( 32, 32 );	// Deliberately non scaling
				iImageIndex = m_pImageList->AddImage( pImage );

				m_mapAvatarsToImageList.Insert( steamIDForPlayer, iImageIndex );
			}
			else
			{
				iImageIndex = m_mapAvatarsToImageList[iMapIndex];
			}

			kv->SetInt( "avatar", iImageIndex );

			CAvatarImage *pAvIm = (CAvatarImage *)m_pImageList->GetImage( iImageIndex );
			pAvIm->UpdateFriendStatus();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Event handler
//-----------------------------------------------------------------------------
void CTFMatchSummary::FireGameEvent( IGameEvent *event )
{
	const char *type = event->GetName();

	if ( FStrEq( type, "competitive_victory" ) )
	{
		Q_memset( m_SkillRatings, 0, sizeof( m_SkillRatings ) );
		Leaderboards_LadderRefresh();
	}
	else if ( FStrEq( type, "competitive_stats_update" ) )
	{
		int iIndex = event->GetInt( "index" );
		Assert( iIndex > 0 && iIndex <= MAX_PLAYERS );
		if ( iIndex > 0 && iIndex <= MAX_PLAYERS )
		{
			m_SkillRatings[iIndex].unRating = event->GetInt( "rating" );			// Rank
			m_SkillRatings[iIndex].nDelta = event->GetInt( "delta" );
			m_SkillRatings[iIndex].nScoreRank = event->GetInt( "score_rank" );		// Medal for Score (Gold, Silver, Bronze, or nothing)		
			m_SkillRatings[iIndex].nKillsRank = event->GetInt( "kills_rank" );		// Medal for Kills
			m_SkillRatings[iIndex].nDamageRank = event->GetInt( "damage_rank" );	// Medal for Damage
			m_SkillRatings[iIndex].nHealingRank = event->GetInt( "healing_rank" );	// Medal for Healing
			m_SkillRatings[iIndex].nSupportRank = event->GetInt( "support_rank" );	// Medal for Rank

			RecalculateMedalCounts();
		}
	}
	else if ( FStrEq( type, "player_abandoned_match" ) )
	{
		m_bPlayerAbandoned = true;
	}
	else if ( FStrEq( type, "client_disconnect" ) )
	{
		m_bPlayerAbandoned = false;
	}
	else if ( FStrEq( type, "show_match_summary" ) )
	{
		SetVisible( true );

		if ( m_pPlayerListRedParent->GetParent() )
		{
			int nRedBadgeOffset = m_pPlayerListRedParent->GetParent()->GetXPos();
			FOR_EACH_VEC( m_pRedBadgePanels, i )
			{
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedBadgePanels[i], "xpos", m_pRedBadgePanels[i]->GetXPos() - nRedBadgeOffset, 0.25, 0.25, vgui::AnimationController::INTERPOLATOR_ACCEL );
			}
		}

		if ( m_pPlayerListBlueParent->GetParent() )
		{
			int nBlueBadgeOffset = m_pPlayerListBlueParent->GetParent()->GetXPos();
			FOR_EACH_VEC( m_pBlueBadgePanels, i )
			{
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueBadgePanels[i], "xpos", m_pBlueBadgePanels[i]->GetXPos() - nBlueBadgeOffset, 0.25, 0.25, vgui::AnimationController::INTERPOLATOR_ACCEL );
			}
		}

		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_pTeamScoresPanel, "HudMatchSummary_SlideInPanels", false );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::InternalUpdateMedalCountForType( int iTeam, StatMedal_t eMedal )
{
	switch ( eMedal )
	{
	case StatMedal_Bronze:
		if ( iTeam == TF_TEAM_RED )
		{
			m_nMedalsToAward_Bronze_Red++;
		}
		else if ( iTeam == TF_TEAM_BLUE )
		{
			m_nMedalsToAward_Bronze_Blue++;
		}
		break;
	case StatMedal_Silver:
		if ( iTeam == TF_TEAM_RED )
		{
			m_nMedalsToAward_Silver_Red++;
		}
		else if ( iTeam == TF_TEAM_BLUE )
		{
			m_nMedalsToAward_Silver_Blue++;
		}
		break;
	case StatMedal_Gold:
		if ( iTeam == TF_TEAM_RED )
		{
			m_nMedalsToAward_Gold_Red++;
		}
		else if ( iTeam == TF_TEAM_BLUE )
		{
			m_nMedalsToAward_Gold_Blue++;
		}
		break;
	case StatMedal_None:
	default:
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::RecalculateMedalCounts()
{
	m_nMedalsToAward_Bronze_Blue = 0;
	m_nMedalsToAward_Silver_Blue = 0;
	m_nMedalsToAward_Gold_Blue = 0;
	m_nMedalsToAward_Bronze_Red = 0;
	m_nMedalsToAward_Silver_Red = 0;
	m_nMedalsToAward_Gold_Red = 0;

	if ( !g_PR )
		return;

	for ( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
	{
		if ( g_PR->IsConnected( playerIndex ) || g_PR->IsValid( playerIndex ) )
		{
			int nTeam = g_PR->GetTeam( playerIndex );
			if ( nTeam >= FIRST_GAME_TEAM )
			{
				InternalUpdateMedalCountForType( nTeam, (StatMedal_t)( m_SkillRatings[playerIndex].nScoreRank ) );
				InternalUpdateMedalCountForType( nTeam, (StatMedal_t)( m_SkillRatings[playerIndex].nKillsRank ) );
				InternalUpdateMedalCountForType( nTeam, (StatMedal_t)( m_SkillRatings[playerIndex].nDamageRank ) );
				InternalUpdateMedalCountForType( nTeam, (StatMedal_t)( m_SkillRatings[playerIndex].nHealingRank ) );
				InternalUpdateMedalCountForType( nTeam, (StatMedal_t)( m_SkillRatings[playerIndex].nSupportRank ) );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::OnTick()
{
	BaseClass::OnTick();

	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

	if ( !IsVisible() || !pLocalPlayer )
		return;

	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
	if ( !pMatchDesc )
		return;

	if ( pMatchDesc->m_params.m_bAllowDrawingAtMatchSummary 
	     && m_pDrawingPanel 
	     && ( m_flDrawingPanelTime > 0 ) 
	     && ( m_flDrawingPanelTime < gpGlobals->curtime ) )
	{
		m_pDrawingPanel->SetVisible( true );
		m_pDrawingPanel->SetKeyBoardInputEnabled( false );
		m_flDrawingPanelTime = -1.f;

		if ( pLocalPlayer )
		{
			pLocalPlayer->EmitSound( "Announcer.SummaryScreenWinners" );
		}
	}

	int nMedalsToAward_Bronze_Total = m_nMedalsToAward_Bronze_Blue + m_nMedalsToAward_Bronze_Red;
	int nMedalsToAward_Silver_Total = m_nMedalsToAward_Silver_Blue + m_nMedalsToAward_Silver_Red;
	int nMedalsToAward_Gold_Total = m_nMedalsToAward_Gold_Blue + m_nMedalsToAward_Gold_Red;

	bool bShowPerformanceMedals = ShowPerformanceMedals();
	bool bMapHasMatchSummaryStage = ( TFGameRules() && TFGameRules()->MapHasMatchSummaryStage() );

	
#ifdef STAGING_ONLY
	bool bUseMatchSummaryStage = tf_test_match_summary.GetBool() || ( pMatchDesc && pMatchDesc->m_params.m_bUseMatchSummaryStage );
#else
	bool bUseMatchSummaryStage = ( pMatchDesc && pMatchDesc->m_params.m_bUseMatchSummaryStage );
#endif

	switch ( m_iCurrentState )
	{
	case MS_STATE_INITIAL:
	{
		bool bUseStage = ( bMapHasMatchSummaryStage && bUseMatchSummaryStage );

		if ( GTFGCClientSystem()->GetSurveyRequest().has_match_id() )
		{
			Panel* pSurveyPanel = CreateSurveyQuestionPanel( this, GTFGCClientSystem()->GetSurveyRequest() );
			pSurveyPanel->MakePopup();
		}

		m_iCurrentState = MS_STATE_DRAWING;
		m_flNextActionTime = bUseStage ? gpGlobals->curtime + MS_STATE_TRANSITION_TO_STATS : gpGlobals->curtime + 2.f;
		m_bXPShown = false;

		if ( !bUseStage )
		{
			// if we're not using the stage we'll just show the doors and then skip to stats with no drawing
			if ( m_pDrawingPanel )
			{
				m_pDrawingPanel->SetVisible( false );
			}
		}
		break;
	}
	case MS_STATE_DRAWING:
		{
			if ( gpGlobals->curtime > m_flNextActionTime )
			{
				if ( m_pDrawingPanel )
				{
					m_pDrawingPanel->SetVisible( false );
				}

				if ( m_pStatsBgPanel )
				{
					m_pStatsBgPanel->SetVisible( true );
				}

				if ( m_pStatsLabelPanel )
				{
					m_pStatsLabelPanel->SetVisible( true );
				}

				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pStatsLabelPanel, "ypos", m_bLargeMatchGroup ? m_iAnimStatsLabelPanel12v12YPos : m_iAnimStatsLabelPanel6v6YPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueMedalsPanel, "ypos", m_iAnimBlueMedalsYPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedMedalsPanel, "ypos", m_iAnimRedMedalsYPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueTeamName, "ypos", m_bLargeMatchGroup ? m_iAnimBlueTeamLabel12v12YPos : m_iAnimBlueTeamLabel6v6YPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamName, "ypos", m_bLargeMatchGroup ? m_iAnimRedTeamLabel12v12YPos : m_iAnimRedTeamLabel6v6YPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pPlayerListBlueParent, "wide", m_iAnimBluePlayerListParent, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueTeamScore, "wide", m_iAnimBlueTeamScore, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueTeamScoreDropshadow, "wide", m_iAnimBlueTeamScoreDropshadow, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueTeamScoreBG, "wide", m_iAnimBlueTeamScoreBG, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBluePlayerListBG, "wide",  m_iAnimBluePlayerListBG, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamScore, "wide", m_iAnimRedTeamScoreWide, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamScore, "xpos", m_iAnimRedTeamScoreXPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamScoreDropshadow, "wide", m_iAnimRedTeamScoreDropshadowWide, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamScoreDropshadow, "xpos", m_iAnimRedTeamScoreDropshadowXPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamScoreBG, "wide", m_iAnimRedTeamScoreBGWide, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamScoreBG, "xpos", m_iAnimRedTeamScoreBGXPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pPlayerListRedParent, "wide", m_iAnimRedPlayerListParentWide, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pPlayerListRedParent, "xpos", m_iAnimRedPlayerListParentXPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedPlayerListBG, "wide", m_iAnimRedPlayerListBGWide, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedPlayerListBG, "xpos", m_iAnimRedPlayerListBGXPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueTeamWinner, "wide", m_iAnimBlueTeamScore, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pBlueTeamWinnerDropshadow, "wide", m_iAnimBlueTeamScoreDropshadow, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamWinner, "wide", m_iAnimRedTeamScoreWide, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamWinner, "xpos", m_iAnimRedTeamScoreXPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamWinnerDropshadow, "wide", m_iAnimRedTeamScoreDropshadowWide, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );
				g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedTeamWinnerDropshadow, "xpos", m_iAnimRedTeamScoreDropshadowXPos, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );

				int nRedBadgeOffset = m_pPlayerListRedParent->GetXPos() - m_iAnimRedPlayerListParentXPos;
				FOR_EACH_VEC( m_pRedBadgePanels, i )
				{
					g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( m_pRedBadgePanels[i], "xpos", m_pRedBadgePanels[i]->GetXPos() - nRedBadgeOffset, 0.0, 0.1, vgui::AnimationController::INTERPOLATOR_ACCEL );

				}

				float flDelay = MS_STATE_TRANSITION_TO_MEDALS;
					
				if ( pLocalPlayer )
				{
					if ( bShowPerformanceMedals )
					{
						const char *pszEntryName = UTIL_GetRandomSoundFromEntry( "Announcer.CompSummaryScreenOutlierQuestion" );
						if ( pszEntryName && pszEntryName[0] )
						{
							flDelay = enginesound->GetSoundDuration( pszEntryName );
							pLocalPlayer->EmitSound( pszEntryName );
						}
					}
					pLocalPlayer->EmitSound( "MatchMaking.ScoreboardPanelSlide" );
				}

				m_iCurrentState = MS_STATE_STATS;
				m_flNextActionTime = gpGlobals->curtime + flDelay;

				m_pRedMedalsPanel->SetVisible( bShowPerformanceMedals );
				m_pBlueMedalsPanel->SetVisible( bShowPerformanceMedals );

				m_pStatsAndMedals->SetText( bShowPerformanceMedals ? g_pVGuiLocalize->Find( "#TF_CompSummary_StatsAndMedals" ) : L"" );
				m_pStatsAndMedalsShadow->SetText( bShowPerformanceMedals ? g_pVGuiLocalize->Find( "#TF_CompSummary_StatsAndMedals" ) : L"" );
			}
			break;
		}
	case MS_STATE_STATS:
		{
			if ( gpGlobals->curtime > m_flNextActionTime )
			{
				m_iCurrentState = bShowPerformanceMedals ? MS_STATE_BRONZE_MEDALS : MS_STATE_FINAL;
				m_nMedalsRevealed = 0;
				m_flNextActionTime = -1;
			}
			break;
		}
	case MS_STATE_BRONZE_MEDALS:
		{
			if ( gpGlobals->curtime > m_flNextActionTime )
			{
				if ( !m_bBlueBronzeValueRevealed && !m_bRedBronzeValueRevealed )
				{
					m_pBlueMedalsPanel->SetDialogVariable( "blueteammedals_bronze", m_nMedalsToAward_Bronze_Blue );
					m_bBlueBronzeValueRevealed = true;
					Panel *pChild = m_pBlueMedalsPanel->FindChildByName( "BlueBronzeMedalValue" );
					if ( pChild )
					{
						int nXPos, nYPos, nWide, nTall;
						pChild->GetBounds( nXPos, nYPos, nWide, nTall );
						FireMedalEffects( pChild, nXPos, nYPos, nWide, nTall, ( m_nMedalsToAward_Bronze_Blue > 0 ) ? StatMedal_Bronze : StatMedal_None );
					}

					m_pRedMedalsPanel->SetDialogVariable( "redteammedals_bronze", m_nMedalsToAward_Bronze_Red );
					m_bRedBronzeValueRevealed = true;
					pChild = m_pRedMedalsPanel->FindChildByName( "RedBronzeMedalValue" );
					if ( pChild )
					{
						int nXPos, nYPos, nWide, nTall;
						pChild->GetBounds( nXPos, nYPos, nWide, nTall );
						FireMedalEffects( pChild, nXPos, nYPos, nWide, nTall, ( m_nMedalsToAward_Bronze_Red > 0 ) ? StatMedal_Bronze : StatMedal_None );
					}

					m_flNextActionTime = gpGlobals->curtime + MS_STATE_TIME_BETWEEN_MEDALS_CATEGORIES;
				}
				else
				{
					if ( ( nMedalsToAward_Bronze_Total > 0 ) && ( m_nMedalsRevealed < nMedalsToAward_Bronze_Total ) )
					{
						Update();
						m_nMedalsRevealed++;
						m_flNextActionTime = gpGlobals->curtime + MS_STATE_TIME_BETWEEN_MEDALS;
					}
					else
					{
						m_iCurrentState = MS_STATE_SILVER_MEDALS;
						m_nMedalsRevealed = 0;
						m_flNextActionTime = MS_STATE_TIME_BETWEEN_MEDALS_CATEGORIES;
					}
				}
			}
			break;
		}
	case MS_STATE_SILVER_MEDALS:
		{
			if ( gpGlobals->curtime > m_flNextActionTime )
			{
				if ( !m_bBlueSilverValueRevealed && !m_bRedSilverValueRevealed )
				{
					m_pBlueMedalsPanel->SetDialogVariable( "blueteammedals_silver", m_nMedalsToAward_Silver_Blue );
					m_bBlueSilverValueRevealed = true;
					Panel *pChild = m_pBlueMedalsPanel->FindChildByName( "BlueSilverMedalValue" );
					if ( pChild )
					{
						int nXPos, nYPos, nWide, nTall;
						pChild->GetBounds( nXPos, nYPos, nWide, nTall );
						FireMedalEffects( pChild, nXPos, nYPos, nWide, nTall, ( m_nMedalsToAward_Silver_Blue > 0 ) ? StatMedal_Silver : StatMedal_None );
					}

					m_pRedMedalsPanel->SetDialogVariable( "redteammedals_silver", m_nMedalsToAward_Silver_Red );
					m_bRedSilverValueRevealed = true;
					pChild = m_pRedMedalsPanel->FindChildByName( "RedSilverMedalValue" );
					if ( pChild )
					{
						int nXPos, nYPos, nWide, nTall;
						pChild->GetBounds( nXPos, nYPos, nWide, nTall );
						FireMedalEffects( pChild, nXPos, nYPos, nWide, nTall, ( m_nMedalsToAward_Silver_Red > 0 ) ? StatMedal_Silver : StatMedal_None );
					}

					m_flNextActionTime = gpGlobals->curtime + MS_STATE_TIME_BETWEEN_MEDALS_CATEGORIES;
				}
				else
				{
					if ( ( nMedalsToAward_Silver_Total > 0 ) && ( m_nMedalsRevealed < nMedalsToAward_Silver_Total ) )
					{
						Update();
						m_nMedalsRevealed++;
						m_flNextActionTime = gpGlobals->curtime + MS_STATE_TIME_BETWEEN_MEDALS;
					}
					else
					{
						m_iCurrentState = MS_STATE_GOLD_MEDALS;
						m_nMedalsRevealed = 0;
						m_flNextActionTime = MS_STATE_TIME_BETWEEN_MEDALS_CATEGORIES;
					}
				}
			}
			break;
		}
	case MS_STATE_GOLD_MEDALS:
		{
			if ( gpGlobals->curtime > m_flNextActionTime )
			{
				if ( !m_bBlueGoldValueRevealed && !m_bRedGoldValueRevealed )
				{
					m_pBlueMedalsPanel->SetDialogVariable( "blueteammedals_gold", m_nMedalsToAward_Gold_Blue );
					m_bBlueGoldValueRevealed = true;
					Panel *pChild = m_pBlueMedalsPanel->FindChildByName( "BlueGoldMedalValue" );
					if ( pChild )
					{
						int nXPos, nYPos, nWide, nTall;
						pChild->GetBounds( nXPos, nYPos, nWide, nTall );
						FireMedalEffects( pChild, nXPos, nYPos, nWide, nTall, ( m_nMedalsToAward_Gold_Blue > 0 ) ? StatMedal_Gold : StatMedal_None );
					}

					m_pRedMedalsPanel->SetDialogVariable( "redteammedals_gold", m_nMedalsToAward_Gold_Red );
					m_bRedGoldValueRevealed = true;
					pChild = m_pRedMedalsPanel->FindChildByName( "RedGoldMedalValue" );
					if ( pChild )
					{
						int nXPos, nYPos, nWide, nTall;
						pChild->GetBounds( nXPos, nYPos, nWide, nTall );
						FireMedalEffects( pChild, nXPos, nYPos, nWide, nTall, ( m_nMedalsToAward_Gold_Red > 0 ) ? StatMedal_Gold : StatMedal_None );
					}

					m_flNextActionTime = gpGlobals->curtime + MS_STATE_TIME_BETWEEN_MEDALS_CATEGORIES;
				}
				else
				{
					if ( ( nMedalsToAward_Gold_Total > 0 ) && ( m_nMedalsRevealed < nMedalsToAward_Gold_Total ) )
					{
						Update();
						m_nMedalsRevealed++;
						m_flNextActionTime = gpGlobals->curtime + MS_STATE_TIME_BETWEEN_MEDALS;
					}
					else
					{
						m_iCurrentState = MS_STATE_FINAL;
						m_nMedalsRevealed = 0;
						m_flNextActionTime = -1;

						if ( pLocalPlayer )
						{
							const char *pszSoundScriptEntry = "Announcer.CompSummaryScreenOutlierNo"; 
							if ( nMedalsToAward_Bronze_Total || nMedalsToAward_Silver_Total || nMedalsToAward_Gold_Total )
							{
								pszSoundScriptEntry = "Announcer.CompSummaryScreenOutlierYes";
							}

							const char *pszSoundName = UTIL_GetRandomSoundFromEntry( pszSoundScriptEntry );
							m_flMedalSoundTime = gpGlobals->curtime + enginesound->GetSoundDuration( pszSoundName ) + 0.5f;
							pLocalPlayer->EmitSound( pszSoundName );

							IGameEvent *event = gameeventmanager->CreateEvent( "ds_screenshot" );
							if ( event )
							{
								event->SetFloat( "delay", 0.5f );
								gameeventmanager->FireEventClientSide( event );
							}
						}
					}
				}
			}
			break;
		}
	default:
	case MS_STATE_FINAL:
		{
			bool bMedalSoundTimeComplete = ( m_flMedalSoundTime > 0 ) && ( m_flMedalSoundTime < gpGlobals->curtime );

			if ( !m_bXPShown /*&& ( !bShowMedals || bMedalSoundTimeComplete ) */)
			{
				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "CompetitiveGame_ShowPvPRankPanel", false );	
				m_bXPShown = true;
			}

			if ( bShowPerformanceMedals )
			{
				if ( bMedalSoundTimeComplete )
				{
					m_flMedalSoundTime = -1.f;
					int iLocalPlayerIndex = GetLocalPlayerIndex();

					if ( ( m_SkillRatings[iLocalPlayerIndex].nScoreRank != StatMedal_None ) ||
						 ( m_SkillRatings[iLocalPlayerIndex].nKillsRank != StatMedal_None ) ||
						 ( m_SkillRatings[iLocalPlayerIndex].nDamageRank != StatMedal_None ) ||
						 ( m_SkillRatings[iLocalPlayerIndex].nHealingRank != StatMedal_None ) ||
						 ( m_SkillRatings[iLocalPlayerIndex].nSupportRank != StatMedal_None ) )
					{
						if ( pLocalPlayer )
						{
							int iClass = RandomInt( TF_CLASS_SCOUT, TF_CLASS_ENGINEER );
							if ( pLocalPlayer->GetPlayerClass() && ( pLocalPlayer->GetPlayerClass()->GetClassIndex() > TF_CLASS_UNDEFINED ) )
							{
								iClass = pLocalPlayer->GetPlayerClass()->GetClassIndex();
							}

							pLocalPlayer->EmitSound( VarArgs( "%s.CompSummaryScreenOutlier", g_aPlayerClassNames_NonLocalized[iClass] ) );
						}
					}
				}
			}

			break;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFMatchSummary::LevelInit( void )
{
	SetVisible( false );
}

void CTFMatchSummary::LevelShutdown( void )
{
	SetVisible( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFMatchSummary::ShowPerformanceMedals( void )
{
	bool bDistributePerformanceMedals = false;

	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		bDistributePerformanceMedals = pMatchDesc->m_params.m_bDistributePerformanceMedals;
	}

	return ( bDistributePerformanceMedals && !m_bPlayerAbandoned );
}