178 lines
6.1 KiB
C++
178 lines
6.1 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//=======================================================================================//
|
|
|
|
#if defined( REPLAY_ENABLED )
|
|
|
|
#ifndef GENERICCLASSBASED_REPLAY_H
|
|
#define GENERICCLASSBASED_REPLAY_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
#include "replay/replay.h"
|
|
#include "replay/iclientreplaycontext.h"
|
|
#include "GameEventListener.h"
|
|
|
|
// For RoundStats_t
|
|
#include "replay/gamedefs.h"
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
extern IClientReplayContext *g_pClientReplayContext;
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
class CGenericClassBasedReplay : public CReplay,
|
|
public CGameEventListener
|
|
{
|
|
typedef CReplay BaseClass;
|
|
public:
|
|
CGenericClassBasedReplay();
|
|
~CGenericClassBasedReplay();
|
|
|
|
virtual void OnBeginRecording();
|
|
virtual void OnEndRecording();
|
|
virtual void OnComplete();
|
|
virtual bool ShouldAllowDelete() const;
|
|
virtual void OnDelete();
|
|
|
|
virtual void FireGameEvent( IGameEvent *pEvent );
|
|
|
|
virtual bool Read( KeyValues *pIn );
|
|
virtual void Write( KeyValues *pOut );
|
|
|
|
virtual void DumpGameSpecificData() const;
|
|
|
|
void SetPlayerClass( int nPlayerClass );
|
|
void SetPlayerTeam( int nPlayerTeam );
|
|
|
|
void RecordPlayerDeath( const char *pKillerName, int nKillerClass );
|
|
|
|
// Add a new kill to the list
|
|
void AddKill( const char *pPlayerName, int nPlayerClass );
|
|
|
|
// Get the player class as a string
|
|
virtual const char *GetPlayerClass() const;
|
|
|
|
// Get the player team as a string
|
|
virtual const char *GetPlayerTeam() const = 0;
|
|
|
|
// Utility to get the material-friendly player class (demoman->demo, heavyweapons->heavy)
|
|
virtual const char *GetMaterialFriendlyPlayerClass() const;
|
|
|
|
// Was there a killer?
|
|
inline bool WasKilled() const { return m_szKillerName[0] != 0; }
|
|
|
|
// Get killer name
|
|
const char *GetKillerName() const;
|
|
|
|
// Get the killer class, if there was a killer
|
|
const char *GetKillerClass() const;
|
|
|
|
int GetDownloadStatus() const;
|
|
|
|
// Kill info
|
|
struct KillData_t
|
|
{
|
|
char m_szPlayerName[MAX_OSPATH];
|
|
int m_nPlayerClass;
|
|
};
|
|
|
|
inline int GetKillCount() const { return m_vecKills.Count(); }
|
|
inline const KillData_t *GetKill( int nKillIndex ) { return m_vecKills[ nKillIndex ]; }
|
|
|
|
// A generic info struct used for dominations, assisted dominations, revenges, assisted revenged...
|
|
// Not all data members are necessarily used
|
|
struct GenericStatInfo_t
|
|
{
|
|
GenericStatInfo_t() : m_nVictimFriendId( 0 ), m_nAssisterFriendId( 0 ) {}
|
|
uint32 m_nVictimFriendId;
|
|
uint32 m_nAssisterFriendId;
|
|
};
|
|
|
|
inline int GetDominationCount() const { return m_vecDominations.Count(); }
|
|
inline const GenericStatInfo_t *GetDomination( int nIndex ) const { return m_vecDominations[ nIndex ]; }
|
|
|
|
inline int GetAssisterDominationCount() const { return m_vecAssisterDominations.Count(); }
|
|
inline const GenericStatInfo_t *GetAssisterDomination( int nIndex ) const { return m_vecAssisterDominations[ nIndex ]; }
|
|
|
|
inline int GetRevengeCount() const { return m_vecRevenges.Count(); }
|
|
inline const GenericStatInfo_t *GetRevenge( int nIndex ) const { return m_vecRevenges[ nIndex ]; }
|
|
|
|
inline int GetAssisterRevengeCount() const { return m_vecAssisterRevenges.Count(); }
|
|
inline const GenericStatInfo_t *GetAssisterRevenge( int nIndex ) const { return m_vecAssisterRevenges[ nIndex ]; }
|
|
|
|
RoundStats_t const &GetStats() const { return m_lifeStats; }
|
|
|
|
protected:
|
|
int m_nPlayerClass;
|
|
int m_nPlayerTeam;
|
|
int m_nStatUndefined;
|
|
|
|
char m_szKillerName[ MAX_OSPATH ];
|
|
int m_nKillerClass;
|
|
|
|
virtual bool IsValidClass( int nClass ) const = 0;
|
|
virtual bool IsValidTeam( int iTeam ) const = 0;
|
|
virtual bool GetCurrentStats( RoundStats_t &out ) = 0;
|
|
virtual const char *GetStatString( int iStat ) const = 0;
|
|
virtual const char *GetPlayerClass( int iClass ) const = 0;
|
|
|
|
virtual void Update();
|
|
|
|
// Domination
|
|
void AddDomination( int nVictimID );
|
|
void AddAssisterDomination( int nVictimID, int nAssiterID );
|
|
|
|
void AddRevenge( int nVictimID );
|
|
void AddAssisterRevenge( int nVictimID, int nAssiterID );
|
|
|
|
float GetKillScreenshotDelay();
|
|
|
|
RoundStats_t m_refStats; // Reference stats, used to compute current stats
|
|
RoundStats_t m_lifeStats; // Stats for this life, based on reference stats (m_refStats)
|
|
|
|
private:
|
|
void MedicUpdate();
|
|
|
|
bool GetFriendIdFromUserId( int nPlayerIndex, uint32 &nFriendIdOut ) const; // Get a friend ID based on player index. Returns true on success
|
|
void AddKillStatFromUserIds( CUtlVector< GenericStatInfo_t * > &vec, int nVictimId, int nAssisterId = 0 );
|
|
void AddKillStatFromFriendIds( CUtlVector< GenericStatInfo_t * > &vec, uint32 nVictimFriendId, uint32 nAssisterFriendId = 0 );
|
|
void WriteKillStatVector( CUtlVector< GenericStatInfo_t * > const &vec, const char *pSubKeyName, const char *pElementKeyName,
|
|
KeyValues *pRootKey, int nNumMembersToWrite ) const;
|
|
void AddKillStats( CUtlVector< GenericStatInfo_t * > &vecKillStats, KeyValues *pIn, const char *pSubKeyName, int iStatIndex );
|
|
void RecordUpdatedStats();
|
|
|
|
CUtlVector< KillData_t * > m_vecKills;
|
|
CUtlVector< GenericStatInfo_t * > m_vecDominations;
|
|
CUtlVector< GenericStatInfo_t * > m_vecAssisterDominations;
|
|
CUtlVector< GenericStatInfo_t * > m_vecRevenges;
|
|
CUtlVector< GenericStatInfo_t * > m_vecAssisterRevenges;
|
|
|
|
// TODO... dominations, achievements, etc.
|
|
};
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
inline CGenericClassBasedReplay *ToGenericClassBasedReplay( CReplay *pClientReplay )
|
|
{
|
|
return static_cast< CGenericClassBasedReplay * >( pClientReplay );
|
|
}
|
|
|
|
inline const CGenericClassBasedReplay *ToGenericClassBasedReplay( const CReplay *pClientReplay )
|
|
{
|
|
return static_cast< const CGenericClassBasedReplay * >( pClientReplay );
|
|
}
|
|
|
|
inline CGenericClassBasedReplay *GetGenericClassBasedReplay( ReplayHandle_t hReplay )
|
|
{
|
|
return ToGenericClassBasedReplay( g_pClientReplayContext->GetReplay( hReplay ) );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
|
|
#endif // GENERICCLASSBASED_REPLAY_H
|
|
|
|
#endif |