Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

425 lines
13 KiB

//========= 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