850 lines
28 KiB
C++
850 lines
28 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================
|
|
#include "cbase.h"
|
|
|
|
#include "tf_mapinfo.h"
|
|
#include <filesystem.h>
|
|
#include "GameEventListener.h"
|
|
#include "econ_item_system.h"
|
|
#include "tf_item_inventory.h"
|
|
#include "econ_contribution.h"
|
|
#include "tf_duel_summary.h"
|
|
#include "gc_clientsystem.h"
|
|
#include "tf_duckleaderboard.h"
|
|
#include "tf_gamerules.h"
|
|
#include "tf_matchmaking_shared.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
#include "hud_macros.h"
|
|
#endif // CLIENT_DLL
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
#ifdef CLIENT_DLL
|
|
ConVar tf_duck_upload_rate( "tf_duck_upload_rate", "2400", FCVAR_DEVELOPMENTONLY ); // Make this DevOnly At ship and 60 seconds
|
|
#endif
|
|
|
|
const char *g_szLadderLeaderboardNames[] =
|
|
{
|
|
"tf2_ladder_6v6",
|
|
"tf2_ladder_public",
|
|
"tf2_ladder_9v9",
|
|
"tf2_ladder_12v12",
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( g_szLadderLeaderboardNames ) == LADDER_LEADERBOARDS_MAX );
|
|
|
|
void __MsgFunc_EOTLDuckEvent( bf_read &msg );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int SortLeaderboardVec( LeaderboardEntry_t * const *p1, LeaderboardEntry_t * const *p2 )
|
|
{
|
|
return ( *p2 )->m_nScore - ( *p1 )->m_nScore;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static void RetrieveLeaderboardEntries( LeaderboardScoresDownloaded_t &scores, CUtlVector< LeaderboardEntry_t* > &entries )
|
|
{
|
|
entries.PurgeAndDeleteElements();
|
|
entries.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.AddToTail( leaderboardEntry );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CLeaderboardInfo::CLeaderboardInfo( const char *pLeaderboardName )
|
|
{
|
|
m_pLeaderboardName = pLeaderboardName ? V_strdup( pLeaderboardName ) : NULL;
|
|
memset( &findLeaderboardResults, 0, sizeof( findLeaderboardResults ) );
|
|
iNumLeaderboardEntries = 0;
|
|
m_kLeaderboardType = kMapLeaderboard;
|
|
m_iMyScore = 0;
|
|
m_bHasPendingUpdate = false;
|
|
m_bLeaderboardFound = false;
|
|
}
|
|
|
|
CLeaderboardInfo::~CLeaderboardInfo()
|
|
{
|
|
downloadedLeaderboardScoresGlobal.PurgeAndDeleteElements();
|
|
downloadedLeaderboardScoresGlobalAroundUser.PurgeAndDeleteElements();
|
|
downloadedLeaderboardScoresFriends.PurgeAndDeleteElements();
|
|
delete m_pLeaderboardName;
|
|
}
|
|
|
|
void CLeaderboardInfo::RetrieveLeaderboardData()
|
|
{
|
|
if ( steamapicontext && steamapicontext->SteamUserStats() )
|
|
{
|
|
if ( m_kLeaderboardType == kMapLeaderboard )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->FindLeaderboard( CFmtStr( "contributions_%s", m_pLeaderboardName ) );
|
|
findLeaderboardCallback.Set( apicall, this, &CLeaderboardInfo::OnFindLeaderboard );
|
|
}
|
|
else if ( m_kLeaderboardType == kDuckLeaderboard || m_kLeaderboardType == kDuckStat )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->FindLeaderboard( m_pLeaderboardName );
|
|
findLeaderboardCallback.Set( apicall, this, &CLeaderboardInfo::OnFindLeaderboard );
|
|
}
|
|
else if ( m_kLeaderboardType == kLadderLeaderboard )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->FindLeaderboard( m_pLeaderboardName );
|
|
findLeaderboardCallback.Set( apicall, this, &CLeaderboardInfo::OnFindLeaderboard );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CLeaderboardInfo::DownloadLeaderboardData()
|
|
{
|
|
if ( !findLeaderboardResults.m_bLeaderboardFound )
|
|
return false;
|
|
|
|
if ( m_kLeaderboardType == kMapLeaderboard )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestGlobal, 1, 5 );
|
|
downloadLeaderboardCallbackGlobal.Set( apicall, this, &CLeaderboardInfo::OnLeaderboardScoresDownloadedGlobal );
|
|
apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -2, 2 );
|
|
downloadLeaderboardCallbackGlobalAroundUser.Set( apicall, this, &CLeaderboardInfo::OnLeaderboardScoresDownloadedGlobalAroundUser );
|
|
apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 1, 5 );
|
|
downloadLeaderboardCallbackFriends.Set( apicall, this, &CLeaderboardInfo::OnLeaderboardScoresDownloadedFriends );
|
|
return true;
|
|
}
|
|
|
|
if ( m_kLeaderboardType == kDuckLeaderboard )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, -6, 6 );
|
|
downloadLeaderboardCallbackFriends.Set( apicall, this, &CLeaderboardInfo::OnLeaderboardScoresDownloadedFriends );
|
|
return true;
|
|
}
|
|
|
|
if ( m_kLeaderboardType == kDuckStat )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 0, 0 );
|
|
downloadLeaderboardCallbackFriends.Set( apicall, this, &CLeaderboardInfo::OnLeaderboardScoresDownloadedFriends );
|
|
return true;
|
|
}
|
|
|
|
if ( m_kLeaderboardType == kLadderLeaderboard )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestGlobal, 1, 100 );
|
|
downloadLeaderboardCallbackGlobal.Set( apicall, this, &CLeaderboardInfo::OnLeaderboardScoresDownloadedGlobal );
|
|
apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( findLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, -45, 45 );
|
|
downloadLeaderboardCallbackFriends.Set( apicall, this, &CLeaderboardInfo::OnLeaderboardScoresDownloadedFriends );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CLeaderboardInfo::OnFindLeaderboard( LeaderboardFindResult_t *pResult, bool bIOFailure )
|
|
{
|
|
findLeaderboardResults = *pResult;
|
|
}
|
|
|
|
void CLeaderboardInfo::OnLeaderboardScoresDownloadedGlobal( LeaderboardScoresDownloaded_t *pResult, bool bIOFailure )
|
|
{
|
|
RetrieveLeaderboardEntries( *pResult, downloadedLeaderboardScoresGlobal );
|
|
iNumLeaderboardEntries = steamapicontext->SteamUserStats()->GetLeaderboardEntryCount( findLeaderboardResults.m_hSteamLeaderboard );
|
|
}
|
|
|
|
void CLeaderboardInfo::OnLeaderboardScoresDownloadedGlobalAroundUser( LeaderboardScoresDownloaded_t *pResult, bool bIOFailure )
|
|
{
|
|
RetrieveLeaderboardEntries( *pResult, downloadedLeaderboardScoresGlobalAroundUser );
|
|
}
|
|
|
|
void CLeaderboardInfo::OnLeaderboardScoresDownloadedFriends( LeaderboardScoresDownloaded_t *pResult, bool bIOFailure )
|
|
{
|
|
RetrieveLeaderboardEntries( *pResult, downloadedLeaderboardScoresFriends );
|
|
iNumLeaderboardEntries = steamapicontext->SteamUserStats()->GetLeaderboardEntryCount( findLeaderboardResults.m_hSteamLeaderboard );
|
|
CSteamID localID;
|
|
if ( steamapicontext && steamapicontext->SteamUser() )
|
|
{
|
|
localID = steamapicontext->SteamUser()->GetSteamID();
|
|
}
|
|
|
|
FOR_EACH_VEC( downloadedLeaderboardScoresFriends, i )
|
|
{
|
|
if ( downloadedLeaderboardScoresFriends[i]->m_steamIDUser == localID )
|
|
{
|
|
if ( m_iMyScore < downloadedLeaderboardScoresFriends[i]->m_nScore )
|
|
{
|
|
// First update on finding the leaderboard, any gotten kills need to add to accumulate
|
|
if ( m_bLeaderboardFound == false )
|
|
{
|
|
if ( m_iMyScore > 0 )
|
|
{
|
|
m_bHasPendingUpdate = true;
|
|
}
|
|
m_iMyScore += downloadedLeaderboardScoresFriends[i]->m_nScore;
|
|
}
|
|
else
|
|
{
|
|
m_iMyScore = downloadedLeaderboardScoresFriends[i]->m_nScore;
|
|
}
|
|
}
|
|
|
|
// Use My Saved Score
|
|
downloadedLeaderboardScoresFriends[i]->m_nScore = m_iMyScore;
|
|
}
|
|
}
|
|
|
|
downloadedLeaderboardScoresFriends.Sort( &SortLeaderboardVec );
|
|
|
|
m_bLeaderboardFound = true;
|
|
}
|
|
|
|
void CLeaderboardInfo::SetMyScore( int score )
|
|
{
|
|
m_iMyScore = score;
|
|
|
|
if ( !m_bLeaderboardFound )
|
|
return;
|
|
|
|
// Update my leaderboard and resort
|
|
iNumLeaderboardEntries = steamapicontext->SteamUserStats()->GetLeaderboardEntryCount( findLeaderboardResults.m_hSteamLeaderboard );
|
|
CSteamID localID;
|
|
if ( steamapicontext && steamapicontext->SteamUser() )
|
|
{
|
|
localID = steamapicontext->SteamUser()->GetSteamID();
|
|
}
|
|
|
|
FOR_EACH_VEC( downloadedLeaderboardScoresFriends, i )
|
|
{
|
|
if ( downloadedLeaderboardScoresFriends[i]->m_steamIDUser == localID )
|
|
{
|
|
if ( m_iMyScore > downloadedLeaderboardScoresFriends[i]->m_nScore )
|
|
{
|
|
// Use My Saved Score
|
|
downloadedLeaderboardScoresFriends[i]->m_nScore = m_iMyScore;
|
|
downloadedLeaderboardScoresFriends.Sort( &SortLeaderboardVec );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CMapInfoContainer : public CAutoGameSystemPerFrame, public CGameEventListener
|
|
{
|
|
public:
|
|
|
|
CMapInfoContainer()
|
|
{
|
|
memset( &m_findDuelLeaderboardResults, 0, sizeof( m_findDuelLeaderboardResults ) );
|
|
m_flNextUpdateDuckScoreTime = Plat_FloatTime() + 10.0f;
|
|
#ifdef CLIENT_DLL
|
|
m_flNextDuckScoresUploadTime = Plat_FloatTime() + tf_duck_upload_rate.GetFloat();
|
|
#endif
|
|
m_flNextLadderUpdateTime = Plat_FloatTime() + 10.f;
|
|
}
|
|
|
|
virtual char const *Name()
|
|
{
|
|
return "CMapInfoContainer";
|
|
}
|
|
|
|
~CMapInfoContainer()
|
|
{
|
|
m_vecMapInfos.PurgeAndDeleteElements();
|
|
m_downloadedDuelLeaderboardScores_GlobalAroundUser.PurgeAndDeleteElements();
|
|
m_downloadedDuelLeaderboardScores_Friends.PurgeAndDeleteElements();
|
|
|
|
// For ducks
|
|
m_vecDuckInfo.PurgeAndDeleteElements();
|
|
// Ladders
|
|
m_vecLadderLeaderboards.PurgeAndDeleteElements();
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
virtual void LevelShutdownPreEntity()
|
|
{
|
|
// upload scores on level leave
|
|
//DuckUploadPendingScores();
|
|
}
|
|
|
|
// Gets called each frame
|
|
virtual void Update( float frametime )
|
|
{
|
|
if ( m_flNextUpdateDuckScoreTime > 0 && m_flNextUpdateDuckScoreTime < Plat_FloatTime() )
|
|
{
|
|
if ( DownloadDuckLeaderboard() )
|
|
{
|
|
m_flNextUpdateDuckScoreTime = -1.0f;
|
|
}
|
|
}
|
|
|
|
if ( m_flNextLadderUpdateTime > 0.f && m_flNextLadderUpdateTime < Plat_FloatTime() )
|
|
{
|
|
if ( DownloadLadderLeaderboard() )
|
|
{
|
|
m_flNextLadderUpdateTime = -1.f;
|
|
}
|
|
}
|
|
|
|
// Duck Journal is off, no longer uploading
|
|
//if ( m_flNextDuckScoresUploadTime < Plat_FloatTime() )
|
|
//{
|
|
// // Hard limit the rate players can update scores
|
|
// float flNextUpdateTime = tf_duck_upload_rate.GetFloat();
|
|
// if ( DuckUploadPendingScores() )
|
|
// {
|
|
// // Request new score
|
|
// m_flNextUpdateDuckScoreTime = Plat_FloatTime() + 10.0f;
|
|
// }
|
|
// // 4x as long if you don't have a Duck Journal
|
|
// C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
// if ( pPlayer )
|
|
// {
|
|
// static CSchemaAttributeDefHandle pAttr_DuckLevelBadge( "duck badge level" );
|
|
// if ( pAttr_DuckLevelBadge )
|
|
// {
|
|
// CTFWearable *pActionItem = pPlayer->GetEquippedWearableForLoadoutSlot( LOADOUT_POSITION_ACTION );
|
|
// // Don't care about the level, just if the attribute is found
|
|
// if ( pActionItem && FindAttribute( pActionItem->GetAttributeContainer()->GetItem(), pAttr_DuckLevelBadge ) )
|
|
// {
|
|
// flNextUpdateTime *= 0.5f;
|
|
// }
|
|
// }
|
|
// }
|
|
// m_flNextDuckScoresUploadTime = Plat_FloatTime() + flNextUpdateTime;
|
|
//}
|
|
}
|
|
#endif // CLIENT_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// for duels
|
|
void DownloadDuelLeaderboard()
|
|
{
|
|
if ( m_findDuelLeaderboardResults.m_bLeaderboardFound )
|
|
{
|
|
// and start downloading the leaderboards
|
|
// friends
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( m_findDuelLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 1, 10 );
|
|
m_downloadLeaderboardCallback_Friends.Set( apicall, this, &CMapInfoContainer::OnDuelLeaderboardScoresDownloaded_Friends );
|
|
// global around user
|
|
apicall = steamapicontext->SteamUserStats()->DownloadLeaderboardEntries( m_findDuelLeaderboardResults.m_hSteamLeaderboard, k_ELeaderboardDataRequestGlobalAroundUser, -4, 5 );
|
|
m_downloadLeaderboardCallback_GlobalAroundUser.Set( apicall, this, &CMapInfoContainer::OnDuelLeaderboardScoresDownloaded_GlobalAroundUser );
|
|
}
|
|
}
|
|
|
|
void OnFindDuelLeaderboard( LeaderboardFindResult_t *pResult, bool bIOFailure )
|
|
{
|
|
m_findDuelLeaderboardResults = *pResult;
|
|
DownloadDuelLeaderboard();
|
|
}
|
|
|
|
void OnDuelLeaderboardScoresDownloaded_GlobalAroundUser( LeaderboardScoresDownloaded_t *pResult, bool bIOFailure )
|
|
{
|
|
RetrieveLeaderboardEntries( *pResult, m_downloadedDuelLeaderboardScores_GlobalAroundUser );
|
|
}
|
|
|
|
void OnDuelLeaderboardScoresDownloaded_Friends( LeaderboardScoresDownloaded_t *pResult, bool bIOFailure )
|
|
{
|
|
RetrieveLeaderboardEntries( *pResult, m_downloadedDuelLeaderboardScores_Friends );
|
|
}
|
|
|
|
// **************************************************************************************************************************
|
|
bool DownloadLadderLeaderboard()
|
|
{
|
|
bool bDownloading = false;
|
|
FOR_EACH_VEC( m_vecLadderLeaderboards, i )
|
|
{
|
|
bDownloading |= m_vecLadderLeaderboards[i]->DownloadLeaderboardData();
|
|
}
|
|
return bDownloading;
|
|
}
|
|
|
|
CLeaderboardInfo *GetLadderLeaderboard( const char *pszName )
|
|
{
|
|
FOR_EACH_VEC( m_vecLadderLeaderboards, i )
|
|
{
|
|
CLeaderboardInfo *pInfo = m_vecLadderLeaderboards[i];
|
|
if ( pszName && pInfo && !V_strcmp( pszName, pInfo->GetLeaderboardName() ) )
|
|
{
|
|
return pInfo;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// **************************************************************************************************************************
|
|
bool DownloadDuckLeaderboard()
|
|
{
|
|
bool bDownloading = false;
|
|
FOR_EACH_VEC( m_vecDuckInfo, i )
|
|
{
|
|
bDownloading |= m_vecDuckInfo[i]->DownloadLeaderboardData();
|
|
}
|
|
return bDownloading;
|
|
}
|
|
|
|
CLeaderboardInfo *GetDuckLeaderboard( const char* kName )
|
|
{
|
|
FOR_EACH_VEC( m_vecDuckInfo, i )
|
|
{
|
|
CLeaderboardInfo *pInfo = m_vecDuckInfo[i];
|
|
if ( strstr( kName, pInfo->GetLeaderboardName() ) != NULL )
|
|
{
|
|
return pInfo;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool DuckUploadPendingScores()
|
|
{
|
|
return false;
|
|
|
|
//CSteamID localID;
|
|
|
|
//if ( !steamapicontext || !steamapicontext->SteamUser() )
|
|
// return false;
|
|
|
|
//localID = steamapicontext->SteamUser()->GetSteamID();
|
|
|
|
//bool bUpdatedScores = false;
|
|
//for ( int i = 0; i < DUCK_NUM_LEADERBOARDS; ++i )
|
|
//{
|
|
// CLeaderboardInfo *pLeaderboard = GetDuckLeaderboard( g_szDuckLeaderboardNames[i] );
|
|
//
|
|
// if ( pLeaderboard && pLeaderboard->IsLeaderboardFound() && pLeaderboard->HasPendingUpdate() )
|
|
// {
|
|
// pLeaderboard->SetHasPendingUpdate( false );
|
|
// bUpdatedScores = true;
|
|
|
|
// int iScoreCheck = RandomInt( INT_MAX / 2, INT_MAX );
|
|
// // Tell the GC to update our duck contribution
|
|
// GCSDK::CProtoBufMsg<CGCMsgGC_PlayerDuckLeaderboard_IndividualUpdate> msg( k_EMsgGC_DuckLeaderboard_IndividualUpdate );
|
|
// msg.Body().set_score( pLeaderboard->GetMyScore() );
|
|
// msg.Body().set_type( i );
|
|
|
|
// MD5Context_t md5Context;
|
|
// MD5Init( &md5Context );
|
|
//
|
|
// AccountID_t unAccountId = localID.GetAccountID();
|
|
// int nScore = pLeaderboard->GetMyScore();
|
|
|
|
// MD5Update( &md5Context, static_cast<const uint8 *>( (void *)&unAccountId ), sizeof( unAccountId ) );
|
|
// MD5Update( &md5Context, static_cast<const uint8 *>( (void *)&nScore ), sizeof( nScore ) );
|
|
// MD5Update( &md5Context, static_cast<const uint8 *>( (void *)&i ), sizeof( i ) );
|
|
// MD5Update( &md5Context, static_cast<const uint8 *>( (void *)&TF_DUCK_ID ), sizeof( TF_DUCK_ID ) );
|
|
// MD5Update( &md5Context, static_cast<const uint8 *>( (void *)&iScoreCheck ), sizeof( iScoreCheck ) );
|
|
//
|
|
// MD5Value_t md5Result;
|
|
// MD5Final( &md5Result.bits[0], &md5Context );
|
|
// msg.Body().set_score_id( &md5Result.bits[0], MD5_DIGEST_LENGTH );
|
|
// msg.Body().set_score_check( iScoreCheck );
|
|
// GCClientSystem()->BSendMessage( msg );
|
|
// }
|
|
//}
|
|
//return bUpdatedScores;
|
|
}
|
|
|
|
void DuckUpdateScore( int iIncrement, EDuckLeaderboardTypes kLeaderboard )
|
|
{
|
|
// Get Current Score
|
|
CLeaderboardInfo *pLeaderboard = GetDuckLeaderboard( g_szDuckLeaderboardNames[kLeaderboard] );
|
|
int iCurrentScore = pLeaderboard->GetMyScore();
|
|
int iNewScore = iCurrentScore + iIncrement;
|
|
|
|
#ifdef CLIENT_DLL
|
|
int iOldLevel = iCurrentScore / DUCK_XP_SCALE;
|
|
int iNewLevel = iNewScore / DUCK_XP_SCALE;
|
|
|
|
if ( iNewLevel > iOldLevel )
|
|
{
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "duck_xp_level_up" );
|
|
if ( event )
|
|
{
|
|
event->SetInt( "level", iNewLevel );
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Set my new score
|
|
pLeaderboard->SetMyScore( iNewScore );
|
|
pLeaderboard->SetHasPendingUpdate( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
virtual bool Init()
|
|
{
|
|
ListenForGameEvent( "item_schema_initialized" );
|
|
#ifdef CLIENT_DLL
|
|
HOOK_MESSAGE( EOTLDuckEvent );
|
|
#endif // CLIENT_DLL
|
|
return true;
|
|
}
|
|
|
|
virtual void FireGameEvent( IGameEvent *event )
|
|
{
|
|
if ( Q_strcmp( event->GetName(), "item_schema_initialized" ) != 0 )
|
|
return;
|
|
|
|
for ( int i = 0; i < GetItemSchema()->GetMapCount(); i++ )
|
|
{
|
|
CLeaderboardInfo *pInfo = new CLeaderboardInfo( GetItemSchema()->GetMasterMapDefByIndex( i )->pszMapName );
|
|
pInfo->m_kLeaderboardType = kMapLeaderboard;
|
|
m_vecMapInfos.AddToTail( pInfo );
|
|
|
|
const MapDef_t *pMapDef = GetItemSchema()->GetMasterMapDefByName( pInfo->GetLeaderboardName() );
|
|
if ( pMapDef && pMapDef->IsCommunityMap() )
|
|
{
|
|
// retrieve leaderboard info
|
|
pInfo->RetrieveLeaderboardData();
|
|
}
|
|
}
|
|
|
|
// find duel leaderboards
|
|
if ( steamapicontext && steamapicontext->SteamUserStats() )
|
|
{
|
|
SteamAPICall_t apicall = steamapicontext->SteamUserStats()->FindLeaderboard( "duel_wins" );
|
|
m_findLeaderboardCallback.Set( apicall, this, &CMapInfoContainer::OnFindDuelLeaderboard );
|
|
}
|
|
|
|
// find duck leaderboards
|
|
for ( int i = 0; i < DUCK_NUM_LEADERBOARDS; i++ )
|
|
{
|
|
CLeaderboardInfo *pInfo = new CLeaderboardInfo( g_szDuckLeaderboardNames[ i ] );
|
|
pInfo->m_kLeaderboardType = i == 0 ? kDuckLeaderboard : kDuckStat;
|
|
m_vecDuckInfo.AddToTail( pInfo );
|
|
|
|
// retrieve leaderboard info
|
|
pInfo->RetrieveLeaderboardData();
|
|
}
|
|
|
|
// Ladder
|
|
for ( int i = 0; i < LADDER_LEADERBOARDS_MAX; i++ )
|
|
{
|
|
CLeaderboardInfo *pInfo = new CLeaderboardInfo( g_szLadderLeaderboardNames[i] );
|
|
pInfo->m_kLeaderboardType = kLadderLeaderboard;
|
|
m_vecLadderLeaderboards.AddToTail( pInfo );
|
|
|
|
// retrieve leaderboard info
|
|
pInfo->RetrieveLeaderboardData();
|
|
}
|
|
}
|
|
|
|
public:
|
|
|
|
CUtlVector< CLeaderboardInfo* > m_vecMapInfos;
|
|
// for duels
|
|
CCallResult< CMapInfoContainer, LeaderboardFindResult_t > m_findLeaderboardCallback;
|
|
CCallResult< CMapInfoContainer, LeaderboardScoresDownloaded_t > m_downloadLeaderboardCallback_GlobalAroundUser;
|
|
CCallResult< CMapInfoContainer, LeaderboardScoresDownloaded_t > m_downloadLeaderboardCallback_Friends;
|
|
LeaderboardFindResult_t m_findDuelLeaderboardResults;
|
|
CUtlVector< LeaderboardEntry_t* > m_downloadedDuelLeaderboardScores_GlobalAroundUser;
|
|
CUtlVector< LeaderboardEntry_t* > m_downloadedDuelLeaderboardScores_Friends;
|
|
|
|
// For ducks
|
|
CUtlVector< CLeaderboardInfo* > m_vecDuckInfo;
|
|
float m_flNextUpdateDuckScoreTime;
|
|
float m_flNextDuckScoresUploadTime;
|
|
|
|
// Ladders
|
|
CUtlVector< CLeaderboardInfo* > m_vecLadderLeaderboards;
|
|
float m_flNextLadderUpdateTime;
|
|
};
|
|
CMapInfoContainer gMapInfoContainer;
|
|
|
|
static CLeaderboardInfo *FindMapInfo( const char *pMapName )
|
|
{
|
|
FOR_EACH_VEC( gMapInfoContainer.m_vecMapInfos, i )
|
|
{
|
|
CLeaderboardInfo *pInfo = gMapInfoContainer.m_vecMapInfos[i];
|
|
if ( strstr( pMapName, pInfo->GetLeaderboardName() ) != NULL )
|
|
return pInfo;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool Leaderboards_GetDuelWins( CUtlVector< LeaderboardEntry_t* > &scores, bool bGlobal )
|
|
{
|
|
if ( gMapInfoContainer.m_findDuelLeaderboardResults.m_bLeaderboardFound )
|
|
{
|
|
if ( bGlobal )
|
|
{
|
|
scores = gMapInfoContainer.m_downloadedDuelLeaderboardScores_GlobalAroundUser;
|
|
}
|
|
else
|
|
{
|
|
scores = gMapInfoContainer.m_downloadedDuelLeaderboardScores_Friends;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// DUCKS
|
|
void Leaderboards_GetDuckLeaderboardSteamIDs( CUtlVector< AccountID_t > &vecIds )
|
|
{
|
|
vecIds.RemoveAll();
|
|
FOR_EACH_VEC( gMapInfoContainer.m_vecDuckInfo, i )
|
|
{
|
|
FOR_EACH_VEC( gMapInfoContainer.m_vecDuckInfo[i]->downloadedLeaderboardScoresFriends, iEntry )
|
|
{
|
|
vecIds.AddToHead( gMapInfoContainer.m_vecDuckInfo[i]->downloadedLeaderboardScoresFriends[iEntry]->m_steamIDUser.GetAccountID() );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Leaderboards_GetDuckLeaderboard( CUtlVector< LeaderboardEntry_t* > &scores, const char* kName )
|
|
{
|
|
CLeaderboardInfo *pLeaderboard = gMapInfoContainer.GetDuckLeaderboard( kName );
|
|
if ( pLeaderboard && pLeaderboard->IsLeaderboardFound() )
|
|
{
|
|
scores = pLeaderboard->downloadedLeaderboardScoresFriends;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int Leaderboards_GetDuckLeaderboardTotalEntryCount( const char* kName )
|
|
{
|
|
CLeaderboardInfo *pLeaderboard = gMapInfoContainer.GetDuckLeaderboard( kName );
|
|
if ( pLeaderboard )
|
|
{
|
|
return pLeaderboard->iNumLeaderboardEntries;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// DUCK Collected Message from Server
|
|
void __MsgFunc_EOTLDuckEvent( bf_read &msg )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
CBasePlayer *pLocalPlayer = CBasePlayer::GetLocalPlayer();
|
|
if ( !pLocalPlayer )
|
|
return;
|
|
|
|
if ( TFGameRules() && TFGameRules()->HaveCheatsBeenEnabledDuringLevel() )
|
|
return;
|
|
|
|
// IsCreated, ID of Creator, ID of Victim, Count, IsGolden
|
|
int iIsCreated = (int)msg.ReadByte();
|
|
int iCreatorId = (int)msg.ReadByte();
|
|
int iVictimId = (int)msg.ReadByte();
|
|
int iToucherId = (int)msg.ReadByte();
|
|
int iDuckTeam = (int)msg.ReadByte();
|
|
int iCount = (int)msg.ReadByte();
|
|
int iDuckFlags = (int)msg.ReadByte();
|
|
|
|
iDuckTeam = 0;
|
|
iVictimId = 0;
|
|
//iDuckFlags = 0;
|
|
|
|
CBasePlayer *pCreator = UTIL_PlayerByIndex( iCreatorId );
|
|
//CBasePlayer *pVictim = UTIL_PlayerByIndex( iVictimId );
|
|
CBasePlayer *pToucher = UTIL_PlayerByIndex( iToucherId );
|
|
|
|
if ( !pCreator )
|
|
{
|
|
iDuckFlags |= DUCK_FLAG_OBJECTIVE;
|
|
}
|
|
// If you were picked up, you need a toucher
|
|
if ( iIsCreated == 0 && pToucher )
|
|
{
|
|
// if I picked them up
|
|
if ( pToucher == pLocalPlayer )
|
|
{
|
|
// Offense
|
|
if ( pCreator && pCreator->GetTeamNumber() == pLocalPlayer->GetTeamNumber() )
|
|
{
|
|
gMapInfoContainer.DuckUpdateScore( iCount, TF_DUCK_SCORING_PERSONAL_PICKUP_OFFENSE );
|
|
gMapInfoContainer.DuckUpdateScore( iCount * DUCK_XP_WEIGHT_OFFENSE, TF_DUCK_SCORING_OVERALL_RATING );
|
|
}
|
|
//defense
|
|
else if ( pCreator && pCreator->GetTeamNumber() != pLocalPlayer->GetTeamNumber() )
|
|
{
|
|
gMapInfoContainer.DuckUpdateScore( iCount, TF_DUCK_SCORING_PERSONAL_PICKUP_DEFENDED );
|
|
gMapInfoContainer.DuckUpdateScore( iCount * DUCK_XP_WEIGHT_DEFENSE, TF_DUCK_SCORING_OVERALL_RATING );
|
|
}
|
|
|
|
// objective
|
|
if ( iDuckFlags & DUCK_FLAG_OBJECTIVE )
|
|
{
|
|
gMapInfoContainer.DuckUpdateScore( iCount, TF_DUCK_SCORING_PERSONAL_PICKUP_OBJECTIVE );
|
|
gMapInfoContainer.DuckUpdateScore( iCount* DUCK_XP_WEIGHT_OBJECTIVE, TF_DUCK_SCORING_OVERALL_RATING );
|
|
}
|
|
|
|
// bonus
|
|
if ( iDuckFlags & DUCK_FLAG_BONUS )
|
|
{
|
|
gMapInfoContainer.DuckUpdateScore( iCount, TF_DUCK_SCORING_PERSONAL_BONUS_PICKUP );
|
|
gMapInfoContainer.DuckUpdateScore( iCount* DUCK_XP_WEIGHT_BONUS, TF_DUCK_SCORING_OVERALL_RATING );
|
|
}
|
|
}
|
|
// Teammate picks up a duck I made
|
|
else if ( pCreator && pCreator == pLocalPlayer && pCreator->GetTeamNumber() == pToucher->GetTeamNumber() )
|
|
{
|
|
gMapInfoContainer.DuckUpdateScore( iCount, TF_DUCK_SCORING_TEAM_PICKUP_MY_DUCKS );
|
|
gMapInfoContainer.DuckUpdateScore( iCount * DUCK_XP_WEIGHT_TEAMMATE, TF_DUCK_SCORING_OVERALL_RATING );
|
|
}
|
|
}
|
|
// Duck Created
|
|
else if ( iIsCreated != 0 )
|
|
{
|
|
// If this is the same as local player
|
|
if ( pLocalPlayer == pCreator )
|
|
{
|
|
gMapInfoContainer.DuckUpdateScore( iCount, TF_DUCK_SCORING_PERSONAL_GENERATION );
|
|
gMapInfoContainer.DuckUpdateScore( iCount * DUCK_XP_WEIGHT_GENERATION, TF_DUCK_SCORING_OVERALL_RATING );
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void Leaderboards_Refresh()
|
|
{
|
|
gMapInfoContainer.DownloadDuelLeaderboard();
|
|
gMapInfoContainer.DownloadDuckLeaderboard();
|
|
gMapInfoContainer.DownloadLadderLeaderboard();
|
|
}
|
|
|
|
void MapInfo_RefreshLeaderboard( const char *pMapName )
|
|
{
|
|
CLeaderboardInfo *pInfo = FindMapInfo( pMapName );
|
|
if ( pInfo )
|
|
{
|
|
pInfo->DownloadLeaderboardData();
|
|
}
|
|
}
|
|
|
|
bool MapInfo_GetLeaderboardInfo( const char *pMapName, CUtlVector< LeaderboardEntry_t* > &scores, int &iNumLeaderboardEntries, uint32 unMinScores )
|
|
{
|
|
CLeaderboardInfo *pInfo = FindMapInfo( pMapName );
|
|
if ( pInfo && pInfo->findLeaderboardResults.m_bLeaderboardFound )
|
|
{
|
|
if ( (uint32)pInfo->downloadedLeaderboardScoresFriends.Count() >= unMinScores )
|
|
{
|
|
scores = pInfo->downloadedLeaderboardScoresFriends;
|
|
}
|
|
else if ( (uint32)pInfo->downloadedLeaderboardScoresGlobalAroundUser.Count() >= unMinScores )
|
|
{
|
|
scores = pInfo->downloadedLeaderboardScoresGlobalAroundUser;
|
|
}
|
|
else
|
|
{
|
|
scores = pInfo->downloadedLeaderboardScoresGlobal;
|
|
}
|
|
iNumLeaderboardEntries = pInfo->iNumLeaderboardEntries;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static const char *FindMapNameForContributionDefinitionIndex( item_definition_index_t unContribDefIndex )
|
|
{
|
|
for ( int i = 0; i < GetItemSchema()->GetMapCount(); i++ )
|
|
{
|
|
const MapDef_t* pMapDef = GetItemSchema()->GetMasterMapDefByIndex( i );
|
|
if ( pMapDef->mapStampDef && pMapDef->mapStampDef->GetDefinitionIndex() == unContribDefIndex )
|
|
return pMapDef->pszMapName;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool MapInfo_DidPlayerDonate( uint32 unAccountID, const char *pLevelName )
|
|
{
|
|
if ( steamapicontext == NULL || steamapicontext->SteamUser() == NULL )
|
|
return false;
|
|
|
|
CSteamID localSteamID = steamapicontext->SteamUser()->GetSteamID();
|
|
CSteamID steamID = localSteamID;
|
|
steamID.SetAccountID( unAccountID );
|
|
|
|
GCSDK::CGCClientSharedObjectCache *pSOCache = GCClientSystem()->GetSOCache( steamID );
|
|
if ( pSOCache == NULL )
|
|
return false;
|
|
|
|
GCSDK::CGCClientSharedObjectTypeCache *pTypeCache = pSOCache->FindTypeCache( CTFMapContribution::k_nTypeID );
|
|
if ( pTypeCache == NULL )
|
|
return false;
|
|
|
|
char pchBaseMapName[ MAX_PATH ];
|
|
Q_FileBase( pLevelName, pchBaseMapName, sizeof(pchBaseMapName) );
|
|
|
|
for ( uint32 i = 0; i < pTypeCache->GetCount(); ++i )
|
|
{
|
|
CTFMapContribution *pMapContribution = (CTFMapContribution*)( pTypeCache->GetObject( i ) );
|
|
|
|
const char *pszMapName = FindMapNameForContributionDefinitionIndex( pMapContribution->Obj().def_index() );
|
|
if ( pszMapName && FStrEq( pszMapName, pchBaseMapName ) )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int MapInfo_GetDonationAmount( uint32 unAccountID, const char *pLevelName )
|
|
{
|
|
if ( steamapicontext == NULL || steamapicontext->SteamUser() == NULL )
|
|
return 0;
|
|
|
|
CSteamID localSteamID = steamapicontext->SteamUser()->GetSteamID();
|
|
CSteamID steamID = localSteamID;
|
|
steamID.SetAccountID( unAccountID );
|
|
|
|
GCSDK::CGCClientSharedObjectCache *pSOCache = GCClientSystem()->GetSOCache( steamID );
|
|
if ( pSOCache == NULL )
|
|
return 0;
|
|
|
|
GCSDK::CGCClientSharedObjectTypeCache *pTypeCache = pSOCache->FindTypeCache( CTFMapContribution::k_nTypeID );
|
|
if ( pTypeCache == NULL )
|
|
return 0;
|
|
|
|
char pchBaseMapName[ MAX_PATH ];
|
|
Q_FileBase( pLevelName, pchBaseMapName, sizeof(pchBaseMapName) );
|
|
|
|
for ( uint32 i = 0; i < pTypeCache->GetCount(); ++i )
|
|
{
|
|
CTFMapContribution *pMapContribution = (CTFMapContribution*)( pTypeCache->GetObject( i ) );
|
|
|
|
const char *pszMapName = FindMapNameForContributionDefinitionIndex( pMapContribution->Obj().def_index() );
|
|
if ( pszMapName && FStrEq( pszMapName, pchBaseMapName ) )
|
|
return pMapContribution->Obj().contribution_level();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Ladders
|
|
//-----------------------------------------------------------------------------
|
|
bool Leaderboards_GetLadderLeaderboard( CUtlVector< LeaderboardEntry_t* > &scores, const char *pszName, bool bGlobal )
|
|
{
|
|
CLeaderboardInfo *pLeaderboard = gMapInfoContainer.GetLadderLeaderboard( pszName );
|
|
if ( pLeaderboard && pLeaderboard->IsLeaderboardFound() )
|
|
{
|
|
scores = bGlobal ? pLeaderboard->downloadedLeaderboardScoresGlobal : pLeaderboard->downloadedLeaderboardScoresFriends;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void Leaderboards_LadderRefresh( void )
|
|
{
|
|
gMapInfoContainer.DownloadLadderLeaderboard();
|
|
}
|