271 lines
11 KiB
C++
271 lines
11 KiB
C++
//========= 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
|