1HEADmaster

1 files changed, 905 insertions, 0 deletions

diff --git a/game/shared/dod/achievements_dod.cpp b/game/shared/dod/achievements_dod.cpp
new file mode 100644
index 0000000..b55b2b4
--- /dev/null
+++ b/game/shared/dod/achievements_dod.cpp
@@ -0,0 +1,905 @@
+//========= 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
\ No newline at end of file