1HEADmaster

1 files changed, 1455 insertions, 0 deletions

diff --git a/game/shared/tf/achievements_tf_maps.cpp b/game/shared/tf/achievements_tf_maps.cpp
new file mode 100644
index 0000000..10e7e61
--- /dev/null
+++ b/game/shared/tf/achievements_tf_maps.cpp
@@ -0,0 +1,1455 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+
+#include "cbase.h"
+
+#ifdef CLIENT_DLL
+
+#include "achievementmgr.h"
+#include "baseachievement.h"
+#include "tf_hud_statpanel.h"
+#include "c_tf_team.h"
+#include "c_tf_player.h"
+#include "c_tf_playerresource.h"
+#include "tf_gamerules.h"
+#include "achievements_tf.h"
+#include "c_team_objectiveresource.h"
+
+
+//======================================================================================================================================
+// FOUNDRY ACHIEVEMENT PACK
+//======================================================================================================================================
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_KillCappingEnemy : public CBaseTFAchievementSimple
+{
+public:
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_KillCappingEnemy, ACHIEVEMENT_TF_MAPS_FOUNDRY_KILL_CAPPING_ENEMY, "TF_MAPS_FOUNDRY_KILL_CAPPING_ENEMY", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_PlayGameFriends : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// are there at least 5 friends in the game? (at least 6 players total)
+			if ( CalcPlayersOnFriendsList( 5 ) )
+			{
+				AwardAchievement();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PlayGameFriends, ACHIEVEMENT_TF_MAPS_FOUNDRY_PLAY_GAME_FRIENDS, "TF_MAPS_FOUNDRY_PLAY_GAME_FRIENDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_WinMinTime : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				float flRoundTime = event->GetFloat( "round_time", 0 );
+				if ( flRoundTime > 0 && flRoundTime < 2 * 60 )
+				{
+					AwardAchievement();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_WinMinTime, ACHIEVEMENT_TF_MAPS_FOUNDRY_WIN_MINTIME, "TF_MAPS_FOUNDRY_WIN_MINTIME", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_WinRounds : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 137 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_foundry" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// Were we on the winning team?
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_WinRounds, ACHIEVEMENT_TF_MAPS_FOUNDRY_WIN_ROUNDS, "TF_MAPS_FOUNDRY_WIN_ROUNDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_FastFinalCap : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+
+		ResetCounts();
+	}
+
+	void ResetCounts()
+	{
+		m_bRecentCapper = false;
+		iCapCount = 0;
+		iCapTimes[0] = 0.0f;
+		iCapTimes[1] = 0.0f;
+	}
+
+	virtual void ListenForEvents( void )
+	{
+		ListenForGameEvent( "teamplay_point_captured" );
+		ListenForGameEvent( "teamplay_round_win" );
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( !pLocalPlayer )
+			return;
+
+		if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
+		{
+			m_bRecentCapper = false;
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) )
+			{
+				iCapTimes[iCapCount%2] = gpGlobals->curtime;
+				iCapCount++;
+
+				const char *cappers = event->GetString( "cappers" );
+				for ( int i = 0 ; i < Q_strlen( cappers ) ; i++ )
+				{
+					int iPlayerIndex = (int) cappers[i];
+					CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+					if ( pPlayer == pLocalPlayer )
+					{
+						m_bRecentCapper = true;
+					}
+				}
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
+		{
+			// If we're the winners and we were involved in capping the last point, we get this achievement.
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) && m_bRecentCapper )
+			{
+				if ( fabs( iCapTimes[1] - iCapTimes[0] ) <= 5.0f )
+				{
+					AwardAchievement();
+				}
+			}
+
+			ResetCounts();
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
+		{
+			ResetCounts();
+		}
+	}
+
+private:
+	bool m_bRecentCapper;
+	int iCapCount;
+	float iCapTimes[2];
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_FastFinalCap, ACHIEVEMENT_TF_MAPS_FOUNDRY_FAST_FINAL_CAP, "TF_MAPS_FOUNDRY_FAST_FINAL_CAP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_TeleportAndCap : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+	}
+
+	virtual void ListenForEvents( void )
+	{
+		ListenForGameEvent( "teamplay_point_captured" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( !pLocalPlayer )
+			return;
+
+		if ( !pLocalPlayer->m_Shared.InCond( TF_COND_TELEPORTED ) )
+			return;
+
+		if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
+		{
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) )
+			{
+				const char *cappers = event->GetString( "cappers" );
+				for ( int i = 0 ; i < Q_strlen( cappers ) ; i++ )
+				{
+					int iPlayerIndex = (int) cappers[i];
+					CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+					if ( pPlayer == pLocalPlayer )
+					{
+						AwardAchievement();
+					}
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_TeleportAndCap, ACHIEVEMENT_TF_MAPS_FOUNDRY_TELEPORT_AND_CAP, "TF_MAPS_FOUNDRY_TELEPORT_AND_CAP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_PushIntoCauldron : public CBaseTFAchievementSimple
+{
+public:
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PushIntoCauldron, ACHIEVEMENT_TF_MAPS_FOUNDRY_PUSH_INTO_CAULDRON, "TF_MAPS_FOUNDRY_PUSH_INTO_CAULDRON", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_PushBackAndWin : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+
+		m_bFinalPointContested = false;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+		ListenForGameEvent( "teamplay_point_startcapture" );
+		ListenForGameEvent( "teamplay_round_start" );
+		ListenForGameEvent( "localplayer_changeteam" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		if ( FStrEq( pszEventName, "teamplay_round_win" ) )
+		{
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				if ( m_bFinalPointContested )
+				{
+					AwardAchievement();
+				}
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
+		{
+			if ( ObjectiveResource() && ( ObjectiveResource()->GetBaseControlPointForTeam( GetLocalPlayerTeam() ) == event->GetInt( "cp" ) ) )
+			{
+				m_bFinalPointContested = true;
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) || FStrEq( pszEventName, "localplayer_changeteam" ) )
+		{
+			m_bFinalPointContested = false;
+		}
+	}
+
+private:
+	bool m_bFinalPointContested;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PushBackAndWin, ACHIEVEMENT_TF_MAPS_FOUNDRY_PUSH_BACK_AND_WIN, "TF_MAPS_FOUNDRY_PUSH_BACK_AND_WIN", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_PlayEachClass : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+
+		m_iClassesPlayed = 0;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && ( pVictim != pAttacker ) && ( pLocalPlayer->m_Shared.GetDesiredPlayerClassIndex() > TF_CLASS_UNDEFINED ) )
+		{
+			m_iClassesPlayed |= ( 1 << pLocalPlayer->m_Shared.GetDesiredPlayerClassIndex() );
+
+			if ( m_iClassesPlayed == 1022 )
+			{
+				AwardAchievement();
+			}
+		}
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_round_start" ) )
+		{
+			m_iClassesPlayed = 0;
+		}
+	}
+
+private:
+	int m_iClassesPlayed;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PlayEachClass, ACHIEVEMENT_TF_MAPS_FOUNDRY_PLAY_EACH_CLASS, "TF_MAPS_FOUNDRY_PLAY_EACH_CLASS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_KillEnemyOnRoof : public CBaseTFAchievementSimple
+{
+public:
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+
+		iKillCount = 0;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_start" );
+		ListenForGameEvent( "player_killed_achievement_zone" );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( pLocalPlayer && ( pLocalPlayer == pVictim ) )
+		{
+			iKillCount = 0;
+		}
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		if ( FStrEq( pszEventName, "teamplay_round_start" ) )
+		{
+			iKillCount = 0;
+		}
+		else if ( FStrEq( pszEventName, "player_killed_achievement_zone" ) )
+		{
+			CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+			CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "attacker" ) ) );
+			CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "victim" ) ) );
+
+			if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && pVictim && ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
+			{
+				iKillCount++;
+				if ( iKillCount >= 2 )
+				{
+					AwardAchievement();
+				}
+			}
+		}
+	}
+
+private:
+	int iKillCount;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_KillEnemyOnRoof, ACHIEVEMENT_TF_MAPS_FOUNDRY_KILL_ENEMY_ON_ROOF, "TF_MAPS_FOUNDRY_KILL_ENEMY_ON_ROOF", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_BackAndForthBattle : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_foundry" );
+
+		m_iCapCount = 0;
+	}
+
+	virtual void ListenForEvents( void )
+	{
+		ListenForGameEvent( "teamplay_point_captured" );
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( !pLocalPlayer )
+			return;
+
+		if ( pLocalPlayer->GetTeamNumber() < FIRST_GAME_TEAM )
+			return;
+
+		if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
+		{
+			// we don't care which team is capping or which point is capped for this achievement
+			m_iCapCount++;
+
+			if ( m_iCapCount >= 15 )
+			{
+				AwardAchievement();
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
+		{
+			m_iCapCount = 0;
+		}
+	}
+
+private:
+	int m_iCapCount;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_BackAndForthBattle, ACHIEVEMENT_TF_MAPS_FOUNDRY_BACK_AND_FORTH_BATTLE, "TF_MAPS_FOUNDRY_BACK_AND_FORTH_BATTLE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFFoundry_AchieveProgress1 : public CAchievement_AchievedCount
+{
+public:
+	DECLARE_CLASS( CAchievementTFFoundry_AchieveProgress1, CAchievement_AchievedCount );
+	void Init() 
+	{
+		BaseClass::Init();
+		SetAchievementsRequired( 7, ACHIEVEMENT_TF_MAPS_FOUNDRY_START_RANGE, ACHIEVEMENT_TF_MAPS_FOUNDRY_END_RANGE );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFFoundry_AchieveProgress1, ACHIEVEMENT_TF_MAPS_FOUNDRY_ACHIEVE_PROGRESS1, "TF_MAPS_FOUNDRY_ACHIEVE_PROGRESS1", 5 );
+
+
+//======================================================================================================================================
+// DOOMSDAY ACHIEVEMENT PACK
+//======================================================================================================================================
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_SoloCapture : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "sd_doomsday" );
+
+		m_bCarriedFromHome = false;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_flag_event" );
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		if ( FStrEq( pszEventName, "teamplay_flag_event" ) )
+		{
+			int iPlayer = event->GetInt( "player" );
+			int iType = event->GetInt( "eventtype" );
+			bool bHome = ( event->GetInt( "home", 0 ) == 1 );
+
+			switch( iType )
+			{
+			case TF_FLAGEVENT_PICKUP:
+				if ( ( iPlayer == GetLocalPlayerIndex() ) && bHome )
+				{
+					m_bCarriedFromHome = true;
+				}
+				else
+				{
+					m_bCarriedFromHome = false;
+				}
+				break;
+			case TF_FLAGEVENT_CAPTURE:
+				if ( ( iPlayer == GetLocalPlayerIndex() ) && m_bCarriedFromHome )
+				{
+					IncrementCount();
+				}
+				break;
+			default:
+				m_bCarriedFromHome = false;
+				break;
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
+		{
+			m_bCarriedFromHome = false;
+		}
+	}
+
+private: 
+	bool	m_bCarriedFromHome;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_SoloCapture, ACHIEVEMENT_TF_MAPS_DOOMSDAY_SOLO_CAPTURE, "TF_MAPS_DOOMSDAY_SOLO_CAPTURE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_PlayGameFriends : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "sd_doomsday" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// are there at least 5 friends in the game? (at least 6 players total)
+			if ( CalcPlayersOnFriendsList( 5 ) )
+			{
+				AwardAchievement();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PlayGameFriends, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PLAY_GAME_FRIENDS, "TF_MAPS_DOOMSDAY_PLAY_GAME_FRIENDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_WinRounds : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 138 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "sd_doomsday" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// Were we on the winning team?
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_WinRounds, ACHIEVEMENT_TF_MAPS_DOOMSDAY_WIN_ROUNDS, "TF_MAPS_DOOMSDAY_WIN_ROUNDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_PlayEachClass : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS );
+		SetGoal( ( TF_LAST_NORMAL_CLASS - 1 ) - TF_FIRST_NORMAL_CLASS + 1 ); //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class
+		SetMapNameFilter( "sd_doomsday" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_flag_event" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_flag_event" ) )
+		{
+			int iPlayer = event->GetInt( "player" );
+			int iType = event->GetInt( "eventtype" );
+	
+			switch( iType )
+			{
+			case TF_FLAGEVENT_CAPTURE:
+				if ( iPlayer == GetLocalPlayerIndex() )
+				{
+					C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
+					if ( pTFPlayer )
+					{
+						int iClass = pTFPlayer->GetPlayerClass()->GetClassIndex();
+						if ( iClass >= TF_FIRST_NORMAL_CLASS && iClass <= ( TF_LAST_NORMAL_CLASS - 1 ) ) //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class
+						{
+							// yes, the achievement is satisfied for this class, set the corresponding bit	    
+							int iBitNumber = ( iClass - TF_FIRST_NORMAL_CLASS );
+							EnsureComponentBitSetAndEvaluate( iBitNumber );
+						}							
+					}
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PlayEachClass, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PLAY_EACH_CLASS, "TF_MAPS_DOOMSDAY_PLAY_EACH_CLASS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_KillEnemiesOnElevator : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "sd_doomsday" );
+
+		m_flTimeWindow = 10.0f;
+		m_nKillsToAchieve = 3;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "player_killed_achievement_zone" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "player_killed_achievement_zone" ) )
+		{
+			int iZoneID = event->GetInt( "zone_id" );
+			if ( iZoneID == 1 ) // capture zone
+			{
+				CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+				CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "attacker" ) ) );
+				CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "victim" ) ) );
+
+				if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && pVictim && ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
+				{
+					int index = m_History.AddToHead();
+					m_History[index] = gpGlobals->curtime;
+					Evaluate();
+				}
+			}
+		}
+	}
+
+	void Evaluate( void )
+	{
+		// remove any times that are older than the window
+		float flTimeDiscard = gpGlobals->curtime - m_flTimeWindow;
+		for ( int i = 0 ; i < m_History.Count() ; i++ )
+		{
+			if ( m_History[i] < flTimeDiscard )
+			{
+				m_History.RemoveMultiple( i, m_History.Count() - i );
+				break;
+			}
+		}
+
+		// have we killed enough players in the time window?
+		if ( m_History.Count() >= m_nKillsToAchieve )
+		{
+			IncrementCount();
+		}
+	}
+	 
+private:
+	CUtlVector< float >	m_History;
+	float m_flTimeWindow;
+	int m_nKillsToAchieve;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_KillEnemiesOnElevator, ACHIEVEMENT_TF_MAPS_DOOMSDAY_KILL_ENEMIES_ON_ELEVATOR, "TF_MAPS_DOOMSDAY_KILL_ENEMIES_ON_ELEVATOR", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_PushBackAndWin : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "sd_doomsday" );
+
+		m_bRocketOpenedByEnemyTeam = false;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+		ListenForGameEvent( "doomsday_rocket_open" );
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		if ( FStrEq( pszEventName, "teamplay_round_win" ) )
+		{
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				if ( m_bRocketOpenedByEnemyTeam )
+				{
+					AwardAchievement();
+				}
+			}
+		}
+		else if ( FStrEq( pszEventName, "doomsday_rocket_open" ) )
+		{
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam != GetLocalPlayerTeam() ) )
+			{
+				m_bRocketOpenedByEnemyTeam = true;
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
+		{
+			m_bRocketOpenedByEnemyTeam = false;
+		}
+	}
+
+private:
+	bool m_bRocketOpenedByEnemyTeam;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PushBackAndWin, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PUSH_BACK_AND_WIN, "TF_MAPS_DOOMSDAY_PUSH_BACK_AND_WIN", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_KillCarriers : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+		SetMapNameFilter( "sd_doomsday" );
+		m_iKillCount = 0;
+	}
+
+	virtual void ListenForEvents( void )
+	{
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( !pLocalPlayer )
+			return;
+
+		if ( pLocalPlayer->GetTeamNumber() < FIRST_GAME_TEAM )
+			return;
+
+		if ( FStrEq( event->GetName(), "teamplay_round_start" ) )
+		{
+			m_iKillCount = 0;
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() && pVictim != C_BasePlayer::GetLocalPlayer() )
+		{
+			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
+
+			if ( pTFVictim && pTFVictim->HasTheFlag() )
+			{
+				m_iKillCount++;
+				if ( m_iKillCount >= 6 )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+
+private:
+	int m_iKillCount;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_KillCarriers, ACHIEVEMENT_TF_MAPS_DOOMSDAY_KILL_CARRIERS, "TF_MAPS_DOOMSDAY_KILL_CARRIERS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_RideTheElevator : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_RideTheElevator, ACHIEVEMENT_TF_MAPS_DOOMSDAY_RIDE_THE_ELEVATOR, "TF_MAPS_DOOMSDAY_RIDE_THE_ELEVATOR", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_DenyNeutralPickup : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_DenyNeutralPickup, ACHIEVEMENT_TF_MAPS_DOOMSDAY_DENY_NEUTRAL_PICKUP, "TF_MAPS_DOOMSDAY_DENY_NEUTRAL_PICKUP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_PushIntoExhaust : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PushIntoExhaust, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PUSH_INTO_EXHAUST, "TF_MAPS_DOOMSDAY_PUSH_INTO_EXHAUST", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_DefendCarrier : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_DefendCarrier, ACHIEVEMENT_TF_MAPS_DOOMSDAY_DEFEND_CARRIER, "TF_MAPS_DOOMSDAY_DEFEND_CARRIER", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFDoomsday_AchieveProgress1 : public CAchievement_AchievedCount
+{
+public:
+	DECLARE_CLASS( CAchievementTFDoomsday_AchieveProgress1, CAchievement_AchievedCount );
+	void Init() 
+	{
+		BaseClass::Init();
+		SetAchievementsRequired( 7, ACHIEVEMENT_TF_MAPS_DOOMSDAY_START_RANGE, ACHIEVEMENT_TF_MAPS_DOOMSDAY_END_RANGE );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_AchieveProgress1, ACHIEVEMENT_TF_MAPS_DOOMSDAY_ACHIEVE_PROGRESS1, "TF_MAPS_DOOMSDAY_ACHIEVE_PROGRESS1", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFStandin_WinRounds : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 139 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_standin_final" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// Were we on the winning team?
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFStandin_WinRounds, ACHIEVEMENT_TF_MAPS_STANDIN_WIN_ROUNDS, "TF_MAPS_STANDIN_WIN_ROUNDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFProcess_WinRounds : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 140 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_process_final" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// Were we on the winning team?
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFProcess_WinRounds, ACHIEVEMENT_TF_MAPS_PROCESS_WIN_ROUNDS, "TF_MAPS_PROCESS_WIN_ROUNDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSnakewater_WinRounds : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 141 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_snakewater_final1" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// Were we on the winning team?
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_WinRounds, ACHIEVEMENT_TF_MAPS_SNAKEWATER_WIN_ROUNDS, "TF_MAPS_SNAKEWATER_WIN_ROUNDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSnakewater_PushBackAndWin : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_snakewater_final1" );
+
+		m_bFinalPointContested = false;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+		ListenForGameEvent( "teamplay_point_startcapture" );
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		if ( FStrEq( pszEventName, "teamplay_round_win" ) )
+		{
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				if ( m_bFinalPointContested )
+				{
+					AwardAchievement();
+				}
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
+		{
+			if ( ObjectiveResource() && ( ObjectiveResource()->GetBaseControlPointForTeam( GetLocalPlayerTeam() ) == event->GetInt( "cp" ) ) )
+			{
+				m_bFinalPointContested = true;
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
+		{
+			m_bFinalPointContested = false;
+		}
+	}
+
+private:
+	bool m_bFinalPointContested;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_PushBackAndWin, ACHIEVEMENT_TF_MAPS_SNAKEWATER_PUSH_BACK_AND_WIN, "TF_MAPS_SNAKEWATER_PUSH_BACK_AND_WIN", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSnakewater_TeamKill : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_snakewater_final1" );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( TFGameRules() && ( TFGameRules()->State_Get() == GR_STATE_RND_RUNNING ) )
+		{
+			if ( pAttacker && ( pAttacker->GetTeamNumber() == GetLocalPlayerTeam() ) )
+			{
+				C_TFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
+				C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
+				
+				if ( pTFAttacker && pTFAttacker->GetTeam() && pTFVictim && pTFVictim->GetTeam() )
+				{
+					// must have 12 or more players on the server
+					if ( pTFAttacker->GetTeam()->GetNumPlayers() + pTFVictim->GetTeam()->GetNumPlayers() >= 12 )
+					{
+						bool bSomeAlive = false;
+						int nTeamCount = pTFVictim->GetTeam()->GetNumPlayers();
+						for ( int i = 0; i < nTeamCount; i++ )
+						{
+							C_BasePlayer *pTemp = pTFVictim->GetTeam()->GetPlayer( i );
+							if ( pTemp && ( pTemp != pTFVictim ) && pTemp->IsAlive() )
+							{
+								// Found one
+								bSomeAlive = true;
+								break;
+							}
+						}
+
+						if ( !bSomeAlive )
+						{
+							AwardAchievement();
+						}
+					}
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_TeamKill, ACHIEVEMENT_TF_MAPS_SNAKEWATER_TEAM_KILL, "TF_MAPS_SNAKEWATER_TEAM_KILL", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSnakewater_DoubleAirDeaths : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_snakewater_final1" );
+		ResetTracking();
+	}
+
+	void ResetTracking()
+	{
+		m_PotentialPartners.RemoveAll();
+		m_nKilledLocalPlayer = -1;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "player_spawn" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( FStrEq( pszEvent, "localplayer_respawn" ) )
+		{
+			ResetTracking();
+		}
+		else if ( FStrEq( pszEvent, "player_spawn" ) )
+		{
+			int nUserId = event->GetInt( "userid" );
+			if ( nUserId > 0 )
+			{
+				int iIndex = m_PotentialPartners.Find( nUserId );
+				if ( iIndex != m_PotentialPartners.InvalidIndex() )
+				{
+					m_PotentialPartners.Remove( iIndex );
+				}
+			}
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		C_TFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
+		C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
+		C_TFPlayer *pTFLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+		// was the victim rocket jumping?
+		if ( event->GetBool( "rocket_jump" ) )
+		{
+			if ( pTFAttacker && pTFVictim && ( pTFAttacker != pTFVictim ) && ( ( pTFAttacker == pTFLocalPlayer ) || ( pTFVictim == pTFLocalPlayer ) ) )
+			{
+				int iWeaponID = event->GetInt( "weaponid" );
+				if ( ( iWeaponID == TF_WEAPON_ROCKETLAUNCHER ) || ( iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT ) )
+				{		
+					if ( pTFAttacker == pTFLocalPlayer )
+					{
+						if ( m_PotentialPartners.Find( pTFVictim->GetUserID() ) == m_PotentialPartners.InvalidIndex() )
+						{
+							m_PotentialPartners.AddToTail( pTFVictim->GetUserID() );
+						}
+					}
+					else if ( pTFVictim == pTFLocalPlayer )
+					{
+						m_nKilledLocalPlayer = pTFAttacker->GetUserID();
+					}
+
+					// evaluate the achievement
+					if ( ( m_nKilledLocalPlayer > -1 ) && ( m_PotentialPartners.Find( m_nKilledLocalPlayer ) != m_PotentialPartners.InvalidIndex() ) )
+					{
+						AwardAchievement();
+					}
+				}
+			}
+		}
+	}
+
+	CUtlVector< int > m_PotentialPartners; // userIDs of the players the localPlayer killed
+	int m_nKilledLocalPlayer; // userID of the player who killed the localPlayer
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_DoubleAirDeaths, ACHIEVEMENT_TF_MAPS_SNAKEWATER_DOUBLE_AIR_DEATHS, "TF_MAPS_SNAKEWATER_DOUBLE_AIR_DEATHS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSnakewater_KillEnemiesInMiddle : public CBaseTFAchievementSimple
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 15 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_snakewater_final1" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "player_killed_achievement_zone" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "player_killed_achievement_zone" ) )
+		{
+			CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+			CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "attacker" ) ) );
+			CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "victim" ) ) );
+
+			if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && pVictim && ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_KillEnemiesInMiddle, ACHIEVEMENT_TF_MAPS_SNAKEWATER_KILL_ENEMIES_IN_MIDDLE, "TF_MAPS_SNAKEWATER_KILL_ENEMIES_IN_MIDDLE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFPowerhouse_WinRounds : public CBaseTFAchievementSimple
+{
+	void Init()
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 142 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_powerhouse" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+		{
+			// Were we on the winning team?
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_WinRounds, ACHIEVEMENT_TF_MAPS_POWERHOUSE_WIN_ROUNDS, "TF_MAPS_POWERHOUSE_WIN_ROUNDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFPowerhouse_PushBackAndWin : public CBaseTFAchievementSimple
+{
+	void Init()
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_powerhouse" );
+
+		m_bFinalPointContested = false;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_win" );
+		ListenForGameEvent( "teamplay_point_startcapture" );
+		ListenForGameEvent( "teamplay_round_start" );
+		ListenForGameEvent( "localplayer_changeteam" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		if ( FStrEq( pszEventName, "teamplay_round_win" ) )
+		{
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
+			{
+				if ( m_bFinalPointContested )
+				{
+					AwardAchievement();
+				}
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
+		{
+			if ( ObjectiveResource() && ( ObjectiveResource()->GetBaseControlPointForTeam( GetLocalPlayerTeam() ) == event->GetInt( "cp" ) ) )
+			{
+				m_bFinalPointContested = true;
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) || FStrEq( pszEventName, "localplayer_changeteam" ) )
+		{
+			m_bFinalPointContested = false;
+		}
+	}
+
+private:
+	bool m_bFinalPointContested;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_PushBackAndWin, ACHIEVEMENT_TF_MAPS_POWERHOUSE_PUSH_BACK_AND_WIN, "TF_MAPS_POWERHOUSE_PUSH_BACK_AND_WIN", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFPowerhouse_FastFinalCap : public CBaseTFAchievementSimple
+{
+	void Init()
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		SetMapNameFilter( "cp_powerhouse" );
+
+		ResetCounts();
+	}
+
+	void ResetCounts()
+	{
+		m_bRecentCapper = false;
+		iCapCount = 0;
+		iCapTimes[0] = 0.0f;
+		iCapTimes[1] = 0.0f;
+	}
+
+	virtual void ListenForEvents( void )
+	{
+		ListenForGameEvent( "teamplay_point_captured" );
+		ListenForGameEvent( "teamplay_round_win" );
+		ListenForGameEvent( "teamplay_round_start" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( !pLocalPlayer )
+			return;
+
+		if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
+		{
+			m_bRecentCapper = false;
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) )
+			{
+				iCapTimes[iCapCount % 2] = gpGlobals->curtime;
+				iCapCount++;
+
+				const char *cappers = event->GetString( "cappers" );
+				for ( int i = 0; i < Q_strlen( cappers ); i++ )
+				{
+					int iPlayerIndex = (int)cappers[i];
+					CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+					if ( pPlayer == pLocalPlayer )
+					{
+						m_bRecentCapper = true;
+					}
+				}
+			}
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
+		{
+			// If we're the winners and we were involved in capping the last point, we get this achievement.
+			int iTeam = event->GetInt( "team" );
+			if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) && m_bRecentCapper )
+			{
+				if ( fabs( iCapTimes[1] - iCapTimes[0] ) <= 15.0f )
+				{
+					AwardAchievement();
+				}
+			}
+
+			ResetCounts();
+		}
+		else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
+		{
+			ResetCounts();
+		}
+	}
+
+private:
+	bool m_bRecentCapper;
+	int iCapCount;
+	float iCapTimes[2];
+};
+DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_FastFinalCap, ACHIEVEMENT_TF_MAPS_POWERHOUSE_FAST_FINAL_CAP, "TF_MAPS_POWERHOUSE_FAST_FINAL_CAP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFPowerhouse_KillCappingPlayer : public CBaseTFAchievement
+{
+	void Init()
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 15 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_powerhouse" );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "killed_capping_player" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "killed_capping_player" ) )
+		{
+			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+			if ( pLocalPlayer )
+			{
+				int iKiller = event->GetInt( "killer", 0 );
+				if ( iKiller == pLocalPlayer->entindex() )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_KillCappingPlayer, ACHIEVEMENT_TF_MAPS_POWERHOUSE_KILL_CAPPING_PLAYER, "TF_MAPS_POWERHOUSE_KILL_CAPPING_PLAYER", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFPowerhouse_KillEnemyInWater : public CBaseTFAchievementSimple
+{
+public:
+	void Init()
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
+		SetGoal( 5 );
+		SetStoreProgressInSteam( true );
+		SetMapNameFilter( "cp_powerhouse" );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+
+		if ( pAttacker == pLocalPlayer && pVictim != pLocalPlayer )
+		{
+			if ( pVictim->GetWaterLevel() != WL_NotInWater )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_KillEnemyInWater, ACHIEVEMENT_TF_MAPS_POWERHOUSE_KILL_ENEMY_IN_WATER, "TF_MAPS_POWERHOUSE_KILL_ENEMY_IN_WATER", 5 );
+
+#endif // CLIENT_DLL