1

game/shared/baseachievement.h

@@ -0,0 +1,270 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef BASEACHIEVEMENT_H
+#define BASEACHIEVEMENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "GameEventListener.h"
+#include "hl2orange.spa.h"
+#include "iachievementmgr.h"
+
+class CAchievementMgr;
+
+//
+// Base class for achievements
+//
+
+class CBaseAchievement : public CGameEventListener, public IAchievement
+{
+	DECLARE_CLASS_NOBASE( CBaseAchievement );
+public:
+	CBaseAchievement();	
+	virtual ~CBaseAchievement();
+	virtual void Init() {}
+	virtual void ListenForEvents() {};
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event );
+
+	int GetAchievementID() { return m_iAchievementID; }
+	void SetAchievementID( int iAchievementID ) { m_iAchievementID = iAchievementID; }
+	void SetName( const char *pszName ) { m_pszName = pszName; }
+	const char *GetName() { return m_pszName; }
+	const char *GetStat() { return m_pszStat?m_pszStat:GetName(); }
+	void SetFlags( int iFlags );
+	int GetFlags() { return m_iFlags; }
+	void SetGoal( int iGoal ) { m_iGoal = iGoal; }
+	int GetGoal() { return m_iGoal; }
+	void SetGameDirFilter( const char *pGameDir );
+	bool HasComponents() { return ( m_iFlags & ACH_HAS_COMPONENTS ) > 0; }	
+	void SetPointValue( int iPointValue ) { m_iPointValue = iPointValue; }
+	int	GetPointValue() { return m_iPointValue; }
+	bool ShouldHideUntilAchieved() { return m_bHideUntilAchieved; }
+	void SetHideUntilAchieved( bool bHide ) { m_bHideUntilAchieved = bHide; }
+	void SetStoreProgressInSteam( bool bStoreProgressInSteam ) { m_bStoreProgressInSteam = bStoreProgressInSteam; }
+	bool StoreProgressInSteam() { return m_bStoreProgressInSteam; }
+	virtual bool ShouldShowProgressNotification() { return true; }
+	virtual void OnPlayerStatsUpdate() {}
+
+	virtual bool ShouldSaveWithGame();
+	bool ShouldSaveGlobal();
+	virtual void PreRestoreSavedGame();
+	virtual void PostRestoreSavedGame();
+	void SetCount( int iCount ) { m_iCount = iCount; }
+	int GetCount() { return m_iCount; }
+	void SetProgressShown( int iProgressShown ) { m_iProgressShown = iProgressShown; }
+	int GetProgressShown() { return m_iProgressShown; }
+	virtual bool IsAchieved() { return m_bAchieved; }
+	virtual bool IsActive();
+	virtual bool LocalPlayerCanEarn( void ) { return true; }
+	void SetAchieved( bool bAchieved ) { m_bAchieved = bAchieved; }
+	virtual bool IsMetaAchievement() { return false; }
+	virtual bool AlwaysListen() { return false; }
+	virtual bool AlwaysEnabled() { return false; }
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] Notification method for derived classes
+	//=============================================================================
+	
+	virtual void OnAchieved() {}
+	uint32 GetUnlockTime() const { return m_uUnlockTime; }
+	void SetUnlockTime( uint32 unlockTime ) { m_uUnlockTime = unlockTime; }
+	
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	uint64 GetComponentBits() { return m_iComponentBits; }
+	void SetComponentBits( uint64 iComponentBits );
+	void OnComponentEvent( const char *pchComponentName );
+	void EnsureComponentBitSetAndEvaluate( int iBitNumber );
+	void EvaluateIsAlreadyAchieved();
+	virtual void OnMapEvent( const char *pEventName );
+	virtual void PrintAdditionalStatus() {}		// for debugging, achievements may report additional status in achievement_status concmd
+	virtual void OnSteamUserStatsStored() {}
+	virtual void UpdateAchievement( int nData ) {}
+	virtual bool ShouldShowOnHUD() { return m_bShowOnHUD; }
+	virtual void SetShowOnHUD( bool bShow );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] Serialization methods
+	//=============================================================================
+	
+	virtual void GetSettings( KeyValues* pNodeOut );				// serialize
+	virtual void ApplySettings( /* const */ KeyValues* pNodeIn );	// unserialize
+	
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	virtual void Think( void ) { return; }
+
+	const char *GetMapNameFilter( void ){ return m_pMapNameFilter; }
+	CAchievementMgr *GetAchievementMgr( void ){ return m_pAchievementMgr; }
+
+protected:
+	virtual void FireGameEvent( IGameEvent *event );
+	virtual void FireGameEvent_Internal( IGameEvent *event ) {};
+	void SetVictimFilter( const char *pClassName );
+	void SetAttackerFilter( const char *pClassName );
+	void SetInflictorFilter( const char *pClassName );
+	void SetInflictorEntityNameFilter( const char *pEntityName );
+	void SetMapNameFilter( const char *pMapName );
+	void SetComponentPrefix( const char *pPrefix );
+	void IncrementCount( int iOptIncrement = 0 );
+	void EvaluateNewAchievement();
+	void AwardAchievement();
+	void ShowProgressNotification();
+	void HandleProgressUpdate();
+	virtual void CalcProgressMsgIncrement();
+	void SetNextThink( float flThinkTime );
+	void ClearThink( void );
+	void SetStat( const char* pStatName ) { m_pszStat = pStatName; }
+
+	const char *m_pszName;								// name of this achievement
+	const char *m_pszStat;								// stat this achievement uses
+	int m_iAchievementID;								// ID of this achievement
+	int	m_iFlags;										// ACH_* flags for this achievement
+	int	m_iGoal;										// goal # of steps to award this achievement
+	int m_iProgressMsgIncrement;						// after how many steps show we show a progress notification
+	int m_iProgressMsgMinimum;							// the minimum progress needed before showing progress notification
+	int m_iPointValue;									// # of points this achievement is worth (currently only used for XBox Live)
+	bool m_bHideUntilAchieved;							// should this achievement be hidden until achieved?
+	bool m_bStoreProgressInSteam;						// should incremental progress be stored in Steam.  A counter with same name as achievement must be set up in Steam.
+	const char *m_pInflictorClassNameFilter;			// if non-NULL, inflictor class name to filter with
+	const char *m_pInflictorEntityNameFilter;			// if non-NULL, inflictor entity name to filter with
+	const char *m_pVictimClassNameFilter;				// if non-NULL, victim class name to filter with
+	const char *m_pAttackerClassNameFilter;				// if non-NULL, attacker class name to filter with
+	const char *m_pMapNameFilter;						// if non-NULL, map name to filter with
+	const char *m_pGameDirFilter;						// if non-NULL, game dir name to filter with
+
+	const char **m_pszComponentNames;			
+	int			m_iNumComponents;
+	const char *m_pszComponentPrefix;
+	int			m_iComponentPrefixLen;
+	bool		m_bAchieved;							// is this achievement achieved
+	uint32		m_uUnlockTime;							// time_t that this achievement was unlocked (0 if before Steamworks unlock time support)
+	int			m_iCount;								// # of steps satisfied toward this achievement (only valid if not achieved)
+	int			m_iProgressShown;						// # of progress msgs we've shown
+	uint64		m_iComponentBits;						// bitfield of components achieved
+	CAchievementMgr *m_pAchievementMgr;					// our achievement manager
+	bool		m_bShowOnHUD;							// if set, the player wants this achievement pinned to the HUD
+
+	friend class CAchievementMgr;
+public:
+	DECLARE_DATADESC();
+};
+
+class CFailableAchievement : public CBaseAchievement
+{
+	DECLARE_CLASS( CFailableAchievement, CBaseAchievement );
+public:
+	CFailableAchievement();
+	void SetFailed();	
+
+	virtual bool ShouldSaveWithGame();
+	virtual void PreRestoreSavedGame();
+	virtual void PostRestoreSavedGame();
+	virtual bool IsAchieved() { return !m_bFailed && BaseClass::IsAchieved(); }
+	virtual bool IsActive() { return m_bActivated && !m_bFailed && BaseClass::IsActive(); }
+	bool IsFailed() { return m_bFailed; }
+
+	virtual void OnMapEvent( const char *pEventName );
+	virtual void OnActivationEvent() { Activate(); }
+	virtual void OnEvaluationEvent();
+	virtual const char *GetActivationEventName() =0;
+	virtual const char *GetEvaluationEventName() =0;
+
+protected:
+	void Activate();
+
+	bool	m_bActivated;		// are we activated? (If there is a map event that turns us on, has that happened)
+	bool	m_bFailed;			// has this achievement failed
+	
+public:
+	DECLARE_DATADESC();
+};
+
+class CMapAchievement : public CBaseAchievement
+{
+	virtual void Init()
+	{
+		SetFlags( ACH_LISTEN_MAP_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievement_AchievedCount : public CBaseAchievement
+{
+public:
+	void Init();
+	virtual void OnSteamUserStatsStored( void );
+	virtual bool IsMetaAchievement() { return true; }
+
+	int GetLowRange() { return m_iLowRange; }
+	int GetHighRange() { return m_iHighRange; }
+	int GetNumRequired() { return m_iNumRequired; }
+
+protected:
+	void SetAchievementsRequired( int iNumRequired, int iLowRange, int iHighRange );
+
+private:
+	int m_iNumRequired;
+	int m_iLowRange;
+	int m_iHighRange;
+};
+
+//
+// Helper class for achievement creation
+//
+ 
+typedef CBaseAchievement* (*achievementCreateFunc) (void);
+class CBaseAchievementHelper
+{
+public:
+	CBaseAchievementHelper( achievementCreateFunc createFunc )
+	{
+		m_pfnCreate = createFunc;
+		m_pNext = s_pFirst;
+		s_pFirst = this;
+	}
+	achievementCreateFunc m_pfnCreate;
+	CBaseAchievementHelper *m_pNext;
+	static CBaseAchievementHelper *s_pFirst;
+};
+
+#define DECLARE_ACHIEVEMENT_( className, achievementID, achievementName, gameDirFilter, iPointValue, bHidden ) \
+static CBaseAchievement *Create_##className( void )					\
+{																		\
+	CBaseAchievement *pAchievement = new className( );					\
+	pAchievement->SetAchievementID( achievementID );					\
+	pAchievement->SetName( achievementName );							\
+	pAchievement->SetPointValue( iPointValue );							\
+	pAchievement->SetHideUntilAchieved( bHidden );						\
+	if ( gameDirFilter ) pAchievement->SetGameDirFilter( gameDirFilter ); \
+	return pAchievement;												\
+};																		\
+static CBaseAchievementHelper g_##className##_Helper( Create_##className );
+
+#define DECLARE_ACHIEVEMENT( className, achievementID, achievementName, iPointValue ) \
+	DECLARE_ACHIEVEMENT_( className, achievementID, achievementName, NULL, iPointValue, false )
+
+#define DECLARE_MAP_EVENT_ACHIEVEMENT_( achievementID, achievementName, gameDirFilter, iPointValue, bHidden ) \
+class CAchievement##achievementID : public CMapAchievement {};		\
+DECLARE_ACHIEVEMENT_( CAchievement##achievementID, achievementID, achievementName, gameDirFilter, iPointValue, bHidden )	\
+
+#define DECLARE_MAP_EVENT_ACHIEVEMENT( achievementID, achievementName, iPointValue )	\
+	DECLARE_MAP_EVENT_ACHIEVEMENT_( achievementID, achievementName, NULL, iPointValue, false )
+
+#define DECLARE_MAP_EVENT_ACHIEVEMENT_HIDDEN( achievementID, achievementName, iPointValue )	\
+	DECLARE_MAP_EVENT_ACHIEVEMENT_( achievementID, achievementName, NULL, iPointValue, true )
+
+#endif // BASEACHIEVEMENT_H