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.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/client/tf/c_tf_gamestats.cpp

1507 lines
45 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Client side stat tracking
//
//=============================================================================//
#include "cbase.h"
#include "c_tf_gamestats.h"
#include <vgui_controls/Controls.h>
#include "vgui/ISystem.h"
#include "steam/steam_api.h"
#include "steamworks_gamestats.h"
#include "c_tf_player.h"
#include "tf_hud_statpanel.h"
#include "econ_item_system.h"
#include "econ_ui.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Must run with -gamestats to be able to turn on/off stats with ConVar below.
static ConVar tf_stats_track( "tf_stats_track",
#ifdef _DEBUG
"0",
#else
"1",
#endif
FCVAR_DEVELOPMENTONLY, "Turn on//off tf stats tracking." );
ConVar tf_matchmaking_ogs_odds( "tf_matchmaking_ogs_odds", "0.05", FCVAR_HIDDEN, "Percentage (0...1) of quickplay queries that will report to OGS" );
const char *g_ItemEventNames[] =
{
// STORE EVENTS
"store_entered",
"store_exited",
"store_tab_changed",
"store_item_selected",
"store_item_previewed",
"store_item_added_to_cart",
"store_item_removed_from_cart",
"store_checkout_attempt",
"store_checkout_failure",
"store_checkout_success",
"store_checkout_item",
// LOADOUT EVENTS
"loadout_entered",
"loadout_exited",
// TRADE EVENTS
"trading_entered",
"trading_exited",
"trading_went_to_armory",
"trading_returned_from_armory",
"trading_request_sent",
"trading_request_received",
"trading_request_rejected",
"trading_request_accepted",
"trading_trade_negotiated",
"trading_trade_success",
"trading_trade_failure",
"trading_item_given",
"trading_item_received",
"trading_item_gifted",
// CRAFTING EVENTS
"crafting_entered",
"crafting_exited",
"crafting_went_to_armory",
"crafting_returned_from_armory",
"crafting_view_blueprints",
"crafting_timeout",
"crafting_failure",
"crafting_success",
"crafting_no_recipe_match",
"crafting_attempt",
"crafting_recipe_found",
// ARMORY EVENTS
"armory_entered",
"armory_exited",
"armory_select_item",
"armory_browse_wiki",
"armory_change_filter",
// GENERAL EVENTS
"item_received",
"item_discarded",
"item_deleted",
"item_used_tool",
"item_used_consumable",
"item_removed_attrib",
"item_changed_style"
// NEW STORE EVENTS
"store2_entered", // This gets written *in addition* to IE_STORE_ENTERED
// THESE STORED AS INTEGERS IN THE DATABASE SO THESE ARE NEW
"item_reset_counters",
"item_put_into_collection",
"" // IE_COUNT
};
COMPILE_TIME_ASSERT( ARRAYSIZE( g_ItemEventNames ) == IE_COUNT );
C_CTFGameStats C_CTF_GameStats;
static bool WeaponInfoLessFunc( const int& e1, const int&e2 )
{
return e1 < e2;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input : -
//-----------------------------------------------------------------------------
C_CTFGameStats::C_CTFGameStats()
{
m_ulExperimentValue = (uint64) ~0;
gamestats = this;
Clear();
m_mapWeaponInfo.SetLessFunc( WeaponInfoLessFunc );
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
// Input : -
//-----------------------------------------------------------------------------
C_CTFGameStats::~C_CTFGameStats()
{
}
//-----------------------------------------------------------------------------
// Purpose: Sets all game stats to their default value
// Input : -
//-----------------------------------------------------------------------------
void C_CTFGameStats::Clear( void )
{
V_strncpy( m_szCountryCode, "unknown", ARRAYSIZE( m_szCountryCode ) );
V_strncpy( m_szAudioLanguage, "unknown", ARRAYSIZE( m_szAudioLanguage ) );
V_strncpy( m_szTextLanguage, "unknown", ARRAYSIZE( m_szTextLanguage ) );
m_bRoundActive = false;
m_bIsDisconnecting = false;
}
//-----------------------------------------------------------------------------
// Purpose: Adds our data to the gamestats data that gets uploaded.
// Returns true if we added data, false if we didn't
//-----------------------------------------------------------------------------
bool C_CTFGameStats::AddDataForSend( KeyValues *pKV, StatSendType_t sendType )
{
// we only have data to send at level shutdown
if ( sendType != STATSEND_APPSHUTDOWN || 0 == tf_stats_track.GetInt() )
{
return false;
}
KeyValues *pKVData = new KeyValues( "tf_configdata" );
if ( NULL == pKVData )
{
Clear();
return false;
}
static ConVarRef sb_quick_list_bit_field( "sb_quick_list_bit_field" );
if ( sb_quick_list_bit_field.IsValid() )
{
pKVData->SetInt( "QuickListBitField", sb_quick_list_bit_field.GetInt() );
}
else
{
pKVData->SetInt( "QuickListBitField", -1 );
}
pKVData->SetString( "TextLanguage", m_szTextLanguage );
pKVData->SetString( "AudioLanguage", m_szAudioLanguage );
pKVData->SetString( "CountryCode", m_szCountryCode );
// Add our tf_configdata as a subkey to the main stat key
pKV->AddSubKey( pKVData );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Since this is a very lean client stat reporter, we can grab all the info
// that we need right in the init call
//-----------------------------------------------------------------------------
bool C_CTFGameStats::Init( void )
{
// If we are on the PC and have access to all the interfaces we need
if ( !IsX360() && engine && vgui::system() && steamapicontext && steamapicontext->SteamUtils() )
{
// We want to track the country code to help with localization. The countrycode is empty when testing on SteamBeta, so we won't get
// data until users in the wild play
const char * countryCode = steamapicontext->SteamUtils()->GetIPCountry();
if ( countryCode != NULL )
{
V_strncpy( m_szCountryCode, countryCode, ARRAYSIZE( m_szCountryCode ) );
}
// Now lets get the text language that Steam is in (If the game supports the language, then the UI is changed to that language).
engine->GetUILanguage( m_szTextLanguage, sizeof( m_szTextLanguage ) );
V_strcpy_safe( m_szAudioLanguage, steamapicontext->SteamApps()->GetCurrentGameLanguage() );
m_currentSession.m_SessionStart = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
ListenForGameEvent( "server_spawn" );
// ListenForGameEvent( "host_quit" );
ListenForGameEvent( "player_stats_updated" );
ListenForGameEvent( "teamplay_round_win" );
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "player_changeclass" );
ListenForGameEvent( "player_hurt" );
ListenForGameEvent( "client_disconnect" );
// A client session lasts from when the application starts to when it is exited.
GetSteamWorksSGameStatsUploader().StartSession();
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: This system is shutting down.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Shutdown()
{
if ( !steamapicontext )
return;
if ( !steamapicontext->SteamUser() )
return;
SW_GameStats_WriteClientSessionSummary();
SW_GameStats_WriteClientWeapons();
GetSteamWorksSGameStatsUploader().EndSession();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_LevelInit( void )
{
m_currentMap.Init( engine->GetLevelName(), engine->GetLevelVersion(), 0, 0, GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
m_currentRound.m_iNumRounds = 0;
m_currentSession.m_iMapsPlayed++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_LevelShutdown( float flElapsed )
{
if ( !m_bIsDisconnecting )
{
SW_GameStats_WriteClientRound( 0, 0, RE_SERVER_MAP_CHANGE );
}
SW_GameStats_WriteClientMap();
}
//-----------------------------------------------------------------------------
// Purpose: Called when the server shuts down or the client disconnects from the server.
//-----------------------------------------------------------------------------
void C_CTFGameStats::ClientDisconnect( int iReason )
{
m_bIsDisconnecting = true;
SW_GameStats_WriteClientRound( 0, 0, iReason );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::FireGameEvent( IGameEvent *event )
{
const char *pEventName = event->GetName();
if ( FStrEq( "server_spawn", pEventName ) )
{
if ( m_currentSession.m_FirstConnect == 0 )
{
m_currentSession.m_FirstConnect = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
}
// In case we join a round that is active, stuff the current time as the round start time.
m_currentRound.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
m_currentMap.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
m_bIsDisconnecting = false;
}
else if ( FStrEq( "host_quit", pEventName ) )
{
// We need this event because client_disconnect is called after the level unloads
// when we're dealing with the client-host of a listen server. Frustrating exception to
// the normal disconnect/shutdown rules.
ClientDisconnect( RE_CLIENT_QUIT );
}
else if ( FStrEq( "client_disconnect", pEventName ) )
{
ClientDisconnect( RE_CLIENT_DISCONNECT );
}
else if ( FStrEq( "teamplay_round_win", pEventName ) )
{
int winningTeam = event->GetInt( "team" );
float roundTime = event->GetFloat( "round_time" );
int fullRound = event->GetInt( "full_round" );
Event_RoundEnd( winningTeam, roundTime, fullRound );
}
else if ( FStrEq( "teamplay_round_active", pEventName ) )
{
Event_RoundActive();
}
else if ( FStrEq( "player_changeclass", pEventName ) )
{
int userid = event->GetInt( "userid" );
int classid = event->GetInt( "class" );
Event_PlayerChangeClass( userid, classid );
}
else if ( FStrEq( "player_hurt", pEventName ) )
{
Event_PlayerHurt( event );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_RoundActive()
{
m_currentRound.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
m_currentMap.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
m_bRoundActive = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_RoundEnd( int winningTeam, float roundTime, int fullRound )
{
SW_GameStats_WriteClientRound( winningTeam, fullRound, RE_ROUND_END );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_PlayerChangeClass( int userid, int classid )
{
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pTFPlayer )
return;
if ( pTFPlayer != UTIL_PlayerByIndex( engine->GetPlayerForUserID( userid ) ) )
return;
m_currentSession.m_ClassesPlayed.Set( classid );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_PlayerHurt( IGameEvent* event /*player_hurt*/ )
{
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pTFPlayer )
return;
int attackerid = event->GetInt( "attacker" );
if ( pTFPlayer != UTIL_PlayerByIndex( engine->GetPlayerForUserID( attackerid ) ) )
return;
if ( !m_bRoundActive )
return;
// My kingdom for a proper damage effects system.
// We need to ignore DOTS in some stats.
int custom = event->GetInt( "custom" );
bool bIsDamageOverTime = IsDOTDmg( custom );
bool bIsTauntDamage = IsTauntDmg( custom );
// Update weapon info with this hit.
int weaponid = event->GetInt( "weaponid" );
int damageamount = event->GetInt( "damageamount" );
TF_Gamestats_WeaponInfo_t info;
int idx = m_mapWeaponInfo.Find( weaponid );
if ( idx == m_mapWeaponInfo.InvalidIndex() )
{
info.weaponID = weaponid;
idx = m_mapWeaponInfo.Insert( weaponid, info );
}
else
{
info = m_mapWeaponInfo[idx];
}
info.totalDamage += damageamount;
if ( !bIsDamageOverTime && !bIsTauntDamage && (gpGlobals->curtime != info.lastUpdateTime) )
{
bool crit = event->GetInt( "crit" );
if ( crit )
{
info.critHits++;
}
info.shotsHit++;
info.shotsMissed--;
}
if ( info.shotsHit )
{
info.avgDamage = info.totalDamage / info.shotsHit;
}
else
{
info.avgDamage = 0;
}
info.lastUpdateTime = gpGlobals->curtime;
m_mapWeaponInfo[idx] = info;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_PlayerFiredWeapon( C_TFPlayer *pPlayer, bool bCritical )
{
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer || (pTFPlayer != pPlayer) )
return;
if ( !m_bRoundActive )
return;
CTFWeaponBase *pTFWeapon = pPlayer->GetActiveTFWeapon();
if ( pTFWeapon )
{
// all shots are assumed to be misses until they hit
int iWeaponID = pTFWeapon->GetWeaponID();
TF_Gamestats_WeaponInfo_t info;
int idx = m_mapWeaponInfo.Find( iWeaponID );
if ( idx == m_mapWeaponInfo.InvalidIndex() )
{
info.weaponID = iWeaponID;
idx = m_mapWeaponInfo.Insert( iWeaponID, info );
}
else
{
info = m_mapWeaponInfo[idx];
}
info.shotsFired++;
info.shotsMissed++;
if ( bCritical )
{
info.critsFired++;
}
m_mapWeaponInfo[idx] = info;
}
}
//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Client Data
// Sends the client's session summary report.
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientSessionSummary()
{
#if !defined(NO_STEAM)
KeyValues* pKVData = new KeyValues( "TF2ClientSessionDetails" );
pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
RTime32 currentClock = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
pKVData->SetInt( "StartTime", m_currentSession.m_SessionStart );
pKVData->SetInt( "EndTime", currentClock );
if ( GetSteamWorksSGameStatsUploader().GetNumServerConnects() > 0 )
{
pKVData->SetInt( "ServerConnects", GetSteamWorksSGameStatsUploader().GetNumServerConnects() );
}
ConVarRef sb_firstopentime( "sb_firstopentime" );
if ( m_currentSession.m_FirstConnect > 0 )
{
int iTimeFromStartToJoin = m_currentSession.m_FirstConnect - m_currentSession.m_SessionStart;
pKVData->SetInt( "TimeFromStartToJoin", iTimeFromStartToJoin );
}
if ( sb_firstopentime.GetInt() > 0 &&
m_currentSession.m_FirstConnect > 0 )
{
int iTimeFromBrowseToJoin = m_currentSession.m_FirstConnect - sb_firstopentime.GetInt();
if ( iTimeFromBrowseToJoin > 0 )
{
pKVData->SetInt( "TimeFromBrowseToJoin", iTimeFromBrowseToJoin );
}
}
if ( sb_firstopentime.GetInt() > 0 )
{
int iTimeFromStartToBrowse = sb_firstopentime.GetInt() - m_currentSession.m_SessionStart;
pKVData->SetInt( "TimeFromStartToBrowse", iTimeFromStartToBrowse );
}
ConVarRef sb_numtimesopened( "sb_numtimesopened" );
pKVData->SetInt( "TimesOpenedServerBrowser", sb_numtimesopened.GetInt() );
int iClassesPlayed = 0;
for ( int i=TF_FIRST_NORMAL_CLASS; i<TF_LAST_NORMAL_CLASS; ++i )
{
if ( m_currentSession.m_ClassesPlayed.IsBitSet( i ) )
{
iClassesPlayed++;
}
}
if ( iClassesPlayed > 0 )
{
pKVData->SetInt( "ClassesPlayed", iClassesPlayed );
}
if ( m_currentSession.m_iMapsPlayed > 0 )
{
pKVData->SetInt( "MapsPlayed", m_currentSession.m_iMapsPlayed );
}
if ( m_currentSession.m_iRoundsPlayed > 0 )
{
pKVData->SetInt( "RoundsPlayed", m_currentSession.m_iRoundsPlayed );
}
/*
FavoriteClass
FavoriteWeapon
FavoriteMap
*/
if ( m_currentSession.m_Summary.iKills > 0 )
{
pKVData->SetInt( "Kills", m_currentSession.m_Summary.iKills );
}
if ( m_currentSession.m_Summary.iDeaths > 0 )
{
pKVData->SetInt( "Deaths", m_currentSession.m_Summary.iDeaths );
}
if ( m_currentSession.m_Summary.iSuicides > 0 )
{
pKVData->SetInt( "Suicides", m_currentSession.m_Summary.iSuicides );
}
if ( m_currentSession.m_Summary.iAssists > 0 )
{
pKVData->SetInt( "Assists", m_currentSession.m_Summary.iAssists );
}
if ( m_currentSession.m_Summary.iBuildingsBuilt > 0 )
{
pKVData->SetInt( "BuildingsBuilt", m_currentSession.m_Summary.iBuildingsBuilt );
}
if ( m_currentSession.m_Summary.iBuildingsDestroyed > 0 )
{
pKVData->SetInt( "BuildingsDestroyed", m_currentSession.m_Summary.iBuildingsDestroyed );
}
if ( m_currentSession.m_Summary.iHeadshots > 0 )
{
pKVData->SetInt( "Headshots", m_currentSession.m_Summary.iHeadshots );
}
if ( m_currentSession.m_Summary.iDominations > 0 )
{
pKVData->SetInt( "Dominations", m_currentSession.m_Summary.iDominations );
}
if ( m_currentSession.m_Summary.iRevenges > 0 )
{
pKVData->SetInt( "Revenges", m_currentSession.m_Summary.iRevenges );
}
if ( m_currentSession.m_Summary.iInvulns > 0 )
{
pKVData->SetInt( "Invulns", m_currentSession.m_Summary.iInvulns );
}
if ( m_currentSession.m_Summary.iTeleports > 0 )
{
pKVData->SetInt( "Teleports", m_currentSession.m_Summary.iTeleports );
}
if ( m_currentSession.m_Summary.iDamageDone > 0 )
{
pKVData->SetInt( "DamageDone", m_currentSession.m_Summary.iDamageDone );
}
if ( m_currentSession.m_Summary.iHealingDone > 0 )
{
pKVData->SetInt( "HealingDone", m_currentSession.m_Summary.iHealingDone );
}
if ( m_currentSession.m_Summary.iCrits > 0 )
{
pKVData->SetInt( "Crits", m_currentSession.m_Summary.iCrits );
}
if ( m_currentSession.m_Summary.iBackstabs > 0 )
{
pKVData->SetInt( "Backstabs", m_currentSession.m_Summary.iBackstabs );
}
if ( m_currentSession.m_Summary.iAchievementsEarned > 0 )
{
pKVData->SetInt( "AchievementsEarned", m_currentSession.m_Summary.iAchievementsEarned );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
#endif
}
extern CBaseGameStats_Driver CBGSDriver;
//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Client Map Data
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientMap()
{
#if !defined(NO_STEAM)
KeyValues* pKVData = new KeyValues( "TF2ClientMaps" );
pKVData->SetInt( "MapIndex", m_currentSession.m_iMapsPlayed );
pKVData->SetInt( "StartTime", m_currentMap.m_iMapStartTime );
pKVData->SetInt( "EndTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
pKVData->SetString( "MapID", m_currentMap.m_Header.m_szMapName );
const char* pszGameTypeID = GetGameTypeID();
if ( pszGameTypeID )
{
pKVData->SetString( "GameTypeID", pszGameTypeID );
}
pKVData->SetInt( "RoundsPlayed", m_currentMap.m_Header.m_iRoundsPlayed );
pKVData->SetInt( "MapVersion", m_currentMap.m_Header.m_nMapRevision );
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Client Round Data
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientRound( int winningTeam, int fullRound, int endReason )
{
if ( !m_bRoundActive )
return;
m_bRoundActive = false;
m_currentSession.m_iRoundsPlayed++;
m_currentMap.m_Header.m_iRoundsPlayed++;
#if !defined(NO_STEAM)
KeyValues* pKVData = new KeyValues( "TF2ClientRounds" );
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pTFPlayer )
return;
localplayerscoring_t *pData = pTFPlayer->m_Shared.GetRoundScoringData();
if ( !pData )
return;
pKVData->SetInt( "MapIndex", m_currentSession.m_iMapsPlayed );
pKVData->SetInt( "RoundIndex", m_currentMap.m_Header.m_iRoundsPlayed );
pKVData->SetInt( "StartTime", m_currentRound.m_iRoundStartTime );
pKVData->SetInt( "EndTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
pKVData->SetString( "EndReason", ClampedArrayElement( g_aRoundEndReasons, endReason ) );
winningTeam = clamp( winningTeam, 0, TF_TEAM_COUNT - 1 );
pKVData->SetString( "WinningTeam", ClampedArrayElement( g_aTeamNames, winningTeam ) );
if ( fullRound > 0 )
{
pKVData->SetInt( "FullRound", fullRound );
}
if ( pData->m_iPoints > 0 )
{
pKVData->SetInt( "PointsScored", pData->m_iPoints );
}
if ( pData->m_iBonusPoints > 0 )
{
pKVData->SetInt( "BonusPointsScored", pData->m_iBonusPoints );
}
if ( pData->m_iKills > 0 )
{
pKVData->SetInt( "Kills", pData->m_iKills );
}
if ( pData->m_iDeaths > 0 )
{
pKVData->SetInt( "Deaths", pData->m_iDeaths );
}
if ( pData->m_iSuicides > 0 )
{
pKVData->SetInt( "Suicides", pData->m_iSuicides );
}
if ( pData->m_iKillAssists > 0 )
{
pKVData->SetInt( "Assists", pData->m_iKillAssists );
}
if ( pData->m_iBuildingsBuilt > 0 )
{
pKVData->SetInt( "BuildingsBuilt", pData->m_iBuildingsBuilt );
}
if ( pData->m_iBuildingsDestroyed > 0 )
{
pKVData->SetInt( "BuildingsDestroyed", pData->m_iBuildingsDestroyed );
}
if ( pData->m_iHeadshots > 0 )
{
pKVData->SetInt( "Headshots", pData->m_iHeadshots );
}
if ( pData->m_iDominations > 0 )
{
pKVData->SetInt( "Dominations", pData->m_iDominations );
}
if ( pData->m_iRevenge > 0 )
{
pKVData->SetInt( "Revenges", pData->m_iRevenge );
}
if ( pData->m_iInvulns > 0 )
{
pKVData->SetInt( "Invulns", pData->m_iInvulns );
}
if ( pData->m_iTeleports > 0 )
{
pKVData->SetInt( "Teleports", pData->m_iTeleports );
}
if ( pData->m_iDamageDone > 0 )
{
pKVData->SetInt( "DamageDone", pData->m_iDamageDone );
}
if ( pData->m_iHealPoints > 0 )
{
pKVData->SetInt( "HealingDone", pData->m_iHealPoints );
}
if ( pData->m_iCrits > 0 )
{
pKVData->SetInt( "Crits", pData->m_iCrits );
}
if ( pData->m_iBackstabs > 0 )
{
pKVData->SetInt( "Backstabs", pData->m_iBackstabs );
}
// Add totals to the current session.
m_currentSession.m_Summary.iKills += pData->m_iKills;
m_currentSession.m_Summary.iDeaths += pData->m_iDeaths;
m_currentSession.m_Summary.iSuicides += pData->m_iSuicides;
m_currentSession.m_Summary.iAssists += pData->m_iKillAssists;
m_currentSession.m_Summary.iBuildingsBuilt += pData->m_iBuildingsBuilt;
m_currentSession.m_Summary.iBuildingsDestroyed += pData->m_iBuildingsDestroyed;
m_currentSession.m_Summary.iHeadshots += pData->m_iHeadshots;
m_currentSession.m_Summary.iDominations += pData->m_iDominations;
m_currentSession.m_Summary.iRevenges += pData->m_iRevenge;
m_currentSession.m_Summary.iInvulns += pData->m_iInvulns;
m_currentSession.m_Summary.iTeleports += pData->m_iTeleports;
m_currentSession.m_Summary.iDamageDone += pData->m_iDamageDone;
m_currentSession.m_Summary.iHealingDone += pData->m_iHealPoints;
m_currentSession.m_Summary.iCrits += pData->m_iCrits;
m_currentSession.m_Summary.iBackstabs += pData->m_iBackstabs;
m_currentRound.Reset(); // Not used anymore?
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Weapons Data
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientWeapons()
{
#if !defined(NO_STEAM)
for ( unsigned int i=0; i<m_mapWeaponInfo.Count(); ++i )
{
KeyValues* pKVData = new KeyValues( "TF2ClientWeapons" );
TF_Gamestats_WeaponInfo_t info = m_mapWeaponInfo[i];
pKVData->SetString( "WeaponID", ClampedArrayElement( g_aWeaponNames, info.weaponID ) );
if ( info.shotsFired > 0 )
{
pKVData->SetInt( "ShotsFired", info.shotsFired );
}
if ( info.shotsHit > 0 )
{
pKVData->SetInt( "ShotsHit", info.shotsHit );
}
if ( info.shotsMissed > 0 )
{
pKVData->SetInt( "ShotsMissed", info.shotsMissed );
}
if ( info.critsFired > 0 )
{
pKVData->SetInt( "CritsFired", info.critsFired );
}
if ( info.critHits > 0 )
{
pKVData->SetInt( "CritHits", info.critHits );
}
if ( info.avgDamage > 0 )
{
pKVData->SetInt( "AvgDamage", info.avgDamage );
}
if ( info.totalDamage > 0 )
{
pKVData->SetInt( "TotalDamage", info.totalDamage );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Records client achievement events for reporting to steam.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_AchievementProgress( int achievementID, const char* achievementName )
{
TF_Gamestats_AchievementEvent_t event( achievementID, achievementName );
m_vecAchievementEvents.AddToTail( event );
m_currentSession.m_Summary.iAchievementsEarned++;
KeyValues* pKVData = new KeyValues( "TF2ClientAchievements" );
pKVData->SetInt( "TimeEarned", event.eventTime );
pKVData->SetInt( "AchievementNum", event.achievementNum );
pKVData->SetString( "AchievementID", event.achievementID );
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
//-----------------------------------------------------------------------------
// Purpose: Weapon stats
//-----------------------------------------------------------------------------
TF_Gamestats_WeaponInfo_t::TF_Gamestats_WeaponInfo_t()
{
weaponID = 0;
critsFired = 0;
shotsFired = 0;
shotsHit = 0;
shotsMissed = 0;
avgDamage = 0;
totalDamage = 0;
critHits = 0;
lastUpdateTime = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Achievement progress recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_AchievementEvent_t::TF_Gamestats_AchievementEvent_t( int in_achievementNum, const char* in_achievementID )
{
eventTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
achievementNum = in_achievementNum;
achievementID = in_achievementID;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
TF_Gamestats_ClientSession_t::TF_Gamestats_ClientSession_t()
{
Reset();
}
//-----------------------------------------------------------------------------
// Purpose: Reset the client session data.
//-----------------------------------------------------------------------------
void TF_Gamestats_ClientSession_t::Reset()
{
Q_memset( &m_Summary, 0, sizeof( m_Summary ) );
m_SessionStart = 0;
m_FirstConnect = 0;
m_iMapsPlayed = 0;
m_iRoundsPlayed = 0;
m_ClassesPlayed.ClearAll();
}
//-----------------------------------------------------------------------------
// Purpose: Item event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_ItemEvent::TF_Gamestats_ItemEvent( int in_eventNum, CEconItemView* in_item )
{
static CSchemaAttributeDefHandle pAttrDef_SupplyCrateSeries( "set supply crate series" );
bUseNameBuf = false;
eventTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
eventNum = in_eventNum;
eventID = g_ItemEventNames[eventNum];
if ( in_item )
{
itemDefIndex = in_item->GetItemDefIndex();
itemID = in_item->GetItemID();
itemName = in_item->GetStaticData()->GetDefinitionName();
// If this is a crate, quality is the series.
float fSeries;
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( in_item, pAttrDef_SupplyCrateSeries, &fSeries ) )
{
bUseNameBuf = true;
Q_snprintf( itemNameBuf, sizeof( itemNameBuf ), "%s, Series %i", itemName, (int)fSeries );
}
}
else
{
itemDefIndex = 0;
itemID = 0;
itemName = NULL;
}
}
//----------------------------------------------------------------------------
// Purpose: Records a catalog event for reporting.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Catalog( int eventID, const char* filter, CEconItemView* item )
{
TF_Gamestats_CatalogEvent event( eventID, item, filter );
m_vecCatalogEvents.AddToTail( event );
KeyValues* pKVData = new KeyValues( "TF2ClientCatalogEvents" );
pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
pKVData->SetInt( "EventCount", m_vecCatalogEvents.Count() );
pKVData->SetInt( "EventTime", event.eventTime );
pKVData->SetString( "ItemEventID", event.eventID );
if ( event.catalogFilter )
{
pKVData->SetString( "CatFilterID", event.catalogFilter );
}
if ( event.itemID > 0 )
{
pKVData->SetUint64( "GlobalIndex", event.itemID );
}
if ( event.itemDefIndex > 0 )
{
pKVData->SetInt( "DefIndex", event.itemDefIndex );
}
if ( event.GetItemName() != NULL )
{
pKVData->SetString( "ItemNameID", event.GetItemName() );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
//-----------------------------------------------------------------------------
// Purpose: Catalog event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_CatalogEvent::TF_Gamestats_CatalogEvent( int in_eventNum, CEconItemView* in_item, const char* filter )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
catalogFilter = filter;
}
//----------------------------------------------------------------------------
// Purpose: Records a catalog event for reporting.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Crafting( int eventID, CEconItemView* item, int numAttempts, int recipeFound )
{
TF_Gamestats_CraftingEvent event( eventID, item, numAttempts, recipeFound );
m_vecCraftingEvents.AddToTail( event );
KeyValues* pKVData = new KeyValues( "TF2ClientCraftingEvents" );
pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
pKVData->SetInt( "EventCount", m_vecCraftingEvents.Count() );
pKVData->SetInt( "EventTime", event.eventTime );
pKVData->SetString( "ItemEventID", event.eventID );
if ( event.itemID > 0 )
{
pKVData->SetUint64( "GlobalIndex", event.itemID );
}
if ( event.itemDefIndex > 0 )
{
pKVData->SetInt( "DefIndex", event.itemDefIndex );
}
if ( event.GetItemName() != NULL )
{
pKVData->SetString( "ItemNameID", event.GetItemName() );
}
if ( event.numAttempts > 0 )
{
pKVData->SetInt( "CraftAttemptNum", event.numAttempts );
}
if ( event.recipeFound > 0 )
{
pKVData->SetInt( "RecipeFound", event.recipeFound );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
//-----------------------------------------------------------------------------
// Purpose: Crafting event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_CraftingEvent::TF_Gamestats_CraftingEvent( int in_eventNum, CEconItemView* in_item, int in_numAttempts, int in_recipe )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
numAttempts = in_numAttempts;
recipeFound = in_recipe;
}
//----------------------------------------------------------------------------
// Purpose: Records a store event for reporting.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Store( int eventID, CEconItemView* item, const char* panelName, int classId,
const cart_item_t* cartItem, int checkoutAttempts, const char* storeError, int totalPrice, int currencyCode )
{
TF_Gamestats_StoreEvent event( eventID, item, panelName, classId, cartItem, checkoutAttempts, storeError, totalPrice, currencyCode );
m_vecStoreEvents.AddToTail( event );
KeyValues* pKVData = new KeyValues( "TF2ClientStoreEvents" );
pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
pKVData->SetInt( "EventCount", m_vecStoreEvents.Count() );
pKVData->SetInt( "EventTime", event.eventTime );
pKVData->SetString( "ItemEventID", event.eventID );
if ( event.eventNum == IE_STORE_ENTERED || event.eventNum == IE_STORE2_ENTERED )
{
if ( m_ulExperimentValue != ((int64) ~0) )
{
pKVData->SetUint64( "GlobalIndex", m_ulExperimentValue );
}
}
else
{
if ( event.itemID > 0 )
{
pKVData->SetUint64( "GlobalIndex", event.itemID );
}
}
if ( event.itemDefIndex > 0 )
{
pKVData->SetInt( "DefIndex", event.itemDefIndex );
}
if ( event.GetItemName() != NULL )
{
pKVData->SetString( "ItemNameID", event.GetItemName() );
}
if ( event.panelName != NULL )
{
pKVData->SetString( "StorePanelID", event.panelName );
}
if ( event.classId > 0 )
{
int iClass = clamp( event.classId, 0, TF_CLASS_COUNT-1 );
pKVData->SetString( "ClassID", g_aPlayerClassNames_NonLocalized[iClass] );
}
if ( event.cartQuantity > 0 )
{
pKVData->SetInt( "NewQuantity", event.cartQuantity );
}
if ( event.cartItemCost > 0 )
{
pKVData->SetInt( "Price", event.cartItemCost );
}
if ( event.currencyCode > 0 )
{
pKVData->SetInt( "CurrencyCode", event.currencyCode-1 );
}
if ( event.checkoutAttempt > 0 )
{
pKVData->SetInt( "CheckoutAttemptNum", event.checkoutAttempt );
}
if ( event.storeError != NULL )
{
pKVData->SetString( "StoreErrorID", event.storeError );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
//-----------------------------------------------------------------------------
// Purpose: Store event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_StoreEvent::TF_Gamestats_StoreEvent( int in_eventNum, CEconItemView* in_item, const char* in_panelName, int in_classId,
const cart_item_t* in_cartItem, int in_checkoutAttempts, const char* in_storeError, int in_totalPrice, int in_currencyCode )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
classId = in_classId;
checkoutAttempt = in_checkoutAttempts;
storeError = NULL;
if ( in_storeError )
{
storeError = in_storeError;
}
panelName = NULL;
if ( in_panelName )
{
panelName = in_panelName;
}
cartQuantity = 0;
cartItemCost = 0;
currencyCode = in_currencyCode;
if ( in_cartItem )
{
CEconItemDefinition *pItemDef = ItemSystem()->GetStaticDataForItemByDefIndex( in_cartItem->pEntry->GetItemDefinitionIndex() );
if ( pItemDef )
{
itemDefIndex = in_cartItem->pEntry->GetItemDefinitionIndex();
itemName = pItemDef->GetDefinitionName();
cartQuantity = in_cartItem->iQuantity;
cartItemCost = in_cartItem->pEntry->GetCurrentPrice( (ECurrency)in_currencyCode );
}
}
if ( in_eventNum == IE_STORE_CHECKOUT_SUCCESS && in_totalPrice > 0 )
{
cartItemCost = in_totalPrice;
}
}
//----------------------------------------------------------------------------
// Purpose: Records a general item transaction event.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_ItemTransaction( int eventID, CEconItemView* item, const char* pszReason, int iQuality )
{
TF_Gamestats_ItemTransactionEvent event( eventID, item, pszReason, iQuality );
m_vecItemTransactionEvents.AddToTail( event );
KeyValues* pKVData = new KeyValues( "TF2ClientItemTransactionEvents" );
pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
pKVData->SetInt( "EventCount", m_vecItemTransactionEvents.Count() );
pKVData->SetInt( "EventTime", event.eventTime );
pKVData->SetString( "ItemEventID", event.eventID );
if ( event.itemID > 0 )
{
pKVData->SetUint64( "GlobalIndex", event.itemID );
}
if ( event.itemDefIndex > 0 )
{
pKVData->SetInt( "DefIndex", event.itemDefIndex );
}
if ( event.GetItemName() != NULL )
{
pKVData->SetString( "ItemNameID", event.GetItemName() );
}
if ( event.reason )
{
pKVData->SetString( "ItemTransReasonID", event.reason );
}
if ( event.itemQuality > 0 )
{
pKVData->SetInt( "ItemQuality", event.itemQuality );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
//-----------------------------------------------------------------------------
// Purpose: Transaction event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_ItemTransactionEvent::TF_Gamestats_ItemTransactionEvent( int in_eventNum, CEconItemView* in_item, const char* in_reason, int in_quality )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
static CSchemaAttributeDefHandle pAttrDef_SupplyCrateSeries( "set supply crate series" );
reason = in_reason;
if ( in_item )
{
itemQuality = in_item->GetItemQuality();
// If this is a crate, quality is the series.
float fSeries;
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( in_item, pAttrDef_SupplyCrateSeries, &fSeries ) )
{
in_quality = fSeries;
}
}
if ( in_quality > 0 )
{
// For crates, indicates the series.
itemQuality = in_quality;
}
}
void C_CTFGameStats::Event_Trading( TF_Gamestats_TradeEvent& event )
{
KeyValues* pKVData = new KeyValues( "TF2ClientTradeEvents" );
pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
pKVData->SetInt( "EventCount", m_vecTradeEvents.Count() );
pKVData->SetInt( "EventTime", event.eventTime );
pKVData->SetString( "ItemEventID", event.eventID );
if ( event.itemID > 0 )
{
pKVData->SetUint64( "GlobalIndex", event.itemID );
}
if ( event.itemDefIndex > 0 )
{
pKVData->SetInt( "DefIndex", event.itemDefIndex );
}
if ( event.GetItemName() != NULL )
{
pKVData->SetString( "ItemNameID", event.GetItemName() );
}
if ( event.localPlayerPartyMatters )
{
pKVData->SetInt( "IsLocalPlayerPartyA", event.localPlayerIsPartyA );
}
if ( event.steamIDPartyA > 0 )
{
pKVData->SetUint64( "SteamIDPartyA", event.steamIDPartyA );
}
if ( event.steamIDPartyB > 0 )
{
pKVData->SetUint64( "SteamIDPartyB", event.steamIDPartyB );
}
if ( event.steamIDRequested > 0 )
{
pKVData->SetUint64( "RequestedTradeWithSteamID", event.steamIDRequested );
}
if ( event.tradeRequests > 0 )
{
pKVData->SetInt( "TradeRequestIndex", event.tradeRequests );
}
if ( event.tradeAttempts > 0 )
{
pKVData->SetInt( "TradeAttemptIndex", event.tradeAttempts );
}
if ( event.reason )
{
pKVData->SetString( "TradeReasonID", event.reason );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
//----------------------------------------------------------------------------
// Purpose: Records an item trade event.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Trading( int eventID, CEconItemView* item, bool localPlayerIsPartyA,
uint64 steamIDPartyA, uint64 steamIDPartyB, int iTradeRequests, int iTradeAttempts )
{
TF_Gamestats_TradeEvent event( eventID, item, localPlayerIsPartyA,
steamIDPartyA, steamIDPartyB, iTradeRequests, iTradeAttempts );
m_vecTradeEvents.AddToTail( event );
Event_Trading( event );
}
void C_CTFGameStats::Event_Trading( int eventID, uint64 steamIDRequested, int iTradeRequests, int iTradeAttempts )
{
TF_Gamestats_TradeEvent event( eventID, steamIDRequested, iTradeRequests, iTradeAttempts );
m_vecTradeEvents.AddToTail( event );
Event_Trading( event );
}
void C_CTFGameStats::Event_Trading( int eventID, int iTradeRequests, const char* reason, int iTradeAttempts )
{
TF_Gamestats_TradeEvent event( eventID, iTradeRequests, reason, iTradeAttempts );
m_vecTradeEvents.AddToTail( event );
Event_Trading( event );
}
//-----------------------------------------------------------------------------
// Purpose: Trade event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_TradeEvent::TF_Gamestats_TradeEvent( int in_eventNum, CEconItemView* in_item, bool in_localPlayerIsPartyA,
uint64 in_steamIDPartyA, uint64 in_steamIDPartyB,
int in_tradeRequests, int in_tradeAttempts )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
localPlayerPartyMatters = true;
localPlayerIsPartyA = in_localPlayerIsPartyA;
steamIDPartyA = in_steamIDPartyA;
steamIDPartyB = in_steamIDPartyB;
steamIDRequested = 0;
tradeRequests = in_tradeRequests;
tradeAttempts = in_tradeAttempts;
reason = NULL;
}
TF_Gamestats_TradeEvent::TF_Gamestats_TradeEvent( int in_eventNum, uint64 in_steamIDRequested,
int in_tradeRequests, int in_tradeAttempts )
: TF_Gamestats_ItemEvent( in_eventNum, NULL )
{
localPlayerPartyMatters = false;
localPlayerIsPartyA = false;
steamIDPartyA = 0;
steamIDPartyB = 0;
steamIDRequested = in_steamIDRequested;
tradeRequests = in_tradeRequests;
tradeAttempts = in_tradeAttempts;
reason = NULL;
}
TF_Gamestats_TradeEvent::TF_Gamestats_TradeEvent( int in_eventNum, int in_tradeRequests, const char* in_reason, int in_tradeAttempts )
: TF_Gamestats_ItemEvent( in_eventNum, NULL )
{
localPlayerPartyMatters = false;
localPlayerIsPartyA = false;
steamIDPartyA = 0;
steamIDPartyB = 0;
steamIDRequested = 0;
tradeRequests = in_tradeRequests;
tradeAttempts = in_tradeAttempts;
reason = in_reason;
}
//-----------------------------------------------------------------------------
// Purpose: Interface stats recorder.
//-----------------------------------------------------------------------------
static const bool g_bRecordClientInterfaceEventsToOGS = false;
/*static*/ void C_CTFGameStats::ImmediateWriteInterfaceEvent( const char *pszEventType, const char *pszEventDesc )
{
if ( !g_bRecordClientInterfaceEventsToOGS )
return;
static uint32 s_unEventCount = 0;
KeyValues* pKVData = new KeyValues( "TF2UIEvents" );
pKVData->SetInt( "EventCounter", s_unEventCount++ );
if ( pszEventType )
{
pKVData->SetString( "EventTypeID", pszEventType );
}
if ( pszEventDesc )
{
pKVData->SetString( "EventDescID", pszEventDesc );
}
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
//-----------------------------------------------------------------------------
// Purpose: post results from first step of quickplay
//-----------------------------------------------------------------------------
int g_iQuickplaySessionIndex = 0;
void C_CTFGameStats::QuickplayResults( const TF_Gamestats_QuickPlay_t &info )
{
// Update index
++g_iQuickplaySessionIndex;
// Determine sampling rate
float odds = tf_matchmaking_ogs_odds.GetFloat();
Assert( odds >= 0.0f && odds <= 1.0f );
if ( GetUniverse() != k_EUniversePublic )
{
odds = 1.0f;
}
// Send full or abbreviated stats?
float r = RandomFloat();
int iDetailLevel = ( r < odds ) ? TF_Gamestats_QuickPlay_t::k_Server_Ineligible : TF_Gamestats_QuickPlay_t::k_Server_Pinged;
// Count up servers that meet various criteria
int nServersResponded = info.m_vecServers.Count();
int nServersEligible = 0;
int nServersSentToGC = 0;
int nServersScoredByGC = 0;
int nServersPinged = 0;
for ( int i = 0 ; i < info.m_vecServers.Count() ; ++i )
{
const TF_Gamestats_QuickPlay_t::eServerStatus &s = info.m_vecServers[i].m_eStatus;
if ( s >= TF_Gamestats_QuickPlay_t::k_Server_Eligible )
{
++nServersEligible;
}
if ( s >= TF_Gamestats_QuickPlay_t::k_Server_RequestedScore )
{
++nServersSentToGC;
}
if ( s >= TF_Gamestats_QuickPlay_t::k_Server_Scored && info.m_vecServers[i].m_fScoreGC > -999.0f )
{
++nServersScoredByGC;
}
if ( s >= TF_Gamestats_QuickPlay_t::k_Server_Pinged )
{
++nServersPinged;
}
}
KeyValues* pKVData = new KeyValues( "TF2QuickPlaySession" );
pKVData->SetInt( "QuickPlaySessionID", g_iQuickplaySessionIndex );
pKVData->SetFloat( "UserHoursPlayed", info.m_fUserHoursPlayed );
pKVData->SetString( "TF2GameModeIDSearched", info.m_sUserGameMode );
pKVData->SetInt( "Result", info.m_eResultCode );
pKVData->SetInt( "ReportDetail", iDetailLevel );
pKVData->SetFloat( "SearchTime", info.m_fSearchTime );
pKVData->SetInt( "ExperimentGroup", info.m_iExperimentGroup );
pKVData->SetInt( "ServersResponded", nServersResponded );
pKVData->SetInt( "ServersEligible", nServersEligible );
pKVData->SetInt( "ServersSentToGC", nServersSentToGC );
pKVData->SetInt( "ServersScoredByGC", nServersScoredByGC );
pKVData->SetInt( "ServersPinged", nServersPinged );
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
for ( int i = 0 ; i < info.m_vecServers.Count() ; ++i )
{
const TF_Gamestats_QuickPlay_t::Server_t &s = info.m_vecServers[i];
// Check if he's not important enough to report
if ( s.m_eStatus < iDetailLevel )
{
continue;
}
pKVData = new KeyValues( "TF2QuickPlayResult" );
pKVData->SetInt( "QuickPlaySessionID", g_iQuickplaySessionIndex );
pKVData->SetInt( "ServerIP", s.m_ip );
pKVData->SetInt( "ServerPort", s.m_port );
pKVData->SetInt( "Status", s.m_eStatus );
pKVData->SetInt( "ServerIsRegistered", s.m_bRegistered ? 1 : 0 );
pKVData->SetInt( "ServerIsValve", s.m_bValve ? 1 : 0 );
pKVData->SetInt( "ServerMapIsNewUserFriendly", s.m_bMapIsNewUserFriendly ? 1 : 0 );
pKVData->SetInt( "ServerMapIsQuickPlayOK", s.m_bMapIsQuickPlayOK ? 1 : 0 );
pKVData->SetInt( "ServerIsSecure", s.m_bSecure ? 1 : 0 );
pKVData->SetInt( "ServerPlayers", s.m_nPlayers );
pKVData->SetInt( "ServerMaxPlayers", s.m_nMaxPlayers );
pKVData->SetString( "MapID", s.m_sMapName );
pKVData->SetInt( "Ping", s.m_iPing );
pKVData->SetFloat( "ScoreServer", s.m_fScoreServer );
pKVData->SetFloat( "ScoreClient", s.m_fScoreClient );
if ( s.m_eStatus >= TF_Gamestats_QuickPlay_t::k_Server_Scored && s.m_fScoreGC > -999.0f )
{
pKVData->SetFloat( "ScoreGC", s.m_fScoreGC );
}
pKVData->SetString( "TF2ServerTagsID", s.m_sTags );
GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}
}