1155 lines
39 KiB
C++
1155 lines
39 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Uploads KeyValue stats to the new SteamWorks gamestats system.
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
#include "cdll_int.h"
|
|
#include "tier2/tier2.h"
|
|
#include <time.h>
|
|
|
|
#ifdef GAME_DLL
|
|
#include "gameinterface.h"
|
|
#elif CLIENT_DLL
|
|
#include "c_playerresource.h"
|
|
#endif
|
|
|
|
#include "steam/isteamutils.h"
|
|
|
|
#include "steamworks_gamestats.h"
|
|
#include "achievementmgr.h"
|
|
#include "icommandline.h"
|
|
|
|
// NOTE: This has to be the last file included!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#if defined(CLIENT_DLL) || defined(CSTRIKE_DLL)
|
|
ConVar steamworks_sessionid_client( "steamworks_sessionid_client", "0", FCVAR_HIDDEN, "The client session ID for the new steamworks gamestats." );
|
|
#endif
|
|
|
|
// This is used to replicate our server id to the client so that client data can be associated with the server's.
|
|
ConVar steamworks_sessionid_server( "steamworks_sessionid_server", "0", FCVAR_REPLICATED | FCVAR_HIDDEN, "The server session ID for the new steamworks gamestats." );
|
|
|
|
// This is used to show when the steam works is uploading stats
|
|
#define steamworks_show_uploads 0
|
|
|
|
// This is a stop gap to disable the steam works game stats from ever initializing in the event that we need it
|
|
#if defined(CSTRIKE_DLL)
|
|
#define steamworks_stats_disable 1
|
|
#else
|
|
#define steamworks_stats_disable 0
|
|
#endif
|
|
|
|
// This is used to control when the stats get uploaded. If we wait until the end of the session, we miss out on all the stats if the server crashes. If we upload as we go, then we will have the data
|
|
#define steamworks_immediate_upload 1
|
|
|
|
// If set to zero all cvars will be tracked.
|
|
#define steamworks_track_cvar 0
|
|
|
|
// If set to non zero only cvars that are don't have default values will be tracked, but only if steamworks_track_cvar is also not zero.
|
|
#define steamworks_track_cvar_diff_only 1
|
|
|
|
// Methods that clients connect to servers. note that positive numbers are reserved
|
|
// for quickplay sessions
|
|
enum
|
|
{
|
|
k_ClientJoinMethod_Unknown = -1,
|
|
k_ClientJoinMethod_ListenServer = -2,
|
|
k_ClientJoinMethod_ServerBrowser_UNKNOWN = -3, // server browser, unknown tab
|
|
k_ClientJoinMethod_Steam = -4,
|
|
k_ClientJoinMethod_Matchmaking = -5,
|
|
k_ClientJoinMethod_Coaching = -6,
|
|
k_ClientJoinMethod_Redirect = -7,
|
|
k_ClientJoinMethod_ServerBrowserInternet = -10,
|
|
k_ClientJoinMethod_ServerBrowserFriends = -11,
|
|
k_ClientJoinMethod_ServerBrowserFavorites = -12,
|
|
k_ClientJoinMethod_ServerBrowserHistory = -13,
|
|
k_ClientJoinMethod_ServerBrowserLAN = -14,
|
|
k_ClientJoinMethod_ServerBrowserSpectator = -15
|
|
};
|
|
|
|
static CSteamWorksGameStatsUploader g_SteamWorksGameStats;
|
|
|
|
extern ConVar developer;
|
|
|
|
#if defined(CLIENT_DLL) || defined(CSTRIKE_DLL)
|
|
void Show_Steam_Stats_Session_ID( void )
|
|
{
|
|
DevMsg( "Client session ID (%s).\n", steamworks_sessionid_client.GetString() );
|
|
DevMsg( "Server session ID (%s).\n", steamworks_sessionid_server.GetString() );
|
|
}
|
|
static ConCommand ShowSteamStatsSessionID( "ShowSteamStatsSessionID", Show_Steam_Stats_Session_ID, "Prints out the game stats session ID's (developer convar must be set to non-zero).", FCVAR_DEVELOPMENTONLY );
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Clients store the server's session IDs so we can associate client rows with server rows.
|
|
//-----------------------------------------------------------------------------
|
|
void ServerSessionIDChangeCallback( IConVar *pConVar, const char *pOldString, float flOldValue )
|
|
{
|
|
ConVarRef var( pConVar );
|
|
if ( var.IsValid() )
|
|
{
|
|
// Treat the variable as a string, since the sessionID is 64 bit and the convar int interface is only 32 bit.
|
|
const char* pVarString = var.GetString();
|
|
uint64 newServerSessionID = Q_atoi64( pVarString );
|
|
g_SteamWorksGameStats.SetServerSessionID( newServerSessionID );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the time since the epoch
|
|
//-----------------------------------------------------------------------------
|
|
time_t CSteamWorksGameStatsUploader::GetTimeSinceEpoch( void )
|
|
{
|
|
if ( steamapicontext && steamapicontext->SteamUtils() )
|
|
return steamapicontext->SteamUtils()->GetServerRealTime();
|
|
else
|
|
{
|
|
// Default to system time.
|
|
time_t aclock;
|
|
time( &aclock );
|
|
return aclock;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns a reference to the global object
|
|
//-----------------------------------------------------------------------------
|
|
CSteamWorksGameStatsUploader& GetSteamWorksSGameStatsUploader()
|
|
{
|
|
return g_SteamWorksGameStats;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor. Sets up the steam callbacks accordingly depending on client/server dll
|
|
//-----------------------------------------------------------------------------
|
|
CSteamWorksGameStatsUploader::CSteamWorksGameStatsUploader() : CAutoGameSystemPerFrame( "CSteamWorksGameStatsUploader" )
|
|
#if !defined(NO_STEAM) && defined(GAME_DLL)
|
|
, m_CallbackSteamSessionInfoIssued( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoIssued )
|
|
, m_CallbackSteamSessionInfoClosed( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoClosed )
|
|
#endif
|
|
{
|
|
|
|
#if !defined(NO_STEAM) && defined(CLIENT_DLL)
|
|
m_CallbackSteamSessionInfoIssued.Register( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoIssued );
|
|
m_CallbackSteamSessionInfoClosed.Register( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoClosed );
|
|
#endif
|
|
|
|
Reset();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks to see if Cvar diff tracking is enabled and if so uploads the diffs
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::UploadCvars()
|
|
{
|
|
if ( steamworks_track_cvar )
|
|
{
|
|
bool bOnlyDiffCvars = steamworks_track_cvar_diff_only;
|
|
|
|
// Get all the Cvar Differences...
|
|
const ConCommandBase *var = g_pCVar->GetCommands();
|
|
|
|
// Loop through vars and print out findings
|
|
for ( ; var; var=var->GetNext() )
|
|
{
|
|
if ( var->IsCommand() )
|
|
continue;
|
|
|
|
if ( var->IsFlagSet(FCVAR_DEVELOPMENTONLY) || var->IsFlagSet(FCVAR_NEVER_AS_STRING) )
|
|
continue;
|
|
|
|
const char* pDefValue = ((ConVar*)var)->GetDefault();
|
|
const char* pValue = ((ConVar*)var)->GetString();
|
|
if ( bOnlyDiffCvars && !Q_stricmp( pDefValue, pValue ) )
|
|
continue;
|
|
|
|
KeyValues *pKV = new KeyValues( "Cvars" );
|
|
pKV->SetUint64( "TimeSubmitted", GetTimeSinceEpoch() );
|
|
pKV->SetString( "CvarID", var->GetName() );
|
|
pKV->SetString( "CvarDefValue", pDefValue );
|
|
pKV->SetString( "CvarValue", pValue );
|
|
|
|
ParseKeyValuesAndSendStats( pKV, false );
|
|
pKV->deleteThis();
|
|
}
|
|
|
|
static const char* csCLcvars[] =
|
|
{
|
|
"-threads",
|
|
"-high",
|
|
"-heap",
|
|
"-dxlevel"
|
|
};
|
|
|
|
for ( int hh=0; hh <ARRAYSIZE(csCLcvars) ; ++hh )
|
|
{
|
|
const char *pszParamValue = CommandLine()->ParmValue( csCLcvars[hh] );
|
|
if ( pszParamValue )
|
|
{
|
|
KeyValues *pKV = new KeyValues( "Cvars" );
|
|
pKV->SetUint64( "TimeSubmitted", GetTimeSinceEpoch() );
|
|
pKV->SetString( "CvarID", csCLcvars[hh] );
|
|
pKV->SetString( "CvarDefValue", "commandline" );
|
|
pKV->SetString( "CvarValue", pszParamValue );
|
|
|
|
ParseKeyValuesAndSendStats( pKV, false );
|
|
pKV->deleteThis();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reset uploader state.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::Reset()
|
|
{
|
|
ClearSessionID();
|
|
|
|
#ifdef CLIENT_DLL
|
|
steamworks_sessionid_client.SetValue( 0 );
|
|
ClearServerSessionID();
|
|
#endif
|
|
|
|
m_ServiceTicking = false;
|
|
m_LastServiceTick = 0;
|
|
m_SessionIDRequestUnsent = false;
|
|
m_SessionIDRequestPending = false;
|
|
m_UploadedStats = false;
|
|
m_bCollectingAny = false;
|
|
m_bCollectingDetails = false;
|
|
m_UserID = 0;
|
|
m_iAppID = 0;
|
|
m_iServerIP = 0;
|
|
m_nClientJoinMethod = k_ClientJoinMethod_Unknown;
|
|
memset( m_pzServerIP, 0, ARRAYSIZE(m_pzServerIP) );
|
|
memset( m_pzMapStart, 0, ARRAYSIZE(m_pzMapStart) );
|
|
memset( m_pzHostName, 0, ARRAYSIZE(m_pzHostName) );
|
|
m_StartTime = 0;
|
|
m_EndTime = 0;
|
|
m_HumanCntInGame = 0;
|
|
m_FriendCntInGame = 0;
|
|
|
|
m_ActiveSession.Reset();
|
|
m_iServerConnectCount = 0;
|
|
|
|
for ( int i=0; i<m_StatsToSend.Count(); ++i )
|
|
{
|
|
m_StatsToSend[i]->deleteThis();
|
|
}
|
|
|
|
m_StatsToSend.RemoveAll();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Init function from CAutoGameSystemPerFrame and must return true.
|
|
//-----------------------------------------------------------------------------
|
|
bool CSteamWorksGameStatsUploader::Init()
|
|
{
|
|
// ListenForGameEvent( "hostname_changed" );
|
|
ListenForGameEvent( "server_spawn" );
|
|
|
|
#ifdef CLIENT_DLL
|
|
ListenForGameEvent( "client_disconnect" );
|
|
ListenForGameEvent( "client_beginconnect" );
|
|
steamworks_sessionid_server.InstallChangeCallback( ServerSessionIDChangeCallback );
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Event handler for gathering basic info as well as ending sessions.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::FireGameEvent( IGameEvent *event )
|
|
{
|
|
if ( !event )
|
|
{
|
|
return;
|
|
}
|
|
|
|
const char *pEventName = event->GetName();
|
|
if ( FStrEq( "hostname_changed", pEventName ) )
|
|
{
|
|
const char *pzHostname = event->GetString( "hostname" );
|
|
if ( pzHostname )
|
|
{
|
|
V_strncpy( m_pzHostName, pzHostname, sizeof( m_pzHostName ) );
|
|
}
|
|
else
|
|
{
|
|
V_strncpy( m_pzHostName, "No Host Name", sizeof( m_pzHostName ) );
|
|
}
|
|
}
|
|
else if ( FStrEq( "server_spawn", pEventName ) )
|
|
{
|
|
|
|
#if 0 // the next three disabled if()'s are in the latest l4d2 branch, I'm not sure if they should be brought over
|
|
if ( !m_pzServerIP[0] )
|
|
#endif
|
|
{
|
|
const char *pzAddress = event->GetString( "address" );
|
|
if ( pzAddress )
|
|
{
|
|
V_snprintf( m_pzServerIP, ARRAYSIZE(m_pzServerIP), "%s:%d", pzAddress, event->GetInt( "port" ) );
|
|
ServerAddressToInt();
|
|
}
|
|
else
|
|
{
|
|
V_strncpy( m_pzServerIP, "No Server Address", sizeof( m_pzServerIP ) );
|
|
m_iServerIP = 0;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
if ( !m_pzHostName[0] )
|
|
#endif
|
|
{
|
|
const char *pzHostname = event->GetString( "hostname" );
|
|
if ( pzHostname )
|
|
{
|
|
V_strncpy( m_pzHostName, pzHostname, sizeof( m_pzHostName ) );
|
|
}
|
|
else
|
|
{
|
|
V_strncpy( m_pzHostName, "No Host Name", sizeof( m_pzHostName ) );
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
if ( !m_pzMapStart[0] )
|
|
#endif
|
|
{
|
|
const char *pzMapName = event->GetString( "mapname" );
|
|
if ( pzMapName )
|
|
{
|
|
V_strncpy( m_pzMapStart, pzMapName, sizeof( m_pzMapStart ) );
|
|
}
|
|
else
|
|
{
|
|
V_strncpy( m_pzMapStart, "No Map Name", sizeof( m_pzMapStart ) );
|
|
}
|
|
}
|
|
|
|
m_bPassword = event->GetBool( "password" );
|
|
}
|
|
#ifdef CLIENT_DLL
|
|
// Started attempting connection to gameserver
|
|
else if ( FStrEq( "client_beginconnect", pEventName ) )
|
|
{
|
|
const char *pszSource = event->GetString( "source", "" );
|
|
m_nClientJoinMethod = k_ClientJoinMethod_Unknown;
|
|
if ( pszSource[0] != '\0' )
|
|
{
|
|
if ( FStrEq( "listenserver", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ListenServer;
|
|
else if ( FStrEq( "serverbrowser", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowser_UNKNOWN;
|
|
else if ( FStrEq( "serverbrowser_internet", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserInternet;
|
|
else if ( FStrEq( "serverbrowser_friends", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserFriends;
|
|
else if ( FStrEq( "serverbrowser_favorites", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserFavorites;
|
|
else if ( FStrEq( "serverbrowser_history", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserHistory;
|
|
else if ( FStrEq( "serverbrowser_lan", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserLAN;
|
|
else if ( FStrEq( "serverbrowser_spectator", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserSpectator;
|
|
else if ( FStrEq( "steam", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_Steam;
|
|
else if ( FStrEq( "matchmaking", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_Matchmaking;
|
|
else if ( FStrEq( "coaching", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_Coaching;
|
|
else if ( FStrEq( "redirect", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_Redirect;
|
|
else if ( sscanf( pszSource, "quickplay_%d", &m_nClientJoinMethod ) == 1 )
|
|
Assert( m_nClientJoinMethod > 0 );
|
|
else
|
|
Warning("Unrecognized client_beginconnect event 'source' argument: '%s'\n", pszSource );
|
|
}
|
|
}
|
|
else if ( FStrEq( "client_disconnect", pEventName ) )
|
|
{
|
|
ClientDisconnect();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets the server session ID but ONLY if it's not 0. We are using this to avoid a race
|
|
// condition where a server sends their session stats before a client does, thereby,
|
|
// resetting the client's server session ID to 0.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::SetServerSessionID( uint64 serverSessionID )
|
|
{
|
|
if ( !serverSessionID )
|
|
return;
|
|
|
|
if ( serverSessionID != m_ActiveSession.m_ServerSessionID )
|
|
{
|
|
m_ActiveSession.m_ServerSessionID = serverSessionID;
|
|
m_ActiveSession.m_ConnectTime = GetTimeSinceEpoch();
|
|
m_ActiveSession.m_DisconnectTime = 0;
|
|
|
|
m_iServerConnectCount++;
|
|
}
|
|
|
|
m_ServerSessionID = serverSessionID;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Writes the disconnect time to the current server session entry.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::ClientDisconnect()
|
|
{
|
|
|
|
// Save client join method, reset it to make sure it gets set properly
|
|
// next time and we don't just reuse the current method
|
|
int nClientJoinMethod = m_nClientJoinMethod;
|
|
m_nClientJoinMethod = k_ClientJoinMethod_Unknown;
|
|
|
|
if ( m_ActiveSession.m_ServerSessionID == 0 )
|
|
return;
|
|
|
|
m_SteamWorksInterface = GetInterface();
|
|
if ( !m_SteamWorksInterface )
|
|
return;
|
|
|
|
if ( !IsCollectingAnyData() )
|
|
return;
|
|
|
|
uint64 ulRowID = 0;
|
|
m_SteamWorksInterface->AddNewRow( &ulRowID, m_SessionID, "ClientSessionLookup" );
|
|
WriteInt64ToTable( m_SessionID, ulRowID, "SessionID" );
|
|
WriteInt64ToTable( m_ActiveSession.m_ServerSessionID, ulRowID, "ServerSessionID" );
|
|
WriteIntToTable( m_ActiveSession.m_ConnectTime, ulRowID, "ConnectTime" );
|
|
WriteIntToTable( GetTimeSinceEpoch(), ulRowID, "DisconnectTime" );
|
|
WriteIntToTable( nClientJoinMethod, ulRowID, "ClientJoinMethod" );
|
|
m_SteamWorksInterface->CommitRow( ulRowID );
|
|
|
|
m_ActiveSession.Reset();
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when the level shuts down.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::LevelShutdown()
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
ClearServerSessionID();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Requests a session ID from steam.
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::RequestSessionID()
|
|
{
|
|
// If we have disabled steam works game stats, don't request ids.
|
|
if ( steamworks_stats_disable )
|
|
{
|
|
DevMsg( "Steamworks Stats: No stats collection because steamworks_stats_disable is set to 1.\n" );
|
|
return k_EResultAccessDenied;
|
|
}
|
|
|
|
if ( developer.GetInt() == 1 )
|
|
{
|
|
// DevMsg( "Steamworks Stats: No stats collection because developer is set to 1.\n" );
|
|
// return k_EResultAccessDenied;
|
|
}
|
|
|
|
// Do not continue if we already have a session id.
|
|
// We must end a session before we can begin a new one.
|
|
if ( m_SessionID )
|
|
{
|
|
return k_EResultOK;
|
|
}
|
|
|
|
// Do not continue if we are waiting a server response for this session request.
|
|
if ( m_SessionIDRequestPending )
|
|
{
|
|
return k_EResultPending;
|
|
}
|
|
|
|
// If a request is unsent, it will be sent as soon as the steam API is available.
|
|
m_SessionIDRequestUnsent = true;
|
|
|
|
// Turn on polling.
|
|
m_ServiceTicking = true;
|
|
|
|
// If we can't use Steam at the moment, we need to wait.
|
|
if ( !AccessToSteamAPI() )
|
|
{
|
|
return k_EResultNoConnection;
|
|
}
|
|
|
|
m_SteamWorksInterface = GetInterface();
|
|
if ( m_SteamWorksInterface )
|
|
{
|
|
int accountType = k_EGameStatsAccountType_Steam;
|
|
#ifdef GAME_DLL
|
|
if ( engine->IsDedicatedServer() )
|
|
{
|
|
accountType = k_EGameStatsAccountType_SteamGameServer;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
DevMsg( "Steamworks Stats: Requesting CLIENT session id.\n" );
|
|
#else
|
|
DevMsg( "Steamworks Stats: Requesting SERVER session id.\n" );
|
|
#endif
|
|
|
|
m_SessionIDRequestUnsent = false;
|
|
m_SessionIDRequestPending = true;
|
|
|
|
// This initiates a callback that will get us our session ID.
|
|
// Callback: Steam_OnSteamSessionInfoIssued
|
|
m_SteamWorksInterface->GetNewSession( accountType, m_UserID, m_iAppID, GetTimeSinceEpoch() );
|
|
}
|
|
|
|
return k_EResultOK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Clears our session id and session id convar.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::ClearSessionID()
|
|
{
|
|
m_SessionID = 0;
|
|
steamworks_sessionid_server.SetValue( 0 );
|
|
}
|
|
|
|
#ifndef NO_STEAM
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: The steam callback used to get our session IDs.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoIssued( GameStatsSessionIssued_t *pGameStatsSessionInfo )
|
|
{
|
|
if ( !m_SessionIDRequestPending )
|
|
{
|
|
// There is no request outstanding.
|
|
return;
|
|
}
|
|
|
|
m_SessionIDRequestPending = false;
|
|
|
|
if ( !pGameStatsSessionInfo )
|
|
{
|
|
// Empty callback!
|
|
ClearSessionID();
|
|
return;
|
|
}
|
|
|
|
if ( pGameStatsSessionInfo->m_eResult != k_EResultOK )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
DevMsg( "Steamworks Stats: CLIENT session id not available.\n" );
|
|
#else
|
|
DevMsg( "Steamworks Stats: SERVER session id not available.\n" );
|
|
#endif
|
|
m_SessionIDRequestUnsent = true; // Queue to re-request a session ID.
|
|
ClearSessionID();
|
|
return;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
DevMsg( "Steamworks Stats: Received CLIENT session id: %llu\n", pGameStatsSessionInfo->m_ulSessionID );
|
|
#else
|
|
DevMsg( "Steamworks Stats: Received SERVER session id: %llu\n", pGameStatsSessionInfo->m_ulSessionID );
|
|
#endif
|
|
|
|
m_StartTime = GetTimeSinceEpoch();
|
|
|
|
m_SessionID = pGameStatsSessionInfo->m_ulSessionID;
|
|
m_bCollectingAny = pGameStatsSessionInfo->m_bCollectingAny;
|
|
m_bCollectingDetails = pGameStatsSessionInfo->m_bCollectingDetails;
|
|
|
|
char sessionIDString[ 32 ];
|
|
Q_snprintf( sessionIDString, sizeof( sessionIDString ), "%llu", m_SessionID );
|
|
|
|
#ifdef CLIENT_DLL
|
|
steamworks_sessionid_client.SetValue( sessionIDString );
|
|
m_FriendCntInGame = GetFriendCountInGame();
|
|
m_HumanCntInGame = GetHumanCountInGame();
|
|
#else
|
|
steamworks_sessionid_server.SetValue( sessionIDString );
|
|
#endif
|
|
|
|
UploadCvars();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: The steam callback to notify us that we've submitted stats.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoClosed( GameStatsSessionClosed_t *pGameStatsSessionInfo )
|
|
{
|
|
if ( !m_UploadedStats )
|
|
return;
|
|
|
|
m_UploadedStats = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Per frame think. Used to periodically check if we have queued operations.
|
|
// For example: we may request a session id before steam is ready.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::FrameUpdatePostEntityThink()
|
|
{
|
|
if ( !m_ServiceTicking )
|
|
return;
|
|
|
|
if ( gpGlobals->realtime - m_LastServiceTick < 3 )
|
|
return;
|
|
m_LastServiceTick = gpGlobals->realtime;
|
|
|
|
if ( !AccessToSteamAPI() )
|
|
return;
|
|
|
|
// Try to resend our request.
|
|
if ( m_SessionIDRequestUnsent )
|
|
{
|
|
RequestSessionID();
|
|
return;
|
|
}
|
|
|
|
// If we had nothing to resend, stop ticking.
|
|
m_ServiceTicking = false;
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Opens a session: requests the session id, etc.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::StartSession()
|
|
{
|
|
RequestSessionID();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Completes a session for the given type.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::EndSession()
|
|
{
|
|
m_EndTime = GetTimeSinceEpoch();
|
|
|
|
if ( !m_SessionID )
|
|
{
|
|
// No session to end.
|
|
return;
|
|
}
|
|
|
|
m_SteamWorksInterface = GetInterface();
|
|
if ( m_SteamWorksInterface )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
DevMsg( "Steamworks Stats: Ending CLIENT session id: %llu\n", m_SessionID );
|
|
#else
|
|
DevMsg( "Steamworks Stats: Ending SERVER session id: %llu\n", m_SessionID );
|
|
#endif
|
|
|
|
// Flush any stats that haven't been sent yet.
|
|
FlushStats();
|
|
|
|
// Always need some data in the session row or we'll crash steam.
|
|
WriteSessionRow();
|
|
m_SteamWorksInterface->EndSession( m_SessionID, m_EndTime, 0 );
|
|
Reset();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Flush any unsent rows.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::FlushStats()
|
|
{
|
|
for ( int i=0; i<m_StatsToSend.Count(); ++i )
|
|
{
|
|
ParseKeyValuesAndSendStats( m_StatsToSend[i] );
|
|
m_StatsToSend[i]->deleteThis();
|
|
}
|
|
|
|
m_StatsToSend.RemoveAll();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Uploads any end of session rows.
|
|
//-----------------------------------------------------------------------------
|
|
void CSteamWorksGameStatsUploader::WriteSessionRow()
|
|
{
|
|
m_SteamWorksInterface = GetInterface();
|
|
if ( !m_SteamWorksInterface )
|
|
return;
|
|
|
|
// The Session row is common to both client and server sessions.
|
|
// It enables keying to other tables.
|
|
|
|
// Don't send SessionID. It's provided by steam. Same with the account's id and type.
|
|
// m_SteamWorksInterface->AddSessionAttributeInt64( m_SessionID, "SessionID", m_SessionID );
|
|
|
|
#ifdef CLIENT_DLL
|
|
// m_SteamWorksInterface->AddSessionAttributeInt64( m_SessionID, "ServerSessionID", m_ServerSessionID );
|
|
#endif
|
|
|
|
m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "AppID", m_iAppID );
|
|
m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "StartTime", m_StartTime );
|
|
m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "EndTime", m_EndTime );
|
|
|
|
#ifndef CLIENT_DLL
|
|
m_SteamWorksInterface->AddSessionAttributeString( m_SessionID, "ServerIP", m_pzServerIP );
|
|
m_SteamWorksInterface->AddSessionAttributeString( m_SessionID, "ServerName", m_pzHostName );
|
|
m_SteamWorksInterface->AddSessionAttributeString( m_SessionID, "StartMap", m_pzMapStart );
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
// TODO CAB: Need to get these added into the clientsessionlookup table
|
|
m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "PlayersInGame", m_HumanCntInGame );
|
|
m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "FriendsInGame", m_FriendCntInGame );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// DATA ACCESS UTILITIES
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Verifies that we have a valid interface and will attempt to obtain a new one if we don't.
|
|
//-----------------------------------------------------------------------------
|
|
bool CSteamWorksGameStatsUploader::VerifyInterface( void )
|
|
{
|
|
if ( !m_SteamWorksInterface )
|
|
{
|
|
m_SteamWorksInterface = GetInterface();
|
|
if ( !m_SteamWorksInterface )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Wrapper function to write an int32 to a table given the row name
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::WriteIntToTable( const int value, uint64 iTableID, const char *pzRow )
|
|
{
|
|
if ( !VerifyInterface() )
|
|
return k_EResultNoConnection;
|
|
|
|
return m_SteamWorksInterface->AddRowAttributeInt( iTableID, pzRow, value );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Wrapper function to write an int64 to a table given the row name
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::WriteInt64ToTable( const uint64 value, uint64 iTableID, const char *pzRow )
|
|
{
|
|
if ( !VerifyInterface() )
|
|
return k_EResultNoConnection;
|
|
|
|
return m_SteamWorksInterface->AddRowAttributeInt64( iTableID, pzRow, value );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Wrapper function to write an float to a table given the row name
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::WriteFloatToTable( const float value, uint64 iTableID, const char *pzRow )
|
|
{
|
|
if ( !VerifyInterface() )
|
|
return k_EResultNoConnection;
|
|
|
|
return m_SteamWorksInterface->AddRowAttributeFloat( iTableID, pzRow, value );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Wrapper function to write an string to a table given the row name
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::WriteStringToTable( const char *value, uint64 iTableID, const char *pzRow )
|
|
{
|
|
if ( !VerifyInterface() )
|
|
return k_EResultNoConnection;
|
|
|
|
return m_SteamWorksInterface->AddRowAtributeString( iTableID, pzRow, value );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Wrapper function to search a KeyValues for a value with the given keyName and add the result to the
|
|
// row. If the key isn't present, return ResultNoMatch to indicate such.
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::WriteOptionalFloatToTable( KeyValues *pKV, const char* keyName, uint64 iTableID, const char *pzRow )
|
|
{
|
|
if ( !VerifyInterface() )
|
|
return k_EResultNoConnection;
|
|
|
|
KeyValues* key = pKV->FindKey( keyName );
|
|
if ( !key )
|
|
return k_EResultNoMatch;
|
|
|
|
float value = key->GetFloat();
|
|
|
|
return m_SteamWorksInterface->AddRowAttributeFloat( iTableID, pzRow, value );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Wrapper function to search a KeyValues for a value with the given keyName and add the result to the
|
|
// row. If the key isn't present, return ResultNoMatch to indicate such.
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::WriteOptionalIntToTable( KeyValues *pKV, const char* keyName, uint64 iTableID, const char *pzRow )
|
|
{
|
|
if ( !VerifyInterface() )
|
|
return k_EResultNoConnection;
|
|
|
|
KeyValues* key = pKV->FindKey( keyName );
|
|
if ( !key )
|
|
return k_EResultNoMatch;
|
|
|
|
int value = key->GetInt();
|
|
|
|
return m_SteamWorksInterface->AddRowAttributeInt( iTableID, pzRow, value );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// STEAM ACCESS UTILITIES
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines if the system can connect to steam
|
|
//-----------------------------------------------------------------------------
|
|
bool CSteamWorksGameStatsUploader::AccessToSteamAPI( void )
|
|
{
|
|
#ifdef GAME_DLL
|
|
return ( steamgameserverapicontext && steamgameserverapicontext->SteamGameServer() && g_pSteamClientGameServer && steamgameserverapicontext->SteamGameServerUtils() );
|
|
#elif CLIENT_DLL
|
|
return ( steamapicontext && steamapicontext->SteamUser() && steamapicontext->SteamUser()->BLoggedOn() && steamapicontext->SteamFriends() && steamapicontext->SteamMatchmaking() );
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: There's no guarantee that your interface pointer will persist across level transitions,
|
|
// so this function will update your interface.
|
|
//-----------------------------------------------------------------------------
|
|
ISteamGameStats* CSteamWorksGameStatsUploader::GetInterface( void )
|
|
{
|
|
HSteamUser hSteamUser = 0;
|
|
HSteamPipe hSteamPipe = 0;
|
|
|
|
#ifdef GAME_DLL
|
|
if ( steamgameserverapicontext && steamgameserverapicontext->SteamGameServer() && steamgameserverapicontext->SteamGameServerUtils() )
|
|
{
|
|
m_UserID = steamgameserverapicontext->SteamGameServer()->GetSteamID().ConvertToUint64();
|
|
m_iAppID = steamgameserverapicontext->SteamGameServerUtils()->GetAppID();
|
|
hSteamUser = SteamGameServer_GetHSteamUser();
|
|
hSteamPipe = SteamGameServer_GetHSteamPipe();
|
|
}
|
|
|
|
// Now let's get the interface for dedicated servers
|
|
if ( g_pSteamClientGameServer && engine && (/*engine->IsDedicatedServerForXbox() ||*/ engine->IsDedicatedServer()) )
|
|
{
|
|
return (ISteamGameStats*)g_pSteamClientGameServer->GetISteamGenericInterface( hSteamUser, hSteamPipe, STEAMGAMESTATS_INTERFACE_VERSION );
|
|
}
|
|
#elif CLIENT_DLL
|
|
if ( steamapicontext && steamapicontext->SteamUser() && steamapicontext->SteamUtils() )
|
|
{
|
|
m_UserID = steamapicontext->SteamUser()->GetSteamID().ConvertToUint64();
|
|
m_iAppID = steamapicontext->SteamUtils()->GetAppID();
|
|
hSteamUser = steamapicontext->SteamUser()->GetHSteamUser();
|
|
hSteamPipe = GetHSteamPipe();
|
|
}
|
|
#endif
|
|
|
|
// Listen server have access to SteamClient
|
|
if ( SteamClient() )
|
|
{
|
|
return (ISteamGameStats*)SteamClient()->GetISteamGenericInterface( hSteamUser, hSteamPipe, STEAMGAMESTATS_INTERFACE_VERSION );
|
|
}
|
|
// If we haven't returned already, then we can't get access to the interface
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Creates a table from the KeyValue file. Do NOT send nested KeyValue objects into this function!
|
|
//-----------------------------------------------------------------------------
|
|
EResult CSteamWorksGameStatsUploader::AddStatsForUpload( KeyValues *pKV, bool bSendImmediately )
|
|
{
|
|
// If the stat system is disabled, then don't accept the keyvalue
|
|
if ( steamworks_stats_disable )
|
|
{
|
|
if ( pKV )
|
|
{
|
|
pKV->deleteThis();
|
|
}
|
|
|
|
return k_EResultNoConnection;
|
|
}
|
|
|
|
if ( pKV )
|
|
{
|
|
// Do we want to immediately upload the stats?
|
|
if ( bSendImmediately && steamworks_immediate_upload )
|
|
{
|
|
ParseKeyValuesAndSendStats( pKV );
|
|
pKV->deleteThis();
|
|
}
|
|
else
|
|
{
|
|
m_StatsToSend.AddToTail( pKV );
|
|
}
|
|
return k_EResultOK;
|
|
}
|
|
|
|
return k_EResultFail;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parses all the keyvalue files we've been sent and creates tables from them and uploads them
|
|
//-----------------------------------------------------------------------------
|
|
double g_rowCommitTime = 0.0f;
|
|
double g_rowWriteTime = 0.0f;
|
|
EResult CSteamWorksGameStatsUploader::ParseKeyValuesAndSendStats( KeyValues *pKV, bool bIncludeClientsServerSessionID )
|
|
{
|
|
if ( !pKV )
|
|
{
|
|
return k_EResultFail;
|
|
}
|
|
|
|
if ( !IsCollectingAnyData() )
|
|
{
|
|
return k_EResultFail;
|
|
}
|
|
|
|
// Refresh the interface in case steam has unloaded
|
|
m_SteamWorksInterface = GetInterface();
|
|
|
|
if ( !m_SteamWorksInterface )
|
|
{
|
|
DevMsg( "WARNING: Attempted to send a steamworks gamestats row when the steamworks interface was not available!" );
|
|
return k_EResultNoConnection;
|
|
}
|
|
|
|
const char *pzTable = pKV->GetName();
|
|
/*
|
|
if ( steamworks_show_uploads )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
// DevMsg( "Client submitting row (%s).\n", pzTable );
|
|
#elif GAME_DLL
|
|
// DevMsg( "Server submitting row (%s).\n", pzTable );
|
|
#endif
|
|
}
|
|
*/
|
|
uint64 iTableID = 0;
|
|
m_SteamWorksInterface->AddNewRow( &iTableID, m_SessionID, pzTable );
|
|
|
|
if ( !iTableID )
|
|
{
|
|
return k_EResultFail;
|
|
}
|
|
|
|
WriteInt64ToTable( m_SessionID, iTableID, "SessionID" );
|
|
#ifdef CLIENT_DLL
|
|
if ( bIncludeClientsServerSessionID )
|
|
{
|
|
WriteInt64ToTable( m_ServerSessionID, iTableID, "ServerSessionID" );
|
|
}
|
|
#endif
|
|
|
|
// Now we need to loop over all the keys in pKV and add the name and value
|
|
for ( KeyValues *pData = pKV->GetFirstSubKey() ; pData != NULL ; pData = pData->GetNextKey() )
|
|
{
|
|
const char *name = pData->GetName();
|
|
|
|
CFastTimer writeTimer;
|
|
writeTimer.Start();
|
|
switch ( pData->GetDataType() )
|
|
{
|
|
case KeyValues::TYPE_STRING: WriteStringToTable( pKV->GetString( name ), iTableID, name );
|
|
break;
|
|
case KeyValues::TYPE_INT: WriteIntToTable( pKV->GetInt( name ), iTableID, name );
|
|
break;
|
|
case KeyValues::TYPE_FLOAT: WriteFloatToTable( pKV->GetFloat( name ), iTableID, name );
|
|
break;
|
|
case KeyValues::TYPE_UINT64: WriteInt64ToTable( pKV->GetUint64( name ), iTableID, name );
|
|
break;
|
|
};
|
|
|
|
writeTimer.End();
|
|
g_rowWriteTime += writeTimer.GetDuration().GetMillisecondsF();
|
|
}
|
|
|
|
CFastTimer commitTimer;
|
|
commitTimer.Start();
|
|
EResult res = m_SteamWorksInterface->CommitRow( iTableID );
|
|
commitTimer.End();
|
|
g_rowCommitTime += commitTimer.GetDuration().GetMillisecondsF();
|
|
|
|
if ( res != k_EResultOK )
|
|
{
|
|
AssertMsg( false, "Failed To Submit table %s", pzTable );
|
|
}
|
|
return res;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reports client's perf data at the end of a client session.
|
|
//---------------------------------`--------------------------------------------
|
|
void CSteamWorksGameStatsUploader::AddClientPerfData( KeyValues *pKV )
|
|
{
|
|
m_SteamWorksInterface = GetInterface();
|
|
if ( !m_SteamWorksInterface )
|
|
return;
|
|
|
|
if ( !IsCollectingAnyData() )
|
|
return;
|
|
|
|
RTime32 currentTime = GetTimeSinceEpoch();
|
|
|
|
uint64 uSessionID = m_SessionID;
|
|
uint64 ulRowID = 0;
|
|
|
|
m_SteamWorksInterface->AddNewRow( &ulRowID, uSessionID, "TF2ClientPerfData" );
|
|
|
|
if ( !ulRowID )
|
|
return;
|
|
|
|
WriteInt64ToTable( m_SessionID, ulRowID, "SessionID" );
|
|
// WriteInt64ToTable( m_ServerSessionID, ulRowID, "ServerSessionID" );
|
|
WriteIntToTable( currentTime, ulRowID, "TimeSubmitted" );
|
|
WriteStringToTable( pKV->GetString( "Map/mapname" ), ulRowID, "MapID");
|
|
WriteIntToTable( pKV->GetInt( "appid" ), ulRowID, "AppID");
|
|
WriteFloatToTable( pKV->GetFloat( "Map/perfdata/AvgFPS" ), ulRowID, "AvgFPS");
|
|
WriteFloatToTable( pKV->GetFloat( "map/perfdata/MinFPS" ), ulRowID, "MinFPS");
|
|
WriteFloatToTable( pKV->GetFloat( "Map/perfdata/MaxFPS" ), ulRowID, "MaxFPS");
|
|
WriteFloatToTable( pKV->GetFloat( "Map/perfdata/StdDevFPS" ), ulRowID, "StdDevFPS");
|
|
|
|
WriteStringToTable( pKV->GetString( "CPUID" ), ulRowID, "CPUID");
|
|
WriteFloatToTable( pKV->GetFloat( "CPUGhz" ), ulRowID, "CPUGhz");
|
|
WriteInt64ToTable( pKV->GetUint64( "CPUModel" ), ulRowID, "CPUModel" );
|
|
WriteInt64ToTable( pKV->GetUint64( "CPUFeatures0" ), ulRowID, "CPUFeatures0" );
|
|
WriteInt64ToTable( pKV->GetUint64( "CPUFeatures1" ), ulRowID, "CPUFeatures1" );
|
|
WriteInt64ToTable( pKV->GetUint64( "CPUFeatures2" ), ulRowID, "CPUFeatures2" );
|
|
|
|
WriteIntToTable( pKV->GetInt( "NumCores" ), ulRowID, "NumCores");
|
|
WriteStringToTable( pKV->GetString( "GPUDrv" ), ulRowID, "GPUDrv");
|
|
WriteIntToTable( pKV->GetInt( "GPUVendor" ), ulRowID, "GPUVendor");
|
|
WriteIntToTable( pKV->GetInt( "GPUDeviceID" ), ulRowID, "GPUDeviceID");
|
|
WriteIntToTable( pKV->GetInt( "GPUDriverVersion" ), ulRowID, "GPUDriverVersion");
|
|
WriteIntToTable( pKV->GetInt( "DxLvl" ), ulRowID, "DxLvl");
|
|
WriteIntToTable( pKV->GetBool( "Map/Windowed" ), ulRowID, "Windowed");
|
|
// WriteIntToTable( pKV->GetBool( "Map/WindowedNoBorder" ), ulRowID, "WindowedNoBorder");
|
|
WriteIntToTable( pKV->GetInt( "width" ), ulRowID, "Width");
|
|
WriteIntToTable( pKV->GetInt( "height" ), ulRowID, "Height");
|
|
WriteIntToTable( pKV->GetInt( "Map/UsedVoice" ), ulRowID, "Usedvoiced");
|
|
WriteStringToTable( pKV->GetString( "Map/Language" ), ulRowID, "Language");
|
|
WriteFloatToTable( pKV->GetFloat( "Map/perfdata/AvgServerPing" ), ulRowID, "AvgServerPing");
|
|
WriteIntToTable( pKV->GetInt( "Map/Caption" ), ulRowID, "IsCaptioned");
|
|
WriteIntToTable( pKV->GetInt( "IsPC" ), ulRowID, "IsPC");
|
|
WriteIntToTable( pKV->GetBool( "Windowed" ), ulRowID, "Windowed");
|
|
WriteIntToTable( pKV->GetInt( "Map/Cheats" ), ulRowID, "Cheats");
|
|
WriteIntToTable( pKV->GetInt( "Map/MapTime" ), ulRowID, "MapTime");
|
|
WriteIntToTable( pKV->GetInt( "MaxDxLevel" ), ulRowID, "MaxDxLvl" );
|
|
|
|
WriteIntToTable( pKV->GetBool( "Map/SteamControllerActive" ), ulRowID, "UsingController" );
|
|
|
|
// Loading time information
|
|
|
|
// If a player exits a map and then exits the game, LoadTimeMap will not be in the key list the second time
|
|
// (when we are sending for app shutdown), so only write it if it's here.
|
|
WriteOptionalFloatToTable( pKV, "Map/LoadTimeMap", ulRowID, "SessionLoadTime");
|
|
|
|
// Main menu load time is only added once, even if we play many games in a row. This prevents a stats bias for
|
|
// people who replay over and over again.
|
|
WriteOptionalFloatToTable( pKV, "Map/LoadTimeMainMenu", ulRowID, "MainmenuLoadTime");
|
|
|
|
m_SteamWorksInterface->CommitRow( ulRowID );
|
|
}
|
|
#endif
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
/**
|
|
* Purpose: Calculates the number of humans in the game
|
|
*/
|
|
int CSteamWorksGameStatsUploader::GetHumanCountInGame()
|
|
{
|
|
int iHumansInGame = 0;
|
|
// TODO: Need to add server/client code to count the number of connected humans.
|
|
return iHumansInGame;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-------------------------------------------------------------------------------------------------
|
|
/**
|
|
* Purpose: Calculates the number of friends in the game
|
|
*/
|
|
int CSteamWorksGameStatsUploader::GetFriendCountInGame()
|
|
{
|
|
// Get the number of steam friends in game
|
|
int friendsInOurGame = 0;
|
|
|
|
|
|
// Do we have access to the steam API?
|
|
if ( AccessToSteamAPI() )
|
|
{
|
|
CSteamID m_SteamID = steamapicontext->SteamUser()->GetSteamID();
|
|
// Let's get our game info so we can use that to test if our friends are connected to the same game as us
|
|
FriendGameInfo_t myGameInfo;
|
|
steamapicontext->SteamFriends()->GetFriendGamePlayed( m_SteamID, &myGameInfo );
|
|
CSteamID myLobby = steamapicontext->SteamMatchmaking()->GetLobbyOwner( myGameInfo.m_steamIDLobby );
|
|
|
|
// This returns the number of friends that are playing a game
|
|
int activeFriendCnt = steamapicontext->SteamFriends()->GetFriendCount( k_EFriendFlagImmediate );
|
|
|
|
// Check each active friend's lobby ID to see if they are in our game
|
|
for ( int h=0; h< activeFriendCnt ; ++h )
|
|
{
|
|
FriendGameInfo_t friendInfo;
|
|
CSteamID friendID = steamapicontext->SteamFriends()->GetFriendByIndex( h, k_EFriendFlagImmediate );
|
|
|
|
if ( steamapicontext->SteamFriends()->GetFriendGamePlayed( friendID, &friendInfo ) )
|
|
{
|
|
// Does our friend have a valid lobby ID?
|
|
if ( friendInfo.m_gameID.IsValid() )
|
|
{
|
|
// Get our friend's lobby info
|
|
CSteamID friendLobby = steamapicontext->SteamMatchmaking()->GetLobbyOwner( friendInfo.m_steamIDLobby );
|
|
|
|
// Double check the validity of the friend lobby ID then check to see if they are in our game
|
|
if ( friendLobby.IsValid() && myLobby == friendLobby )
|
|
{
|
|
++friendsInOurGame;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return friendsInOurGame;
|
|
}
|
|
#endif
|
|
|
|
void CSteamWorksGameStatsUploader::ServerAddressToInt()
|
|
{
|
|
CUtlStringList IPs;
|
|
V_SplitString( m_pzServerIP, ".", IPs );
|
|
|
|
if ( IPs.Count() < 4 )
|
|
{
|
|
// Not an actual IP.
|
|
m_iServerIP = 0;
|
|
return;
|
|
}
|
|
|
|
byte ip[4];
|
|
m_iServerIP = 0;
|
|
for ( int i=0; i<IPs.Count() && i<4; ++i )
|
|
{
|
|
ip[i] = (byte) Q_atoi( IPs[i] );
|
|
}
|
|
m_iServerIP = (ip[0]<<24) + (ip[1]<<16) + (ip[2]<<8) + ip[3];
|
|
}
|
|
|