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.
534 lines
16 KiB
534 lines
16 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
//============================================================================= |
|
|
|
#ifndef EP2_GAMESTATS_H |
|
#define EP2_GAMESTATS_H |
|
#ifdef _WIN32 |
|
#pragma once |
|
#endif |
|
|
|
#include "ep1_gamestats.h" |
|
#include "tier1/utlstring.h" |
|
|
|
#include <time.h> |
|
|
|
// EP2 Game Stats |
|
enum Ep2GameStatsVersions_t |
|
{ |
|
EP2_GAMESTATS_FILE_VERSION_01 = 001, |
|
EP2_GAMESTATS_FILE_VERSION_02 = 002, |
|
|
|
EP2_GAMESTATS_CURRENT_VERSION = EP2_GAMESTATS_FILE_VERSION_02, |
|
}; |
|
|
|
enum Ep2GameStatsLumpIds_t |
|
{ |
|
EP2STATS_LUMP_HEADER = 1, |
|
EP2STATS_LUMP_DEATH, |
|
EP2STATS_LUMP_NPC, |
|
EP2STATS_LUMP_WEAPON, |
|
EP2STATS_LUMP_SAVEGAMEINFO, |
|
EP2STATS_LUMP_TAG, |
|
EP2STATS_LUMP_GENERIC, |
|
EP2_MAX_LUMP_COUNT |
|
}; |
|
|
|
// EP2 Game Level Stats Data |
|
struct Ep2LevelStats_t |
|
{ |
|
public: |
|
enum FloatCounterTypes_t |
|
{ |
|
COUNTER_DAMAGETAKEN = 0, |
|
|
|
NUM_FLOATCOUNTER_TYPES, |
|
}; |
|
|
|
enum IntCounterTypes_t |
|
{ |
|
COUNTER_CRATESSMASHED = 0, |
|
COUNTER_OBJECTSPUNTED, |
|
COUNTER_VEHICULARHOMICIDES, |
|
COUNTER_DISTANCE_INVEHICLE, |
|
COUNTER_DISTANCE_ONFOOT, |
|
COUNTER_DISTANCE_ONFOOTSPRINTING, |
|
COUNTER_FALLINGDEATHS, |
|
COUNTER_VEHICLE_OVERTURNED, |
|
COUNTER_LOADGAME_STILLALIVE, |
|
COUNTER_LOADS, |
|
COUNTER_SAVES, |
|
COUNTER_GODMODES, |
|
COUNTER_NOCLIPS, |
|
|
|
NUM_INTCOUNTER_TYPES, |
|
}; |
|
|
|
Ep2LevelStats_t() : |
|
m_bInitialized( false ), |
|
m_flLevelStartTime( 0.0f ) |
|
{ |
|
Q_memset( m_IntCounters, 0, sizeof( m_IntCounters ) ); |
|
Q_memset( m_FloatCounters, 0, sizeof( m_FloatCounters ) ); |
|
} |
|
~Ep2LevelStats_t() |
|
{ |
|
} |
|
|
|
Ep2LevelStats_t( const Ep2LevelStats_t &other ) |
|
{ |
|
m_bInitialized = other.m_bInitialized; |
|
m_flLevelStartTime = other.m_flLevelStartTime; |
|
m_Header = other.m_Header; |
|
m_aPlayerDeaths = other.m_aPlayerDeaths; |
|
Q_memcpy( m_IntCounters, other.m_IntCounters, sizeof( m_IntCounters ) ); |
|
Q_memcpy( m_FloatCounters, other.m_FloatCounters, sizeof( m_FloatCounters ) ); |
|
int i; |
|
for ( i = other.m_dictEntityDeaths.First(); i != other.m_dictEntityDeaths.InvalidIndex(); i = other.m_dictEntityDeaths.Next( i ) ) |
|
{ |
|
m_dictEntityDeaths.Insert( other.m_dictEntityDeaths.GetElementName( i ), other.m_dictEntityDeaths[ i ] ); |
|
} |
|
for ( i = other.m_dictWeapons.First(); i != other.m_dictWeapons.InvalidIndex(); i = other.m_dictWeapons.Next( i ) ) |
|
{ |
|
m_dictWeapons.Insert( other.m_dictWeapons.GetElementName( i ), other.m_dictWeapons[ i ] ); |
|
} |
|
m_SaveGameInfo = other.m_SaveGameInfo; |
|
} |
|
|
|
// Create and destroy. |
|
void Init( const char *pszMapName, float flStartTime, char const *pchTag, int nMapVersion ) |
|
{ |
|
// Initialize. |
|
m_Header.m_iVersion = EP2_GAMESTATS_CURRENT_VERSION; |
|
Q_strncpy( m_Header.m_szMapName, pszMapName, sizeof( m_Header.m_szMapName ) ); |
|
m_Header.m_flTime = 0.0f; |
|
|
|
// Start the level timer. |
|
m_flLevelStartTime = flStartTime; |
|
|
|
Q_strncpy( m_Tag.m_szTagText, pchTag, sizeof( m_Tag.m_szTagText ) ); |
|
m_Tag.m_nMapVersion = nMapVersion; |
|
} |
|
|
|
void Shutdown( float flEndTime ) |
|
{ |
|
m_Header.m_flTime = flEndTime - m_flLevelStartTime; |
|
} |
|
|
|
void AppendToBuffer( CUtlBuffer &SaveBuffer ) |
|
{ |
|
// Always write out as current version |
|
m_Header.m_iVersion = EP2_GAMESTATS_CURRENT_VERSION; |
|
|
|
// Write out the lumps. |
|
CBaseGameStats::AppendLump( EP2_MAX_LUMP_COUNT, SaveBuffer, EP2STATS_LUMP_HEADER, 1, sizeof( Ep2LevelStats_t::LevelHeader_t ), static_cast<void*>( &m_Header ) ); |
|
CBaseGameStats::AppendLump( EP2_MAX_LUMP_COUNT, SaveBuffer, EP2STATS_LUMP_TAG, 1, sizeof( Ep2LevelStats_t::Tag_t ), static_cast< void * >( &m_Tag ) ); |
|
CBaseGameStats::AppendLump( EP2_MAX_LUMP_COUNT, SaveBuffer, EP2STATS_LUMP_DEATH, m_aPlayerDeaths.Count(), sizeof( Ep2LevelStats_t::PlayerDeathsLump_t ), static_cast<void*>( m_aPlayerDeaths.Base() ) ); |
|
{ |
|
CUtlBuffer buf; |
|
buf.Put( (const void *)m_IntCounters, sizeof( m_IntCounters ) ); |
|
buf.Put( (const void *)m_FloatCounters, sizeof( m_FloatCounters ) ); |
|
buf.PutInt( m_dictEntityDeaths.Count() ); |
|
for ( int i = m_dictEntityDeaths.First(); i != m_dictEntityDeaths.InvalidIndex(); i = m_dictEntityDeaths.Next( i ) ) |
|
{ |
|
buf.PutString( m_dictEntityDeaths.GetElementName( i ) ); |
|
buf.Put( (const void *)&m_dictEntityDeaths[ i ], sizeof( Ep2LevelStats_t::EntityDeathsLump_t ) ); |
|
} |
|
CBaseGameStats::AppendLump( EP2_MAX_LUMP_COUNT, SaveBuffer, EP2STATS_LUMP_NPC, 1, buf.TellPut(), buf.Base() ); |
|
} |
|
{ |
|
CUtlBuffer buf; |
|
buf.PutInt( m_dictWeapons.Count() ); |
|
for ( int i = m_dictWeapons.First(); i != m_dictWeapons.InvalidIndex(); i = m_dictWeapons.Next( i ) ) |
|
{ |
|
buf.PutString( m_dictWeapons.GetElementName( i ) ); |
|
buf.Put( (const void *)&m_dictWeapons[ i ], sizeof( Ep2LevelStats_t::WeaponLump_t ) ); |
|
} |
|
CBaseGameStats::AppendLump( EP2_MAX_LUMP_COUNT, SaveBuffer, EP2STATS_LUMP_WEAPON, 1, buf.TellPut(), buf.Base() ); |
|
} |
|
{ |
|
CUtlBuffer buf; |
|
buf.PutString( m_SaveGameInfo.m_sCurrentSaveFile.String() ); |
|
buf.PutInt( m_SaveGameInfo.m_nCurrentSaveFileTime ); |
|
buf.PutInt( m_SaveGameInfo.m_Records.Count() ); |
|
for ( int i = 0 ; i < m_SaveGameInfo.m_Records.Count(); ++i ) |
|
{ |
|
buf.Put( (const void *)&m_SaveGameInfo.m_Records[ i ], sizeof( Ep2LevelStats_t::SaveGameInfoRecord2_t ) ); |
|
} |
|
CBaseGameStats::AppendLump( EP2_MAX_LUMP_COUNT, SaveBuffer, EP2STATS_LUMP_SAVEGAMEINFO, 1, buf.TellPut(), buf.Base() ); |
|
} |
|
{ |
|
CUtlBuffer buf; |
|
buf.PutShort( Ep2LevelStats_t::GenericStatsLump_t::LumpVersion ); |
|
buf.PutInt( m_dictGeneric.Count() ); |
|
for ( int i = m_dictGeneric.First(); i != m_dictGeneric.InvalidIndex(); i = m_dictGeneric.Next( i ) ) |
|
{ |
|
buf.PutString( m_dictGeneric.GetElementName( i ) ); |
|
buf.Put( (const void *)&m_dictGeneric[ i ], sizeof( Ep2LevelStats_t::GenericStatsLump_t ) ); |
|
} |
|
CBaseGameStats::AppendLump( EP2_MAX_LUMP_COUNT, SaveBuffer, EP2STATS_LUMP_GENERIC, 1, buf.TellPut(), buf.Base() ); |
|
} |
|
} |
|
|
|
static void LoadData( CUtlDict<Ep2LevelStats_t, unsigned short>& items, CUtlBuffer &LoadBuffer ) |
|
{ |
|
// Read the next lump. |
|
unsigned short iLump = 0; |
|
unsigned short iLumpCount = 0; |
|
|
|
Ep2LevelStats_t *pItem = NULL; |
|
|
|
while( CBaseGameStats::GetLumpHeader( EP2_MAX_LUMP_COUNT, LoadBuffer, iLump, iLumpCount, true ) ) |
|
{ |
|
switch ( iLump ) |
|
{ |
|
case EP2STATS_LUMP_HEADER: |
|
{ |
|
Ep2LevelStats_t::LevelHeader_t header; |
|
CBaseGameStats::LoadLump( LoadBuffer, iLumpCount, sizeof( Ep2LevelStats_t::LevelHeader_t ), &header ); |
|
pItem = &items[ items.Insert( header.m_szMapName ) ]; |
|
pItem->m_Header = header; |
|
pItem->m_Tag.Clear(); |
|
Assert( pItem ); |
|
} |
|
break; |
|
case EP2STATS_LUMP_TAG: |
|
{ |
|
Assert( pItem ); |
|
CBaseGameStats::LoadLump( LoadBuffer, iLumpCount, sizeof( Ep2LevelStats_t::Tag_t ), &pItem->m_Tag ); |
|
} |
|
break; |
|
case EP2STATS_LUMP_DEATH: |
|
{ |
|
Assert( pItem ); |
|
pItem->m_aPlayerDeaths.SetCount( iLumpCount ); |
|
CBaseGameStats::LoadLump( LoadBuffer, iLumpCount, sizeof( Ep2LevelStats_t::PlayerDeathsLump_t ), static_cast<void*>( pItem->m_aPlayerDeaths.Base() ) ); |
|
} |
|
break; |
|
case EP2STATS_LUMP_NPC: |
|
{ |
|
Assert( pItem ); |
|
LoadBuffer.Get( ( void * )pItem->m_IntCounters, sizeof( pItem->m_IntCounters ) ); |
|
LoadBuffer.Get( ( void * )pItem->m_FloatCounters, sizeof( pItem->m_FloatCounters ) ); |
|
int c = LoadBuffer.GetInt(); |
|
for ( int i = 0 ; i < c; ++i ) |
|
{ |
|
Ep2LevelStats_t::EntityDeathsLump_t data; |
|
char npcName[ 512 ]; |
|
LoadBuffer.GetString( npcName, sizeof( npcName ) ); |
|
LoadBuffer.Get( &data, sizeof( data ) ); |
|
pItem->m_dictEntityDeaths.Insert( npcName, data ); |
|
} |
|
} |
|
break; |
|
case EP2STATS_LUMP_WEAPON: |
|
{ |
|
Assert( pItem ); |
|
int c = LoadBuffer.GetInt(); |
|
for ( int i = 0 ; i < c; ++i ) |
|
{ |
|
Ep2LevelStats_t::WeaponLump_t data; |
|
char weaponName[ 512 ]; |
|
LoadBuffer.GetString( weaponName, sizeof( weaponName ) ); |
|
LoadBuffer.Get( &data, sizeof( data ) ); |
|
pItem->m_dictWeapons.Insert( weaponName, data ); |
|
} |
|
} |
|
break; |
|
case EP2STATS_LUMP_SAVEGAMEINFO: |
|
{ |
|
Assert( pItem ); |
|
Ep2LevelStats_t::SaveGameInfo_t *info = &pItem->m_SaveGameInfo; |
|
char sz[ 512 ]; |
|
LoadBuffer.GetString( sz, sizeof( sz ) ); |
|
info->m_sCurrentSaveFile = sz; |
|
info->m_nCurrentSaveFileTime = LoadBuffer.GetInt(); |
|
int c = LoadBuffer.GetInt(); |
|
for ( int i = 0 ; i < c; ++i ) |
|
{ |
|
Ep2LevelStats_t::SaveGameInfoRecord2_t rec; |
|
if ( pItem->m_Header.m_iVersion >= EP2_GAMESTATS_FILE_VERSION_02 ) |
|
{ |
|
LoadBuffer.Get( &rec, sizeof( rec ) ); |
|
} |
|
else |
|
{ |
|
size_t s = sizeof( Ep2LevelStats_t::SaveGameInfoRecord_t ); |
|
LoadBuffer.Get( &rec, s ); |
|
} |
|
info->m_Records.AddToTail( rec ); |
|
} |
|
info->m_pCurrentRecord = NULL; |
|
if ( info->m_Records.Count() > 0 ) |
|
{ |
|
info->m_pCurrentRecord = &info->m_Records[ info->m_Records.Count() - 1 ]; |
|
} |
|
} |
|
break; |
|
case EP2STATS_LUMP_GENERIC: |
|
{ |
|
Assert( pItem ); |
|
int version = LoadBuffer.GetShort(); |
|
if ( version == Ep2LevelStats_t::GenericStatsLump_t::LumpVersion ) |
|
{ |
|
int c = LoadBuffer.GetInt(); |
|
Assert( c < 2 * 1024 * 1024 ); |
|
for ( int i = 0 ; i < c; ++i ) |
|
{ |
|
Ep2LevelStats_t::GenericStatsLump_t data; |
|
char pchStatName[ 512 ]; |
|
LoadBuffer.GetString( pchStatName, sizeof( pchStatName ) ); |
|
LoadBuffer.Get( &data, sizeof( data ) ); |
|
pItem->m_dictGeneric.Insert( pchStatName, data ); |
|
} |
|
} |
|
else |
|
{ |
|
Error( "Unsupported GenericStatsLump_t::LumpVersion" ); |
|
} |
|
} |
|
break; |
|
} |
|
} |
|
} |
|
|
|
public: |
|
// Level header data. |
|
struct LevelHeader_t |
|
{ |
|
static const unsigned short LumpId = EP2STATS_LUMP_HEADER; // Lump ids. |
|
byte m_iVersion; // Version of the game stats file. |
|
char m_szMapName[64]; // Name of the map. |
|
float m_flTime; // Time spent in level. |
|
}; |
|
|
|
// Simple "tag" applied to all data in database (e.g., "PLAYTEST") |
|
struct Tag_t |
|
{ |
|
static const unsigned short LumpId = EP2STATS_LUMP_TAG; |
|
|
|
void Clear() |
|
{ |
|
Q_memset( m_szTagText, 0, sizeof( m_szTagText ) ); |
|
m_nMapVersion = 0; |
|
} |
|
|
|
char m_szTagText[ 8 ]; |
|
int m_nMapVersion; |
|
}; |
|
|
|
// Player deaths. |
|
struct PlayerDeathsLump_t |
|
{ |
|
static const unsigned short LumpId = EP2STATS_LUMP_DEATH; // Lump ids. |
|
short nPosition[3]; // Position of death. |
|
// short iWeapon; // Weapon that killed the player. |
|
// byte iAttackClass; // Class that killed the player. |
|
// byte iTargetClass; // Class of the player killed. |
|
}; |
|
|
|
struct EntityDeathsLump_t |
|
{ |
|
static const unsigned short LumpId = EP2STATS_LUMP_NPC; |
|
|
|
EntityDeathsLump_t() : |
|
m_nBodyCount( 0u ), |
|
m_nKilledPlayer( 0u ) |
|
{ |
|
} |
|
|
|
EntityDeathsLump_t( const EntityDeathsLump_t &other ) |
|
{ |
|
m_nBodyCount = other.m_nBodyCount; |
|
m_nKilledPlayer = other.m_nKilledPlayer; |
|
} |
|
|
|
unsigned int m_nBodyCount; // Number killed by player |
|
unsigned int m_nKilledPlayer; // Number of times entity killed player |
|
}; |
|
|
|
struct WeaponLump_t |
|
{ |
|
static const unsigned short LumpId = EP2STATS_LUMP_WEAPON; |
|
|
|
WeaponLump_t() : |
|
m_nShots( 0 ), |
|
m_nHits( 0 ), |
|
m_flDamageInflicted( 0.0 ) |
|
{ |
|
} |
|
|
|
WeaponLump_t( const WeaponLump_t &other ) |
|
{ |
|
m_nShots = other.m_nShots; |
|
m_nHits = other.m_nHits; |
|
m_flDamageInflicted = other.m_flDamageInflicted; |
|
} |
|
|
|
unsigned int m_nShots; |
|
unsigned int m_nHits; |
|
double m_flDamageInflicted; |
|
}; |
|
|
|
struct SaveGameInfoRecord_t |
|
{ |
|
SaveGameInfoRecord_t() : |
|
m_nFirstDeathIndex( -1 ), |
|
m_nNumDeaths( 0 ), |
|
m_nSaveHealth( -1 ) |
|
{ |
|
Q_memset( m_nSavePos, 0, sizeof( m_nSavePos ) ); |
|
} |
|
|
|
int m_nFirstDeathIndex; |
|
int m_nNumDeaths; |
|
// Health and player pos from the save file |
|
short m_nSavePos[ 3 ]; |
|
short m_nSaveHealth; |
|
}; |
|
|
|
#pragma pack( 1 ) |
|
// Adds save game type |
|
struct SaveGameInfoRecord2_t : public SaveGameInfoRecord_t |
|
{ |
|
enum SaveType_t |
|
{ |
|
TYPE_UNKNOWN = 0, |
|
TYPE_AUTOSAVE, |
|
TYPE_USERSAVE |
|
}; |
|
|
|
SaveGameInfoRecord2_t() : |
|
m_SaveType( (byte)TYPE_UNKNOWN ) |
|
{ |
|
} |
|
|
|
byte m_SaveType; |
|
}; |
|
#pragma pack() |
|
|
|
struct SaveGameInfo_t |
|
{ |
|
static const unsigned short LumpId = EP2STATS_LUMP_SAVEGAMEINFO; |
|
|
|
SaveGameInfo_t() : |
|
m_nCurrentSaveFileTime( 0 ), |
|
m_pCurrentRecord( NULL ) |
|
{ |
|
} |
|
|
|
void Latch( char const *pchSaveName, time_t uFileTime ) |
|
{ |
|
m_pCurrentRecord = &m_Records[ m_Records.AddToTail() ]; |
|
m_nCurrentSaveFileTime = uFileTime; |
|
m_sCurrentSaveFile = pchSaveName; |
|
} |
|
|
|
CUtlVector< SaveGameInfoRecord2_t > m_Records; |
|
SaveGameInfoRecord2_t *m_pCurrentRecord; |
|
time_t m_nCurrentSaveFileTime; |
|
CUtlString m_sCurrentSaveFile; |
|
}; |
|
|
|
struct GenericStatsLump_t |
|
{ |
|
static const unsigned short LumpId = EP2STATS_LUMP_GENERIC; |
|
static const unsigned short LumpVersion = 1; |
|
|
|
GenericStatsLump_t() : |
|
m_unCount( 0u ), |
|
m_flCurrentValue( 0.0 ) |
|
{ |
|
m_Pos[ 0 ] = m_Pos[ 1 ] = m_Pos[ 2 ] = 0; |
|
} |
|
|
|
short m_Pos[ 3 ]; |
|
unsigned int m_unCount; |
|
double m_flCurrentValue; |
|
}; |
|
|
|
// Data. |
|
LevelHeader_t m_Header; // Level header. |
|
Tag_t m_Tag; |
|
CUtlVector<PlayerDeathsLump_t> m_aPlayerDeaths; // List of player deaths. |
|
CUtlDict< EntityDeathsLump_t, int > m_dictEntityDeaths; |
|
CUtlDict< WeaponLump_t, int > m_dictWeapons; |
|
CUtlDict< GenericStatsLump_t, int > m_dictGeneric; |
|
|
|
SaveGameInfo_t m_SaveGameInfo; |
|
float m_FloatCounters[ NUM_FLOATCOUNTER_TYPES ]; |
|
uint64 m_IntCounters[ NUM_INTCOUNTER_TYPES ]; |
|
|
|
// Temporary data. |
|
bool m_bInitialized; // Has the map Map Stat Data been initialized. |
|
float m_flLevelStartTime; |
|
}; |
|
|
|
#if defined( GAME_DLL ) |
|
class CEP2GameStats : public CEP1GameStats |
|
{ |
|
typedef CEP1GameStats BaseClass; |
|
|
|
public: |
|
CEP2GameStats(); |
|
virtual ~CEP2GameStats(); |
|
|
|
virtual CBaseGameStats *OnInit( CBaseGameStats *pCurrentGameStats, char const *gamedir ) { return pCurrentGameStats; } |
|
|
|
virtual bool UserPlayedAllTheMaps( void ); |
|
virtual const char *GetStatSaveFileName( void ); |
|
virtual const char *GetStatUploadRegistryKeyName( void ); |
|
|
|
// Buffers. |
|
virtual void AppendCustomDataToSaveBuffer( CUtlBuffer &SaveBuffer ); |
|
virtual void LoadCustomDataFromBuffer( CUtlBuffer &LoadBuffer ); |
|
|
|
// Events |
|
virtual void Event_LevelInit( void ); |
|
virtual void Event_PlayerKilled( CBasePlayer *pPlayer, const CTakeDamageInfo &info ); |
|
virtual void Event_PlayerDamage( CBasePlayer *pBasePlayer, const CTakeDamageInfo &info ); |
|
virtual void Event_PlayerKilledOther( CBasePlayer *pAttacker, CBaseEntity *pVictim, const CTakeDamageInfo &info ); |
|
virtual void Event_CrateSmashed(); |
|
virtual void Event_Punted( CBaseEntity *pObject ); |
|
virtual void Event_PlayerTraveled( CBasePlayer *pBasePlayer, float distanceInInches, bool bInVehicle, bool bSprinting ); |
|
virtual void Event_WeaponFired( CBasePlayer *pShooter, bool bPrimary, char const *pchWeaponName ); |
|
virtual void Event_WeaponHit( CBasePlayer *pShooter, bool bPrimary, char const *pchWeaponName, const CTakeDamageInfo &info ); |
|
virtual void Event_SaveGame( void ); |
|
virtual void Event_LoadGame( void ); |
|
virtual void Event_FlippedVehicle( CBasePlayer *pDriver, CPropVehicleDriveable *pVehicle ); |
|
// Called before .sav file is actually loaded (player should still be in previous level, if any) |
|
virtual void Event_PreSaveGameLoaded( char const *pSaveName, bool bInGame ); |
|
virtual void Event_PlayerEnteredGodMode( CBasePlayer *pBasePlayer ); |
|
virtual void Event_PlayerEnteredNoClip( CBasePlayer *pBasePlayer ); |
|
virtual void Event_DecrementPlayerEnteredNoClip( CBasePlayer *pBasePlayer ); |
|
// Generic statistics lump |
|
virtual void Event_IncrementCountedStatistic( const Vector& vecAbsOrigin, char const *pchStatisticName, float flIncrementAmount ); |
|
|
|
public: //FIXME: temporary used for CC_ListDeaths command |
|
Ep2LevelStats_t *FindOrAddMapStats( const char *szMapName ); |
|
|
|
public: |
|
|
|
Ep2LevelStats_t::EntityDeathsLump_t *FindDeathsLump( char const *npcName ); |
|
Ep2LevelStats_t::WeaponLump_t *FindWeaponsLump( char const *pchWeaponName, bool bPrimary ); |
|
Ep2LevelStats_t::GenericStatsLump_t *FindGenericLump( char const *pchStatName ); |
|
// Utilities. |
|
Ep2LevelStats_t *GetCurrentMap( void ) { return m_pCurrentMap; } |
|
|
|
Ep2LevelStats_t *m_pCurrentMap; |
|
CUtlDict<Ep2LevelStats_t, unsigned short> m_dictMapStats; |
|
enum |
|
{ |
|
INVEHICLE = 0, |
|
ONFOOT, |
|
ONFOOTSPRINTING, |
|
|
|
NUM_TRAVEL_TYPES |
|
}; |
|
float m_flInchesRemainder[ NUM_TRAVEL_TYPES ]; |
|
}; |
|
#endif |
|
|
|
#endif // EP2_GAMESTATS_H
|
|
|