426 lines
13 KiB
C++
426 lines
13 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Entity that propagates mann vs machine stats
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef TF_MANN_VS_MACHINE_STATS_H
|
|
#define TF_MANN_VS_MACHINE_STATS_H
|
|
|
|
#include "tf_player_shared.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
#define CTFPlayer C_TFPlayer
|
|
#define CMannVsMachineStats C_MannVsMachineStats
|
|
#define CMannVsMachineWaveStats C_MannVsMachineWaveStats
|
|
#define CMannVsMachineLocalWaveStats C_MannVsMachineLocalWaveStats
|
|
#define CMannVsMachineUpgradeEvent C_MannVsMachineUpgradeEvent
|
|
#define CMannVsMachinePlayerWaveStats C_MannVsMachinePlayerWaveStats
|
|
class C_TFPlayer;
|
|
#else
|
|
class CTFPlayer;
|
|
#endif
|
|
|
|
//class CMannVsMachineStats;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Public interface to hide the inner-workings (which allows me to iterate on it and not force everyone to recompile)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The types of events sent down to clients. Add to the end of the appropriate section
|
|
// for backwards compatibility.
|
|
enum eMannVsMachineEvent
|
|
{
|
|
kMVMEvent_Player_Points,
|
|
kMVMEvent_Player_Death,
|
|
kMVMEvent_Player_PickedUpCredits,
|
|
kMVMEvent_Player_BoughtInstantRespawn,
|
|
kMVMEvent_Player_BoughtBottle,
|
|
kMVMEvent_Player_BoughtUpgrade,
|
|
kMVMEvent_Player_ActiveUpgrades,
|
|
// max
|
|
kMVMEvent_Max = 255
|
|
};
|
|
|
|
enum eMvMEnemyTypes
|
|
{
|
|
kMvMEnemy_Bot,
|
|
kMvMEnemy_Giant,
|
|
kMvMEnemy_Tank
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Stats for a wave
|
|
struct CMannVsMachineWaveStats
|
|
{
|
|
CMannVsMachineWaveStats()
|
|
{
|
|
nCreditsDropped = 0;
|
|
nCreditsAcquired = 0;
|
|
nCreditsBonus = 0;
|
|
nPlayerDeaths = 0;
|
|
nBuyBacks = 0;
|
|
nAttempts = 0;
|
|
}
|
|
|
|
void ClearStats ()
|
|
{
|
|
nCreditsDropped = 0;
|
|
nCreditsAcquired = 0;
|
|
nCreditsBonus = 0;
|
|
nPlayerDeaths = 0;
|
|
nBuyBacks = 0;
|
|
nAttempts = 0;
|
|
}
|
|
|
|
void operator+=( const CMannVsMachineWaveStats &rhs )
|
|
{
|
|
nCreditsDropped += rhs.nCreditsDropped;
|
|
nCreditsAcquired += rhs.nCreditsAcquired;
|
|
nCreditsBonus += rhs.nCreditsBonus;
|
|
nPlayerDeaths += rhs.nPlayerDeaths;
|
|
nBuyBacks += rhs.nBuyBacks;
|
|
nAttempts += rhs.nAttempts;
|
|
}
|
|
|
|
DECLARE_EMBEDDED_NETWORKVAR();
|
|
DECLARE_CLASS_NOBASE( CMannVsMachineWaveStats );
|
|
|
|
CNetworkVar( uint32, nCreditsDropped );
|
|
CNetworkVar( uint32, nCreditsAcquired );
|
|
CNetworkVar( uint32, nCreditsBonus );
|
|
CNetworkVar( uint32, nPlayerDeaths );
|
|
CNetworkVar( uint32, nBuyBacks );
|
|
CNetworkVar( uint32, nAttempts );
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Stats for a wave
|
|
struct CMannVsMachineLocalWaveStats
|
|
{
|
|
CMannVsMachineLocalWaveStats()
|
|
{
|
|
nCreditsDropped = 0;
|
|
nCreditsAcquired = 0;
|
|
nCreditsBonus = 0;
|
|
nPlayerDeaths = 0;
|
|
nBuyBacks = 0;
|
|
nAttempts = 0;
|
|
}
|
|
|
|
CMannVsMachineLocalWaveStats( const CMannVsMachineLocalWaveStats &rhs )
|
|
{
|
|
nCreditsDropped = rhs.nCreditsDropped;
|
|
nCreditsAcquired = rhs.nCreditsAcquired;
|
|
nCreditsBonus = rhs.nCreditsBonus;
|
|
nPlayerDeaths = rhs.nPlayerDeaths;
|
|
nBuyBacks = rhs.nBuyBacks;
|
|
nAttempts = rhs.nAttempts;
|
|
}
|
|
|
|
CMannVsMachineLocalWaveStats operator=( const CMannVsMachineLocalWaveStats &rhs )
|
|
{
|
|
nCreditsDropped = rhs.nCreditsDropped;
|
|
nCreditsAcquired = rhs.nCreditsAcquired;
|
|
nCreditsBonus = rhs.nCreditsBonus;
|
|
nPlayerDeaths = rhs.nPlayerDeaths;
|
|
nBuyBacks = rhs.nBuyBacks;
|
|
nAttempts = rhs.nAttempts;
|
|
return *this;
|
|
}
|
|
|
|
CMannVsMachineLocalWaveStats operator=( const CMannVsMachineWaveStats &rhs )
|
|
{
|
|
nCreditsDropped = rhs.nCreditsDropped;
|
|
nCreditsAcquired = rhs.nCreditsAcquired;
|
|
nCreditsBonus = rhs.nCreditsBonus;
|
|
nPlayerDeaths = rhs.nPlayerDeaths;
|
|
nBuyBacks = rhs.nBuyBacks;
|
|
nAttempts = rhs.nAttempts;
|
|
return *this;
|
|
}
|
|
|
|
void operator+=( const CMannVsMachineWaveStats &rhs )
|
|
{
|
|
nCreditsDropped += rhs.nCreditsDropped;
|
|
nCreditsAcquired += rhs.nCreditsAcquired;
|
|
nCreditsBonus += rhs.nCreditsBonus;
|
|
nPlayerDeaths += rhs.nPlayerDeaths;
|
|
nBuyBacks += rhs.nBuyBacks;
|
|
nAttempts += rhs.nAttempts;
|
|
}
|
|
|
|
uint32 nCreditsDropped;
|
|
uint32 nCreditsAcquired;
|
|
uint32 nCreditsBonus;
|
|
uint32 nPlayerDeaths;
|
|
uint32 nBuyBacks;
|
|
uint32 nAttempts;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Player stats for a wave
|
|
struct CMannVsMachineUpgradeEvent
|
|
{
|
|
uint16 nItemDef;
|
|
uint16 nAttributeDef;
|
|
uint16 nQuality;
|
|
};
|
|
typedef CUtlVector< CMannVsMachineUpgradeEvent > tMVMUpgradesVector;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
struct CMannVsMachinePlayerStats
|
|
{
|
|
CMannVsMachinePlayerStats()
|
|
: nDeaths( 0 )
|
|
, nBotDamage( 0 )
|
|
, nGiantDamage( 0 )
|
|
, nTankDamage( 0 )
|
|
{
|
|
}
|
|
|
|
CMannVsMachinePlayerStats( const CMannVsMachinePlayerStats &rhs )
|
|
{
|
|
nDeaths = rhs.nDeaths;
|
|
nBotDamage = rhs.nBotDamage;
|
|
nGiantDamage = rhs.nGiantDamage;
|
|
nTankDamage = rhs.nTankDamage;
|
|
}
|
|
|
|
uint32 nDeaths;
|
|
uint32 nBotDamage;
|
|
uint32 nGiantDamage;
|
|
uint32 nTankDamage;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
struct CPlayerWaveSpendingStats
|
|
{
|
|
CPlayerWaveSpendingStats()
|
|
: nCreditsSpentOnBuyBacks( 0 )
|
|
, nCreditsSpentOnBottles( 0 )
|
|
, nCreditsSpentOnUpgrades ( 0 )
|
|
{
|
|
}
|
|
|
|
CPlayerWaveSpendingStats( const CPlayerWaveSpendingStats &rhs )
|
|
{
|
|
nCreditsSpentOnBuyBacks = rhs.nCreditsSpentOnBuyBacks;
|
|
nCreditsSpentOnBottles = rhs.nCreditsSpentOnBottles;
|
|
nCreditsSpentOnUpgrades = rhs.nCreditsSpentOnUpgrades;
|
|
}
|
|
|
|
CPlayerWaveSpendingStats operator=( const CPlayerWaveSpendingStats &rhs )
|
|
{
|
|
nCreditsSpentOnBuyBacks = rhs.nCreditsSpentOnBuyBacks;
|
|
nCreditsSpentOnBottles = rhs.nCreditsSpentOnBottles;
|
|
nCreditsSpentOnUpgrades = rhs.nCreditsSpentOnUpgrades;
|
|
return *this;
|
|
}
|
|
|
|
void operator+=( const CPlayerWaveSpendingStats &rhs )
|
|
{
|
|
nCreditsSpentOnBuyBacks += rhs.nCreditsSpentOnBuyBacks;
|
|
nCreditsSpentOnBottles += rhs.nCreditsSpentOnBottles;
|
|
nCreditsSpentOnUpgrades += rhs.nCreditsSpentOnUpgrades;
|
|
}
|
|
|
|
uint32 nCreditsSpentOnBuyBacks;
|
|
uint32 nCreditsSpentOnBottles;
|
|
uint32 nCreditsSpentOnUpgrades; // Bottles are NOT upgrades in this list
|
|
};
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// initialize the stats for Mann Vs Machine
|
|
void MannVsMachineStats_Init();
|
|
|
|
// get the current wave
|
|
uint32 MannVsMachineStats_GetCurrentWave();
|
|
|
|
// Reporting currency stats for game code
|
|
uint32 MannVsMachineStats_GetAcquiredCredits( int idxWave = -1, bool bIncludeBonus = true );
|
|
uint32 MannVsMachineStats_GetDroppedCredits( int idxWave = -1 );
|
|
uint32 MannVsMachineStats_GetMissedCredits( int idxWave = -1 );
|
|
|
|
#ifdef GAME_DLL
|
|
|
|
struct edict_t;
|
|
|
|
// Reset the player events associated with the player, such as when they disconnect
|
|
void MannVsMachineStats_ResetPlayerEvents( CTFPlayer *pTFPlayer );
|
|
|
|
// Round events
|
|
void MannVsMachineStats_RoundEvent_CreditsDropped( uint32 waveIdx, int nAmount );
|
|
|
|
// Player events
|
|
void MannVsMachineStats_PlayerEvent_PointsChanged( CTFPlayer *pTFPlayer, int nPoints );
|
|
void MannVsMachineStats_PlayerEvent_Died( CTFPlayer *pTFPlayer );
|
|
void MannVsMachineStats_PlayerEvent_Upgraded( CTFPlayer *pTFPlayer, uint16 nItemDef, uint16 nAttributeDef, uint16 nQuality, int16 nCost, bool bIsBottle );
|
|
void MannVsMachineStats_PlayerEvent_PickedUpCredits( CTFPlayer *pTFPlayer, uint32 idxWave, int nCreditsAmount );
|
|
void MannVsMachineStats_PlayerEvent_BoughtInstantRespawn( CTFPlayer *pTFPlayer, int nCost );
|
|
|
|
void MannVsMachineStats_SetPopulationFile( const char * pPopulationFile );
|
|
#endif // GAME_DLL
|
|
|
|
#ifdef CLIENT_DLL
|
|
float MannVsMachineStats_GetFirstEventTime();
|
|
float MannVsMachineStats_GetLastEventTime();
|
|
#endif // end defined(CLIENT_DLL)
|
|
|
|
struct CAllPlayerSpendingStats
|
|
{
|
|
CPlayerWaveSpendingStats m_playerStats[MAX_PLAYERS+1];
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Container class for all the mann vs machine stats we track for a round and for a player
|
|
class CMannVsMachineStats : public CBaseEntity
|
|
{
|
|
DECLARE_CLASS( CMannVsMachineStats, CBaseEntity );
|
|
public:
|
|
DECLARE_NETWORKCLASS();
|
|
|
|
CMannVsMachineStats();
|
|
virtual ~CMannVsMachineStats();
|
|
|
|
uint32 GetCurrentWave() const { return m_iCurrentWaveIdx; }
|
|
|
|
// CBaseEntity
|
|
virtual int ObjectCaps( void ) { return BaseClass::ObjectCaps() | FCAP_DONT_SAVE; }
|
|
|
|
void ResetStats( );
|
|
void ResetPlayerEvents( CTFPlayer *pTFPlayer );
|
|
void ResetUpgradeSpending( CTFPlayer *pTFPlayer );
|
|
|
|
// Dropped, Acquired stats
|
|
uint32 GetAcquiredCredits( int iWaveIdx, bool bWithBonus = true );
|
|
uint32 GetDroppedCredits( int iWaveIdx );
|
|
uint32 GetMissedCredits( int iWaveIdx );
|
|
uint32 GetBonusCredits ( int iWaveIdx );
|
|
|
|
#ifdef GAME_DLL
|
|
virtual int UpdateTransmitState( void ) { return SetTransmitState( FL_EDICT_ALWAYS ); }
|
|
|
|
void SetMapName ( const char *pMapName ) { m_pMapName = pMapName; }
|
|
void SetPopFile ( const char *pPopFile ) { m_pPopFileName = pPopFile; }
|
|
|
|
// Call when the round is over
|
|
void RoundOver( bool bHumansWon );
|
|
|
|
// Set the current wave that will be updated
|
|
void SetCurrentWave( uint32 idxWave );
|
|
|
|
// Round events.
|
|
void RoundEvent_WaveStart();
|
|
void RoundEvent_WaveEnd( bool bSuccess );
|
|
void RoundEvent_AcquiredCredits( uint32 idxWave, int nAmount, bool bIsBonus );
|
|
void RoundEvent_CreditsDropped( uint32 waveIdx, int nAmount );
|
|
|
|
// player events
|
|
void PlayerEvent_PointsChanged( CTFPlayer *pTFPlayer, int nPoints );
|
|
void PlayerEvent_Died( CTFPlayer *pTFPlayer );
|
|
void PlayerEvent_Upgraded( CTFPlayer *pTFPlayer, uint16 nItemDef, uint16 nAttributeDef, uint8 nQuality, int16 nCost, bool bIsBottle );
|
|
void PlayerEvent_PickedUpCredits( CTFPlayer *pTFPlayer, uint32 idxWave, int nCreditsAmount );
|
|
void PlayerEvent_BoughtInstantRespawn( CTFPlayer *pTFPlayer, int nCost );
|
|
|
|
void PlayerEvent_DealtDamageToBots( CTFPlayer *pTFPlayer, int damage );
|
|
void PlayerEvent_DealtDamageToGiants( CTFPlayer *pTFPlayer, int damage );
|
|
void PlayerEvent_DealtDamageToTanks( CTFPlayer *pTFPlayer, int damage );
|
|
|
|
// send a user message to clients so that they can record what's going on a per player basis
|
|
void NotifyPlayerEvent( CTFPlayer *pTFPlayer, uint32 idxWave, eMannVsMachineEvent eType, int nValue, int nParam = 0 );
|
|
void NotifyTargetPlayerEvent( CTFPlayer *pTFPlayer, uint32 idxWave, eMannVsMachineEvent eType, int nCost );
|
|
|
|
void SendUpgradesToPlayer( CTFPlayer *pTFPlayer, CUtlVector< CUpgradeInfo > *upgrades );
|
|
|
|
void NotifyPlayerActiveUpgradeCosts( CTFPlayer *pTFPlayer, int nSpending );
|
|
|
|
#endif // GAME_DLL
|
|
|
|
// Shared stats
|
|
void ClearCurrentPlayerWaveSpendingStats( int idxWave );
|
|
CPlayerWaveSpendingStats *GetSpending( int iWaveIndex, uint64 steamId );
|
|
int GetUpgradeSpending( CTFPlayer *pTFPlayer = NULL );
|
|
int GetBottleSpending( CTFPlayer *pTFPlayer = NULL );
|
|
int GetBuyBackSpending( CTFPlayer *pTFPlayer = NULL );
|
|
|
|
#ifdef CLIENT_DLL
|
|
virtual void OnDataChanged( DataUpdateType_t updateType );
|
|
|
|
// Message from Server about Client Upgrades
|
|
void ClearLocalPlayerUpgrades ();
|
|
void AddLocalPlayerUpgrade( int iPlayerClass, item_definition_index_t iItemDef );
|
|
|
|
int GetLocalPlayerUpgradeSpending( int idxWave );
|
|
int GetLocalPlayerBottleSpending( int idxWave );
|
|
int GetLocalPlayerBuyBackSpending ( int idxWave );
|
|
|
|
// Client Side Reporting
|
|
void SW_ReportClientUpgradePurchase( uint8 waveIdx, uint16 nItemDef, uint16 nAttributeDef, uint8 nQuality, int16 nCost );
|
|
void SW_ReportClientBuyBackPurchase( uint8 waveIdx, uint16 nCost );
|
|
void SW_ReportClientWaveSummary( uint16 serverWaveID, CMannVsMachinePlayerStats stats );
|
|
|
|
CUtlVector< CUpgradeInfo > *GetLocalPlayerUpgrades() { return &m_vecLocalPlayerUpgrades; }
|
|
CPlayerWaveSpendingStats *GetLocalSpending ( int iWaveIdx ); // Helper
|
|
|
|
void SetPlayerActiveUpgradeCosts( uint64 playerId, int nSpending );
|
|
int GetPlayerActiveUpgradeCosts( uint64 playerId );
|
|
|
|
#endif // CLIENT_DLL
|
|
|
|
// Respec
|
|
uint16 GetNumRespecsEarnedInWave( void ) { return m_nRespecsAwardedInWave; }
|
|
uint32 GetAcquiredCreditsForRespec( void ) { return m_iCurrencyCollectedForRespec; }
|
|
#ifdef GAME_DLL
|
|
void SetNumRespecsEarnedInWave( uint16 nNum ) { m_nRespecsAwardedInWave = nNum; }
|
|
void SetAcquiredCreditsForRespec( uint16 nNum ) { m_iCurrencyCollectedForRespec = nNum; }
|
|
#endif // GAME_DLL
|
|
|
|
private:
|
|
// helper
|
|
CMannVsMachineLocalWaveStats GetWaveStats( int iWaveIdx );
|
|
|
|
void OnStatsChanged();
|
|
|
|
#ifdef GAME_DLL
|
|
|
|
void ResetWaveStats();
|
|
|
|
// Submitting Data to OGS
|
|
void SW_ReportWaveSummary ( int waveIndex, bool bIsSuccess );
|
|
|
|
CMannVsMachinePlayerStats m_playerStats[MAX_PLAYERS+1];
|
|
|
|
const char *m_pPopFileName;
|
|
const char *m_pMapName;
|
|
|
|
#endif // GAME_DLL
|
|
|
|
CMannVsMachineWaveStats m_runningTotalWaveStats;
|
|
CMannVsMachineWaveStats m_previousWaveStats;
|
|
CMannVsMachineWaveStats m_currentWaveStats;
|
|
|
|
CNetworkVar( uint32, m_iCurrentWaveIdx );
|
|
CNetworkVar( uint32, m_iServerWaveID );
|
|
|
|
// Shared stats
|
|
CUtlMap< uint64, CPlayerWaveSpendingStats > m_currWaveSpendingStats;
|
|
CUtlMap< uint64, CPlayerWaveSpendingStats > m_prevWaveSpendingStats; // CurrWave - 1
|
|
CUtlMap< uint64, CPlayerWaveSpendingStats > m_allPrevWaveSpendingStats; // Total of all previous Waves
|
|
|
|
// Respec
|
|
CNetworkVar( uint32, m_iCurrencyCollectedForRespec ); // Tracks total money collected, regardless of wave status
|
|
CNetworkVar( uint16, m_nRespecsAwardedInWave );
|
|
|
|
#ifdef CLIENT_DLL
|
|
CUtlVector< CUpgradeInfo > m_vecLocalPlayerUpgrades;
|
|
|
|
CUtlMap< uint64, int > m_teamActiveUpgrades;
|
|
#endif
|
|
};
|
|
|
|
CMannVsMachineStats *MannVsMachineStats_GetInstance();
|
|
|
|
#endif // TF_MANN_VS_MACHINE_STATS_H
|