source-engine/game/shared/dod/achievements_dod.cpp

905 lines
23 KiB
C++
Raw Normal View History

2022-04-16 09:05:19 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#ifdef CLIENT_DLL
#include "achievementmgr.h"
#include "baseachievement.h"
#include "c_dod_player.h"
#include "dod_shareddefs.h"
#include "c_dod_objective_resource.h"
#include "dod_gamerules.h"
CAchievementMgr g_AchievementMgrDOD; // global achievement mgr for DOD
//-----------------------------------------------------------------------------
// Purpose: Query if the gamerules allows achievement progress at this time
//-----------------------------------------------------------------------------
bool GameRulesAllowsAchievements( void )
{
return ( DODGameRules()->State_Get() == STATE_RND_RUNNING );
}
class CAchievementDODThrowBackGren : public CBaseAchievement
{
void Init()
{
// listen for player kill enemy events, base class will increment count each time that happens
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !GameRulesAllowsAchievements() )
return;
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pAttacker == pLocalPlayer && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
// if we are allies and killed with a german grenade
// or if we are axis and killed with a us grenade
const char *killedwith = event->GetString( "weapon" );
int iLocalTeam = pLocalPlayer->GetTeamNumber();
if ( ( iLocalTeam == TEAM_ALLIES && ( FStrEq( killedwith, "frag_ger" ) || FStrEq( killedwith, "riflegren_ger" ) ) ) ||
( iLocalTeam == TEAM_AXIS && ( FStrEq( killedwith, "frag_us" ) || FStrEq( killedwith, "riflegren_us" ) ) ) )
{
// This kill was made with an enemy grenade.
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODThrowBackGren, ACHIEVEMENT_DOD_THROW_BACK_GREN, "DOD_THROW_BACK_GREN", 1 );
class CAchievementDODConsecutiveHeadshots : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// Handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODConsecutiveHeadshots, ACHIEVEMENT_DOD_CONSECUTIVE_HEADSHOTS, "DOD_CONSECUTIVE_HEADSHOTS", 1 );
class CAchievementDODMGPositionStreak : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// Handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODMGPositionStreak, ACHIEVEMENT_DOD_MG_POSITION_STREAK, "DOD_MG_POSITION_STREAK", 1 );
class CAchievementDODWinKnifeFight : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !GameRulesAllowsAchievements() )
return;
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pAttacker == pLocalPlayer && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
const char *killedwith = event->GetString( "weapon" );
if ( FStrEq( killedwith, "amerknife" ) || FStrEq( killedwith, "spade" ) )
{
C_DODPlayer *pDodVictim = ToDODPlayer( pVictim );
if ( pDodVictim )
{
CWeaponDODBase *pWpn = pDodVictim->GetActiveDODWeapon();
if ( pWpn && pWpn->GetDODWpnData().m_WeaponType == WPN_TYPE_MELEE )
{
// Kill was made with a melee weapon, killer had melee weapon out
IncrementCount();
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODWinKnifeFight, ACHIEVEMENT_DOD_WIN_KNIFE_FIGHT, "DOD_WIN_KNIFE_FIGHT", 1 );
const char *pszOfficialMaps[] =
{
"dod_anzio",
"dod_avalanche",
"dod_argentan",
"dod_colmar",
"dod_donner",
"dod_flash",
"dod_jagd",
"dod_kalt",
"dod_palermo"
};
class CAchievementDODCustomMaps : public CBaseAchievement
{
// Requires a player to kill at least one player on 5 different non-official maps
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 5 );
SetStoreProgressInSteam( true );
m_bCheckedCurrentMap = false;
}
virtual void ListenForEvents()
{
// hax, this is called from LevelInitPreEntity, init per-level here
m_bCheckedCurrentMap = false;
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( m_bCheckedCurrentMap )
return;
// don't store the map name if we're not going to give achievement progress
if ( m_pAchievementMgr->WereCheatsEverOn() )
return;
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pAttacker == pLocalPlayer && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
char szMap[MAX_PATH];
Q_FileBase( engine->GetLevelName(), szMap, ARRAYSIZE( szMap ) );
if ( !IsOfficialMap( szMap ) && !HasPlayedThisCustomMap() )
{
IncrementCount();
UTIL_IncrementMapKey( "killed_a_player" );
}
// stop listening
m_bCheckedCurrentMap = true;
}
}
bool HasPlayedThisCustomMap( void )
{
return ( UTIL_GetMapKeyCount( "killed_a_player" ) > 0 );
}
bool IsOfficialMap( const char *pszMapName )
{
bool bFound = false;
for ( int i=0;i<ARRAYSIZE(pszOfficialMaps);i++ )
{
if ( FStrEq( pszMapName, pszOfficialMaps[i] ) )
{
bFound = true;
break;
}
}
return bFound;
}
bool m_bCheckedCurrentMap;
};
DECLARE_ACHIEVEMENT( CAchievementDODCustomMaps, ACHIEVEMENT_DOD_PLAY_CUSTOM_MAPS, "DOD_PLAY_CUSTOM_MAPS", 1 );
class CAchievementDODKillsWithGrenade : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
// hax, this is called from LevelInitPreEntity, init per-level here
m_flLastKillTime = 0;
m_iKillCount = 0;
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !GameRulesAllowsAchievements() )
return;
C_DODPlayer *pLocalPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pAttacker == pLocalPlayer )
{
// reject non-grenade/non-rocket inflictors
const char *killedwith = event->GetString( "weapon" );
if ( Q_strncmp( killedwith, "frag_", 5 ) &&
Q_strncmp( killedwith, "riflegren_", 10 ) &&
!FStrEq( killedwith, "pschreck" ) &&
!FStrEq( killedwith, "bazooka" ) )
{
m_flLastKillTime = 0;
return;
}
if ( ( gpGlobals->curtime - m_flLastKillTime ) > 0.25 )
{
m_iKillCount = 0;
}
m_iKillCount++;
m_flLastKillTime = gpGlobals->curtime;
if ( m_iKillCount == 4 )
{
IncrementCount();
}
}
}
private:
float m_flLastKillTime;
int m_iKillCount;
};
DECLARE_ACHIEVEMENT( CAchievementDODKillsWithGrenade, ACHIEVEMENT_DOD_KILLS_WITH_GRENADE, "DOD_KILLS_WITH_GRENADE", 1 );
class CAchievementDODLongRangeRocket : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// Handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODLongRangeRocket, ACHIEVEMENT_DOD_LONG_RANGE_ROCKET, "DOD_LONG_RANGE_ROCKET", 1 );
class CAchievementDODEndRoundKills : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
m_iKillCount = 0;
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_spawn" );
}
// Reset the count when we spawn
void FireGameEvent_Internal( IGameEvent *event )
{
if ( m_iKillCount > 0 && 0 == Q_strcmp( event->GetName(), "player_spawn" ) && C_BasePlayer::GetLocalPlayer() )
{
int iUserID = event->GetInt("userid");
if ( iUserID == C_BasePlayer::GetLocalPlayer()->GetUserID() )
{
m_iKillCount = 0;
}
}
}
// count kills in endround. No requirement that your team must have won the round - grenades count
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
DODRoundState state = DODGameRules()->State_Get();
if ( state == STATE_ALLIES_WIN || state == STATE_AXIS_WIN )
{
Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
m_iKillCount++;
if ( m_iKillCount > 3 )
{
IncrementCount();
}
}
}
}
int m_iKillCount;
};
DECLARE_ACHIEVEMENT( CAchievementDODEndRoundKills, ACHIEVEMENT_DOD_END_ROUND_KILLS, "DOD_END_ROUND_KILLS", 1 );
class CAchievementDODCapLastFlag : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODCapLastFlag, ACHIEVEMENT_DOD_CAP_LAST_FLAG, "DOD_CAP_LAST_FLAG", 1 );
class CAchievementDODUseEnemyWeapons : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// Handled on server
};
DECLARE_ACHIEVEMENT( CAchievementDODUseEnemyWeapons, ACHIEVEMENT_DOD_USE_ENEMY_WEAPONS, "DOD_USE_ENEMY_WEAPONS", 1 );
class CAchievementDODKillDominatingMG : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// Handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODKillDominatingMG, ACHIEVEMENT_DOD_KILL_DOMINATING_MG, "DOD_KILL_DOMINATING_MG", 1 );
class CAchievementDODColmarDefense : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// Handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODColmarDefense, ACHIEVEMENT_DOD_COLMAR_DEFENSE, "DOD_COLMAR_DEFENSE", 1 );
class CAchievementDODJagdOvertimeCap : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// Handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODJagdOvertimeCap, ACHIEVEMENT_DOD_JAGD_OVERTIME_CAP, "DOD_JAGD_OVERTIME_CAP", 1 );
class CAchievementDODWeaponMastery : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
// Handled on server
}
};
DECLARE_ACHIEVEMENT( CAchievementDODWeaponMastery, ACHIEVEMENT_DOD_WEAPON_MASTERY, "DOD_WEAPON_MASTERY", 1 );
class CAchievementDODBlockCaptures : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "dod_capture_blocked" );
}
// New achievement rule - block a capture that would have lost the game for your team
void FireGameEvent_Internal( IGameEvent *event )
{
if ( !GameRulesAllowsAchievements() )
return;
Assert( FStrEq( event->GetName(), "dod_capture_blocked" ) );
// was a blocked defuse or plant, don't count
if ( event->GetBool("bomb") )
return;
if ( !g_pObjectiveResource )
return;
C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pPlayer && pPlayer->entindex() == event->GetInt("blocker") )
{
int iCP = event->GetInt( "cp" );
bool bIsLastOwnedPoint = true;
int iPlayerTeam = pPlayer->GetTeamNumber();
for( int i=0;i<g_pObjectiveResource->GetNumControlPoints();i++ )
{
// assume we own the one we blocked
if ( i == iCP )
continue;
// if we find any other points owned by us that aren't hidden, this wasn't the last point
if( !g_pObjectiveResource->IsCPVisible(i) )
continue;
if ( g_pObjectiveResource->GetOwningTeam(i) == iPlayerTeam )
{
bIsLastOwnedPoint = false;
break;
}
}
if ( bIsLastOwnedPoint )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODBlockCaptures, ACHIEVEMENT_DOD_BLOCK_CAPTURES, "DOD_BLOCK_CAPTURES", 1 );
// achievements part deux
// kills as allies
// kills as axis
class CBaseAchievementKillsOnTeam : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 5000 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
if ( pAttacker->GetTeamNumber() == GetTeam() )
{
IncrementCount();
}
}
}
virtual int GetTeam( void ) = 0;
};
class CAchievementKillsAsAllies : public CBaseAchievementKillsOnTeam
{
virtual int GetTeam( void ) { return TEAM_ALLIES; }
};
DECLARE_ACHIEVEMENT( CAchievementKillsAsAllies, ACHIEVEMENT_DOD_KILLS_AS_ALLIES, "DOD_KILLS_AS_ALLIES", 1 );
class CAchievementKillsAsAxis : public CBaseAchievementKillsOnTeam
{
virtual int GetTeam( void ) { return TEAM_AXIS; }
};
DECLARE_ACHIEVEMENT( CAchievementKillsAsAxis, ACHIEVEMENT_DOD_KILLS_AS_AXIS, "DOD_KILLS_AS_AXIS", 1 );
// rifleman
// assault
// support
// sniper
// mg
// bazooka
class CBaseAchievementKillsAsClass : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1000 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
C_DODPlayer *pDODAttacker = ToDODPlayer( pAttacker );
if ( pDODAttacker->m_Shared.PlayerClass() == GetClass() )
{
IncrementCount();
}
}
}
virtual int GetClass( void ) = 0;
};
#define DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( classIndex, achievementID ) \
class CAchievement_##achievementID : public CBaseAchievementKillsAsClass \
{ \
virtual int GetClass( void ) { return classIndex; } \
}; \
DECLARE_ACHIEVEMENT( CAchievement_##achievementID, ACHIEVEMENT_##achievementID, #achievementID, 1 ) \
DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 0, DOD_KILLS_AS_RIFLEMAN );
DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 1, DOD_KILLS_AS_ASSAULT );
DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 2, DOD_KILLS_AS_SUPPORT );
DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 3, DOD_KILLS_AS_SNIPER );
DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 4, DOD_KILLS_AS_MG );
DECLARE_KILLS_AS_CLASS_ACHIEVEMENT( 5, DOD_KILLS_AS_BAZOOKAGUY );
// per weapon
class CBaseAchievementKillsWithWeapon : public CBaseAchievement
{
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
Assert( pAttacker == C_BasePlayer::GetLocalPlayer() );
if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() && event != NULL )
{
if ( FStrEq( event->GetString( "weapon", "" ), GetWeaponName() ) )
{
IncrementCount();
}
}
}
virtual const char *GetWeaponName( void ) = 0;
};
#define DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( weaponName, goalKills, achievementID ) \
class CAchievement_##achievementID : public CBaseAchievementKillsWithWeapon \
{ \
void Init() \
{ \
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL ); \
SetGoal( goalKills ); \
SetStoreProgressInSteam( true ); \
} \
\
virtual const char *GetWeaponName( void ) { return weaponName; } \
}; \
DECLARE_ACHIEVEMENT( CAchievement_##achievementID, ACHIEVEMENT_##achievementID, #achievementID, 1 ) \
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "garand", 500, DOD_KILLS_WITH_GARAND );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "thompson", 500, DOD_KILLS_WITH_THOMPSON );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "bar", 500, DOD_KILLS_WITH_BAR );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "spring", 500, DOD_KILLS_WITH_SPRING );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "30cal", 500, DOD_KILLS_WITH_30CAL );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "bazooka", 500, DOD_KILLS_WITH_BAZOOKA );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "k98", 500, DOD_KILLS_WITH_K98 );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "mp40", 500, DOD_KILLS_WITH_MP40 );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "mp44", 500, DOD_KILLS_WITH_MP44 );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "k98_scoped", 500, DOD_KILLS_WITH_K98SCOPED );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "mg42", 500, DOD_KILLS_WITH_MG42 );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "pschreck", 500, DOD_KILLS_WITH_PSCHRECK );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "colt", 150, DOD_KILLS_WITH_COLT );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "p38", 150, DOD_KILLS_WITH_P38 );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "c96", 150, DOD_KILLS_WITH_C96 );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "m1carbine", 150, DOD_KILLS_WITH_M1CARBINE );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "amerknife", 150, DOD_KILLS_WITH_AMERKNIFE );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "spade", 150, DOD_KILLS_WITH_SPADE );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "punch", 150, DOD_KILLS_WITH_PUNCH );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "frag_us", 250, DOD_KILLS_WITH_FRAG_US );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "frag_ger", 250, DOD_KILLS_WITH_FRAG_GER );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "riflegren_us", 250, DOD_KILLS_WITH_RIFLEGREN_US );
DECLARE_KILLS_WITH_WEAPON_ACHIEVEMENT( "riflegren_ger", 250, DOD_KILLS_WITH_RIFLEGREN_GER );
// flag captures
class CAchievementDODFlagCaptureGrind : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "dod_point_captured" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
Assert( FStrEq( event->GetName(), "dod_point_captured" ) );
if ( event->GetBool( "bomb" ) == true )
return;
if ( !GameRulesAllowsAchievements() )
return;
C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( !pPlayer )
return;
int iLocalPlayerIndex = pPlayer->entindex();
const char *cappers = event->GetString("cappers");
int len = Q_strlen(cappers);
for( int i=0;i<len;i++ )
{
if ( iLocalPlayerIndex == (int)cappers[i] )
{
IncrementCount();
break;
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODFlagCaptureGrind, ACHIEVEMENT_DOD_CAPTURE_GRIND, "DOD_CAPTURE_GRIND", 1 );
class CAchievementDODBlockCapturesGrind : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "dod_capture_blocked" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( !GameRulesAllowsAchievements() )
return;
Assert( FStrEq( event->GetName(), "dod_capture_blocked" ) );
if ( event->GetBool( "bomb" ) )
return;
C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pPlayer && pPlayer->entindex() == event->GetInt( "blocker" ) )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODBlockCapturesGrind, ACHIEVEMENT_DOD_BLOCK_CAPTURES_GRIND, "DOD_BLOCK_CAPTURES_GRIND", 1 );
class CAchievementDODRoundsWonGrind : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "dod_round_win" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( !GameRulesAllowsAchievements() )
return;
Assert( FStrEq( event->GetName(), "dod_round_win" ) );
C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( !pPlayer )
return;
if ( event->GetInt( "team" ) == pPlayer->GetTeamNumber() )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODRoundsWonGrind, ACHIEVEMENT_DOD_ROUNDS_WON_GRIND, "DOD_ROUNDS_WON_GRIND", 1 );
class CAchievementDODBombsPlantedGrind : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "dod_bomb_planted" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
Assert( FStrEq( event->GetName(), "dod_bomb_planted" ) );
C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( pPlayer && pPlayer->GetUserID() == event->GetInt("userid" ) )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODBombsPlantedGrind, ACHIEVEMENT_DOD_BOMBS_PLANTED_GRIND, "DOD_BOMBS_PLANTED_GRIND", 1 );
class CAchievementDODBombsDefusedGrind : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "dod_bomb_defused" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
Assert( FStrEq( event->GetName(), "dod_bomb_defused" ) );
if ( event->GetInt("userid") == C_BasePlayer::GetLocalPlayer()->GetUserID() )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODBombsDefusedGrind, ACHIEVEMENT_DOD_BOMBS_DEFUSED_GRIND, "DOD_BOMBS_DEFUSED_GRIND", 1 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementDOD_All_Pack_1 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementDOD_All_Pack_1, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 51, 0, 51 );
}
// Complete all dod achievements
};
DECLARE_ACHIEVEMENT( CAchievementDOD_All_Pack_1, ACHIEVEMENT_DOD_ALL_PACK_1, "DOD_ALL_PACK_1", 5 );
// 2011 Summer sale achievement
// Win a round on each of the winter themed maps, dod_kalt and dod_colmar
// player is not required to have been present at the start of the round
class CAchievementDODBeatTheHeat : public CBaseAchievement
{
public:
DECLARE_CLASS( CAchievementDODBeatTheHeat, CBaseAchievement );
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS );
static const char *szComponents[] =
{
"dod_kalt", "dod_colmar"
};
m_pszComponentNames = szComponents;
m_iNumComponents = ARRAYSIZE( szComponents );
SetGoal( m_iNumComponents );
BaseClass::Init();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "dod_round_win" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( !GameRulesAllowsAchievements() )
return;
Assert( FStrEq( event->GetName(), "dod_round_win" ) );
C_DODPlayer *pPlayer = C_DODPlayer::GetLocalDODPlayer();
if ( !pPlayer )
return;
if ( event->GetInt( "team" ) == pPlayer->GetTeamNumber() )
{
OnComponentEvent( m_pAchievementMgr->GetMapName() );
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODBeatTheHeat, ACHIEVEMENT_DOD_BEAT_THE_HEAT, "DOD_BEAT_THE_HEAT", 1 );
// Winter 2011
class CAchievementDODCollectHolidayGifts : public CBaseAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 3 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "christmas_gift_grab" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
// if ( !UTIL_IsHolidayActive( kHoliday_Christmas ) )
// return;
if ( Q_strcmp( event->GetName(), "christmas_gift_grab" ) == 0 )
{
int iPlayer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
CBaseEntity *pPlayer = UTIL_PlayerByIndex( iPlayer );
if ( pPlayer && pPlayer == C_DODPlayer::GetLocalDODPlayer() )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementDODCollectHolidayGifts, ACHIEVEMENT_DOD_COLLECT_HOLIDAY_GIFTS, "DOD_COLLECT_HOLIDAY_GIFTS", 5 );
#endif // CLIENT_DLL