//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Client side stat tracking // //=============================================================================// #include "cbase.h" #include "c_tf_gamestats.h" #include #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 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; iSetString( "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( 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( 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 ); } }