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

1188 lines
39 KiB
Raw Blame History

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