1690 lines
54 KiB
C++
1690 lines
54 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
//
|
||
// Purpose:
|
||
//
|
||
// $NoKeywords: $
|
||
//=============================================================================//
|
||
|
||
#include "cbase.h"
|
||
|
||
#include "tf_mann_vs_machine_stats.h"
|
||
#include "filesystem.h"
|
||
#include "steamworks_gamestats.h"
|
||
#include "econ_item_description.h"
|
||
#include "econ_item_system.h"
|
||
#include "econ_item_schema.h"
|
||
#include "econ_item_constants.h"
|
||
|
||
#ifdef GAME_DLL
|
||
#include "dt_utlvector_send.h"
|
||
#include "tf_gamerules.h"
|
||
#include "tf_player.h"
|
||
#include "tf_gc_server.h"
|
||
#else
|
||
#include "dt_utlvector_recv.h"
|
||
#include "c_tf_player.h"
|
||
#include "hud_macros.h"
|
||
#include "tf_hud_mann_vs_machine_status.h"
|
||
#include "c_tf_objective_resource.h"
|
||
#include "player_vs_environment/c_tf_upgrades.h"
|
||
#endif
|
||
|
||
// memdbgon must be the last include file in a .cpp file!!!
|
||
#include "tier0/memdbgon.h"
|
||
|
||
extern ConVar tf_mm_trusted;
|
||
|
||
extern ConVar tf_mvm_respec_limit;
|
||
extern ConVar tf_mvm_respec_credit_goal;
|
||
|
||
static CMannVsMachineStats *g_pMVMStats = NULL;
|
||
|
||
//-----------------------------------------------------------------------------
|
||
#ifdef CLIENT_DLL
|
||
// Avoid redef warnings
|
||
#undef CTFPlayer
|
||
#define CTFPlayer C_TFPlayer
|
||
#define CMannVsMachineStats C_MannVsMachineStats
|
||
#endif
|
||
|
||
BEGIN_NETWORK_TABLE_NOBASE( CMannVsMachineWaveStats, DT_CMannVsMachineWaveStats )
|
||
#if defined( GAME_DLL )
|
||
SendPropInt( SENDINFO( nCreditsDropped ), 16, SPROP_UNSIGNED ),
|
||
SendPropInt( SENDINFO( nCreditsAcquired ), 16, SPROP_UNSIGNED ),
|
||
SendPropInt( SENDINFO( nCreditsBonus ), 16, SPROP_UNSIGNED ),
|
||
SendPropInt( SENDINFO( nPlayerDeaths ), 16, SPROP_UNSIGNED ),
|
||
SendPropInt( SENDINFO( nBuyBacks ), 8, SPROP_UNSIGNED ),
|
||
#else
|
||
|
||
RecvPropInt( RECVINFO( nCreditsDropped ) ),
|
||
RecvPropInt( RECVINFO( nCreditsAcquired ) ),
|
||
RecvPropInt( RECVINFO( nCreditsBonus ) ),
|
||
RecvPropInt( RECVINFO( nPlayerDeaths ) ),
|
||
RecvPropInt( RECVINFO( nBuyBacks ) ),
|
||
#endif
|
||
END_NETWORK_TABLE()
|
||
|
||
LINK_ENTITY_TO_CLASS( tf_mann_vs_machine_stats, CMannVsMachineStats );
|
||
IMPLEMENT_NETWORKCLASS_ALIASED( MannVsMachineStats, DT_MannVsMachineStats )
|
||
|
||
BEGIN_NETWORK_TABLE( CMannVsMachineStats, DT_MannVsMachineStats )
|
||
#if defined ( GAME_DLL )
|
||
SendPropInt( SENDINFO( m_iCurrentWaveIdx ), 8, SPROP_UNSIGNED ),
|
||
SendPropInt( SENDINFO( m_iServerWaveID ), 8, SPROP_UNSIGNED ),
|
||
SendPropDataTable( SENDINFO_DT(m_runningTotalWaveStats), &REFERENCE_SEND_TABLE(DT_CMannVsMachineWaveStats) ),
|
||
SendPropDataTable( SENDINFO_DT(m_previousWaveStats), &REFERENCE_SEND_TABLE(DT_CMannVsMachineWaveStats) ),
|
||
SendPropDataTable( SENDINFO_DT(m_currentWaveStats), &REFERENCE_SEND_TABLE(DT_CMannVsMachineWaveStats) ),
|
||
SendPropInt( SENDINFO( m_iCurrencyCollectedForRespec ), -1, SPROP_VARINT ),
|
||
SendPropInt( SENDINFO( m_nRespecsAwardedInWave ), 8, SPROP_UNSIGNED ),
|
||
#else
|
||
RecvPropInt( RECVINFO( m_iCurrentWaveIdx ) ),
|
||
RecvPropInt( RECVINFO( m_iServerWaveID ) ),
|
||
RecvPropDataTable(RECVINFO_DT(m_runningTotalWaveStats), 0, &REFERENCE_RECV_TABLE(DT_CMannVsMachineWaveStats)),
|
||
RecvPropDataTable(RECVINFO_DT(m_previousWaveStats), 0, &REFERENCE_RECV_TABLE(DT_CMannVsMachineWaveStats)),
|
||
RecvPropDataTable(RECVINFO_DT(m_currentWaveStats), 0, &REFERENCE_RECV_TABLE(DT_CMannVsMachineWaveStats)),
|
||
RecvPropInt( RECVINFO( m_iCurrencyCollectedForRespec ) ),
|
||
RecvPropInt( RECVINFO( m_nRespecsAwardedInWave ) ),
|
||
#endif
|
||
END_NETWORK_TABLE()
|
||
|
||
#ifdef CLIENT_DLL
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Server message that tells that a mann vs machine event occurred
|
||
//-----------------------------------------------------------------------------
|
||
static void __MsgFunc_MVMStatsReset( bf_read &msg )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->ResetStats( );
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Server message that tells that a mann vs machine event occurred
|
||
//-----------------------------------------------------------------------------
|
||
static void __MsgFunc_MVMPlayerEvent( bf_read &msg )
|
||
{
|
||
// Deprecated.
|
||
// Dont delete this or its HOOK_MESSAGE below or else demos will break
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Reports Player Spending
|
||
//-----------------------------------------------------------------------------
|
||
static void __MsgFunc_MVMLocalPlayerWaveSpendingValue( bf_read &msg )
|
||
{
|
||
if ( !g_pMVMStats )
|
||
return;
|
||
|
||
// PlayerIdx(8), Wave(1), Type(1), Cost(2)
|
||
uint64 playerID;
|
||
if ( !msg.ReadBytes( &playerID, sizeof(playerID) ) )
|
||
{
|
||
DevMsg( " Unable to Get Player SteamID from __MsgFunc_MVMLocalPlayerWaveSpendingValue() " );
|
||
return;
|
||
}
|
||
|
||
uint8 idxWave = msg.ReadByte();
|
||
eMannVsMachineEvent eType = (eMannVsMachineEvent)msg.ReadByte();
|
||
int16 nCost = msg.ReadWord();
|
||
|
||
CPlayerWaveSpendingStats *pPlayerStats = g_pMVMStats->GetSpending( idxWave, playerID );
|
||
if ( !pPlayerStats )
|
||
return;
|
||
|
||
CSteamID steamId( playerID );
|
||
C_TFPlayer *pTFPlayer = ToTFPlayer( GetPlayerBySteamID( steamId ) );
|
||
C_TFPlayer *pTFLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
||
switch ( eType )
|
||
{
|
||
case kMVMEvent_Player_BoughtInstantRespawn:
|
||
pPlayerStats->nCreditsSpentOnBuyBacks += nCost;
|
||
// Read the event msg and pass it on to MVMStats
|
||
if ( pTFPlayer == pTFLocalPlayer )
|
||
{
|
||
g_pMVMStats->SW_ReportClientBuyBackPurchase( idxWave, nCost );
|
||
}
|
||
break;
|
||
case kMVMEvent_Player_BoughtBottle:
|
||
pPlayerStats->nCreditsSpentOnBottles += nCost;
|
||
break;
|
||
case kMVMEvent_Player_BoughtUpgrade:
|
||
pPlayerStats->nCreditsSpentOnUpgrades += nCost;
|
||
break;
|
||
case kMVMEvent_Player_ActiveUpgrades:
|
||
g_pMVMStats->SetPlayerActiveUpgradeCosts( playerID, nCost );
|
||
break;
|
||
} // switch
|
||
|
||
}
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Server message that tells that a mann vs machine event occurred
|
||
//-----------------------------------------------------------------------------
|
||
static void __MsgFunc_MVMResetPlayerStats( bf_read &msg )
|
||
{
|
||
if ( !g_pMVMStats )
|
||
return;
|
||
|
||
uint8 playerIndex = msg.ReadByte();
|
||
|
||
C_TFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
|
||
if ( !pTFPlayer )
|
||
return;
|
||
|
||
g_pMVMStats->ResetPlayerEvents( pTFPlayer );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Handling a Server message that notifies that a player has upgraded in MvM
|
||
//-----------------------------------------------------------------------------
|
||
static void __MsgFunc_MVMPlayerUpgradedEvent( bf_read &msg )
|
||
{
|
||
//if ( !g_pMVMStats )
|
||
// return;
|
||
//
|
||
//// Read the data
|
||
//// PlayerIdx(1), WaveIdx(1), ItemDef(2), AttributeDef(2), Quality(1), cost(2)
|
||
//uint8 playerIndex = msg.ReadByte();
|
||
//uint8 idxWave = msg.ReadByte();
|
||
//uint16 nItemDef = msg.ReadWord();
|
||
//uint16 nAttributeDef = msg.ReadWord();
|
||
//uint8 nQuality = msg.ReadByte();
|
||
//int16 nCost = msg.ReadWord();
|
||
|
||
//CMannVsMachineUpgradeEvent upgrade;
|
||
//upgrade.nItemDef = nItemDef;
|
||
//upgrade.nAttributeDef = nAttributeDef;
|
||
//upgrade.nQuality = nQuality;
|
||
|
||
//C_TFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
|
||
//C_TFPlayer *pTFLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
||
//// Report Stats if Local Player
|
||
//if ( pTFPlayer && pTFLocalPlayer && ( pTFPlayer == pTFLocalPlayer ) )
|
||
//{
|
||
// // Read the event msg and pass it on to MVMStats
|
||
// g_pMVMStats->SW_ReportClientUpgradePurchase( idxWave, nItemDef, nAttributeDef, nQuality, nCost );
|
||
//}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Message for the Local Player that it should clear its upgrade vector
|
||
static void __MsgFunc_MVMLocalPlayerUpgradesClear( bf_read &msg )
|
||
{
|
||
if ( !g_pMVMStats )
|
||
return;
|
||
|
||
// Read the data
|
||
//uint8 count = msg.ReadByte();
|
||
|
||
g_pMVMStats->ClearLocalPlayerUpgrades();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Message for the local player about an upgrade that it owns
|
||
static void __MsgFunc_MVMLocalPlayerUpgradesValue( bf_read &msg )
|
||
{
|
||
if ( !g_pMVMStats )
|
||
return;
|
||
|
||
// Read the data
|
||
// Class(1), ItemDef(2), Upgrade(1), cost(1)
|
||
uint8 playerClass = msg.ReadByte();
|
||
uint16 nItemDef = msg.ReadWord();
|
||
//uint8 upgrade = msg.ReadByte();
|
||
//uint16 cost = msg.ReadByte();
|
||
|
||
g_pMVMStats->AddLocalPlayerUpgrade( playerClass, (item_definition_index_t)nItemDef );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Message for the player that it should clear spending stats history for target wave
|
||
static void __MsgFunc_MVMResetPlayerWaveSpendingStats( bf_read &msg )
|
||
{
|
||
if ( !g_pMVMStats )
|
||
return;
|
||
|
||
// Read the data
|
||
// Wave(1)
|
||
uint8 idxWave = msg.ReadByte();
|
||
|
||
g_pMVMStats->ClearCurrentPlayerWaveSpendingStats( idxWave );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Server message that tells that the current wave has ended and a new one has begun (including resets)
|
||
//-----------------------------------------------------------------------------
|
||
static void __MsgFunc_MVMWaveChange( bf_read &msg )
|
||
{
|
||
if ( !g_pMVMStats )
|
||
return;
|
||
|
||
// Read the data
|
||
uint16 waveID = msg.ReadWord();
|
||
|
||
CMannVsMachinePlayerStats stats;
|
||
|
||
stats.nDeaths = msg.ReadByte();
|
||
stats.nBotDamage = msg.ReadLong();
|
||
stats.nGiantDamage = msg.ReadLong();
|
||
stats.nTankDamage = msg.ReadLong();
|
||
|
||
// Send the Stats
|
||
g_pMVMStats->SW_ReportClientWaveSummary( waveID, stats );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
static void __MsgFunc_MVMResetPlayerUpgradeSpending( bf_read &msg )
|
||
{
|
||
if ( !g_pMVMStats )
|
||
return;
|
||
|
||
uint8 playerIndex = msg.ReadByte();
|
||
|
||
C_TFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
|
||
if ( !pTFPlayer )
|
||
return;
|
||
|
||
g_pMVMStats->ResetUpgradeSpending( pTFPlayer );
|
||
}
|
||
|
||
#endif // CLIENT_DLL
|
||
|
||
//------------------------------------------------------------------------------
|
||
// CMannVsMachineStats
|
||
//------------------------------------------------------------------------------
|
||
CMannVsMachineStats::CMannVsMachineStats()
|
||
{
|
||
g_pMVMStats = this;
|
||
|
||
#ifdef GAME_DLL
|
||
SetCurrentWave( 0 );
|
||
Q_memset( m_playerStats, 0, sizeof( m_playerStats ) );
|
||
#else
|
||
m_iCurrentWaveIdx = 0;
|
||
|
||
m_teamActiveUpgrades.Purge();
|
||
m_teamActiveUpgrades.SetLessFunc( DefLessFunc (uint64) );
|
||
#endif
|
||
m_currWaveSpendingStats.SetLessFunc( DefLessFunc (uint64) );
|
||
m_prevWaveSpendingStats.SetLessFunc( DefLessFunc (uint64) );
|
||
m_allPrevWaveSpendingStats.SetLessFunc( DefLessFunc (uint64) );
|
||
|
||
m_iCurrencyCollectedForRespec = 0;
|
||
m_nRespecsAwardedInWave = 0;
|
||
//m_nEventID = 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: DTOR
|
||
//-----------------------------------------------------------------------------
|
||
CMannVsMachineStats::~CMannVsMachineStats()
|
||
{
|
||
g_pMVMStats = NULL;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::ResetStats( )
|
||
{
|
||
#ifdef GAME_DLL
|
||
// notify everyone to reset everything
|
||
CBroadcastRecipientFilter filter;
|
||
filter.MakeReliable();
|
||
UserMessageBegin( filter, "MVMStatsReset" );
|
||
MessageEnd();
|
||
|
||
SetCurrentWave( 0 );
|
||
|
||
m_runningTotalWaveStats.ClearStats();
|
||
m_previousWaveStats.ClearStats();
|
||
m_currentWaveStats.ClearStats();
|
||
|
||
#else
|
||
m_vecLocalPlayerUpgrades.Purge();
|
||
m_teamActiveUpgrades.Purge();
|
||
#endif
|
||
|
||
m_currWaveSpendingStats.RemoveAll();
|
||
m_prevWaveSpendingStats.RemoveAll();
|
||
m_allPrevWaveSpendingStats.RemoveAll();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::ResetPlayerEvents( CTFPlayer *pTFPlayer )
|
||
{
|
||
if ( pTFPlayer->IsBot() )
|
||
return;
|
||
|
||
#ifdef GAME_DLL
|
||
CBroadcastRecipientFilter filter;
|
||
filter.MakeReliable();
|
||
UserMessageBegin( filter, "MVMResetPlayerStats" );
|
||
WRITE_BYTE( (uint8)pTFPlayer->entindex() );
|
||
MessageEnd();
|
||
#endif
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::ResetUpgradeSpending( CTFPlayer *pTFPlayer )
|
||
{
|
||
if ( !pTFPlayer )
|
||
return;
|
||
|
||
if ( pTFPlayer->IsBot() )
|
||
return;
|
||
|
||
CSteamID steamID;
|
||
if ( pTFPlayer && pTFPlayer->GetSteamID( &steamID ) )
|
||
{
|
||
int iWave = m_currWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_currWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
m_currWaveSpendingStats[iWave].nCreditsSpentOnUpgrades = 0;
|
||
}
|
||
|
||
iWave = m_allPrevWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_allPrevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
m_allPrevWaveSpendingStats[iWave].nCreditsSpentOnUpgrades = 0;
|
||
}
|
||
|
||
iWave = m_prevWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_prevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
m_prevWaveSpendingStats[iWave].nCreditsSpentOnUpgrades = 0;
|
||
}
|
||
}
|
||
|
||
#ifdef GAME_DLL
|
||
CBroadcastRecipientFilter filter;
|
||
filter.MakeReliable();
|
||
UserMessageBegin( filter, "MVMResetPlayerUpgradeSpending" );
|
||
WRITE_BYTE( (uint8)pTFPlayer->entindex() );
|
||
MessageEnd();
|
||
#endif
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Returns acquired credits - default is all waves
|
||
//-----------------------------------------------------------------------------
|
||
uint32 CMannVsMachineStats::GetAcquiredCredits( int iWaveIdx, bool bWithBonus /*= true*/ )
|
||
{
|
||
CMannVsMachineLocalWaveStats waveStats = GetWaveStats( iWaveIdx );
|
||
|
||
if ( bWithBonus )
|
||
return waveStats.nCreditsAcquired + waveStats.nCreditsBonus;
|
||
else
|
||
return waveStats.nCreditsAcquired;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Returns dropped credits for a target wave. If target wave is -1, returns sum of all waves
|
||
//-----------------------------------------------------------------------------
|
||
uint32 CMannVsMachineStats::GetDroppedCredits( int iWaveIdx )
|
||
{
|
||
CMannVsMachineLocalWaveStats waveStats = GetWaveStats( iWaveIdx );
|
||
return waveStats.nCreditsDropped;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Number of Credits missed (dropped and not collected)
|
||
//-----------------------------------------------------------------------------
|
||
uint32 CMannVsMachineStats::GetMissedCredits( int iWaveIdx )
|
||
{
|
||
CMannVsMachineLocalWaveStats waveStats = GetWaveStats( iWaveIdx );
|
||
return waveStats.nCreditsDropped - waveStats.nCreditsAcquired;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Returns credit bonus for a target wave. If target wave is -1, returns sum of all waves
|
||
//-----------------------------------------------------------------------------
|
||
uint32 CMannVsMachineStats::GetBonusCredits( int iWaveIdx )
|
||
{
|
||
CMannVsMachineLocalWaveStats waveStats = GetWaveStats( iWaveIdx );
|
||
return waveStats.nCreditsBonus;
|
||
}
|
||
//=============================================================================//
|
||
#ifdef GAME_DLL
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::RoundOver( bool bHumansWon )
|
||
{
|
||
// Send Stats to OGS
|
||
// Increment server wave id since victory uses the previous "wave" and this one has yet to be incremented
|
||
m_iServerWaveID++;
|
||
SW_ReportWaveSummary( m_iCurrentWaveIdx, bHumansWon );
|
||
m_iServerWaveID--;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::SetCurrentWave( uint32 idxWave )
|
||
{
|
||
// Advancing Wave, compact in the stats
|
||
if ( idxWave > m_iCurrentWaveIdx )
|
||
{
|
||
m_runningTotalWaveStats += m_previousWaveStats;
|
||
m_previousWaveStats = m_currentWaveStats;
|
||
}
|
||
|
||
if ( idxWave == 0 )
|
||
{
|
||
// Purge it all
|
||
m_runningTotalWaveStats.ClearStats();
|
||
m_previousWaveStats.ClearStats();
|
||
m_currentWaveStats.ClearStats();
|
||
}
|
||
|
||
m_iCurrentWaveIdx = idxWave;
|
||
|
||
// Notify Players of Reset of current Wave for PlayerStats
|
||
CBroadcastRecipientFilter filter;
|
||
filter.MakeReliable();
|
||
|
||
UserMessageBegin( filter, "MVMResetPlayerWaveSpendingStats" );
|
||
WRITE_BYTE( (uint8)m_iCurrentWaveIdx );
|
||
MessageEnd();
|
||
|
||
ResetWaveStats();
|
||
OnStatsChanged();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::RoundEvent_WaveStart()
|
||
{
|
||
// Starting a new wave
|
||
// Report the previous successful wave.
|
||
if ( m_iCurrentWaveIdx > 0 && m_currentWaveStats.nAttempts == 0)
|
||
{
|
||
SW_ReportWaveSummary( m_iCurrentWaveIdx - 1, true );
|
||
}
|
||
|
||
// reset stats
|
||
ResetWaveStats();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::RoundEvent_WaveEnd( bool bSuccess )
|
||
{
|
||
// if failed, report immediately,
|
||
// report successes on starting the next wave because of currency picked up late
|
||
ConVar *sv_cheats = g_pCVar->FindVar( "sv_cheats" );
|
||
if ( !bSuccess && ( !sv_cheats || !sv_cheats->GetBool() ) )
|
||
{
|
||
m_currentWaveStats.nAttempts++;
|
||
SW_ReportWaveSummary( m_iCurrentWaveIdx, false );
|
||
ResetWaveStats();
|
||
OnStatsChanged();
|
||
|
||
CBroadcastRecipientFilter filter;
|
||
filter.MakeReliable();
|
||
UserMessageBegin( filter, "MVMWaveFailed" );
|
||
MessageEnd();
|
||
}
|
||
|
||
// Send a User message to Clients to send there data
|
||
// Tell each client their damage
|
||
CUtlVector< CTFPlayer * > playerVector;
|
||
CollectPlayers( &playerVector, TF_TEAM_PVE_DEFENDERS );
|
||
for( int i=0; i<playerVector.Count(); ++i )
|
||
{
|
||
CTFPlayer *player = playerVector[i];
|
||
CMannVsMachinePlayerStats stats = m_playerStats[player->entindex()];
|
||
|
||
CSingleUserRecipientFilter filter( player );
|
||
filter.MakeReliable();
|
||
|
||
// ServerWaveID(2), deaths(1), damageBot(4), damageGiant(4), damageTank(4)
|
||
UserMessageBegin( filter, "MVMWaveChange" );
|
||
WRITE_WORD( (uint16)m_iServerWaveID );
|
||
WRITE_BYTE( (uint8)stats.nDeaths );
|
||
WRITE_LONG( stats.nBotDamage );
|
||
WRITE_LONG( stats.nGiantDamage );
|
||
WRITE_LONG( stats.nTankDamage );
|
||
MessageEnd();
|
||
}
|
||
|
||
// Increment the ServerId
|
||
m_iServerWaveID++;
|
||
Q_memset( m_playerStats, 0, sizeof( m_playerStats ) );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::RoundEvent_AcquiredCredits( uint32 idxWave, int nAmount, bool bIsBonus )
|
||
{
|
||
if ( idxWave == (int)m_iCurrentWaveIdx )
|
||
{
|
||
if ( bIsBonus )
|
||
{
|
||
m_currentWaveStats.nCreditsBonus += nAmount;
|
||
}
|
||
else
|
||
{
|
||
m_currentWaveStats.nCreditsAcquired += nAmount;
|
||
}
|
||
}
|
||
else if ( idxWave == m_iCurrentWaveIdx - 1 )
|
||
{
|
||
if ( bIsBonus )
|
||
{
|
||
m_previousWaveStats.nCreditsBonus += nAmount;
|
||
}
|
||
else
|
||
{
|
||
m_previousWaveStats.nCreditsAcquired += nAmount;
|
||
}
|
||
}
|
||
|
||
OnStatsChanged();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::RoundEvent_CreditsDropped( uint32 idxWave, int nAmount )
|
||
{
|
||
if ( idxWave == m_iCurrentWaveIdx )
|
||
{
|
||
m_currentWaveStats.nCreditsDropped += nAmount;
|
||
}
|
||
else if ( idxWave == m_iCurrentWaveIdx - 1 )
|
||
{
|
||
m_previousWaveStats.nCreditsDropped += nAmount;
|
||
}
|
||
OnStatsChanged();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_PointsChanged( CTFPlayer *pTFPlayer, int nPoints )
|
||
{
|
||
//
|
||
// Deprecated
|
||
//
|
||
|
||
//if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
// return;
|
||
|
||
//OnStatsChanged();
|
||
//NotifyPlayerEvent( pTFPlayer, m_iCurrentWaveIdx, kMVMEvent_Player_Points, nPoints );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_Died( CTFPlayer *pTFPlayer )
|
||
{
|
||
if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
return;
|
||
|
||
m_playerStats[pTFPlayer->entindex()].nDeaths += 1;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_Upgraded( CTFPlayer *pTFPlayer, uint16 nItemDef, uint16 nAttributeDef, uint8 nQuality, int16 nCost, bool bIsBottle )
|
||
{
|
||
if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
return;
|
||
|
||
OnStatsChanged();
|
||
|
||
CBroadcastRecipientFilter filter;
|
||
filter.MakeReliable();
|
||
|
||
// PlayerIdx(1), WaveIdx(1), ItemDef(2), AttributeDef(2), Quality(1), cost(2)
|
||
// send user message
|
||
UserMessageBegin( filter, "MVMPlayerUpgradedEvent" );
|
||
WRITE_BYTE( (uint8)pTFPlayer->entindex() );
|
||
WRITE_BYTE( (uint8)m_iCurrentWaveIdx );
|
||
WRITE_WORD( nItemDef );
|
||
WRITE_WORD( nAttributeDef );
|
||
WRITE_BYTE( nQuality);
|
||
WRITE_WORD( nCost );
|
||
MessageEnd();
|
||
|
||
if ( bIsBottle )
|
||
{
|
||
NotifyTargetPlayerEvent( pTFPlayer, m_iCurrentWaveIdx, kMVMEvent_Player_BoughtBottle, nCost );
|
||
}
|
||
else
|
||
{
|
||
NotifyTargetPlayerEvent( pTFPlayer, m_iCurrentWaveIdx, kMVMEvent_Player_BoughtUpgrade, nCost );
|
||
}
|
||
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_PickedUpCredits( CTFPlayer *pTFPlayer, uint32 idxWave, int nCreditsAmount )
|
||
{
|
||
if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
return;
|
||
|
||
OnStatsChanged();
|
||
NotifyPlayerEvent( pTFPlayer, idxWave, kMVMEvent_Player_PickedUpCredits, nCreditsAmount );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_BoughtInstantRespawn( CTFPlayer *pTFPlayer, int nCost )
|
||
{
|
||
if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
return;
|
||
|
||
m_currentWaveStats.nBuyBacks++;
|
||
OnStatsChanged();
|
||
|
||
NotifyTargetPlayerEvent( pTFPlayer, m_iCurrentWaveIdx, kMVMEvent_Player_BoughtInstantRespawn, nCost );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_DealtDamageToBots( CTFPlayer *pTFPlayer, int damage )
|
||
{
|
||
if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
return;
|
||
|
||
m_playerStats[pTFPlayer->entindex()].nBotDamage += damage;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_DealtDamageToGiants( CTFPlayer *pTFPlayer, int damage )
|
||
{
|
||
if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
return;
|
||
|
||
m_playerStats[pTFPlayer->entindex()].nGiantDamage += damage;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::PlayerEvent_DealtDamageToTanks( CTFPlayer *pTFPlayer, int damage )
|
||
{
|
||
if ( pTFPlayer->IsBot() || !TFGameRules() || !TFGameRules()->IsPVEModeActive() )
|
||
return;
|
||
|
||
m_playerStats[pTFPlayer->entindex()].nTankDamage += damage;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::NotifyPlayerEvent( CTFPlayer *pTFPlayer, uint32 idxWave, eMannVsMachineEvent eType, int nValue, int nParam )
|
||
{
|
||
// Deprecated
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::NotifyTargetPlayerEvent( CTFPlayer *pTFPlayer, uint32 idxWave, eMannVsMachineEvent eType, int nCost )
|
||
{
|
||
CBroadcastRecipientFilter filter;
|
||
filter.MakeReliable();
|
||
|
||
// Client
|
||
UserMessageBegin( filter, "MVMLocalPlayerWaveSpendingValue" );
|
||
uint64 id = pTFPlayer->GetSteamIDAsUInt64();
|
||
|
||
WRITE_BITS( &id, 64 );
|
||
WRITE_BYTE( (uint8)idxWave );
|
||
WRITE_BYTE( (uint8)eType );
|
||
WRITE_WORD( (uint16)nCost );
|
||
MessageEnd();
|
||
|
||
// Server
|
||
uint64 steamID = pTFPlayer->GetSteamIDAsUInt64();
|
||
CPlayerWaveSpendingStats *pPlayerStats = g_pMVMStats->GetSpending( idxWave, steamID );
|
||
if ( !pPlayerStats )
|
||
return;
|
||
|
||
switch ( eType )
|
||
{
|
||
case kMVMEvent_Player_BoughtInstantRespawn:
|
||
// Don't track refunds (permanent cost)
|
||
pPlayerStats->nCreditsSpentOnBuyBacks += nCost;
|
||
break;
|
||
case kMVMEvent_Player_BoughtBottle:
|
||
// Don't track refunds (permanent cost)
|
||
pPlayerStats->nCreditsSpentOnBottles += nCost;
|
||
break;
|
||
case kMVMEvent_Player_BoughtUpgrade:
|
||
pPlayerStats->nCreditsSpentOnUpgrades += nCost;
|
||
break;
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Tell the Player What Upgrades they have
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::SendUpgradesToPlayer( CTFPlayer *pTFPlayer, CUtlVector< CUpgradeInfo > *upgrades )
|
||
{
|
||
CRecipientFilter filter;
|
||
filter.AddRecipient( pTFPlayer );
|
||
|
||
if ( upgrades == NULL )
|
||
{
|
||
UserMessageBegin( filter, "MVMLocalPlayerUpgradesClear" );
|
||
WRITE_BYTE( 0 );
|
||
MessageEnd();
|
||
return;
|
||
}
|
||
|
||
// Send the reset command
|
||
UserMessageBegin( filter, "MVMLocalPlayerUpgradesClear" );
|
||
WRITE_BYTE( 0 );
|
||
MessageEnd();
|
||
|
||
// send all the upgrades
|
||
// Class(1), ItemDef(2), Upgrade(1), cost(2)
|
||
for ( int i = 0; i < upgrades->Count(); ++i )
|
||
{
|
||
UserMessageBegin( filter, "MVMLocalPlayerUpgradesValue" );
|
||
WRITE_BYTE( (uint8)upgrades->Element(i).m_iPlayerClass );
|
||
WRITE_WORD( (uint16)upgrades->Element(i).m_itemDefIndex );
|
||
WRITE_BYTE( (uint8)upgrades->Element(i).m_upgrade );
|
||
WRITE_WORD( (uint16)upgrades->Element(i).m_nCost );
|
||
MessageEnd();
|
||
}
|
||
}
|
||
|
||
//=============================================================================//
|
||
void CMannVsMachineStats::NotifyPlayerActiveUpgradeCosts( CTFPlayer *pTFPlayer, int nSpending )
|
||
{
|
||
NotifyTargetPlayerEvent( pTFPlayer, 0, kMVMEvent_Player_ActiveUpgrades, nSpending );
|
||
}
|
||
#endif // GAME_DLL
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Clear The Player spending stats for this wave
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::ClearCurrentPlayerWaveSpendingStats( int idxWave )
|
||
{
|
||
// If the wave is different then the current, we're changing waves and need to save this stuff off if we're advancing
|
||
|
||
if ( idxWave != (int)m_iCurrentWaveIdx )
|
||
{
|
||
// if wave incremented, we changed waves to save off the previous wave data
|
||
m_prevWaveSpendingStats.RemoveAll();
|
||
|
||
FOR_EACH_MAP_FAST( m_currWaveSpendingStats, i )
|
||
{
|
||
// Save off current wave in to previous
|
||
int iWave = m_prevWaveSpendingStats.Insert(m_currWaveSpendingStats.Key(i), CPlayerWaveSpendingStats() );
|
||
m_prevWaveSpendingStats[iWave] = m_currWaveSpendingStats[i];
|
||
|
||
// Append current wave in to all prev
|
||
int allIndex = m_allPrevWaveSpendingStats.Find( m_currWaveSpendingStats.Key(i) );
|
||
if ( allIndex != m_allPrevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
m_allPrevWaveSpendingStats[allIndex] += m_currWaveSpendingStats[i];
|
||
}
|
||
else
|
||
{
|
||
allIndex = m_allPrevWaveSpendingStats.Insert( m_currWaveSpendingStats.Key(i), CPlayerWaveSpendingStats() );
|
||
m_allPrevWaveSpendingStats[allIndex] = m_currWaveSpendingStats[i];
|
||
}
|
||
}
|
||
}
|
||
// Purge away current stats
|
||
m_currWaveSpendingStats.RemoveAll();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
CPlayerWaveSpendingStats *CMannVsMachineStats::GetSpending( int iWaveIndex, uint64 steamId )
|
||
{
|
||
if ( iWaveIndex == (int)m_iCurrentWaveIdx )
|
||
{
|
||
int iWave = m_currWaveSpendingStats.Find( steamId );
|
||
if ( iWave != m_currWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
return &m_currWaveSpendingStats[iWave];
|
||
}
|
||
else
|
||
{
|
||
iWave = m_currWaveSpendingStats.Insert( steamId, CPlayerWaveSpendingStats() );
|
||
return &m_currWaveSpendingStats[iWave];
|
||
}
|
||
}
|
||
else if ( iWaveIndex == -1 )
|
||
{
|
||
int iWave = m_allPrevWaveSpendingStats.Find( steamId );
|
||
if ( iWave != m_allPrevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
return &m_allPrevWaveSpendingStats[iWave];
|
||
}
|
||
else
|
||
{
|
||
iWave = m_allPrevWaveSpendingStats.Insert( steamId, CPlayerWaveSpendingStats() );
|
||
return &m_allPrevWaveSpendingStats[iWave];
|
||
}
|
||
}
|
||
else if ( iWaveIndex == (int)(m_iCurrentWaveIdx - 1) )
|
||
{
|
||
int iWave = m_prevWaveSpendingStats.Find( steamId );
|
||
if ( iWave != m_prevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
return &m_prevWaveSpendingStats[iWave];
|
||
}
|
||
else
|
||
{
|
||
iWave = m_prevWaveSpendingStats.Insert( steamId, CPlayerWaveSpendingStats() );
|
||
return &m_prevWaveSpendingStats[iWave];
|
||
}
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int CMannVsMachineStats::GetUpgradeSpending( CTFPlayer *pTFPlayer /*= NULL*/ )
|
||
{
|
||
int spending = 0;
|
||
|
||
CSteamID steamID;
|
||
if ( pTFPlayer && pTFPlayer->GetSteamID( &steamID ) )
|
||
{
|
||
int iWave = m_currWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_currWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
spending += m_currWaveSpendingStats[iWave].nCreditsSpentOnUpgrades;
|
||
}
|
||
|
||
iWave = m_allPrevWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_allPrevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
spending += m_allPrevWaveSpendingStats[iWave].nCreditsSpentOnUpgrades;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
FOR_EACH_MAP_FAST ( m_currWaveSpendingStats, iPlayer )
|
||
{
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( CSteamID( m_currWaveSpendingStats.Key( iPlayer ) ) );
|
||
if ( pPlayer )
|
||
{
|
||
spending += m_currWaveSpendingStats[iPlayer].nCreditsSpentOnUpgrades;
|
||
}
|
||
}
|
||
|
||
FOR_EACH_MAP_FAST ( m_allPrevWaveSpendingStats, iPlayer )
|
||
{
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( CSteamID( m_allPrevWaveSpendingStats.Key( iPlayer ) ) );
|
||
if ( pPlayer )
|
||
{
|
||
spending += m_allPrevWaveSpendingStats[iPlayer].nCreditsSpentOnUpgrades;
|
||
}
|
||
}
|
||
}
|
||
|
||
return spending;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int CMannVsMachineStats::GetBottleSpending( CTFPlayer *pTFPlayer /*= NULL*/ )
|
||
{
|
||
int spending = 0;
|
||
|
||
CSteamID steamID;
|
||
if ( pTFPlayer && pTFPlayer->GetSteamID( &steamID ) )
|
||
{
|
||
int iWave = m_currWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_currWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
spending += m_currWaveSpendingStats[iWave].nCreditsSpentOnBottles;
|
||
}
|
||
|
||
iWave = m_allPrevWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_allPrevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
spending += m_allPrevWaveSpendingStats[iWave].nCreditsSpentOnBottles;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
FOR_EACH_MAP_FAST ( m_currWaveSpendingStats, iPlayer )
|
||
{
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( CSteamID( m_currWaveSpendingStats.Key( iPlayer ) ) );
|
||
if ( pPlayer )
|
||
{
|
||
spending += m_currWaveSpendingStats[iPlayer].nCreditsSpentOnBottles;
|
||
}
|
||
}
|
||
|
||
FOR_EACH_MAP_FAST ( m_allPrevWaveSpendingStats, iPlayer )
|
||
{
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( CSteamID( m_allPrevWaveSpendingStats.Key( iPlayer ) ) );
|
||
if ( pPlayer )
|
||
{
|
||
spending += m_allPrevWaveSpendingStats[iPlayer].nCreditsSpentOnBottles;
|
||
}
|
||
}
|
||
}
|
||
|
||
return spending;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int CMannVsMachineStats::GetBuyBackSpending( CTFPlayer *pTFPlayer /*= NULL*/ )
|
||
{
|
||
int spending = 0;
|
||
|
||
CSteamID steamID;
|
||
if ( pTFPlayer && pTFPlayer->GetSteamID( &steamID ) )
|
||
{
|
||
int iWave = m_currWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_currWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
spending += m_currWaveSpendingStats[iWave].nCreditsSpentOnBuyBacks;
|
||
}
|
||
|
||
iWave = m_allPrevWaveSpendingStats.Find( steamID.ConvertToUint64() );
|
||
if ( iWave != m_allPrevWaveSpendingStats.InvalidIndex() )
|
||
{
|
||
spending += m_allPrevWaveSpendingStats[iWave].nCreditsSpentOnBuyBacks;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
FOR_EACH_MAP_FAST ( m_currWaveSpendingStats, iPlayer )
|
||
{
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( CSteamID( m_currWaveSpendingStats.Key( iPlayer ) ) );
|
||
if ( pPlayer )
|
||
{
|
||
spending += m_currWaveSpendingStats[iPlayer].nCreditsSpentOnBuyBacks;
|
||
}
|
||
}
|
||
|
||
FOR_EACH_MAP_FAST ( m_allPrevWaveSpendingStats, iPlayer )
|
||
{
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( CSteamID( m_allPrevWaveSpendingStats.Key( iPlayer ) ) );
|
||
if ( pPlayer )
|
||
{
|
||
spending += m_allPrevWaveSpendingStats[iPlayer].nCreditsSpentOnBuyBacks;
|
||
}
|
||
}
|
||
}
|
||
|
||
return spending;
|
||
}
|
||
|
||
//=============================================================================//
|
||
#ifdef CLIENT_DLL
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::OnDataChanged( DataUpdateType_t updateType )
|
||
{
|
||
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Clear Local Player Upgrades
|
||
//-----------------------------------------------------------------------------
|
||
CPlayerWaveSpendingStats *CMannVsMachineStats::GetLocalSpending ( int iWaveIdx )
|
||
{
|
||
CSteamID steamId;
|
||
if ( C_TFPlayer::GetLocalTFPlayer()->GetSteamID( &steamId ) )
|
||
{
|
||
return GetSpending( iWaveIdx, steamId.ConvertToUint64() );
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Set the active upgrade costs for this player
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::SetPlayerActiveUpgradeCosts( uint64 steamId, int nSpending )
|
||
{
|
||
int iUpgrade = m_teamActiveUpgrades.Find(steamId);
|
||
if ( iUpgrade != m_teamActiveUpgrades.InvalidIndex() )
|
||
{
|
||
m_teamActiveUpgrades[iUpgrade] = nSpending;
|
||
}
|
||
else
|
||
{
|
||
m_teamActiveUpgrades.Insert( steamId, nSpending );
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Get Player Active Upgrade Costs
|
||
//-----------------------------------------------------------------------------
|
||
int CMannVsMachineStats::GetPlayerActiveUpgradeCosts( uint64 steamId64 )
|
||
{
|
||
// 0, give team total
|
||
if ( steamId64 == 0 )
|
||
{
|
||
int nSpending = 0;
|
||
FOR_EACH_MAP_FAST ( m_teamActiveUpgrades, i )
|
||
{
|
||
CSteamID steamId( m_teamActiveUpgrades.Key( i ) );
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( steamId );
|
||
if ( pPlayer )
|
||
{
|
||
nSpending += m_teamActiveUpgrades[ i ];
|
||
}
|
||
}
|
||
|
||
return nSpending;
|
||
}
|
||
else
|
||
{
|
||
CSteamID steamId( steamId64 );
|
||
CBasePlayer * pPlayer = GetPlayerBySteamID( steamId );
|
||
if ( pPlayer )
|
||
{
|
||
int iUpgrade = m_teamActiveUpgrades.Find( steamId64 );
|
||
if ( iUpgrade != m_teamActiveUpgrades.InvalidIndex() )
|
||
return m_teamActiveUpgrades[iUpgrade];
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Clear Local Player Upgrades
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::ClearLocalPlayerUpgrades ()
|
||
{
|
||
m_vecLocalPlayerUpgrades.Purge();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Add Local Player Upgrade
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::AddLocalPlayerUpgrade ( int iPlayerClass, item_definition_index_t iItemDef )
|
||
{
|
||
CUpgradeInfo upgrade;
|
||
upgrade.m_iPlayerClass = iPlayerClass;
|
||
upgrade.m_itemDefIndex = iItemDef;
|
||
upgrade.m_upgrade = 0;
|
||
upgrade.m_nCost = 0;
|
||
|
||
m_vecLocalPlayerUpgrades.AddToTail( upgrade );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int CMannVsMachineStats::GetLocalPlayerUpgradeSpending( int idxWave )
|
||
{
|
||
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
||
if ( pPlayer == NULL )
|
||
return 0;
|
||
|
||
CPlayerWaveSpendingStats *pStats = GetLocalSpending( idxWave );
|
||
return pStats ? pStats->nCreditsSpentOnUpgrades : 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int CMannVsMachineStats::GetLocalPlayerBottleSpending( int idxWave )
|
||
{
|
||
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
||
if ( pPlayer == NULL )
|
||
return 0;
|
||
|
||
CPlayerWaveSpendingStats *pStats = GetLocalSpending( idxWave );
|
||
return pStats ? pStats->nCreditsSpentOnBottles : 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
int CMannVsMachineStats::GetLocalPlayerBuyBackSpending ( int idxWave )
|
||
{
|
||
C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
|
||
if ( pPlayer == NULL )
|
||
return 0;
|
||
|
||
CPlayerWaveSpendingStats *pStats = GetLocalSpending( idxWave );
|
||
return pStats ? pStats->nCreditsSpentOnBuyBacks : 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Submits the use of MvM Credits
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::SW_ReportClientUpgradePurchase( uint8 waveIdx, uint16 nItemDef, uint16 nAttributeDef, uint8 nQuality, int16 nCost )
|
||
{
|
||
// Disabled due to bad key indexing.
|
||
// Make a V2 if this data is wanted
|
||
|
||
// Old Table
|
||
//-----------------------------------------------------------------------------
|
||
// OGS TF2ClientMvMWaveCreditSpend: MvM mode - credit spend
|
||
//-----------------------------------------------------------------------------
|
||
//START_TABLE( k_ESchemaCatalogOGS, TF2ClientMvMWaveCreditSpend, TABLE_PROP_NORMAL )
|
||
//INT_FIELD( nID, ID, int32 ) // Auto-increment fake key
|
||
//INT_FIELD( llSessionID, SessionID, uint64 )
|
||
//INT_FIELD( llServerSessionID, ServerSessionID, uint64 ) // Duplicated data from Session table due to game client anomalies
|
||
//INT_FIELD( nServerWaveID, ServerWaveID, int32 ) // Incrementing WaveId PerAttempt
|
||
//INT_FIELD( ulAccountID, AccountID, uint64 ) // Duplicated data from Session table due to game client anomalies
|
||
//INT_FIELD( nWaveNumber, WaveNumber, uint8 )
|
||
//INT_FIELD( nItemCategoryID, MvMItemCategoryID, int16 ) // References TF2MvMItemCategoryReference
|
||
//INT_FIELD( nItemNameID, MvMItemNameID, int32 ) // References TF2MvMItemNameReference
|
||
//INT_FIELD( nItemCost, ItemCost, int32 )
|
||
//INT_FIELD( RTime32EventTime, EventTime, RTime32 )
|
||
//PRIMARY_KEY_CLUSTERED( 100, nID )
|
||
//WIPE_TABLE_BETWEEN_TESTS( k_EWipePolicyWipeForAllTests )
|
||
//AUTOINCREMENT_FIELD( nID )
|
||
//PARTITION_INTERVAL( k_EPartitionIntervalDaily )
|
||
//OWNING_APPLICATION( 440 )
|
||
//END_TABLE
|
||
|
||
|
||
|
||
//#if !defined(NO_STEAM)
|
||
// ConVar *sv_cheats = g_pCVar->FindVar( "sv_cheats" );
|
||
// if ( sv_cheats && sv_cheats->GetBool() )
|
||
// return;
|
||
//
|
||
// C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
// if ( !pTFPlayer )
|
||
// return;
|
||
//
|
||
// // Get Data needed for this report
|
||
// const CEconItemAttributeDefinition *pAttributeDef = ItemSystem()->GetItemSchema()->GetAttributeDefinition( nAttributeDef );
|
||
// if ( !pAttributeDef )
|
||
// return;
|
||
//
|
||
// float flValue = 1.0f;
|
||
// if ( !MannVsMachine_GetUpgradeInfo( pAttributeDef->GetDefinitionIndex(), nQuality, flValue ) )
|
||
// return;
|
||
//
|
||
// CSteamID steamIDForPlayer;
|
||
// if ( !pTFPlayer->GetSteamID( &steamIDForPlayer ) )
|
||
// return;
|
||
//
|
||
// KeyValuesAD pKeyValues( "data" );
|
||
//
|
||
// // Create and Send the report
|
||
// //SessionId, ServerSessionId, AccountID, ServerWaveID, WaveNumber, MvMItemCategoryID, MvMItemNameID, ItemCost, EventTime
|
||
// KeyValues* pKVData = new KeyValues( "TF2ClientMvMWaveCreditSpend" );
|
||
// pKVData->SetInt( "ID", ++m_nEventID );
|
||
//
|
||
// // ServerSessionID - Auto
|
||
// // SessionID - Auto
|
||
//
|
||
// // AccountID
|
||
// pKVData->SetUint64( "AccountID", steamIDForPlayer.ConvertToUint64() );
|
||
//
|
||
// //ServerWaveID - Use provided ID not m_iServerWaveID as that may have changed
|
||
// pKVData->SetInt( "ServerWaveID", m_iServerWaveID );
|
||
//
|
||
// // WaveNumber
|
||
// pKVData->SetInt( "WaveNumber", waveIdx + 1 );
|
||
//
|
||
// // MvMItemNameID
|
||
// if ( nItemDef )
|
||
// {
|
||
// const CEconItemDefinition *pItemDef = ItemSystem()->GetItemSchema()->GetItemDefinition( nItemDef );
|
||
// pKVData->SetString( "MvMItemNameID", pItemDef->GetDefinitionName() );
|
||
// }
|
||
// else
|
||
// {
|
||
// pKVData->SetString( "MvMItemNameID", g_aPlayerClassNames_NonLocalized[ pTFPlayer->GetPlayerClass()->GetClassIndex() ] );
|
||
// }
|
||
//
|
||
// // MvMItemCategoryID
|
||
// pKVData->SetString( "MvMItemCategoryID", pAttributeDef->GetDefinitionName() );
|
||
//
|
||
// // ItemCost
|
||
// pKVData->SetInt( "ItemCost", nCost );
|
||
//
|
||
// // EventTime
|
||
// pKVData->SetInt( "EventTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
|
||
//
|
||
// // Send to DB
|
||
// GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
|
||
//
|
||
//#endif // !defined(NO_STEAM)
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Submits the use of MvM Credits
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::SW_ReportClientBuyBackPurchase ( uint8 waveIdx, uint16 nCost )
|
||
{
|
||
//#if !defined(NO_STEAM)
|
||
// ConVar *sv_cheats = g_pCVar->FindVar( "sv_cheats" );
|
||
// if ( sv_cheats && sv_cheats->GetBool() )
|
||
// return;
|
||
//
|
||
// C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
// if ( !pTFPlayer )
|
||
// return;
|
||
//
|
||
// CSteamID steamIDForPlayer;
|
||
// if ( !pTFPlayer->GetSteamID( &steamIDForPlayer ) )
|
||
// return;
|
||
//
|
||
// // Create and Send the report
|
||
// //SessionId, ServerSessionId, AccountID, ServerWaveID, WaveNumber, MvMItemCategoryID, MvMItemNameID, ItemCost, EventTime
|
||
// KeyValues* pKVData = new KeyValues( "TF2ClientMvMWaveCreditSpend" );
|
||
//
|
||
// // ID - Auto
|
||
// // ServerSessionID - Auto
|
||
// // SessionID - Auto
|
||
//
|
||
// // AccountID
|
||
// pKVData->SetUint64( "AccountID", steamIDForPlayer.ConvertToUint64() );
|
||
//
|
||
// //ServerWaveID - Use provided ID not m_iServerWaveID as that may have changed
|
||
// pKVData->SetInt( "ServerWaveID", m_iServerWaveID );
|
||
//
|
||
// // WaveNumber
|
||
// pKVData->SetInt( "WaveNumber", waveIdx + 1 );
|
||
//
|
||
// // MvMItemNameID
|
||
// static char szAnsi[64];
|
||
// g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( g_aPlayerClassNames[ pTFPlayer->GetPlayerClass()->GetClassIndex() ] ), szAnsi, sizeof(szAnsi) );
|
||
// pKVData->SetString( "MvMItemNameID", szAnsi );
|
||
//
|
||
// // MvMItemCategoryID
|
||
// pKVData->SetString( "MvMItemCategoryID", "BuyBack");
|
||
//
|
||
// // ItemCost
|
||
// pKVData->SetInt( "ItemCost", nCost );
|
||
//
|
||
// // EventTime
|
||
// pKVData->SetInt( "EventTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
|
||
//
|
||
// // Send to DB
|
||
// GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
|
||
//
|
||
//#endif // !defined(NO_STEAM)
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Submits the use of MvM Credits
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::SW_ReportClientWaveSummary( uint16 waveID, CMannVsMachinePlayerStats stats )
|
||
{
|
||
// Disabled due to bad key indexing.
|
||
// Make a V2 if this data is wanted
|
||
// Old Table
|
||
//-----------------------------------------------------------------------------
|
||
// OGS TF2ClientMvMWaveSummary: MvM mode <20> Player wave summary information
|
||
//-----------------------------------------------------------------------------
|
||
//START_TABLE( k_ESchemaCatalogOGS, TF2ClientMvMWaveSummary, TABLE_PROP_NORMAL )
|
||
//INT_FIELD( nID, ID, int32 ) // Auto-increment fake key
|
||
//INT_FIELD( nServerWaveID, ServerWaveID, int32 ) // ID of ServerMvMWaveSummary Entry this is linked with, How do we get this?
|
||
//INT_FIELD( llSessionID, SessionID, uint64 )
|
||
//INT_FIELD( llServerSessionID, ServerSessionID, uint64 ) // Duplicated data from Session table due to game client anomalies
|
||
//INT_FIELD( ulAccountID, AccountID, uint64 ) // Duplicated data from Session table due to game client anomalies
|
||
//INT_FIELD( nDamageToBots, DamageToBots, int32 )
|
||
//INT_FIELD( nDamageToTanks, DamageToTanks, int32 )
|
||
//INT_FIELD( nDamageToGiants, DamageToGiants, int32 )
|
||
//INT_FIELD( nDeaths, Deaths, uint8 )
|
||
//INT_FIELD( nClass, Class, int64 ) // References TF2ClassReference
|
||
//INT_FIELD( nPrimaryWeapon, PrimaryWeapon, int32 ) // References TF2MvMItemNameReference
|
||
//INT_FIELD( nSecondaryWeapon, SecondaryWeapon, int32 ) // References TF2MvMItemNameReference
|
||
//INT_FIELD( nMeleeWeapon, MeleeWeapon, int32 ) // References TF2MvMItemNameReference
|
||
//INT_FIELD( bHasBottle, HasBottle, int8 )
|
||
//PRIMARY_KEY_CLUSTERED( 100, nID )
|
||
//WIPE_TABLE_BETWEEN_TESTS( k_EWipePolicyWipeForAllTests )
|
||
//AUTOINCREMENT_FIELD( nID )
|
||
//PARTITION_INTERVAL( k_EPartitionIntervalDaily )
|
||
//OWNING_APPLICATION( 440 )
|
||
//END_TABLE
|
||
|
||
|
||
//#if !defined(NO_STEAM)
|
||
// ConVar *sv_cheats = g_pCVar->FindVar( "sv_cheats" );
|
||
// if ( sv_cheats && sv_cheats->GetBool() )
|
||
// return;
|
||
//
|
||
// C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
// if ( !pTFPlayer )
|
||
// return;
|
||
//
|
||
// CSteamID steamIDForPlayer;
|
||
// if ( !pTFPlayer->GetSteamID( &steamIDForPlayer ) )
|
||
// return;
|
||
//
|
||
// // Class
|
||
// int iClass = pTFPlayer->GetPlayerClass()->GetClassIndex();
|
||
//
|
||
// // Invalid Class, Spectators?
|
||
// if ( iClass < TF_FIRST_NORMAL_CLASS || iClass >= TF_LAST_NORMAL_CLASS )
|
||
// return;
|
||
//
|
||
// // Create and Send the report
|
||
// //[ID] ,[ServerWaveID] ,[SessionID] ,[AccountID] ,[DamageToBots] ,[DamageToTanks] ,[DamageToGiants]
|
||
// //,[Deaths] ,[Class] ,[PrimaryWeapon] ,[SecondaryWeapon] ,[MeleeWeapon] ,[HasBottle]
|
||
// KeyValues* pKVData = new KeyValues( "TF2ClientMvMWaveSummary" );
|
||
// pKVData->SetInt( "ID", ++m_nEventID );
|
||
//
|
||
// // ServerSessionID - Auto
|
||
// // SessionID - Auto
|
||
//
|
||
// // AccountID
|
||
// pKVData->SetUint64( "AccountID", steamIDForPlayer.ConvertToUint64() );
|
||
//
|
||
// //Damage
|
||
// pKVData->SetInt( "DamageToBots", stats.nBotDamage );
|
||
// pKVData->SetInt( "DamageToGiants", stats.nGiantDamage );
|
||
// pKVData->SetInt( "DamageToTanks", stats.nTankDamage );
|
||
//
|
||
// // Death
|
||
// pKVData->SetInt( "Deaths", stats.nDeaths );
|
||
//
|
||
// //ServerWaveID - Use provided ID not m_iServerWaveID as that may have changed
|
||
// pKVData->SetInt( "ServerWaveID", waveID );
|
||
//
|
||
// static char szAnsi[512];
|
||
// pKVData->SetString( "Class", g_aPlayerClassNames_NonLocalized[ iClass ] );
|
||
//
|
||
// // Primary
|
||
// CEconItemView *pPrimaryView = TFInventoryManager()->GetItemInLoadoutForClass( iClass, LOADOUT_POSITION_PRIMARY );
|
||
// const CEconItemDefinition *pPrimaryDef = pPrimaryView->GetItemDefinition();
|
||
//
|
||
// if ( pPrimaryDef )
|
||
// {
|
||
// g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find ( pPrimaryDef->GetItemBaseName() ) , szAnsi, sizeof(szAnsi) );
|
||
// pKVData->SetString( "PrimaryWeapon", szAnsi );
|
||
// }
|
||
//
|
||
// // Secondary
|
||
// CEconItemView *pSecondaryView = TFInventoryManager()->GetItemInLoadoutForClass( iClass, LOADOUT_POSITION_SECONDARY );
|
||
// const CEconItemDefinition *pSecondaryDef = pSecondaryView->GetItemDefinition();
|
||
//
|
||
// if ( pSecondaryDef )
|
||
// {
|
||
// g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find ( pSecondaryDef->GetItemBaseName() ) , szAnsi, sizeof(szAnsi) );
|
||
// pKVData->SetString( "SecondaryWeapon", szAnsi );
|
||
// }
|
||
//
|
||
// // Melee
|
||
// CEconItemView *pMeleeView = TFInventoryManager()->GetItemInLoadoutForClass( iClass, LOADOUT_POSITION_MELEE );
|
||
// const CEconItemDefinition *pMeleeDef = pMeleeView->GetItemDefinition();
|
||
//
|
||
// if ( pMeleeDef )
|
||
// {
|
||
// g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find ( pMeleeDef->GetItemBaseName() ) , szAnsi, sizeof(szAnsi) );
|
||
// pKVData->SetString( "MeleeWeapon", szAnsi );
|
||
// }
|
||
//
|
||
// // Check for power up bottle
|
||
// CEconItemView *pActionView = TFInventoryManager()->GetItemInLoadoutForClass( iClass, LOADOUT_POSITION_ACTION );
|
||
// //489 is bottle - Power Up Canteen (MvM)
|
||
// pKVData->SetBool( "HasBottle", pActionView->GetItemDefIndex() == 489 );
|
||
//
|
||
// // Send to DB
|
||
// GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
|
||
//
|
||
//#endif // !defined(NO_STEAM)
|
||
}
|
||
#endif // CLIENT_DLL
|
||
//=============================================================================//
|
||
//-----------------------------------------------------------------------------
|
||
// PRIVATE
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Returns a copy of the WaveStats if legit
|
||
//-----------------------------------------------------------------------------
|
||
CMannVsMachineLocalWaveStats CMannVsMachineStats::GetWaveStats( int iWaveIdx )
|
||
{
|
||
CMannVsMachineLocalWaveStats waveStats;
|
||
|
||
if ( iWaveIdx == (int)m_iCurrentWaveIdx )
|
||
{
|
||
waveStats = m_currentWaveStats;
|
||
}
|
||
else if ( iWaveIdx >= 0 && iWaveIdx == (int)m_iCurrentWaveIdx - 1 )
|
||
{
|
||
waveStats = m_previousWaveStats;
|
||
}
|
||
else if ( iWaveIdx == -1 )
|
||
{
|
||
waveStats = m_runningTotalWaveStats;
|
||
waveStats += m_previousWaveStats;
|
||
waveStats += m_currentWaveStats;
|
||
}
|
||
return waveStats;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Advances Event time for the next set of events
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::OnStatsChanged()
|
||
{
|
||
NetworkStateChanged();
|
||
}
|
||
|
||
#ifdef GAME_DLL
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Reset the tracked wave stats
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::ResetWaveStats()
|
||
{
|
||
m_currentWaveStats.ClearStats();
|
||
m_nRespecsAwardedInWave = 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Submits the WaveSummary Data to OGS
|
||
//-----------------------------------------------------------------------------
|
||
void CMannVsMachineStats::SW_ReportWaveSummary ( int waveIdx, bool bIsSuccess )
|
||
{
|
||
// Disabled due to bad key indexing.
|
||
// Make a V2 if this data is wanted
|
||
//#if !defined(NO_STEAM)
|
||
// ConVar *sv_cheats = g_pCVar->FindVar( "sv_cheats" );
|
||
// if ( sv_cheats && sv_cheats->GetBool() )
|
||
// return;
|
||
//
|
||
// CMannVsMachineWaveStats stats;
|
||
// if ( waveIdx == (int)m_iCurrentWaveIdx )
|
||
// {
|
||
// stats = m_currentWaveStats;
|
||
// }
|
||
// else if ( waveIdx == (int)m_iCurrentWaveIdx - 1)
|
||
// {
|
||
// stats = m_previousWaveStats;
|
||
// }
|
||
// else
|
||
// {
|
||
// return;
|
||
// }
|
||
//
|
||
// KeyValues* pKVData = new KeyValues( "TF2ServerMvMWaveSummary" );
|
||
//
|
||
// // ServerSessionID - Auto
|
||
// pKVData->SetUint64( "ServerSessionID", GetSteamWorksSGameStatsUploader().GetSessionID());
|
||
// pKVData->SetInt( "ID", ++m_nEventID );
|
||
// //ServerWaveID, if we won this wave, use the previous WaveID
|
||
// int iServerWaveID = m_iServerWaveID;
|
||
// if ( bIsSuccess )
|
||
// {
|
||
// iServerWaveID--;
|
||
// }
|
||
// pKVData->SetInt( "ServerWaveID", iServerWaveID );
|
||
//
|
||
// // WaveNumber
|
||
// pKVData->SetInt( "WaveNumber", waveIdx + 1 );
|
||
//
|
||
// // PopulationFileID
|
||
// pKVData->SetString( "PopulationFileID", m_pPopFileName );
|
||
//
|
||
// //// MoneyCollected
|
||
// pKVData->SetInt( "MoneyCollected", stats.nCreditsAcquired );
|
||
// //
|
||
// //// MoneyMissed
|
||
// pKVData->SetInt( "MoneyMissed", stats.nCreditsDropped - stats.nCreditsAcquired );
|
||
// //
|
||
// //// Attempts
|
||
// pKVData->SetInt( "Attempts", stats.nAttempts );
|
||
//
|
||
// // IsSuccess
|
||
// pKVData->SetBool( "IsSuccess", bIsSuccess );
|
||
//
|
||
// // IsSuccess
|
||
// bool bMannUp = false;
|
||
// bool bInLobby = false;
|
||
// CTFLobby *pLobby = GTFGCClientSystem()->GetLobby();
|
||
// if ( pLobby )
|
||
// {
|
||
// bInLobby = true;
|
||
// bMannUp = IsMannUpGroup( pLobby->GetMatchGroup() );
|
||
// }
|
||
//
|
||
// pKVData->SetBool( "IsTrustedServer", bInLobby );
|
||
//
|
||
// pKVData->SetBool( "IsMannUp", bMannUp );
|
||
//
|
||
// // EventTime
|
||
// pKVData->SetInt( "EventTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
|
||
//
|
||
// // Send to DB
|
||
// GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
|
||
//
|
||
//#endif // !defined(NO_STEAM)
|
||
}
|
||
|
||
#endif // GAME_DLL
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// End CMannVsMachineStats
|
||
//-----------------------------------------------------------------------------
|
||
|
||
void MannVsMachineStats_Init()
|
||
{
|
||
#ifdef GAME_DLL
|
||
CBaseEntity::Create( "tf_mann_vs_machine_stats", vec3_origin, vec3_angle );
|
||
#else
|
||
HOOK_MESSAGE( MVMPlayerEvent );
|
||
HOOK_MESSAGE( MVMResetPlayerStats );
|
||
HOOK_MESSAGE( MVMStatsReset );
|
||
HOOK_MESSAGE( MVMPlayerUpgradedEvent );
|
||
HOOK_MESSAGE( MVMLocalPlayerUpgradesClear );
|
||
HOOK_MESSAGE( MVMLocalPlayerUpgradesValue );
|
||
HOOK_MESSAGE( MVMResetPlayerWaveSpendingStats );
|
||
HOOK_MESSAGE( MVMLocalPlayerWaveSpendingValue );
|
||
HOOK_MESSAGE( MVMWaveChange );
|
||
HOOK_MESSAGE( MVMResetPlayerUpgradeSpending );
|
||
#endif
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Helper Functions
|
||
//-----------------------------------------------------------------------------
|
||
uint32 MannVsMachineStats_GetCurrentWave()
|
||
{
|
||
return g_pMVMStats ? g_pMVMStats->GetCurrentWave() : 0;
|
||
}
|
||
|
||
uint32 MannVsMachineStats_GetAcquiredCredits( int idxWave /*= - 1 */, bool bIncludeBonus /*= true*/ )
|
||
{
|
||
return g_pMVMStats ? g_pMVMStats->GetAcquiredCredits( idxWave, bIncludeBonus ) : 0;
|
||
}
|
||
|
||
uint32 MannVsMachineStats_GetDroppedCredits( int idxWave )
|
||
{
|
||
return g_pMVMStats ? g_pMVMStats->GetDroppedCredits( idxWave ) : 0;
|
||
}
|
||
|
||
uint32 MannVsMachineStats_GetMissedCredits( int idxWave )
|
||
{
|
||
return g_pMVMStats ? g_pMVMStats->GetMissedCredits( idxWave ) : 0;
|
||
}
|
||
|
||
CMannVsMachineStats *MannVsMachineStats_GetInstance()
|
||
{
|
||
return g_pMVMStats;
|
||
}
|
||
|
||
|
||
#ifdef GAME_DLL
|
||
|
||
void MannVsMachineStats_ResetPlayerEvents( CTFPlayer *pTFPlayer )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->ResetPlayerEvents( pTFPlayer );
|
||
}
|
||
}
|
||
|
||
void MannVsMachineStats_RoundEvent_CreditsDropped( uint32 waveIdx, int nAmount )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->RoundEvent_CreditsDropped( waveIdx, nAmount );
|
||
}
|
||
}
|
||
|
||
void MannVsMachineStats_PlayerEvent_PointsChanged( CTFPlayer *pTFPlayer, int nPoints )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->PlayerEvent_PointsChanged( pTFPlayer, nPoints );
|
||
}
|
||
}
|
||
|
||
void MannVsMachineStats_PlayerEvent_Died( CTFPlayer *pTFPlayer )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->PlayerEvent_Died( pTFPlayer );
|
||
}
|
||
}
|
||
|
||
void MannVsMachineStats_PlayerEvent_Upgraded( CTFPlayer *pTFPlayer, uint16 nItemDef, uint16 nAttributeDef, uint16 nQuality, int16 nCost, bool bIsBottle )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->PlayerEvent_Upgraded( pTFPlayer, nItemDef, nAttributeDef, nQuality, nCost, bIsBottle );
|
||
}
|
||
}
|
||
|
||
void MannVsMachineStats_PlayerEvent_PickedUpCredits( CTFPlayer *pTFPlayer, uint32 idxWave, int nCreditsAmount )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->PlayerEvent_PickedUpCredits( pTFPlayer, idxWave, nCreditsAmount );
|
||
}
|
||
}
|
||
|
||
void MannVsMachineStats_PlayerEvent_BoughtInstantRespawn( CTFPlayer *pTFPlayer, int nCost )
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->PlayerEvent_BoughtInstantRespawn( pTFPlayer, nCost );
|
||
}
|
||
}
|
||
|
||
void MannVsMachineStats_SetPopulationFile( const char * pPopulationFile)
|
||
{
|
||
if ( g_pMVMStats )
|
||
{
|
||
g_pMVMStats->SetPopFile( pPopulationFile );
|
||
}
|
||
}
|
||
|
||
#endif // GAME_DLL
|
||
|