560 lines
18 KiB
C++
560 lines
18 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
|
|
#include "tf_wardata.h"
|
|
#include "gcsdk/enumutils.h"
|
|
#include "schemainitutils.h"
|
|
#ifdef CLIENT_DLL
|
|
#include "c_tf_player.h"
|
|
#endif
|
|
#ifdef GAME_DLL
|
|
#include "tf_player.h"
|
|
#endif
|
|
|
|
using namespace GCSDK;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get user's War Data by steamID and war ID. Returns NULL if it
|
|
// doesnt exist or if the war is inactive and bLoadEvenIfWarInactive
|
|
// is false. On the GC bLoadSOCacheIfNeeded will load the user's
|
|
// SOCache if needed in order to try and get their war data
|
|
//-----------------------------------------------------------------------------
|
|
CWarData* GetPlayerWarData( const CSteamID& steamID, war_definition_index_t warDefIndex, bool bLoadEvenIfWarInactive
|
|
#ifdef GC_DLL
|
|
, bool bLoadSOCacheIfNeeded
|
|
#endif
|
|
)
|
|
{
|
|
const CWarDefinition* pWarDef = GetItemSchema()->GetWarDefinitionByIndex( warDefIndex );
|
|
// If the war isn't active and we weren't told to ignore that, then return NULL
|
|
if ( !pWarDef || ( !bLoadEvenIfWarInactive && !pWarDef->IsActive() ) )
|
|
return NULL;
|
|
|
|
#ifdef GC_DLL
|
|
CGCSharedObjectCache *pSOCache = GGCBase()->FindSOCache( steamID );
|
|
|
|
// Load their SO cache if needed
|
|
if ( pSOCache == NULL && bLoadSOCacheIfNeeded )
|
|
{
|
|
pSOCache = GGCBase()->YieldingFindOrLoadSOCache( steamID );
|
|
}
|
|
#else
|
|
GCSDK::CGCClientSharedObjectCache *pSOCache = GCClientSystem()->GetSOCache( steamID );
|
|
#endif
|
|
|
|
if ( pSOCache )
|
|
{
|
|
auto *pTypeCache = pSOCache->FindTypeCache( CWarData::k_nTypeID );
|
|
if ( pTypeCache )
|
|
{
|
|
int nCount = pTypeCache->GetCount();
|
|
for( int i=0; i < nCount; ++i )
|
|
{
|
|
CWarData* pWarData = static_cast< CWarData* >( pTypeCache->GetObject( i ) );
|
|
if ( pWarData->Obj().war_id() == warDefIndex )
|
|
return pWarData;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
CWarData* GetLocalPlayerWarData( war_definition_index_t warDefIndex )
|
|
{
|
|
if ( !steamapicontext || !steamapicontext->SteamUser() )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return GetPlayerWarData( steamapicontext->SteamUser()->GetSteamID(), warDefIndex, true );
|
|
}
|
|
#endif
|
|
|
|
|
|
CWarDefinition::CWarDefinition()
|
|
: m_nDefIndex( INVALID_WAR_DEF_INDEX )
|
|
, m_pszLocalizedWarname( NULL )
|
|
, m_pszDefName( NULL )
|
|
, m_mapSides( DefLessFunc( SidesMap_t::KeyType_t ) )
|
|
, m_rtTimeEnd( 0 )
|
|
, m_rtTimeStart( 0 )
|
|
{}
|
|
|
|
bool CWarDefinition::BInitFromKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
|
|
{
|
|
m_nDefIndex = atoi( pKV->GetName() );
|
|
SCHEMA_INIT_CHECK( m_nDefIndex != INVALID_WAR_DEF_INDEX, "Missing 'war_id' for war def %s", pKV->GetName() );
|
|
|
|
m_pszDefName = pKV->GetString( "name" );
|
|
SCHEMA_INIT_CHECK( m_nDefIndex != INVALID_WAR_DEF_INDEX, "Missing 'name' for war def %s", pKV->GetName() );
|
|
|
|
const char *pszTime = pKV->GetString( "start_time", NULL );
|
|
SCHEMA_INIT_CHECK( pszTime != NULL, "war definition %s does not have 'start_time'", pKV->GetName() );
|
|
m_rtTimeStart = ( pszTime && pszTime[0] )
|
|
? CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszTime )
|
|
: RTime32(0);
|
|
|
|
pszTime = pKV->GetString( "end_time", NULL );
|
|
SCHEMA_INIT_CHECK( pszTime != NULL, "war definition %s does not have 'end_time'", pKV->GetName() );
|
|
m_rtTimeEnd = ( pszTime && pszTime[0] )
|
|
? CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszTime )
|
|
: RTime32(0);
|
|
|
|
KeyValues* pKVSidesBlock = pKV->FindKey( "sides" );
|
|
FOR_EACH_TRUE_SUBKEY( pKVSidesBlock, pKVSide )
|
|
{
|
|
auto& side = m_mapSides[m_mapSides.Insert( atoi( pKVSide->GetName() ) ) ];
|
|
side.BInitFromKV( pKV->GetName(), pKVSide, pVecErrors );
|
|
}
|
|
|
|
m_pszLocalizedWarname = pKV->GetString( "localized_name", NULL );
|
|
SCHEMA_INIT_CHECK( m_pszLocalizedWarname != NULL, "war definition %s does not have 'localized_name'", pKV->GetName() );
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
const CWarDefinition::CWarSideDefinition_t* CWarDefinition::GetSide( war_side_t nSide ) const
|
|
{
|
|
if ( IsValidSide( nSide ) )
|
|
{
|
|
SidesMap_t::IndexType_t idx = m_mapSides.Find( nSide );
|
|
if ( idx != m_mapSides.InvalidIndex() )
|
|
{
|
|
return &m_mapSides[ idx ];
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CWarDefinition::IsActive() const
|
|
{
|
|
Assert( m_rtTimeEnd != 0 );
|
|
Assert( m_rtTimeStart != 0 );
|
|
if ( m_rtTimeEnd == 0 || m_rtTimeStart == 0 )
|
|
return false;
|
|
|
|
return CRTime::RTime32TimeCur() > m_rtTimeStart && CRTime::RTime32TimeCur() < m_rtTimeEnd;
|
|
}
|
|
|
|
bool CWarDefinition::IsValidSide( war_side_t nSide ) const
|
|
{
|
|
FOR_EACH_MAP_FAST( m_mapSides, i )
|
|
{
|
|
if ( m_mapSides[i].m_nSideIndex == nSide )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CWarDefinition::CWarSideDefinition_t::BInitFromKV( const char* pszContainingWarName, KeyValues *pKVSide, CUtlVector<CUtlString> *pVecErrors )
|
|
{
|
|
m_nSideIndex = (war_side_t)atoi( pKVSide->GetName() );
|
|
SCHEMA_INIT_CHECK( m_nSideIndex != INVALID_WAR_SIDE, "war definition %s has invalid side index: %d", pszContainingWarName, m_nSideIndex );
|
|
|
|
m_pszLocalizedName = pKVSide->GetString( "localized_name", NULL );
|
|
SCHEMA_INIT_CHECK( m_pszLocalizedName != NULL, "war definition %s side %s missing side localization name", pszContainingWarName, pKVSide->GetName() );
|
|
|
|
m_pszLeaderboardName = pKVSide->GetString( "leaderboard_name", NULL );
|
|
SCHEMA_INIT_CHECK( m_pszLocalizedName != NULL, "war definition %s side %s missing side leaderboard name", pszContainingWarName, pKVSide->GetName() );
|
|
|
|
//TODO BRETT: Grab the leaderboard now?
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
CWarData::CWarData()
|
|
{
|
|
Obj().set_account_id( 0 );
|
|
Obj().set_war_id( INVALID_WAR_DEF_INDEX );
|
|
Obj().set_affiliation( INVALID_WAR_SIDE );
|
|
Obj().set_points_scored( 0 );
|
|
}
|
|
#ifdef GC
|
|
|
|
IMPLEMENT_CLASS_MEMPOOL( CWarData, 1000, UTLMEMORYPOOL_GROW_SLOW );
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
CWarData::CWarData( uint32 unAccountID, war_definition_index_t eWarID, war_side_t eSide )
|
|
{
|
|
Obj().set_account_id( unAccountID );
|
|
Obj().set_war_id( eWarID );
|
|
Obj().set_affiliation( eSide );
|
|
Obj().set_points_scored( 0 );
|
|
}
|
|
|
|
bool CWarData::BYieldingAddInsertToTransaction( GCSDK::CSQLAccess & sqlAccess )
|
|
{
|
|
CSchWarData schWarData;
|
|
WriteToRecord( &schWarData );
|
|
return CSchemaSharedObjectHelper::BYieldingAddInsertToTransaction( sqlAccess, &schWarData );
|
|
}
|
|
|
|
bool CWarData::BYieldingAddWriteToTransaction( GCSDK::CSQLAccess & sqlAccess, const CUtlVector< int > &fields )
|
|
{
|
|
CSchWarData schWarData;
|
|
WriteToRecord( &schWarData );
|
|
CColumnSet csDatabaseDirty( schWarData.GetPSchema()->GetRecordInfo() );
|
|
csDatabaseDirty.MakeEmpty();
|
|
FOR_EACH_VEC( fields, nField )
|
|
{
|
|
switch ( fields[nField] )
|
|
{
|
|
case CSOWarData::kAccountIdFieldNumber : csDatabaseDirty.BAddColumn( CSchWarData::k_iField_unAccountID ); break;
|
|
case CSOWarData::kWarIdFieldNumber : csDatabaseDirty.BAddColumn( CSchWarData::k_iField_unWarID ); break;
|
|
case CSOWarData::kAffiliationFieldNumber : csDatabaseDirty.BAddColumn( CSchWarData::k_iField_unAffiliation ); break;
|
|
case CSOWarData::kPointsScoredFieldNumber : csDatabaseDirty.BAddColumn( CSchWarData::k_iField_unPointsScored ); break;
|
|
default:
|
|
Assert( false );
|
|
}
|
|
}
|
|
return CSchemaSharedObjectHelper::BYieldingAddWriteToTransaction( sqlAccess, &schWarData, csDatabaseDirty );
|
|
}
|
|
|
|
bool CWarData::BYieldingAddRemoveToTransaction( GCSDK::CSQLAccess & sqlAccess )
|
|
{
|
|
CSchWarData schDuelSummary;
|
|
WriteToRecord( &schDuelSummary );
|
|
return CSchemaSharedObjectHelper::BYieldingAddRemoveToTransaction( sqlAccess, &schDuelSummary );
|
|
}
|
|
|
|
void CWarData::WriteToRecord( CSchWarData *pWarData ) const
|
|
{
|
|
pWarData->m_unAccountID = Obj().account_id();
|
|
pWarData->m_unWarID = Obj().war_id();
|
|
pWarData->m_unAffiliation = Obj().affiliation();
|
|
pWarData->m_unPointsScored = Obj().points_scored();
|
|
}
|
|
|
|
void CWarData::ReadFromRecord( const CSchWarData & warData )
|
|
{
|
|
Obj().set_account_id( warData.m_unAccountID );
|
|
Obj().set_war_id( warData.m_unWarID );
|
|
Obj().set_affiliation( warData.m_unAffiliation );
|
|
Obj().set_points_scored( warData.m_unPointsScored );
|
|
}
|
|
#endif
|
|
|
|
#if defined( CLIENT_DLL ) || defined( GC )
|
|
CTFWarGlobalDataHelper::CTFWarGlobalDataHelper()
|
|
: m_bInitialized( false )
|
|
, m_mapWarStats( DefLessFunc( WarStatsMap_t::KeyType_t ) )
|
|
#ifdef CLIENT_DLL
|
|
, m_flLastUpdateRequest( 0.f )
|
|
, m_flLastUpdated( 0.f )
|
|
#endif
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
Init();
|
|
#endif
|
|
}
|
|
|
|
CGCMsgGC_War_GlobalStatsResponse* CTFWarGlobalDataHelper::FindOrCreateWarData( war_definition_index_t nWarDef, bool bCreateIfDoesntExist )
|
|
{
|
|
const CWarDefinition* pWarDef = GetItemSchema()->GetWarDefinitionByIndex( nWarDef );
|
|
if ( !pWarDef )
|
|
return NULL;
|
|
|
|
if ( nWarDef == INVALID_WAR_DEF_INDEX )
|
|
return NULL;
|
|
|
|
CGCMsgGC_War_GlobalStatsResponse* pGlobalData = NULL;
|
|
|
|
auto waridx = m_mapWarStats.Find( (war_definition_index_t)nWarDef );
|
|
if ( waridx == m_mapWarStats.InvalidIndex() && bCreateIfDoesntExist )
|
|
{
|
|
waridx = m_mapWarStats.Insert( nWarDef );
|
|
m_mapWarStats[ waridx ].set_war_id( nWarDef );
|
|
}
|
|
|
|
if ( waridx != m_mapWarStats.InvalidIndex() )
|
|
{
|
|
pGlobalData = &m_mapWarStats[ waridx ];
|
|
}
|
|
|
|
return pGlobalData;
|
|
}
|
|
|
|
CGCMsgGC_War_GlobalStatsResponse_SideScore* CTFWarGlobalDataHelper::FindOrCreateWarDataSide( war_side_t nWarSide, war_definition_index_t nWarDef, bool bCreateIfDoesntExist )
|
|
{
|
|
// Make sure it's a valid war
|
|
const CWarDefinition* pWarDef = GetItemSchema()->GetWarDefinitionByIndex( nWarDef );
|
|
if ( !pWarDef )
|
|
return NULL;
|
|
|
|
// Valid side on a valid awr
|
|
if ( !pWarDef->IsValidSide( nWarSide ) )
|
|
return NULL;
|
|
|
|
// Find or create the war stats
|
|
CGCMsgGC_War_GlobalStatsResponse* pWarStats = FindOrCreateWarData( nWarDef, bCreateIfDoesntExist );
|
|
if ( !pWarStats )
|
|
return NULL;
|
|
|
|
// Find or create the side for the war
|
|
CGCMsgGC_War_GlobalStatsResponse_SideScore* pSide = NULL;
|
|
for( int i=0; i < pWarStats->side_scores_size(); ++i )
|
|
{
|
|
if ( pWarStats->side_scores( i ).side() == nWarSide )
|
|
{
|
|
pSide = pWarStats->mutable_side_scores( i );
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Didn't already exist. Create and initialize
|
|
if ( pSide == NULL && bCreateIfDoesntExist )
|
|
{
|
|
pSide = pWarStats->add_side_scores();
|
|
pSide->set_score( 0 );
|
|
pSide->set_side( nWarSide );
|
|
}
|
|
|
|
return pSide;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: On the GC, grab all records for the war and tally up the global stats
|
|
// On the client, send a request for what the GC has
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWarGlobalDataHelper::Init()
|
|
{
|
|
#ifdef GC
|
|
TSQLCmdStr sStatement;
|
|
const CColumnSet csCountsCount = CSET_FULL( CSchWarData );
|
|
BuildSelectStatementText( &sStatement, csCountsCount );
|
|
TSQLCmdStr sLoadQuery;
|
|
|
|
CSQLAccess sqlAccess;
|
|
if( !sqlAccess.BYieldingExecute( "CTFWarGlobalDataHelper::Init", sLoadQuery ) )
|
|
{
|
|
EmitError( SPEW_GC, __FUNCTION__": Failed to run load query!\n" );
|
|
return;
|
|
}
|
|
|
|
CUtlVector< CSchWarData > vecRecords;
|
|
if ( !sqlAccess.BYieldingReadRecordsWithQuery< CSchWarData >( &vecRecords, sStatement, csCountsCount ) )
|
|
{
|
|
EmitError( SPEW_GC, __FUNCTION__": Failed to read spy vs engy points!\n" );
|
|
return;
|
|
}
|
|
|
|
// Tally up points for each side
|
|
FOR_EACH_VEC( vecRecords, i )
|
|
{
|
|
const CSchWarData& record = vecRecords[i];
|
|
|
|
AddToSideScore( record.m_unWarID, record.m_unAffiliation, record.m_unPointsScored );
|
|
}
|
|
|
|
m_bInitialized = true;
|
|
#else
|
|
|
|
RequestUpdateGlobalStats();
|
|
RequestLeaderboard();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the stats. We're initialized once we do this.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWarGlobalDataHelper::SetGlobalStats( const CGCMsgGC_War_GlobalStatsResponse& newData )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
m_flLastUpdated = Plat_FloatTime();
|
|
#endif
|
|
m_bInitialized = true;
|
|
|
|
CGCMsgGC_War_GlobalStatsResponse* pExistingData = FindOrCreateWarData( newData.war_id(), true );
|
|
if ( pExistingData )
|
|
{
|
|
pExistingData->CopyFrom( newData );
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "global_war_data_updated" );
|
|
if ( event )
|
|
{
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void CTFWarGlobalDataHelper::AddToSideScore( war_definition_index_t nWar, war_side_t nSide, uint32 nValue )
|
|
{
|
|
Assert( nWar != INVALID_WAR_DEF_INDEX );
|
|
Assert( nSide != INVALID_WAR_SIDE );
|
|
|
|
CGCMsgGC_War_GlobalStatsResponse_SideScore* pSide = FindOrCreateWarDataSide( nSide, nWar, true );
|
|
if ( pSide )
|
|
{
|
|
pSide->set_score( pSide->score() + nValue );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Grab the Spy stats. Request an update if we're on the client and stale
|
|
//-----------------------------------------------------------------------------
|
|
uint64 CTFWarGlobalDataHelper::GetGlobalSideScore( war_definition_index_t nWar, war_side_t nSide )
|
|
{
|
|
Assert( nWar != INVALID_WAR_DEF_INDEX );
|
|
Assert( nSide != INVALID_WAR_SIDE );
|
|
|
|
#ifdef CLIENT_DLL
|
|
CheckGlobalStatsStaleness();
|
|
#endif
|
|
|
|
CGCMsgGC_War_GlobalStatsResponse_SideScore* pSide = FindOrCreateWarDataSide( nSide, nWar, true );
|
|
if ( pSide )
|
|
{
|
|
return pSide->score();
|
|
}
|
|
|
|
Assert( false );
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Ask the GC for the global stats.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWarGlobalDataHelper::RequestUpdateGlobalStats()
|
|
{
|
|
// Ask for new war stats
|
|
GCSDK::CProtoBufMsg<CGCMsgGC_War_RequestGlobalStats> msg( k_EMsgGC_War_RequestGlobalStats );
|
|
msg.Body().set_war_id( PYRO_VS_HEAVY_WAR_DEF_INDEX ); // TODO Brett: Get all the war data
|
|
GCClientSystem()->BSendMessage( msg );
|
|
m_flLastUpdateRequest = Plat_FloatTime();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks if we're "stale". If so, request new stats from the GC.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWarGlobalDataHelper::CheckGlobalStatsStaleness()
|
|
{
|
|
float flTimeSinceLastRequest = Plat_FloatTime() - m_flLastUpdateRequest;
|
|
if ( flTimeSinceLastRequest > 30.f )
|
|
{
|
|
RequestUpdateGlobalStats();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Requests the war leaderboard
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWarGlobalDataHelper::RequestLeaderboard()
|
|
{
|
|
//TODO BRETT loop all the wars and grab each one
|
|
|
|
/*if ( steamapicontext && steamapicontext->SteamUserStats() )
|
|
{
|
|
CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
|
|
GCSDK::CGCClientSharedObjectCache *pSOCache = GCClientSystem()->GetSOCache( steamID );
|
|
if ( pSOCache )
|
|
{
|
|
GCSDK::CGCClientSharedObjectTypeCache *pTypeCache = pSOCache->FindTypeCache( CWarData::k_nTypeID );
|
|
if ( pTypeCache )
|
|
{
|
|
CWarData *pWarData = (CWarData*)pTypeCache->GetObject( 0 );
|
|
if ( pWarData )
|
|
{
|
|
eSide = (EWarSides)pWarData->Obj().affiliation();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( eSide != k_EInvalidSide )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->FindLeaderboard( eSide == k_ESpy ? k_pszSpyVsEngyLeaderboard_Spy : k_pszSpyVsEngyLeaderboard_Engy );
|
|
m_findLeaderboardCallback.Set( apicall, this, &CTFWarGlobalDataHelper::OnFindLeaderboard );
|
|
}
|
|
}*/
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Requests the war leaderboard
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWarGlobalDataHelper::OnFindLeaderboard( LeaderboardFindResult_t *pResult, bool bIOFailure )
|
|
{
|
|
m_findLeaderboardResults = *pResult;
|
|
DownloadLeaderboard();
|
|
}
|
|
|
|
void CTFWarGlobalDataHelper::DownloadLeaderboard()
|
|
{
|
|
if ( m_findLeaderboardResults.m_bLeaderboardFound )
|
|
{
|
|
// friends
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( m_findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 1, 10 );
|
|
downloadLeaderboardCallbackFriends.Set( apicall, this, &CTFWarGlobalDataHelper::OnLeaderboardScoresDownloaded_Friends );
|
|
// global around user
|
|
apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( m_findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestGlobal, 1, 10 );
|
|
downloadLeaderboardCallbackGlobal.Set( apicall, this, &CTFWarGlobalDataHelper::OnLeaderboardScoresDownloaded_Global );
|
|
}
|
|
}
|
|
|
|
static void RetrieveLeaderboardEntries( LeaderboardScoresDownloaded_t &scores, CTFWarGlobalDataHelper::LeaderBoardEntries_t &entries )
|
|
{
|
|
entries.m_bInitialized = true;
|
|
entries.m_vecEntries.PurgeAndDeleteElements();
|
|
entries.m_vecEntries.EnsureCapacity( scores.m_cEntryCount );
|
|
for ( int i = 0; i < scores.m_cEntryCount; ++i )
|
|
{
|
|
LeaderboardEntry_t *leaderboardEntry = new LeaderboardEntry_t;
|
|
if ( steamapicontext->SteamUserStats()->GetDownloadedLeaderboardEntry( scores.m_hSteamLeaderboardEntries, i, leaderboardEntry, NULL, 0 ) )
|
|
{
|
|
entries.m_vecEntries.AddToTail( leaderboardEntry );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTFWarGlobalDataHelper::OnLeaderboardScoresDownloaded_Global( LeaderboardScoresDownloaded_t *pResult, bool bIOFailure )
|
|
{
|
|
RetrieveLeaderboardEntries( *pResult, downloadedLeaderboardScoresGlobal );
|
|
}
|
|
|
|
void CTFWarGlobalDataHelper::OnLeaderboardScoresDownloaded_Friends( LeaderboardScoresDownloaded_t *pResult, bool bIOFailure )
|
|
{
|
|
RetrieveLeaderboardEntries( *pResult, downloadedLeaderboardScoresFriends );
|
|
}
|
|
|
|
class CGC_War_GlobalStatsResponse : public GCSDK::CGCClientJob
|
|
{
|
|
public:
|
|
CGC_War_GlobalStatsResponse( GCSDK::CGCClient *pGCClient ) : GCSDK::CGCClientJob( pGCClient ) { }
|
|
|
|
virtual bool BYieldingRunJobFromMsg( GCSDK::IMsgNetPacket *pNetPacket )
|
|
{
|
|
GCSDK::CProtoBufMsg< CGCMsgGC_War_GlobalStatsResponse > msg( pNetPacket );
|
|
|
|
GetWarData().SetGlobalStats( msg.Body() );
|
|
|
|
return true;
|
|
}
|
|
};
|
|
GC_REG_JOB( GCSDK::CGCClient, CGC_War_GlobalStatsResponse, "CGC_War_GlobalStatsResponse", k_EMsgGC_War_GlobalStatsResponse, GCSDK::k_EServerTypeGCClient );
|
|
#endif
|
|
|
|
CTFWarGlobalDataHelper& GetWarData()
|
|
{
|
|
#ifdef GC
|
|
return GGCTF()->GetGlobalWarData();
|
|
#else
|
|
static CTFWarGlobalDataHelper s_WarData;
|
|
return s_WarData;
|
|
#endif
|
|
}
|
|
|
|
#endif // defined( CLIENT_DLL ) || defined( GC )
|