tf2/tf2_src/game/client/tf/tf_hud_statpanel.cpp

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

#include "cbase.h"
#ifdef WIN32
#include "winerror.h"
#endif
#include "tf_hud_statpanel.h"
#include "tf_hud_winpanel.h"
#include <vgui/IVGui.h>
#include "vgui_controls/AnimationController.h"
#include "iclientmode.h"
#include "c_tf_playerresource.h"
#include <vgui_controls/Label.h>
#include <vgui/ILocalize.h>
#include <vgui/ISurface.h>
#include "tf/c_tf_player.h"
#include "tf/c_tf_team.h"
#include "tf/tf_steamstats.h"
#include "filesystem.h"
#include "dmxloader/dmxloader.h"
#include "fmtstr.h"
#include "tf_statsummary.h"
#include "usermessages.h"
#include "hud_macros.h"
#include "ixboxsystem.h"
#include "achievementmgr.h"
#include "tf_hud_freezepanel.h"
#include "tf_gamerules.h"
#include "tf_mapinfo.h"
#include <vgui_controls/MessageBox.h>

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

DECLARE_HUDELEMENT_DEPTH( CTFStatPanel, 1 );
DECLARE_HUD_MESSAGE( CTFStatPanel, PlayerStatsUpdate );
DECLARE_HUD_MESSAGE( CTFStatPanel, MapStatsUpdate );

BEGIN_DMXELEMENT_UNPACK( RoundStats_t )
	DMXELEMENT_UNPACK_FIELD( "iNumShotsHit", "0", int, m_iStat[TFSTAT_SHOTS_HIT] )
	DMXELEMENT_UNPACK_FIELD( "iNumShotsFired", "0", int, m_iStat[TFSTAT_SHOTS_FIRED] )
	DMXELEMENT_UNPACK_FIELD( "iNumberOfKills", "0", int, m_iStat[TFSTAT_KILLS] )
	DMXELEMENT_UNPACK_FIELD( "iNumDeaths", "0", int, m_iStat[TFSTAT_DEATHS] )
	DMXELEMENT_UNPACK_FIELD( "iDamageDealt", "0", int, m_iStat[TFSTAT_DAMAGE] )
	DMXELEMENT_UNPACK_FIELD( "iPlayTime", "0", int, m_iStat[TFSTAT_PLAYTIME] )
	DMXELEMENT_UNPACK_FIELD( "iPointCaptures", "0", int, m_iStat[TFSTAT_CAPTURES] )
	DMXELEMENT_UNPACK_FIELD( "iPointDefenses", "0", int, m_iStat[TFSTAT_DEFENSES] )
	DMXELEMENT_UNPACK_FIELD( "iDominations", "0", int, m_iStat[TFSTAT_DOMINATIONS] )
	DMXELEMENT_UNPACK_FIELD( "iRevenge", "0", int, m_iStat[TFSTAT_REVENGE] )
	DMXELEMENT_UNPACK_FIELD( "iPointsScored", "0", int, m_iStat[TFSTAT_POINTSSCORED] )
	DMXELEMENT_UNPACK_FIELD( "iBuildingsDestroyed", "0", int, m_iStat[TFSTAT_BUILDINGSDESTROYED] )
	DMXELEMENT_UNPACK_FIELD( "iHeadshots", "0", int, m_iStat[TFSTAT_HEADSHOTS] )
	DMXELEMENT_UNPACK_FIELD( "iHealthPointsHealed", "0", int, m_iStat[TFSTAT_HEALING] )
	DMXELEMENT_UNPACK_FIELD( "iNumInvulnerable", "0", int, m_iStat[TFSTAT_INVULNS] )
	DMXELEMENT_UNPACK_FIELD( "iKillAssists", "0", int, m_iStat[TFSTAT_KILLASSISTS] )
	DMXELEMENT_UNPACK_FIELD( "iBackstabs", "0", int, m_iStat[TFSTAT_BACKSTABS] )
	DMXELEMENT_UNPACK_FIELD( "iHealthPointsLeached", "0", int, m_iStat[TFSTAT_HEALTHLEACHED] )
	DMXELEMENT_UNPACK_FIELD( "iBuildingsBuilt", "0", int, m_iStat[TFSTAT_BUILDINGSBUILT] )
	DMXELEMENT_UNPACK_FIELD( "iSentryKills", "0", int, m_iStat[TFSTAT_MAXSENTRYKILLS] )
	DMXELEMENT_UNPACK_FIELD( "iNumTeleports", "0", int, m_iStat[TFSTAT_TELEPORTS] )
	DMXELEMENT_UNPACK_FIELD( "iFireDamage", "0", int, m_iStat[TFSTAT_FIREDAMAGE] )
	DMXELEMENT_UNPACK_FIELD( "iBonusPoints", "0", int, m_iStat[TFSTAT_BONUS_POINTS] )
	DMXELEMENT_UNPACK_FIELD( "iBlastDamage", "0", int, m_iStat[TFSTAT_BLASTDAMAGE] )
END_DMXELEMENT_UNPACK( RoundStats_t, s_RoundStatsUnpack )

BEGIN_DMXELEMENT_UNPACK( RoundMapStats_t )
	DMXELEMENT_UNPACK_FIELD( "iPlayTime", "0", int, m_iStat[TFMAPSTAT_PLAYTIME] )
END_DMXELEMENT_UNPACK( RoundMapStats_t, s_RoundMapStatsUnpack )

BEGIN_DMXELEMENT_UNPACK( ClassStats_t )
	DMXELEMENT_UNPACK_FIELD( "iPlayerClass", "0", int, iPlayerClass )
	DMXELEMENT_UNPACK_FIELD( "iNumberOfRounds", "0", int, iNumberOfRounds )
	// RoundStats_t		accumulated;
	// RoundStats_t		max;
	// RoundStats_t		currentRound;
	// RoundStats_t		accumulatedMVM;
	// RoundStats_t		maxMVM;
END_DMXELEMENT_UNPACK( ClassStats_t, s_ClassStatsUnpack )

BEGIN_DMXELEMENT_UNPACK( MapStats_t )
	DMXELEMENT_UNPACK_FIELD( "iMapID", "0", map_identifier_t, iMapID )
	DMXELEMENT_UNPACK_FIELD( "iNumberOfRounds", "0", int, iNumberOfRounds )
	// RoundStats_t		accumulated;
	// RoundStats_t		currentRound;
END_DMXELEMENT_UNPACK( MapStats_t, s_MapStatsUnpack )

// priority order of stats to display record for; earlier position in list is highest
TFStatType_t g_statPriority[] = { TFSTAT_HEADSHOTS, TFSTAT_BACKSTABS, TFSTAT_MAXSENTRYKILLS, TFSTAT_HEALING, TFSTAT_KILLS, TFSTAT_KILLASSISTS,  
	TFSTAT_DAMAGE, TFSTAT_DOMINATIONS, TFSTAT_INVULNS, TFSTAT_BUILDINGSDESTROYED, TFSTAT_CAPTURES, TFSTAT_DEFENSES, TFSTAT_REVENGE, TFSTAT_TELEPORTS, TFSTAT_BUILDINGSBUILT, 
	TFSTAT_HEALTHLEACHED, TFSTAT_POINTSSCORED, TFSTAT_PLAYTIME, TFSTAT_BONUS_POINTS };
// stat types that we don't display records for, kept in this list just so we can assert all stats appear in one list or the other
TFStatType_t g_statUnused[] = { TFSTAT_DEATHS, TFSTAT_UNDEFINED, TFSTAT_SHOTS_FIRED, TFSTAT_SHOTS_HIT, TFSTAT_FIREDAMAGE, TFSTAT_BLASTDAMAGE,
	TFSTAT_DAMAGETAKEN, TFSTAT_HEALTHKITS, TFSTAT_AMMOKITS, TFSTAT_CLASSCHANGES, TFSTAT_CRITS, TFSTAT_SUICIDES, TFSTAT_CURRENCY_COLLECTED, TFSTAT_DAMAGE_ASSIST, TFSTAT_HEALING_ASSIST, 
	TFSTAT_DAMAGE_BOSS, TFSTAT_DAMAGE_BLOCKED, TFSTAT_DAMAGE_RANGED, TFSTAT_DAMAGE_RANGED_CRIT_RANDOM, TFSTAT_DAMAGE_RANGED_CRIT_BOOSTED, TFSTAT_REVIVED, TFSTAT_THROWABLEHIT, TFSTAT_THROWABLEKILL, TFSTAT_KILLS_RUNECARRIER, TFSTAT_FLAGRETURNS,
	TFSTAT_KILLSTREAK_MAX };

// priority order of stats to display record for; earlier position in list is highest
TFMapStatType_t g_mapStatPriority[] = { TFMAPSTAT_PLAYTIME };
// stat types that we don't display records for, kept in this list just so we can assert all stats appear in one list or the other
TFMapStatType_t g_mapStatUnused[] = { TFMAPSTAT_UNDEFINED };

// localization keys for stat panel text, must be in same order as TFStatType_t
const char *g_szLocalizedRecordText[] =
{
	"",
	"[shots hit]",
	"[shots fired]",
	"#StatPanel_Kills",	
	"[deaths]",
	"#StatPanel_DamageDealt",
	"#StatPanel_Captures",
	"#StatPanel_Defenses",
	"#StatPanel_Dominations",
	"#StatPanel_Revenge",
	"#StatPanel_PointsScored",
	"#StatPanel_BuildingsDestroyed",
	"#StatPanel_Headshots",
	"#StatPanel_PlayTime",
	"#StatPanel_Healing",
	"#StatPanel_Invulnerable",
	"#StatPanel_KillAssists",
	"#StatPanel_Backstabs",
	"#StatPanel_HealthLeached",
	"#StatPanel_BuildingsBuilt",
	"#StatPanel_SentryKills",		
	"#StatPanel_Teleports",
	"#StatPanel_BonusPoints"
};

const char *g_szLocalizedMVMRecordText[] =
{
	"",
	"[shots hit]",
	"[shots fired]",
	"#StatPanel_MVM_Kills",	
	"[deaths]",
	"#StatPanel_MVM_DamageDealt",
	"#StatPanel_MVM_Captures",
	"#StatPanel_MVM_Defenses",
	"#StatPanel_MVM_Dominations",
	"#StatPanel_MVM_Revenge",
	"#StatPanel_MVM_PointsScored",
	"#StatPanel_MVM_BuildingsDestroyed",
	"#StatPanel_MVM_Headshots",
	"#StatPanel_MVM_PlayTime",
	"#StatPanel_MVM_Healing",
	"#StatPanel_MVM_Invulnerable",
	"#StatPanel_MVM_KillAssists",
	"#StatPanel_MVM_Backstabs",
	"#StatPanel_MVM_HealthLeached",
	"#StatPanel_MVM_BuildingsBuilt",
	"#StatPanel_MVM_SentryKills",		
	"#StatPanel_MVM_Teleports",
	"#StatPanel_MVM_BonusPoints"
};


static CTFStatPanel *statPanel = NULL;
extern CAchievementMgr g_AchievementMgrTF;

//-----------------------------------------------------------------------------
// Purpose: Returns the static stats panel
//-----------------------------------------------------------------------------
CTFStatPanel *GetStatPanel()
{
	return statPanel;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTFStatPanel::CTFStatPanel( const char *pElementName )
: EditablePanel( NULL, "StatPanel" ), CHudElement( pElementName )
{
	// Assert that all defined stats are in our prioritized list or explicitly unused
	Assert( ARRAYSIZE( g_statPriority ) + ARRAYSIZE( g_statUnused ) == TFSTAT_TOTAL );
	Assert( ARRAYSIZE( g_mapStatPriority ) + ARRAYSIZE( g_mapStatUnused ) == TFMAPSTAT_TOTAL );

	ResetDisplayedStat();
	m_bStatsChanged = false;
	m_bLocalFileTrusted = false;
	m_flTimeLastSpawn = 0;
	vgui::Panel *pParent = g_pClientMode->GetViewport();
	SetParent( pParent );
	m_bShouldBeVisible = false;
	SetScheme( "ClientScheme" );
	statPanel = this;

	m_pClassImage = new CTFClassImage( this, "StatPanelClassImage" );

	// Read stats from disk.  (Definitive stat store for X360; for PC, whatever we get from Steam is authoritative.)
	ReadStats();

	RegisterForRenderGroup( "mid" );
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CTFStatPanel::~CTFStatPanel()
{
	if ( statPanel == this )
		statPanel = NULL;
}

//-----------------------------------------------------------------------------
// Purpose: called when level is shutting down
//-----------------------------------------------------------------------------
void CTFStatPanel::LevelShutdown()
{
	// write out stats if they've changed
	WriteStats();
	UpdateStatSummaryPanel();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::Reset()
{
	if ( gpGlobals->curtime > m_flTimeHide )
	{
		Hide();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Resets which stat is being displayed
//-----------------------------------------------------------------------------
void CTFStatPanel::ResetDisplayedStat()
{
	m_iCurStatValue = 0;
	m_iCurStatTeam = TEAM_UNASSIGNED;
	m_statType = TFSTAT_UNDEFINED;
	m_recordBreakType = RECORDBREAK_NONE;
	m_iCurStatClass = TF_CLASS_UNDEFINED;
	m_bDisplayAfterSpawn = false;
	m_flTimeHide = 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::Init()
{
	// listen for events
	HOOK_HUD_MESSAGE( CTFStatPanel, PlayerStatsUpdate );
	HOOK_HUD_MESSAGE( CTFStatPanel, MapStatsUpdate );
	ListenForGameEvent( "player_spawn" );

	Hide();

	CHudElement::Init();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::UpdateStats( int iClass, const RoundStats_t &stats, bool bAlive )
{
	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pPlayer )
		return;

	// don't count stats if cheats on, commentary mode, etc
	if ( !g_AchievementMgrTF.CheckAchievementsEnabled() )
		return;

	ClassStats_t &classStats = GetClassStats( iClass );

	bool bMVM = TFGameRules() && TFGameRules()->IsMannVsMachineMode();

	if ( bMVM )
	{
		classStats.AccumulateMVMRound( stats );
	}
	else
	{
		classStats.AccumulateRound( stats );
	}

	// sentry kills is a max value rather than a count, meaningless to accumulate
	classStats.accumulated.m_iStat[TFSTAT_MAXSENTRYKILLS] = 0;	
	classStats.accumulatedMVM.m_iStat[TFSTAT_MAXSENTRYKILLS] = 0;

	ResetDisplayedStat();
	m_iCurStatClass = iClass;

	// run through all stats we keep records for, update the max value, and if a record is set,
	// remember the highest priority record
	for ( int i= ARRAYSIZE( g_statPriority )-1; i >= 0; i-- )
	{
		TFStatType_t statType = g_statPriority[i];
		if ( statType == TFSTAT_BONUS_POINTS )
			continue;

		int iCur = stats.m_iStat[statType];
		int iMax = ( bMVM ? classStats.maxMVM.m_iStat[statType] : classStats.max.m_iStat[statType] );
		if ( iCur > iMax )
		{
			// Record was set, remember what stat set a record.
			if ( bMVM )
			{
				classStats.maxMVM.m_iStat[statType] = iCur;
			}
			else
			{
				classStats.max.m_iStat[statType] = iCur;
			}

			m_iCurStatValue = iCur;
			m_statType = statType;
			m_recordBreakType = RECORDBREAK_BEST;
		}
		else if ( ( iCur > 0 ) && ( m_recordBreakType <= RECORDBREAK_TIE ) && ( iCur == iMax ) )
		{
			// if we haven't broken a record and we tied this one, display it
			m_iCurStatValue = iCur;
			m_statType = statType;
			m_recordBreakType = RECORDBREAK_TIE;
		}
		else if ( ( iCur > 0 ) && ( m_recordBreakType <= RECORDBREAK_CLOSE ) && ( iCur >= (int) ( (float) iMax * 0.8f ) ) )
		{
			// if we haven't broken a record or tied a record but we came close to this one, display it
			m_iCurStatValue = iCur;
			m_statType = statType;
			m_recordBreakType = RECORDBREAK_CLOSE;
		}
	}

	m_bStatsChanged = true;

	if ( m_statType > TFSTAT_UNDEFINED )
	{
		m_iCurStatTeam = pPlayer->GetTeamNumber();
		if ( !bAlive || ( gpGlobals->curtime - m_flTimeLastSpawn < 3.0 ) )
		{
			// show the panel now if dead or very recently spawned
			vgui::ivgui()->AddTickSignal( GetVPanel(), 1000 );
			extern ConVar hud_freezecamhide;
			if ( !hud_freezecamhide.GetBool() && !IsTakingAFreezecamScreenshot() )
			{
				ShowStatPanel( m_iCurStatClass, m_iCurStatTeam, m_iCurStatValue, m_statType, m_recordBreakType, bAlive );
				m_flTimeHide = gpGlobals->curtime + 20.0f;
			}
		}
		else
		{
			// otherwise wait until next spawn to show panel
			m_bDisplayAfterSpawn = true;
		}
	}

	IGameEvent * event = gameeventmanager->CreateEvent( "player_stats_updated" );
	if ( event )
	{
		event->SetBool( "forceupload", false );
		gameeventmanager->FireEventClientSide( event );
	}

	UpdateStatSummaryPanel();
}

void CTFStatPanel::UpdateMapStats( map_identifier_t iMapID, const RoundMapStats_t &stats )
{
	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pPlayer )
		return;

	// It's ok to count map stats while cheating and such
	//if ( !g_AchievementMgrTF.CheckAchievementsEnabled() )
	//	return;

	MapStats_t &mapStats = GetMapStats( iMapID );

	mapStats.AccumulateRound( stats );

	ResetDisplayedStat();
	m_iCurStatClass = iMapID;

	m_bStatsChanged = true;

	IGameEvent * event = gameeventmanager->CreateEvent( "player_stats_updated" );
	if ( event )
	{
		event->SetBool( "forceupload", false );
		gameeventmanager->FireEventClientSide( event );
	}

	UpdateStatSummaryPanel();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::TestStatPanel( TFStatType_t statType, RecordBreakType_t recordType )
{
	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pPlayer )
	{
		Msg( "Please load a map first.\n" );
		return;
	}

	bool bMVM = TFGameRules() && TFGameRules()->IsMannVsMachineMode();

	m_iCurStatClass = pPlayer->GetPlayerClass()->GetClassIndex();
	ClassStats_t &classStats = GetClassStats( m_iCurStatClass );
	m_iCurStatValue = bMVM ? classStats.maxMVM.m_iStat[statType] : classStats.max.m_iStat[statType];
	m_iCurStatTeam = pPlayer->GetTeamNumber();

	ShowStatPanel( m_iCurStatClass, m_iCurStatTeam, m_iCurStatValue, statType, recordType, false );
}

//-----------------------------------------------------------------------------
// Purpose: Writes stat file.  Used as primary storage for X360.  For PC,
//			Steam is authoritative but we write stat file for debugging (although
//			we never read it).
//-----------------------------------------------------------------------------
void CTFStatPanel::WriteStats( void )
{
	if ( !m_bStatsChanged )
		return;

	MEM_ALLOC_CREDIT();

	DECLARE_DMX_CONTEXT();
	CDmxElement *pPlayerStats = CreateDmxElement( "PlayerStats" );
	CDmxElementModifyScope modify( pPlayerStats );

	// get Steam ID.  If not logged into Steam, use 0
	int iSteamID = 0;
	if ( steamapicontext->SteamUser() )
	{
		CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
		iSteamID = steamID.GetAccountID();
	}	
	// Calc CRC of all data to make the local data file somewhat tamper-resistant
	int iCRC = CalcCRC( iSteamID );

	pPlayerStats->SetValue( "iVersion", static_cast<int>( PLAYERSTATS_FILE_VERSION ) );
	pPlayerStats->SetValue( "SteamID", iSteamID );	
	pPlayerStats->SetValue( "iTimestamp", iCRC );	// store the CRC with a non-obvious name

	CDmxAttribute *pClassStatsList = pPlayerStats->AddAttribute( "aClassStats" );
	CUtlVector< CDmxElement* >& classStats = pClassStatsList->GetArrayForEdit<CDmxElement*>();

	modify.Release();

	for( int i = 0; i < m_aClassStats.Count(); i++ )
	{
		const ClassStats_t &stat = m_aClassStats[ i ];

		// strip out any garbage class data
		if ( ( stat.iPlayerClass > (TF_LAST_NORMAL_CLASS-1) ) || ( stat.iPlayerClass < TF_FIRST_NORMAL_CLASS ) )
			continue;

		CDmxElement *pClass = CreateDmxElement( "ClassStats_t" );
		classStats.AddToTail( pClass );

		CDmxElementModifyScope modifyClass( pClass );

		pClass->SetValue( "comment: classname", g_aPlayerClassNames_NonLocalized[ stat.iPlayerClass ] );
		pClass->AddAttributesFromStructure( &stat, s_ClassStatsUnpack );

		CDmxElement *pAccumulated = CreateDmxElement( "RoundStats_t" );
		pAccumulated->AddAttributesFromStructure( &stat.accumulated, s_RoundStatsUnpack );
		pClass->SetValue( "accumulated", pAccumulated );

		CDmxElement *pMax = CreateDmxElement( "RoundStats_t" );
		pMax->AddAttributesFromStructure( &stat.max, s_RoundStatsUnpack );
		pClass->SetValue( "max", pMax );

		CDmxElement *pAccumulatedMVM = CreateDmxElement( "RoundStats_t" );
		pAccumulatedMVM->AddAttributesFromStructure( &stat.accumulatedMVM, s_RoundStatsUnpack );
		pClass->SetValue( "accumulatedmvm", pAccumulatedMVM );

		CDmxElement *pMaxMVM = CreateDmxElement( "RoundStats_t" );
		pMaxMVM->AddAttributesFromStructure( &stat.maxMVM, s_RoundStatsUnpack );
		pClass->SetValue( "maxmvm", pMaxMVM );
	}

	CDmxAttribute *pMapStatsList = pPlayerStats->AddAttribute( "aMapStats" );
	CUtlVector< CDmxElement* >& mapStats = pMapStatsList->GetArrayForEdit<CDmxElement*>();

	for( int i = 0; i < m_aMapStats.Count(); i++ )
	{
		const MapStats_t &stat = m_aMapStats[ i ];

		// strip out any garbage map data
		if ( !IsValidMapID( stat.iMapID ) )
			continue;

		CDmxElement *pMap = CreateDmxElement( "MapStats_t" );
		mapStats.AddToTail( pMap );

		CDmxElementModifyScope modifyClass( pMap );

		pMap->SetValue( "comment: mapname", GetMapNameFromID( stat.iMapID ) );
		pMap->AddAttributesFromStructure( &stat, s_MapStatsUnpack );

		CDmxElement *pAccumulated = CreateDmxElement( "RoundMapStats_t" );
		pAccumulated->AddAttributesFromStructure( &stat.accumulated, s_RoundMapStatsUnpack );
		pMap->SetValue( "accumulated", pAccumulated );
	}

	if ( IsX360() )
	{
#ifdef _X360
		if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID || XBX_GetStorageDeviceId() == XBX_STORAGE_DECLINED )
			return;
#endif
	}

	char szFilename[_MAX_PATH];

	if ( IsX360() )
		Q_snprintf( szFilename, sizeof( szFilename ), "cfg:/tf2_playerstats.dmx" );
	else
		Q_snprintf( szFilename, sizeof( szFilename ), "tf2_playerstats.dmx" );

	{
		MEM_ALLOC_CREDIT();
		CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
		if ( SerializeDMX( buf, pPlayerStats, szFilename ) )
		{
			filesystem->WriteFile( szFilename, "MOD", buf );
		}
	}

	CleanupDMX( pPlayerStats );

	if ( IsX360() )
	{
		xboxsystem->FinishContainerWrites();
	}

	m_bStatsChanged = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFStatPanel::ReadStats( void )
{
	CDmxElement *pPlayerStats;

	DECLARE_DMX_CONTEXT();

	if ( IsX360() )
	{
#ifdef _X360
		if ( XBX_GetStorageDeviceId() == XBX_INVALID_STORAGE_ID || XBX_GetStorageDeviceId() == XBX_STORAGE_DECLINED )
			return false;
#endif
	}

	char	szFilename[_MAX_PATH];

	if ( IsX360() )
	{
		Q_snprintf( szFilename, sizeof( szFilename ), "cfg:/tf2_playerstats.dmx" );
	}
	else
	{
		Q_snprintf( szFilename, sizeof( szFilename ), "tf2_playerstats.dmx" );
	}

	MEM_ALLOC_CREDIT();

	bool bOk = UnserializeDMX( szFilename, "MOD", true, &pPlayerStats );

	if ( !bOk )
		return false;

	int iVersion = pPlayerStats->GetValue< int >( "iVersion" );
	if ( iVersion > PLAYERSTATS_FILE_VERSION )
	{
		// file is beyond our comprehension
		return false;
	}

	int iSteamID = pPlayerStats->GetValue<int>( "SteamID" );
	int iCRCFile = pPlayerStats->GetValue<int>( "iTimestamp" );	

	const CUtlVector< CDmxElement* > &aClassStatsList = pPlayerStats->GetArray< CDmxElement * >( "aClassStats" );
	int iCount = aClassStatsList.Count();
	m_aClassStats.SetCount( iCount );
	for( int i = 0; i < m_aClassStats.Count(); i++ )
	{
		CDmxElement *pClass = aClassStatsList[ i ];
		ClassStats_t &stat = m_aClassStats[ i ];

		pClass->UnpackIntoStructure( &stat, sizeof( stat ), s_ClassStatsUnpack );

		CDmxElement *pAccumulated = pClass->GetValue< CDmxElement * >( "accumulated" );
		if ( pAccumulated )
		{
			pAccumulated->UnpackIntoStructure( &stat.accumulated, sizeof( stat.accumulated ), s_RoundStatsUnpack );
		}

		CDmxElement *pMax = pClass->GetValue< CDmxElement * >( "max" );
		if ( pMax )
		{
			pMax->UnpackIntoStructure( &stat.max, sizeof( stat.max ), s_RoundStatsUnpack );
		}

		CDmxElement *pAccumulatedMVM = pClass->GetValue< CDmxElement * >( "accumulatedMVM" );
		if ( pAccumulatedMVM )
		{
			pAccumulatedMVM->UnpackIntoStructure( &stat.accumulatedMVM, sizeof( stat.accumulatedMVM ), s_RoundStatsUnpack );
		}

		CDmxElement *pMaxMVM = pClass->GetValue< CDmxElement * >( "maxMVM" );
		if ( pMaxMVM )
		{
			pMaxMVM->UnpackIntoStructure( &stat.maxMVM, sizeof( stat.maxMVM ), s_RoundStatsUnpack );
		}
	}

	const CUtlVector< CDmxElement* > &aMapStatsList = pPlayerStats->GetArray< CDmxElement * >( "aMapStats" );
	iCount = aMapStatsList.Count();
	m_aMapStats.SetCount( iCount );
	for( int i = 0; i < aMapStatsList.Count(); i++ )
	{
		CDmxElement *pMap = aMapStatsList[ i ];
		MapStats_t &stat = m_aMapStats[ i ];

		pMap->UnpackIntoStructure( &stat, sizeof( stat ), s_MapStatsUnpack );

		CDmxElement *pAccumulated = pMap->GetValue< CDmxElement * >( "accumulated" );
		if ( pAccumulated )
		{
			pAccumulated->UnpackIntoStructure( &stat.accumulated, sizeof( stat.accumulated ), s_RoundMapStatsUnpack );
		}
	}

	CleanupDMX( pPlayerStats );

	UpdateStatSummaryPanel();

	// check file CRC and steam ID to see if we think this file has not been tampered with
	int iCRC = CalcCRC( iSteamID );
	// does file CRC match CRC generated from file data, and is there a Steam ID in the file
	if ( ( iCRC == iCRCFile ) && ( iSteamID > 0 ) && steamapicontext->SteamUser() ) 
	{		
		// does the file Steam ID match current Steam ID (so you can't hand around files)
		CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
		if ( steamID.GetAccountID() == (uint32) iSteamID )
		{
			m_bLocalFileTrusted = true;
		}
	}

	m_bStatsChanged = false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Calcs CRC of all stat data
//-----------------------------------------------------------------------------
int CTFStatPanel::CalcCRC( int iSteamID )
{
	CRC32_t crc;
	CRC32_Init( &crc );

	// make a CRC of stat data
	CRC32_ProcessBuffer( &crc, &iSteamID, sizeof( iSteamID ) );

	for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass <= TF_LAST_NORMAL_CLASS; iClass++ )
	{
		// add each class' data to the CRC
		ClassStats_t &classStats = GetClassStats( iClass );
		CRC32_ProcessBuffer( &crc, &classStats, sizeof( classStats ) );
		// since the class data structure is highly guessable from the file, add one other thing to make the CRC hard to hack w/o code disassembly
		int iObfuscate = iClass * iClass;
		CRC32_ProcessBuffer( &crc, &iObfuscate, sizeof( iObfuscate ) );	
	}

	CRC32_Final( &crc );

	return (int) ( crc & 0x7FFFFFFF );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::ShowStatPanel( int iClass, int iTeam, int iCurStatValue, TFStatType_t statType, RecordBreakType_t recordBreakType,
								 bool bAlive )
{
	bool bMVM = TFGameRules() && TFGameRules()->IsMannVsMachineMode();

	// If this is MvM mode and we're looking at the round end, dont show the stats
	// panel because the PVEWinPanel will be up
	if( bMVM && TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
	{
		return;
	}

	ClassStats_t &classStats = GetClassStats( iClass );
	vgui::Label *pLabel = dynamic_cast<Label *>( FindChildByName( "summaryLabel" ) );
	if ( !pLabel )
		return;

	const char *pRecordTextSuffix[RECORDBREAK_MAX] = { "", "close", "tie", "best" };

	const char *pLocalizedTitle = bAlive ? "#StatPanel_Title_Alive" : "#StatPanel_Title_Dead";
	SetDialogVariable( "title", g_pVGuiLocalize->Find( pLocalizedTitle ) );
	SetDialogVariable( "stattextlarge", "" );
	SetDialogVariable( "stattextsmall", "" );
	if ( recordBreakType == RECORDBREAK_CLOSE )
	{		
		// if we are displaying that the player got close to a record, show current & best values
		char szCur[32],szBest[32];
		wchar_t wzCur[32],wzBest[32];
		GetStatValueAsString( iCurStatValue, statType, szCur, ARRAYSIZE( szCur ) );
		GetStatValueAsString( bMVM ? classStats.maxMVM.m_iStat[statType] : classStats.max.m_iStat[statType], statType, szBest, ARRAYSIZE( szBest ) );
		g_pVGuiLocalize->ConvertANSIToUnicode( szCur, wzCur, sizeof( wzCur ) );
		g_pVGuiLocalize->ConvertANSIToUnicode( szBest, wzBest, sizeof( wzBest ) );
		wchar_t *wzFormat = g_pVGuiLocalize->Find( "#StatPanel_Format_Close" );
		wchar_t wzText[256];
		g_pVGuiLocalize->ConstructString_safe( wzText, wzFormat, 2, wzCur, wzBest );
		SetDialogVariable( "stattextsmall", wzText );
	}
	else
	{
		// player broke or tied a record, just show current value
		char szValue[32];
		GetStatValueAsString( iCurStatValue, statType, szValue, ARRAYSIZE( szValue ) );
		SetDialogVariable( "stattextlarge", szValue );
	}

	SetDialogVariable( "statdesc", g_pVGuiLocalize->Find( CFmtStr( "%s_%s", bMVM ? g_szLocalizedMVMRecordText[statType] : g_szLocalizedRecordText[statType], 
		pRecordTextSuffix[recordBreakType] ) ) );

	// Set the class name. We can't use a dialog variable because it's a string that's already
	// been set using a dialog variable, and apparently we don't support nested dialog variables.
	wchar_t szOriginalSummary[ 256 ];
	wchar_t szSummary[ 256 ];

	// This is the field that "statdesc" completed for us
	pLabel->GetText( szOriginalSummary, sizeof( szOriginalSummary ) );
	const wchar_t *pszPlayerClass = L"undefined";

	if ( ( iClass >= TF_FIRST_NORMAL_CLASS ) && ( iClass <= TF_LAST_NORMAL_CLASS ) )
	{
		pszPlayerClass = g_pVGuiLocalize->Find( g_aPlayerClassNames[ iClass ] );
	}

	g_pVGuiLocalize->ConstructString_safe( szSummary, szOriginalSummary, 1, pszPlayerClass );

	pLabel->SetText( szSummary );

	if ( m_pClassImage )
	{
		m_pClassImage->SetClass( iTeam, iClass, 0 );
	}

	Show();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::FireGameEvent( IGameEvent * event )
{
	const char *pEventName = event->GetName();

	if ( Q_strcmp( "player_spawn", pEventName ) == 0 )
	{
		int iUserID = event->GetInt( "userid" );
		if ( !C_TFPlayer::GetLocalTFPlayer() || ( C_TFPlayer::GetLocalTFPlayer()->GetUserID() != iUserID ) )
			return;

		if ( m_bDisplayAfterSpawn )
		{
			// if we have a panel to display after spawn, show it now
			vgui::ivgui()->AddTickSignal( GetVPanel(), 1000 );
			ShowStatPanel( m_iCurStatClass, m_iCurStatTeam, m_iCurStatValue, m_statType, m_recordBreakType, true );
			m_flTimeHide = gpGlobals->curtime + 12.0f;
			m_bDisplayAfterSpawn = false;
		}
		else
		{
			// hide panel if we're currently showing it
			Hide();
		}		
		m_flTimeLastSpawn = gpGlobals->curtime;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	LoadControlSettings( "resource/UI/StatPanel_Base.res" );

	vgui::Panel *pStatBox = FindChildByName("StatBox");
	if ( pStatBox )
	{
		// Dirty hack: Make the statbox update now, and then change its bgColor.
		// When it then gets ApplySchemeSetting called shortly after this, it doesn't
		// reapply the scheme because its dirty-scheme flag has been removed.
		pStatBox->ApplySchemeSettings( pScheme );
		pStatBox->SetBgColor( GetSchemeColor("TransparentLightBlack", pScheme) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::OnTick()
{
	// see if it's time to hide the panel
	if ( m_flTimeHide > 0 && gpGlobals->curtime > m_flTimeHide )
	{
		Hide();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::Show()
{
	m_bShouldBeVisible = true;

	HideLowerPriorityHudElementsInGroup( "mid" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::Hide()
{
	m_bShouldBeVisible = false;
	if ( m_flTimeHide > 0 )
	{
		m_flTimeHide = 0;
		vgui::ivgui()->RemoveTickSignal( GetVPanel() );
	}

	UnhideLowerPriorityHudElementsInGroup( "mid" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFStatPanel::ShouldDraw( void )
{
	if ( !m_bShouldBeVisible )
		return false;

	if ( IsTakingAFreezecamScreenshot() )
		return false;
	
	if ( TFGameRules() && TFGameRules()->IsInArenaMode() == true )
	{
		m_flTimeHide = gpGlobals->curtime;
		return false;
	}

	return CHudElement::ShouldDraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::ClearStatsInMemory( void )
{
	m_aClassStats.RemoveAll();
	m_aMapStats.RemoveAll();
	m_bStatsChanged = true;
	ResetDisplayedStat();
	UpdateStatSummaryPanel();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFStatPanel::ResetStats( void )
{
	// Only allow this action if the player is connected to steam and the achievement manager exists.
	// Otherwise, our stat panel stats, stat file, and local steam context stats will be out of sync because UploadStats will fail.
	CAchievementMgr *pAchievementMgr = dynamic_cast<CAchievementMgr *>( engine->GetAchievementMgr() );
	if ( !steamapicontext->SteamUserStats() || !pAchievementMgr )
	{
		MessageBox *msg = new MessageBox( "#TF_SteamRequired", "#TF_SteamRequiredResetStats" );
		if ( msg != NULL )
		{
			msg->AddActionSignalTarget(this);
			msg->MoveToFront();
			msg->DoModal();
		}
		return;
	}

	// The following operations are order dependent:

	// Nukes the panel's version of the stats. Note that after this is called the local steam stats are out of sync.
	ClearStatsInMemory();

	// WriteStats will write out our stat file (not really used on the PC, authoritative on the XBox 360).
	WriteStats();

	// At this point local and remote steam stats are out of sync.

	// Nuke the players stats on steam to seal the deal.
	steamapicontext->SteamUserStats()->ResetAllStats( false );

	// UploadStats will pull the players' class stats from CTFStatPanel and stomp the steam stats in memory.
	g_TFSteamStats.UploadStats();
}

//-----------------------------------------------------------------------------
// Purpose: returns class stat struct for specified class
//-----------------------------------------------------------------------------
ClassStats_t &CTFStatPanel::GetClassStats( int iClass )
{
	Assert( statPanel );
	Assert( iClass >= TF_FIRST_NORMAL_CLASS );
	Assert( iClass <= TF_LAST_NORMAL_CLASS );
	int i;
	for( i = 0; i < statPanel->m_aClassStats.Count(); i++ )
	{
		if ( statPanel->m_aClassStats[i].iPlayerClass == iClass )
			return statPanel->m_aClassStats[i];
	}

	ClassStats_t stats;
	stats.iPlayerClass = iClass;
	statPanel->m_aClassStats.AddToTail( stats );
	return statPanel->m_aClassStats[statPanel->m_aClassStats.Count()-1];
}

MapStats_t &CTFStatPanel::GetMapStats( map_identifier_t iMapID )
{
	Assert( statPanel );
	Assert( IsValidMapID( iMapID ) );
	int i;
	for( i = 0; i < statPanel->m_aMapStats.Count(); i++ )
	{
		if ( statPanel->m_aMapStats[i].iMapID == iMapID )
			return statPanel->m_aMapStats[i];
	}

	MapStats_t stats;
	stats.iMapID = iMapID;
	statPanel->m_aMapStats.AddToTail( stats );
	return statPanel->m_aMapStats[statPanel->m_aMapStats.Count()-1];
}

bool CTFStatPanel::IsValidMapID( map_identifier_t iMapID )
{
	for ( int i = 0; i < GetItemSchema()->GetMapCount(); i++ )
	{
		const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByIndex( i );
		if ( iMapID == pMap->GetStatsIdentifier() )
		{
			return true;
		}
	}

	return false;
}

const char* CTFStatPanel::GetMapNameFromID( map_identifier_t iMapID )
{
	for ( int i = 0; i < GetItemSchema()->GetMapCount(); i++ )
	{
		const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByIndex( i );
		if ( iMapID == pMap->GetStatsIdentifier() )
		{
			return pMap->pszMapName;
		}
	}

	return "";
}

//-----------------------------------------------------------------------------
// Purpose: Updates the stat summary panel w/current stats
//-----------------------------------------------------------------------------
void CTFStatPanel::UpdateStatSummaryPanel()
{
	UpdateStatSummaryPanels( m_aClassStats );
}


//-----------------------------------------------------------------------------
// Purpose: Return the total time this player has played the game, in hours.
//-----------------------------------------------------------------------------
float CTFStatPanel::GetTotalHoursPlayed( void )
{
	float totalTimePlayed = 0;

	for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
	{		
		totalTimePlayed += GetClassStats( iClass ).accumulated.m_iStat[ TFSTAT_PLAYTIME ] + GetClassStats( iClass ).accumulatedMVM.m_iStat[ TFSTAT_PLAYTIME ];
	}
	
	return totalTimePlayed / ( 60.0f * 60.0f );
}


//-----------------------------------------------------------------------------
// Purpose: Renders stat value as string
//-----------------------------------------------------------------------------
void CTFStatPanel::GetStatValueAsString( int iValue, TFStatType_t statType, char *value, int valuelen )
{
	if ( TFSTAT_PLAYTIME == statType )
	{
		// Format time as a time string
		Q_strncpy( value, FormatSeconds( iValue ), valuelen );
	}
	else
	{
		// all other stats are just displayed as #'s
		Q_snprintf( value, valuelen, "%d", iValue );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called when we get a stat update for the local player
//-----------------------------------------------------------------------------
void CTFStatPanel::MsgFunc_PlayerStatsUpdate( bf_read &msg )
{
	RoundStats_t stats;

	// get the fixed-size information
	int iClass = msg.ReadByte();
	bool bAlive = msg.ReadByte();
	int iSendBits = msg.ReadLong();

	Assert( iClass >= TF_FIRST_NORMAL_CLASS && iClass <= TF_LAST_NORMAL_CLASS );
	if ( iClass < TF_FIRST_NORMAL_CLASS || iClass > TF_LAST_NORMAL_CLASS )
		return;

	// the bitfield indicates which stats are contained in the message.  Set the stats appropriately.
	int iStat = TFSTAT_FIRST;
	while ( iSendBits > 0 && iStat <= TFSTAT_LAST )
	{
		if ( iSendBits & 1 )
		{
			stats.m_iStat[iStat] = msg.ReadLong();
		}
		iSendBits >>= 1;
		iStat++;
	}

	// sanity check: the message should contain exactly the # of bytes we expect based on the bit field
	Assert( !msg.IsOverflowed() );
	Assert( 0 == msg.GetNumBytesLeft() );
	// if byte count isn't correct, bail out and don't use this data, rather than risk polluting player stats with garbage
	if ( msg.IsOverflowed() || ( 0 != msg.GetNumBytesLeft() ) )
		return;

	UpdateStats( iClass, stats, bAlive );
}

void CTFStatPanel::MsgFunc_MapStatsUpdate( bf_read &msg )
{
	RoundMapStats_t stats;

	// get the fixed-size information
	map_identifier_t iMapID = msg.ReadUBitLong( 32 );
	int iSendBits = msg.ReadLong();

	if ( !IsValidMapID( iMapID ) )
		return;

	// the bitfield indicates which stats are contained in the message.  Set the stats appropriately.
	int iStat = TFMAPSTAT_FIRST;
	while ( iSendBits > 0 && iStat <= TFMAPSTAT_LAST )
	{
		if ( iSendBits & 1 )
		{
			stats.m_iStat[iStat] = msg.ReadLong();
		}
		iSendBits >>= 1;
		iStat++;
	}

	// sanity check: the message should contain exactly the # of bytes we expect based on the bit field
	Assert( !msg.IsOverflowed() );
	Assert( 0 == msg.GetNumBytesLeft() );
	// if byte count isn't correct, bail out and don't use this data, rather than risk polluting player stats with garbage
	if ( msg.IsOverflowed() || ( 0 != msg.GetNumBytesLeft() ) )
		return;

	UpdateMapStats( iMapID, stats );
}

/**********************************************************************************/

void TestStatPanel( const CCommand &args )
{
	int iPanelType;

	if( args.ArgC() < 2 )
	{
		ConMsg( "Usage:  teststatpanel < panel type > < optional record type >\n" );
		ConMsg( "Usable panel types are %d to %d. Record types are %d to %d\n", TFSTAT_FIRST, TFSTAT_LAST, RECORDBREAK_NONE+1, RECORDBREAK_MAX-1 );
		return;
	}

	if ( statPanel )
	{
		iPanelType = atoi( args.Arg( 1 ) );
		int iRecordType = RECORDBREAK_BEST;

		if ( args.ArgC() >= 3 )
		{
			iRecordType = atoi( args.Arg( 2 ) );
		}

		if ( ( iPanelType <= TFSTAT_UNDEFINED ) || ( iPanelType >= TFSTAT_TOTAL ) || (iRecordType <= RECORDBREAK_NONE) || (iRecordType >= RECORDBREAK_MAX) )
		{
			ConMsg( "Usage:  teststatpanel < panel type > < optional record type >\n" );
			ConMsg( "Usable panel types are %d to %d. Record types are %d to %d\n", TFSTAT_FIRST, TFSTAT_LAST, RECORDBREAK_NONE+1, RECORDBREAK_MAX-1 );
			return;
		}

		statPanel->TestStatPanel( (TFStatType_t) iPanelType, (RecordBreakType_t)iRecordType );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void HideStatPanel()
{
	if ( statPanel )
	{
		statPanel->Hide();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ResetPlayerStats()
{
	if ( statPanel )
	{
		statPanel->ResetStats();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void RefreshPlayerStats()
{
	if ( statPanel )
	{
		if ( !statPanel->ReadStats() )
		{
			// Read failed, need to clear everything
			statPanel->ClearStatsInMemory();
		}
	}
}

ConCommand teststatpanel( "teststatpanel", TestStatPanel, "", FCVAR_DEVELOPMENTONLY );
ConCommand hidestatpanel( "hidestatpanel", HideStatPanel, "", FCVAR_DEVELOPMENTONLY );
ConCommand refreshplayerstats( "refreshplayerstats", RefreshPlayerStats, "", FCVAR_DEVELOPMENTONLY );

ConCommand resetplayerstats( "resetplayerstats", ResetPlayerStats, "", FCVAR_CLIENTCMD_CAN_EXECUTE );