{

public:

//=============================================================================

// HPE_BEGIN

// [dwenger] Steam Cloud Support

//=============================================================================

enum SteamCloudPersisting

{

SteamCloudPersist_Off = 0,

SteamCloudPersist_On,

};

CAchievementMgr( SteamCloudPersisting ePersistToSteamCloud = SteamCloudPersist_Off );

//=============================================================================

// HPE_END

//=============================================================================

virtual bool Init();

virtual void PostInit();

virtual void Shutdown();

virtual void LevelInitPreEntity();

virtual void LevelShutdownPreEntity();

virtual void InitializeAchievements();

virtual void Update( float frametime );

#ifdef GAME_DLL

virtual void FrameUpdatePostEntityThink();

#endif

void OnMapEvent( const char *pchEventName );

// Interfaces exported to other dlls for achievement list queries

IAchievement* GetAchievementByIndex( int index );

int GetAchievementCount();

CBaseAchievement *GetAchievementByID( int iAchievementID );

CUtlMap<int, CBaseAchievement *> &GetAchievements() { return m_mapAchievement; }

CBaseAchievement *GetAchievementByName( const char *pchName );

bool HasAchieved( const char *pchName );

void UploadUserData();

void DownloadUserData();

void SaveGlobalState( bool bAsync = false );

void LoadGlobalState();

void SaveGlobalStateIfDirty( bool bAsync = false );

void EnsureGlobalStateLoaded();

void AwardAchievement( int iAchievementID );

void UpdateAchievement( int iAchievementID, int nData );

void PreRestoreSavedGame();

void PostRestoreSavedGame();

void ResetAchievements();

void ResetAchievement( int iAchievementID );

void PrintAchievementStatus();

float GetLastClassChangeTime() { return m_flLastClassChangeTime; }

float GetTeamplayStartTime() { return m_flTeamplayStartTime; }

int GetMiniroundsCompleted() { return m_iMiniroundsCompleted; }

const char *GetMapName() { return m_szMap; }

void OnAchievementEvent( int iAchievementID, int iCount = 1 );

void CheckMetaAchievements( void );

void SetDirty( bool bDirty )

{

if (bDirty)

{

m_bGlobalStateDirty = true;

m_bSteamDataDirty = true;

}

}

//=============================================================================

// HPE_END

//=============================================================================

bool CheckAchievementsEnabled();

bool LoggedIntoSteam()

{

#if !defined(NO_STEAM)

return ( steamapicontext->SteamUser() && steamapicontext->SteamUserStats() && steamapicontext->SteamUser()->BLoggedOn() );

#else

return false;

#endif

}

float GetTimeLastUpload() { return m_flTimeLastSaved; } // time we last uploaded to Steam

bool WereCheatsEverOn( void ) { return m_bCheatsEverOn; }

#if !defined(NO_STEAM)

STEAM_CALLBACK( CAchievementMgr, Steam_OnUserStatsReceived, UserStatsReceived_t, m_CallbackUserStatsReceived );

STEAM_CALLBACK( CAchievementMgr, Steam_OnUserStatsStored, UserStatsStored_t, m_CallbackUserStatsStored );

#endif

void SetAchievementThink( CBaseAchievement *pAchievement, float flThinkTime );

private:

void FireGameEvent( IGameEvent *event );

void OnKillEvent( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event );

void ResetAchievement_Internal( CBaseAchievement *pAchievement );

void UpdateStateFromSteam_Internal();

CUtlMap<int, CBaseAchievement *> m_mapAchievement; // map of all achievements

CUtlVector<CBaseAchievement *> m_vecAchievement; // vector of all achievements for accessing by index

CUtlVector<CBaseAchievement *> m_vecKillEventListeners; // vector of achievements that are listening for kill events

CUtlVector<CBaseAchievement *> m_vecMapEventListeners; // vector of achievements that are listening for map events

CUtlVector<CBaseAchievement *> m_vecComponentListeners; // vector of achievements that are listening for components that make up an achievement

CUtlMap<int, CAchievement_AchievedCount *> m_mapMetaAchievement; // map of CAchievement_AchievedCount

struct achievementthink_t

{

float m_flThinkTime;

CBaseAchievement *pAchievement;

};

CUtlVector<achievementthink_t> m_vecThinkListeners; // vector of achievements that are actively thinking

float m_flLevelInitTime;

float m_flLastClassChangeTime; // Time when player last changed class

float m_flTeamplayStartTime; // Time when player joined a non-spectating team. Not updated if she switches game teams; cleared if she joins spectator

float m_iMiniroundsCompleted; // # of minirounds played since game start (for maps that have minirounds)

char m_szMap[MAX_PATH]; // file base of map name, cached since we access it frequently in this form

bool m_bGlobalStateDirty; // do we have interesting state changes that needs to be saved?

bool m_bSteamDataDirty; // do we have changes to upload to Steamworks?

bool m_bGlobalStateLoaded; // have we loaded global state

bool m_bCheatsEverOn; // have cheats ever been turned on in this level

float m_flTimeLastSaved; // last time we uploaded to Steam

//=============================================================================

// HPE_BEGIN

// [dwenger] Steam Cloud Support

//=============================================================================

bool m_bPersistToSteamCloud; // true = persist data to steam cloud

//=============================================================================

// HPE_END

//=============================================================================

CUtlVector<int> m_AchievementsAwarded;