1HEADmaster

1 files changed, 1890 insertions, 0 deletions

diff --git a/game/shared/tf/achievements_tf_soldier.cpp b/game/shared/tf/achievements_tf_soldier.cpp
new file mode 100644
index 0000000..59a89af
--- /dev/null
+++ b/game/shared/tf/achievements_tf_soldier.cpp
@@ -0,0 +1,1890 @@
+//========= 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_tf_objective_resource.h"
+#include "tf_weapon_shovel.h"
+#include "tf_weapon_rocketlauncher.h"
+#include "movevars_shared.h"
+
+//======================================================================================================================================
+// SOLDIER ACHIEVEMENT PACK
+//======================================================================================================================================
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_RJEqualizerKill : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_RJEqualizerKill, ACHIEVEMENT_TF_SOLDIER_RJ_EQUALIZER_KILL, "TF_SOLDIER_RJ_EQUALIZER_KILL", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_BuffTeammates : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "deploy_buff_banner" );
+		ListenForGameEvent( "player_buff" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( FStrEq( pszEvent, "teamplay_round_active" ) ||
+			 FStrEq( pszEvent, "localplayer_respawn" ) )
+		{
+			m_nBuffCount = 0;
+			m_BuffedPlayers.RemoveAll();
+		}
+		else if ( FStrEq( pszEvent, "deploy_buff_banner" ) )
+		{
+			int iSoldier = engine->GetPlayerForUserID( event->GetInt( "buff_owner" ) );
+			CBasePlayer *pSoldier = UTIL_PlayerByIndex( iSoldier );
+			if ( pSoldier && pSoldier == C_TFPlayer::GetLocalTFPlayer() )
+			{
+				// the local player has deployed their banner, clear our list for the current banner so we can track who we buff
+				m_BuffedPlayers.RemoveAll();
+			}
+		}
+		else if ( FStrEq( pszEvent, "player_buff" ) )
+		{
+			int iSoldier = engine->GetPlayerForUserID( event->GetInt( "buff_owner" ) );
+			CBasePlayer *pSoldier = UTIL_PlayerByIndex( iSoldier );
+			if ( pSoldier && pSoldier == C_TFPlayer::GetLocalTFPlayer() )
+			{
+				int iPlayer = event->GetInt( "userid" );
+				if ( iPlayer != pSoldier->GetUserID() )
+				{
+					// this is not the local player being buffed (can't buff yourself for this achievement)
+					int iIndex = m_BuffedPlayers.Find( iPlayer );
+					if ( iIndex == m_BuffedPlayers.InvalidIndex() )
+					{
+						// they're not in our list for the currently deployed banner
+						m_BuffedPlayers.AddToTail( iPlayer );
+						m_nBuffCount++;
+
+						if ( m_nBuffCount >= 15 )
+						{
+							IncrementCount();
+						}
+					}
+				}
+			}
+		}
+	}
+
+private:
+	int m_nBuffCount;
+	CUtlVector< int > m_BuffedPlayers;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_BuffTeammates, ACHIEVEMENT_TF_SOLDIER_BUFF_TEAMMATES, "TF_SOLDIER_BUFF_TEAMMATES", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillDemomanGrind : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 500 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
+		{
+			// no friendly fire kills
+			if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+			{
+				CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
+				if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_DEMOMAN ) )
+				{
+					// we killed a demoman
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillDemomanGrind, ACHIEVEMENT_TF_SOLDIER_KILL_DEMOMAN_GRIND, "TF_SOLDIER_KILL_DEMOMAN_GRIND", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillEngy : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillEngy, ACHIEVEMENT_TF_SOLDIER_KILL_ENGY, "TF_SOLDIER_KILL_ENGY", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillPyro : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+		SetDefLessFunc( m_Pyros );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "object_deflected" );
+		m_Pyros.RemoveAll();
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( FStrEq( pszEvent, "teamplay_round_active" ) ||
+			 FStrEq( pszEvent, "localplayer_respawn" ) )
+		{
+			m_Pyros.RemoveAll();
+		}
+		else if ( FStrEq( pszEvent, "object_deflected" ) )
+		{
+			int iSoldier = engine->GetPlayerForUserID( event->GetInt( "ownerid" ) );
+			CBasePlayer *pSoldier = UTIL_PlayerByIndex( iSoldier );
+			if ( pSoldier && pSoldier == C_TFPlayer::GetLocalTFPlayer() )
+			{
+				int iWeaponID = event->GetInt( "weaponid" );
+				bool bRocketLauncherUsed = (iWeaponID == TF_WEAPON_ROCKETLAUNCHER) || (iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT);
+				// this was one of our objects...was it a rocket?
+				if ( bRocketLauncherUsed )
+				{
+					// add or update them in our list
+					int iIndex = m_Pyros.Find( event->GetInt( "userid" ) );
+					if ( iIndex != m_Pyros.InvalidIndex() )
+					{
+						m_Pyros[iIndex] = gpGlobals->curtime;
+					}
+					else
+					{
+						m_Pyros.Insert( event->GetInt( "userid" ), gpGlobals->curtime );
+					}
+				}
+			}
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
+		{
+			CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
+			if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_PYRO ) )
+			{
+				int iIndex = m_Pyros.Find( pTFVictim->GetUserID() );
+				if ( iIndex != m_Pyros.InvalidIndex() )
+				{
+					if ( gpGlobals->curtime - m_Pyros[iIndex] <= 10.0f )
+					{
+						// we killed someone in our list within the required time
+						IncrementCount();
+					}
+				}
+			}
+		}
+	}
+
+private:
+	CUtlMap< int, float > m_Pyros; // userID and most recent time they deflected one of our rockets
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillPyro, ACHIEVEMENT_TF_SOLDIER_KILL_PYRO, "TF_SOLDIER_KILL_PYRO", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_NemesisShovelKill : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
+		{
+			if ( event->GetInt( "weaponid" ) == TF_WEAPON_SHOVEL && event->GetInt( "customkill" ) == 0 )
+			{
+				// did the assister get revenge?
+				if ( event->GetInt( "death_flags" ) & TF_DEATH_REVENGE )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_NemesisShovelKill, ACHIEVEMENT_TF_SOLDIER_NEMESIS_SHOVEL_KILL, "TF_SOLDIER_NEMESIS_SHOVEL_KILL", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_DestroyStickies : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		m_nPipesDestroyed = 0;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "player_destroyed_pipebomb" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( FStrEq( pszEvent, "teamplay_round_active" ) ||
+			 FStrEq( pszEvent, "localplayer_respawn" ) )
+		{
+			m_nPipesDestroyed = 0;
+		}
+		else if ( FStrEq( pszEvent, "player_destroyed_pipebomb" ) )
+		{
+			int iUserID = event->GetInt( "userid" );
+
+			CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
+			if ( pLocalTFPlayer && pLocalTFPlayer->GetUserID() == iUserID )
+			{
+				if ( pLocalTFPlayer->GetActiveTFWeapon() )
+				{
+					if ( pLocalTFPlayer->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_SHOTGUN_SOLDIER )
+					{
+						m_nPipesDestroyed++;
+
+						if ( m_nPipesDestroyed >= 10 )
+						{
+							IncrementCount();
+						}
+					}
+				}
+			}
+		}
+	}
+
+private:
+	int m_nPipesDestroyed;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_DestroyStickies, ACHIEVEMENT_TF_SOLDIER_DESTROY_STICKIES, "TF_SOLDIER_DESTROY_STICKIES", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_CrouchRocketJump : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "rocket_jump" );
+		ListenForGameEvent( "rocket_jump_landed" );
+		ResetTracking();
+	}
+
+	void ResetTracking( void )
+	{
+		ClearThink();
+		m_flStartingZ = 0.0f;
+	}
+
+	void CheckHeight( void )
+	{
+		CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
+		if ( pLocalTFPlayer )
+		{
+			float flCurrentZ = pLocalTFPlayer->GetAbsOrigin().z;
+
+			// check the settings for gravity
+			if ( ( flCurrentZ > m_flStartingZ ) && ( GetCurrentGravity() == 800.0f ) )
+			{
+				if ( flCurrentZ - m_flStartingZ > 450.0f )
+				{
+					IncrementCount();
+				}
+			}
+			else
+			{
+				// we've fallen below our starting Z or someone has messed with gravity, so reset our tracking
+				ResetTracking();
+			}
+		}
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( FStrEq( pszEvent, "teamplay_round_active" ) ||
+			 FStrEq( pszEvent, "localplayer_respawn" ) )
+		{
+			ResetTracking();
+		}
+		else if ( FStrEq( pszEvent, "rocket_jump" ) )
+		{
+			int iUserID = event->GetInt( "userid" );
+
+			CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
+			if ( pLocalTFPlayer && pLocalTFPlayer->GetUserID() == iUserID )
+			{
+				m_flStartingZ = pLocalTFPlayer->GetAbsOrigin().z;
+				SetNextThink( 0.1 );
+			}
+		}
+		else if ( FStrEq( pszEvent, "rocket_jump_landed" ) )
+		{
+			int iUserID = event->GetInt( "userid" );
+
+			CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
+			if ( pLocalTFPlayer && pLocalTFPlayer->GetUserID() == iUserID )
+			{
+				CheckHeight();
+				ResetTracking();
+			}
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		if ( pVictim == C_BasePlayer::GetLocalPlayer() )
+		{
+			ResetTracking();
+		}
+	}
+
+	virtual void Think( void )
+	{
+		CheckHeight();
+		SetNextThink( 0.1 );
+	}
+
+private:
+	float m_flStartingZ;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_CrouchRocketJump, ACHIEVEMENT_TF_SOLDIER_CROUCH_ROCKET_JUMP, "TF_SOLDIER_CROUCH_ROCKET_JUMP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_EqualizerStreak : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+		m_nStreak = 0;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "localplayer_healed" );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
+		{
+			if ( event->GetInt( "weaponid" ) == TF_WEAPON_SHOVEL )
+			{
+				CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
+				if ( pLocalTFPlayer && pLocalTFPlayer->GetActiveTFWeapon() )
+				{
+					CTFShovel *pShovel = static_cast< CTFShovel* >( pLocalTFPlayer->GetActiveTFWeapon() );
+					if ( pShovel && pShovel->GetShovelType() == SHOVEL_DAMAGE_BOOST )
+					{
+						m_nStreak++;
+
+						if ( m_nStreak >= 3 )
+						{
+							IncrementCount();
+						}
+					}
+				}
+			}
+		}
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
+			 FStrEq( event->GetName(), "localplayer_respawn" ) ||
+			 FStrEq( event->GetName(), "localplayer_healed" ) )
+		{
+			m_nStreak = 0;
+		}
+	}
+
+private:
+	int m_nStreak;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_EqualizerStreak, ACHIEVEMENT_TF_SOLDIER_EQUALIZER_STREAK, "TF_SOLDIER_EQUALIZER_STREAK", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_BuffFriends : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// client CTFPlayerShared::PulseSoldierBuff() awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_BuffFriends, ACHIEVEMENT_TF_SOLDIER_BUFF_FRIENDS, "TF_SOLDIER_BUFF_FRIENDS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillGroupWithCrocket : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		m_iKilledBySameRocket = 0;
+		m_fDamageTime = 0;
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_round_active" ) || 
+			FStrEq( event->GetName(), "localplayer_respawn" ) )
+		{
+			m_iKilledBySameRocket = 0;
+			m_fDamageTime = 0;
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		int iWeaponID = event->GetInt( "weaponid" );
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() && 
+			(iWeaponID == TF_WEAPON_ROCKETLAUNCHER || iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT) )
+		{
+			if ( event->GetInt( "damagebits" ) & DMG_CRITICAL )
+			{
+				if ( gpGlobals->curtime > m_fDamageTime+1.f )
+				{
+					m_fDamageTime = gpGlobals->curtime;
+					m_iKilledBySameRocket = 0;
+				}
+				m_iKilledBySameRocket++;
+				if ( m_iKilledBySameRocket == 3 )
+				{
+					IncrementCount(); 
+				}
+			}
+		}
+	}
+
+	int			m_iKilledBySameRocket;
+	float		m_fDamageTime;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillGroupWithCrocket, ACHIEVEMENT_TF_SOLDIER_KILL_GROUP_WITH_CROCKET, "TF_SOLDIER_KILL_GROUP_WITH_CROCKET", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillTwoDuringRocketJump : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "rocket_jump" );
+		ListenForGameEvent( "rocket_jump_landed" );
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		m_iKilledDuringRJ = 0;
+		m_bRocketJumping = false;
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
+			FStrEq( event->GetName(), "localplayer_respawn" ) )
+		{
+			m_iKilledDuringRJ = 0;
+			m_bRocketJumping = false;
+		}
+		else if ( FStrEq( event->GetName(), "rocket_jump_landed" ) )
+		{
+			C_TFPlayer *pTFAttacker = NULL;
+			int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+			if ( iIndex > 0 )
+			{
+				pTFAttacker = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );
+				if ( pTFAttacker != C_BasePlayer::GetLocalPlayer() )
+					return;
+			}
+			else
+				return;
+			m_iKilledDuringRJ = 0;
+			m_bRocketJumping = false;
+		}
+		else if ( FStrEq( event->GetName(), "rocket_jump" ) )
+		{
+			C_TFPlayer *pTFAttacker = NULL;
+			int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+			if ( iIndex > 0 )
+			{
+				pTFAttacker = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );
+				if ( pTFAttacker != C_BasePlayer::GetLocalPlayer() )
+					return;
+			}
+			else
+				return;
+			m_iKilledDuringRJ = 0;
+			m_bRocketJumping = true;
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		CTFPlayer *pTFPlayer = ToTFPlayer( pAttacker );
+		if ( pTFPlayer && (pTFPlayer == C_BasePlayer::GetLocalPlayer()) )
+		{
+			if ( m_bRocketJumping )
+			{
+				m_iKilledDuringRJ++;
+				if ( m_iKilledDuringRJ == 2 )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+
+	bool	m_bRocketJumping;
+	int		m_iKilledDuringRJ;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillTwoDuringRocketJump, ACHIEVEMENT_TF_SOLDIER_KILL_TWO_DURING_ROCKET_JUMP, "TF_SOLDIER_KILL_TWO_DURING_ROCKET_JUMP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillTaunt : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
+		SetGoal( 1 );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+		if ( pAttacker == pLocalPlayer )
+		{
+			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
+			if ( pTFVictim && event->GetInt( "customkill" ) == TF_DMG_CUSTOM_TAUNTATK_GRENADE )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillTaunt, ACHIEVEMENT_TF_SOLDIER_KILL_TAUNT, "TF_SOLDIER_KILL_TAUNT", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_DefendMedic : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "medic_defended" );
+		m_iMedicDefended = 0;
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
+			FStrEq( event->GetName(), "localplayer_respawn" ) )
+		{
+			m_iMedicDefended = 0;
+		}
+		else if ( FStrEq( event->GetName(), "medic_defended" ) )
+		{
+			m_iMedicDefended++;
+			if ( m_iMedicDefended == 3 )
+			{
+				IncrementCount();
+			}
+		}
+	}
+
+	int m_iMedicDefended;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_DefendMedic, ACHIEVEMENT_TF_SOLDIER_DEFEND_MEDIC, "TF_SOLDIER_DEFEND_MEDIC", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillWithEqualizerWhileHurt : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
+		SetGoal( 20 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( !pVictim || !pVictim->IsPlayer() )
+			return;
+
+		CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
+		if ( pTFAttacker && (pTFAttacker == C_BasePlayer::GetLocalPlayer()) && (event->GetInt( "weaponid" ) == TF_WEAPON_SHOVEL) )
+		{
+			CTFShovel *pShovel = static_cast<CTFShovel*>(pTFAttacker->GetActiveWeapon());
+			if ( pShovel && (pShovel->GetShovelType() == SHOVEL_DAMAGE_BOOST) )
+			{
+				if ( pAttacker->GetHealth() < 25 )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillWithEqualizerWhileHurt, ACHIEVEMENT_TF_SOLDIER_KILL_WITH_EQUALIZER_WHILE_HURT, "TF_SOLDIER_KILL_WITH_EQUALIZER_WHILE_HURT", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillAirborneTargetWhileAirborne : public CBaseTFAchievement
+{
+	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 ( pAttacker == C_BasePlayer::GetLocalPlayer() && !(pAttacker->GetFlags() & FL_ONGROUND) )
+		{
+			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
+
+			if ( pTFVictim )
+			{
+				if ( !(pTFVictim->GetFlags() & FL_ONGROUND) && pTFVictim->IsPlayerClass( TF_CLASS_SOLDIER ) )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillAirborneTargetWhileAirborne, ACHIEVEMENT_TF_SOLDIER_KILL_AIRBORNE_TARGET_WHILE_AIRBORNE, "TF_SOLDIER_KILL_AIRBORNE_TARGET_WHILE_AIRBORNE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_BounceThenShotgun : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );		
+		SetDefLessFunc( m_BouncedPlayers );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ListenForGameEvent( "player_hurt" );
+		m_BouncedPlayers.RemoveAll();
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
+			 FStrEq( event->GetName(), "localplayer_respawn" ) )
+		{
+			m_BouncedPlayers.RemoveAll();
+		}
+		else if ( FStrEq( event->GetName(), "player_hurt" ) )
+		{
+			int iSoldier = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
+			CBasePlayer *pSoldier = UTIL_PlayerByIndex( iSoldier );
+			if ( pSoldier && pSoldier == C_TFPlayer::GetLocalTFPlayer() )
+			{
+				int iVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+				CBasePlayer *pVictim = UTIL_PlayerByIndex( iVictim );
+				if ( pVictim )
+				{
+					//Vector vVictimVelocity = pVictim->GetAbsVelocity();
+					bool bVictimGrounded = pVictim->GetFlags() & FL_ONGROUND;
+					int iWeaponID = event->GetInt( "weaponid" );
+					bool bRocketLauncherUsed = (iWeaponID == TF_WEAPON_ROCKETLAUNCHER) || (iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT);
+					if ( bVictimGrounded && bRocketLauncherUsed )
+					{
+						int iIndex = m_BouncedPlayers.Find( pVictim->GetUserID() );
+						if ( iIndex != m_BouncedPlayers.InvalidIndex() )
+						{
+							// they're already in our list
+							m_BouncedPlayers[iIndex] = gpGlobals->curtime;
+						}
+						else
+						{
+							// we need to add them
+							m_BouncedPlayers.Insert( pVictim->GetUserID(), gpGlobals->curtime );
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
+		{
+			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
+			if ( pTFVictim && !( pTFVictim->GetFlags() & FL_ONGROUND ) && ( event->GetInt( "weaponid" ) == TF_WEAPON_SHOTGUN_SOLDIER ) )
+			{
+				int iIndex = m_BouncedPlayers.Find( pTFVictim->GetUserID() );
+				if ( iIndex != m_BouncedPlayers.InvalidIndex() )
+				{
+					if ( gpGlobals->curtime < m_BouncedPlayers[iIndex] + 4.f )
+					{
+						IncrementCount();
+					}
+				}
+			}
+		}
+	}
+
+	CUtlMap< int, float > m_BouncedPlayers; // userID and most recent time they were bounced
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_BounceThenShotgun, ACHIEVEMENT_TF_SOLDIER_BOUNCE_THEN_SHOTGUN, "TF_SOLDIER_BOUNCE_THEN_SHOTGUN", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillAirborneWithDirectHit : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 10 );		
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( pAttacker != C_BasePlayer::GetLocalPlayer() )
+			return;
+
+		C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
+		if ( !pTFVictim )
+			return;
+
+		C_TFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
+		if ( !pTFAttacker )
+			return;
+
+		CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
+
+		int iMiniCritAirborne = 0;
+		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritAirborne, mini_crit_airborne );
+		if ( iMiniCritAirborne == 1 && !(pTFVictim->GetFlags() & FL_ONGROUND) )
+		{
+			IncrementCount();
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillAirborneWithDirectHit, ACHIEVEMENT_TF_SOLDIER_KILL_AIRBORNE_WITH_DIRECT_HIT, "TF_SOLDIER_KILL_AIRBORNE_WITH_DIRECT_HIT", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillSniperWhileDead : public CBaseTFAchievement
+{
+	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 ) 
+	{
+		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
+
+		int iWeaponID = event->GetInt( "weaponid" );
+		bool bRocketLauncherUsed = (iWeaponID == TF_WEAPON_ROCKETLAUNCHER) || (iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT);
+		if ( pTFVictim && (pAttacker == C_TFPlayer::GetLocalTFPlayer()) && (pAttacker->IsAlive() == false) &&
+			bRocketLauncherUsed && pTFVictim->IsPlayerClass( TF_CLASS_SNIPER ) )
+		{
+			IncrementCount();
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillSniperWhileDead, ACHIEVEMENT_TF_SOLDIER_KILL_SNIPER_WHILE_DEAD, "TF_SOLDIER_KILL_SNIPER_WHILE_DEAD", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_DestroySentryOutOfRange : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 5 );
+		SetStoreProgressInSteam( true );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_DestroySentryOutOfRange, ACHIEVEMENT_TF_SOLDIER_DESTROY_SENTRY_OUT_OF_RANGE, "TF_SOLDIER_DESTROY_SENTRY_OUT_OF_RANGE", 5 );
+
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_AssistMedicUbercharge : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1 );
+		m_iPlayersGibbed = 0;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "player_invulned" );
+	}
+
+	virtual void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "player_invulned" ) )
+		{
+			int iTarget = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+			CBaseEntity *pPlayer = UTIL_PlayerByIndex( iTarget );
+			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+			if ( pPlayer == pLocalPlayer )
+			{
+				m_iPlayersGibbed = 0;
+			}
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( pAttacker == pLocalPlayer && pVictim && pVictim->IsPlayer() && pVictim != pLocalPlayer )
+		{
+			if ( event->GetInt( "death_flags" ) & TF_DEATH_GIBBED )
+			{
+				if ( pLocalPlayer->m_Shared.InCond( TF_COND_INVULNERABLE ) || pLocalPlayer->m_Shared.InCond( TF_COND_CRITBOOSTED ) ||
+					pLocalPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
+				{
+					m_iPlayersGibbed++;
+					if ( m_iPlayersGibbed >= 5 )
+					{
+						IncrementCount();
+					}
+				}
+			}
+		}
+	}
+
+private:
+	int		m_iPlayersGibbed;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_AssistMedicUbercharge, ACHIEVEMENT_TF_SOLDIER_ASSIST_MEDIC_UBER, "TF_SOLDIER_ASSIST_MEDIC_UBER", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_ShootMultCrits : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_ShootMultCrits, ACHIEVEMENT_TF_SOLDIER_SHOOT_MULT_CRITS, "TF_SOLDIER_SHOOT_MULT_CRITS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillDefenseless : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1 );
+	}
+
+	virtual bool LocalPlayerCanEarn( void ) 
+	{ 
+		if ( TFGameRules() )
+		{
+			bool bMVMAchievement = ( m_iAchievementID >= ACHIEVEMENT_TF_MVM_START_RANGE && m_iAchievementID <= ACHIEVEMENT_TF_MVM_END_RANGE );
+
+			if ( ( bMVMAchievement && !TFGameRules()->IsMannVsMachineMode() ) || ( !bMVMAchievement && TFGameRules()->IsMannVsMachineMode() ) )
+			{
+				return false;
+			}
+		}
+
+		// This achievement can be earned while we're in the post-win state
+		return IsLocalTFPlayerClass( TF_CLASS_SOLDIER );
+	}
+
+	virtual void ListenForEvents()
+	{
+		m_iPlayersKilled = 0;
+		ListenForGameEvent( "teamplay_win_panel" );
+	}
+
+	virtual void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_win_panel" ) )
+		{
+			m_iPlayersKilled = 0;
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		if ( TFGameRules()->State_Get() != GR_STATE_TEAM_WIN )
+			return;
+
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( pAttacker == pLocalPlayer && pVictim && pVictim->IsPlayer() && pVictim != pLocalPlayer )
+		{
+			m_iPlayersKilled++;
+			if ( m_iPlayersKilled >= 3 )
+			{
+				IncrementCount();
+			}
+		}
+	}
+
+private:
+	int		m_iPlayersKilled;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillDefenseless, ACHIEVEMENT_TF_SOLDIER_KILL_DEFENSELESS, "TF_SOLDIER_KILL_DEFENSELESS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillWhileOnFire : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 20 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( pAttacker == pLocalPlayer && pVictim && pVictim->IsPlayer() && pVictim != pLocalPlayer )
+		{
+			if ( pLocalPlayer->m_Shared.InCond(TF_COND_BURNING) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillWhileOnFire, ACHIEVEMENT_TF_SOLDIER_KILL_ON_FIRE, "TF_SOLDIER_KILL_ON_FIRE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_FreezeTaunts : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// Give opponents freezecams of you taunting
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_FreezeTaunts, ACHIEVEMENT_TF_SOLDIER_FREEZECAM_TAUNT, "TF_SOLDIER_FREEZECAM_TAUNT", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_FreezeGibs : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// Give opponents freezecams of you with X gibs onscreen
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_FreezeGibs, ACHIEVEMENT_TF_SOLDIER_FREEZECAM_GIBS, "TF_SOLDIER_FREEZECAM_GIBS", 5 );
+
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillSpyKiller : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents( void )
+	{
+		m_vecBackstabbers.Purge();
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+		if ( FStrEq( pszEvent, "teamplay_round_active" ) ||	FStrEq( pszEvent, "localplayer_respawn" ) )
+		{
+			m_vecBackstabbers.Purge();
+		}
+	}
+
+	int	GetBackstabberIndex( CBaseEntity *pTarget )
+	{
+		for ( int i = 0; i < m_vecBackstabbers.Count(); i++ )
+		{
+			if ( m_vecBackstabbers[i].hSpy == pTarget )
+				return i;
+		}
+		return -1;
+	}
+
+	void AddNewBackstabber( CBaseEntity *pTarget )
+	{
+		if ( !pTarget )
+			return;
+
+		// see if the target is already in our list or get a new index
+		int iTargetIndex = GetBackstabberIndex( pTarget );
+		if ( iTargetIndex == -1 )
+		{
+			iTargetIndex = m_vecBackstabbers.AddToTail();
+		}
+
+		m_vecBackstabbers[iTargetIndex].hSpy = pTarget;
+		m_vecBackstabbers[iTargetIndex].flBackstabWindow = gpGlobals->curtime + 5.0f; // 5 seconds to kill the target
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( pVictim == pLocalPlayer )
+			return;
+
+		CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
+		if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_SPY ) && pVictim->InSameTeam( pLocalPlayer ) )
+		{
+			int customkill = event->GetInt( "customkill" );
+			if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
+			{
+				AddNewBackstabber( pTFAttacker );
+			}
+		}
+		else if ( pAttacker == pLocalPlayer && pVictim && pVictim->IsPlayer() )
+		{
+			int iTargetIndex = GetBackstabberIndex( pVictim );
+			if ( iTargetIndex != -1 )
+			{
+				if ( m_vecBackstabbers[iTargetIndex].flBackstabWindow > gpGlobals->curtime )
+				{
+					// We killed him within 5 seconds of him backstabbing a buddy
+					IncrementCount();
+				}
+
+				m_vecBackstabbers.Remove( iTargetIndex );
+			}
+		}
+	}	
+
+private:
+	struct backstabber_t
+	{
+		EHANDLE hSpy;
+		float flBackstabWindow;
+	};
+	CUtlVector<backstabber_t> m_vecBackstabbers;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillSpyKiller, ACHIEVEMENT_TF_SOLDIER_KILL_SPY_KILLER, "TF_SOLDIER_KILL_SPY_KILLER", 5 );
+
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_GibGrind : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
+		SetGoal( 1000 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( pAttacker == pLocalPlayer && pVictim && pVictim->IsPlayer() && pVictim != pLocalPlayer )
+		{
+			if ( event->GetInt( "death_flags" ) & TF_DEATH_GIBBED )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_GibGrind, ACHIEVEMENT_TF_SOLDIER_GIB_GRIND, "TF_SOLDIER_GIB_GRIND", 5 );
+
+
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_DuoSoldierKills : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 10 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "player_death" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "player_death" ) )
+		{
+			int iAttackerIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
+			if ( iAttackerIndex == 0 )
+				return;
+			CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( iAttackerIndex ) );
+			if ( !pAttacker )
+				return;
+
+			int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
+			if ( iAssisterIndex == 0 )
+				return;
+			CTFPlayer *pAssister = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );
+			if ( !pAssister )
+				return;
+
+			if ( pAttacker == C_BasePlayer::GetLocalPlayer() && pAssister->IsPlayerClass( TF_CLASS_SOLDIER ) )
+			{
+				// We are the attacker and the assist is from a soldier.
+				IncrementCount();
+				return;
+			}
+
+			if ( pAssister == C_BasePlayer::GetLocalPlayer() && pAttacker->IsPlayerClass( TF_CLASS_SOLDIER ) )
+			{
+				// We are the assister and the kill is from a soldier.
+				IncrementCount();
+				return;
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_DuoSoldierKills, ACHIEVEMENT_TF_SOLDIER_DUO_SOLDIER_KILLS, "TF_SOLDIER_DUO_SOLDIER_KILLS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_MVP : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 10 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "player_mvp" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "player_mvp" ) )
+		{
+			CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "player" ) ) );
+			if ( !pTFPlayer )
+				return;
+			
+			if ( pTFPlayer == C_BasePlayer::GetLocalPlayer() )
+			{
+				if ( CalcTeammateCount() >= 5 )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_MVP, ACHIEVEMENT_TF_SOLDIER_MVP, "TF_SOLDIER_MVP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_ThreeDominations : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		nDominations = 0;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_round_start" );
+		ListenForGameEvent( "localplayer_respawn" );		
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( ( FStrEq( pszEvent, "localplayer_respawn" ) || FStrEq( pszEvent, "teamplay_round_start" ) ) )
+		{
+			nDominations = 0;
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		// Player died	
+		if ( pVictim == C_BasePlayer::GetLocalPlayer() )
+		{
+			nDominations = 0;
+			return;
+		}
+
+		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
+		{
+			bool bDomination = event->GetInt( "death_flags" ) & TF_DEATH_DOMINATION;
+
+			if ( bDomination )
+			{
+				CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
+				if ( pTFVictim )
+				{
+					nDominations++; 
+				}
+			}
+		}
+
+		if ( nDominations >= 3 )
+		{
+			IncrementCount();
+		}
+	}
+
+private:
+
+	int nDominations;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_ThreeDominations, ACHIEVEMENT_TF_SOLDIER_THREE_DOMINATIONS, "TF_SOLDIER_THREE_DOMINATIONS", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_RideTheCart : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "controlpoint_starttouch" );
+		ListenForGameEvent( "controlpoint_endtouch" );
+		ListenForGameEvent( "teamplay_round_win" );
+		ListenForGameEvent( "teamplay_round_start" );
+		ResetStatus();
+		m_nRideTime = 30;
+	}
+
+	void ResetStatus()
+	{
+		ClearThink();
+		m_bIsThinking = false;
+		m_fRideStartTime = 0;
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		// Pushed the cart onto the cap before time
+		if ( Q_strcmp( event->GetName(), "teamplay_round_win" ) == 0 && m_bIsThinking )
+		{
+			ResetStatus();
+		}
+
+		if ( Q_strcmp( event->GetName(), "teamplay_round_start" ) == 0 && m_bIsThinking )
+		{
+			ResetStatus();
+		}
+
+		if ( !TFGameRules() || TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT )
+			return;
+
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( !pLocalPlayer )
+			return;
+
+		C_TFTeam *pTeam = GetGlobalTFTeam( pLocalPlayer->GetTeamNumber() );
+		if ( pTeam->GetRole() != TEAM_ROLE_ATTACKERS )
+			return;
+
+		// Player in cart trigger.  Register the time.
+		if ( Q_strcmp( event->GetName(), "controlpoint_starttouch" ) == 0 && !m_bIsThinking )
+		{
+			int iPlayerIndex = event->GetInt( "player", 0 );
+
+			if ( iPlayerIndex == GetLocalPlayerIndex() )
+			{
+				m_fRideStartTime = gpGlobals->curtime + (float)m_nRideTime;
+				SetNextThink( m_nRideTime );
+				m_bIsThinking = true;
+			}
+		}
+
+		// Reset conditions:
+		// Left the trigger
+		if ( Q_strcmp( event->GetName(), "controlpoint_endtouch" ) == 0 && m_bIsThinking )
+		{
+			int iPlayerIndex = event->GetInt( "player", 0 );
+
+			if ( iPlayerIndex == GetLocalPlayerIndex() )
+			{
+				ResetStatus();
+			}
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		// Died in the trigger
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+		if ( pVictim == pLocalPlayer && m_bIsThinking )
+		{
+			ResetStatus();
+		}
+	}
+
+	virtual void Think( void )
+	{
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+		if ( !TFGameRules() )
+			return;
+
+		if ( pLocalPlayer && pLocalPlayer->IsAlive() && m_fRideStartTime <= gpGlobals->curtime )
+		{
+			IncrementCount();
+		}
+	}
+
+private:
+
+	int		m_nRideTime;
+	float	m_fRideStartTime;
+	bool	m_bIsThinking;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_RideTheCart, ACHIEVEMENT_TF_SOLDIER_RIDE_THE_CART, "TF_SOLDIER_RIDE_THE_CART", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillTwentyFromAbove : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 20 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
+
+		if ( pLocalPlayer )
+		{
+			int iWeaponID = event->GetInt( "weaponid" );
+			bool bRocketLauncherUsed = (iWeaponID == TF_WEAPON_ROCKETLAUNCHER) || (iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT);
+			if ( pAttacker == pLocalPlayer && bRocketLauncherUsed )
+			{	
+				// Determine height difference - probably need to factor in distance, too
+				Vector vecAttacker = pAttacker->GetAbsOrigin();
+				Vector vecVictim = pVictim->GetAbsOrigin();
+				Vector vecDelta = vecAttacker - vecVictim;
+
+				// Msg( "ZDelta: %f \n", vecDelta.z );
+				if ( vecDelta.z >= 92 )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillTwentyFromAbove, ACHIEVEMENT_TF_SOLDIER_KILL_TWENTY_FROM_ABOVE, "TF_SOLDIER_KILL_TWENTY_FROM_ABOVE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_KillFiveStunned : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 5 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
+	{
+		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
+
+		if ( pLocalPlayer )
+		{
+			if ( pAttacker == pLocalPlayer )
+			{
+				int iStunFlags = event->GetInt( "stun_flags" );
+
+				if ( ( iStunFlags & TF_STUN_LOSER_STATE ) != 0 ||
+					 ( iStunFlags & TF_STUN_CONTROLS ) != 0 )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_KillFiveStunned, ACHIEVEMENT_TF_SOLDIER_KILL_FIVE_STUNNED, "TF_SOLDIER_KILL_FIVE_STUNNED", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_DefendCapThirtyTimes : public CBaseTFAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 30 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "teamplay_capture_blocked" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( FStrEq( event->GetName(), "teamplay_capture_blocked" ) )
+		{
+			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+			if ( pLocalPlayer )
+			{
+				int iBlocker = event->GetInt( "blocker", 0 );
+				if ( iBlocker == GetLocalPlayerIndex() )
+				{
+					IncrementCount();
+				}
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_DefendCapThirtyTimes, ACHIEVEMENT_TF_SOLDIER_DEFEND_CAP_THIRTY_TIMES, "TF_SOLDIER_DEFEND_CAP_THIRTY_TIMES", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_AchieveProgress1 : public CAchievement_AchievedCount
+{
+public:
+	DECLARE_CLASS( CAchievementTFSoldier_AchieveProgress1, CAchievement_AchievedCount );
+	void Init() 
+	{
+		BaseClass::Init();
+		SetAchievementsRequired( 5, ACHIEVEMENT_TF_SOLDIER_START_RANGE, ACHIEVEMENT_TF_SOLDIER_END_RANGE );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_AchieveProgress1, ACHIEVEMENT_TF_SOLDIER_ACHIEVE_PROGRESS1, "TF_SOLDIER_ACHIEVE_PROGRESS1", 5 );
+
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_AchieveProgress2 : public CAchievement_AchievedCount
+{
+public:
+	DECLARE_CLASS( CAchievementTFSoldier_AchieveProgress2, CAchievement_AchievedCount );
+	void Init() 
+	{
+		BaseClass::Init();
+		SetAchievementsRequired( 11, ACHIEVEMENT_TF_SOLDIER_START_RANGE, ACHIEVEMENT_TF_SOLDIER_END_RANGE );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_AchieveProgress2, ACHIEVEMENT_TF_SOLDIER_ACHIEVE_PROGRESS2, "TF_SOLDIER_ACHIEVE_PROGRESS2", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_AchieveProgress3 : public CAchievement_AchievedCount
+{
+public:
+	DECLARE_CLASS( CAchievementTFSoldier_AchieveProgress3, CAchievement_AchievedCount );
+	void Init() 
+	{
+		BaseClass::Init();
+		SetAchievementsRequired( 17, ACHIEVEMENT_TF_SOLDIER_START_RANGE, ACHIEVEMENT_TF_SOLDIER_END_RANGE );
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_AchieveProgress3, ACHIEVEMENT_TF_SOLDIER_ACHIEVE_PROGRESS3, "TF_SOLDIER_ACHIEVE_PROGRESS3", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_ParachuteKillGroup : public CBaseTFAchievement
+{
+public:
+	void Init()
+	{
+		SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+		ResetTracking();
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "parachute_deploy" );
+		ListenForGameEvent( "parachute_holster" );
+	}
+
+	void ResetTracking( void )
+	{
+		m_nKills = 0;
+		m_bParachuteDeployed = false;
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( FStrEq( pszEvent, "parachute_deploy" ) )
+		{
+			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
+			{
+				ResetTracking();
+				m_bParachuteDeployed = true;
+			}
+		}
+		else if ( FStrEq( pszEvent, "parachute_holster" ) )
+		{
+			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
+			{
+				ResetTracking();
+			}
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		if ( pVictim )
+		{
+			// Local player died	
+			if ( pVictim == C_BasePlayer::GetLocalPlayer() )
+			{
+				ResetTracking();
+			}
+			else if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
+			{
+				if ( m_bParachuteDeployed )
+				{
+					m_nKills++;
+					if ( m_nKills >= 3 )
+					{
+						IncrementCount();
+					}
+				}
+			}
+		}
+	}
+
+private:
+	int m_nKills;
+	bool m_bParachuteDeployed;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_ParachuteKillGroup, ACHIEVEMENT_TF_SOLDIER_PARACHUTE_KILL_GROUP, "TF_SOLDIER_PARACHUTE_KILL_GROUP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_ParachuteDistance : public CBaseTFAchievement
+{
+public:
+	void Init()
+	{
+		SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1233619 );
+		SetStoreProgressInSteam( true );
+		ResetTracking();
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "parachute_deploy" );
+		ListenForGameEvent( "parachute_holster" );
+	}
+
+	void ResetTracking( void )
+	{
+		ClearThink();
+		m_flLastZ = 0.0;
+	}
+
+	void CheckHeight( void )
+	{
+		CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+		if ( pLocalPlayer )
+		{
+			float flCurrentZ = pLocalPlayer->GetAbsOrigin().z;
+			float flDela = m_flLastZ - flCurrentZ;
+
+			// make sure we've fallen....we may have been pushed upwards
+			if ( flDela > 0.0f )
+			{
+				IncrementCount( (int)( flDela ) );
+			}
+
+			m_flLastZ = flCurrentZ;
+		}
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEvent = event->GetName();
+
+		if ( FStrEq( pszEvent, "parachute_deploy" ) )
+		{
+			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
+			{
+				CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+				if ( pLocalPlayer )
+				{
+					m_flLastZ = pLocalPlayer->GetAbsOrigin().z;
+					SetNextThink( 0.1 );
+				}
+			}
+		}
+		else if ( FStrEq( pszEvent, "parachute_holster" ) )
+		{
+			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
+			{
+				ResetTracking();
+			}
+		}
+	}
+
+	virtual void Think( void )
+	{
+		CheckHeight();
+		SetNextThink( 0.1 );
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		// Local player died	
+		if ( pVictim == C_BasePlayer::GetLocalPlayer() )
+		{
+			ResetTracking();
+		}
+	}
+
+private:
+	float m_flLastZ;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_ParachuteDistance, ACHIEVEMENT_TF_SOLDIER_PARACHUTE_DISTANCE, "TF_SOLDIER_PARACHUTE_DISTANCE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_ParachuteKillParachute : public CBaseTFAchievement
+{
+public:
+	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 )
+	{
+		CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
+		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
+		if ( pTFAttacker && pTFVictim && ( pTFAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
+		{
+			if ( ( pTFAttacker->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) ) && ( pTFVictim->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) ) )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_ParachuteKillParachute, ACHIEVEMENT_TF_SOLDIER_PARACHUTE_KILL_PARACHUTE, "TF_SOLDIER_PARACHUTE_KILL_PARACHUTE", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_AirstrikeMaxClip : public CBaseTFAchievement
+{
+public:
+	void Init()
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	// server awards this achievement, no other code within achievement necessary
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_AirstrikeMaxClip, ACHIEVEMENT_TF_SOLDIER_AIRSTRIKE_MAX_CLIP, "TF_SOLDIER_AIRSTRIKE_MAX_CLIP", 5 );
+
+//----------------------------------------------------------------------------------------------------------------
+class CAchievementTFSoldier_AirstrikeGroupKill : public CBaseTFAchievement
+{
+public:
+	void Init() 
+	{
+		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	void ResetTracking( void )
+	{
+		m_iKilledDuringRJ = 0;
+		m_bRocketJumping = false;
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "rocket_jump" );
+		ListenForGameEvent( "rocket_jump_landed" );
+		ListenForGameEvent( "teamplay_round_active" );
+		ListenForGameEvent( "localplayer_respawn" );
+		ResetTracking();
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		const char *pszEventName = event->GetName();
+
+		if ( FStrEq( pszEventName, "teamplay_round_active" ) ||
+			 FStrEq( pszEventName, "localplayer_respawn" ) )
+		{
+			ResetTracking();
+		}
+		else if ( FStrEq( pszEventName, "rocket_jump_landed" ) )
+		{
+			int iUserID = event->GetInt( "userid" );
+
+			CBasePlayer *pLocalPlayer = CBasePlayer::GetLocalPlayer();
+			if ( pLocalPlayer && ( pLocalPlayer->GetUserID() == iUserID ) )
+			{
+				ResetTracking();
+			}
+		}
+		else if ( FStrEq( pszEventName, "rocket_jump" ) )
+		{
+			int iUserID = event->GetInt( "userid" );
+
+			CBasePlayer *pLocalPlayer = CBasePlayer::GetLocalPlayer();
+			if ( pLocalPlayer && ( pLocalPlayer->GetUserID() == iUserID ) )
+			{
+				m_iKilledDuringRJ = 0;
+				m_bRocketJumping = true;
+			}
+		}
+	}
+
+	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
+	{
+		if ( pVictim && ( pAttacker == CBasePlayer::GetLocalPlayer() ) )
+		{
+			if ( m_bRocketJumping && ( event->GetInt( "weaponid" ) == TF_WEAPON_ROCKETLAUNCHER ) )
+			{
+				CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
+				if ( pTFAttacker )
+				{
+					CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
+					if ( pWeapon )
+					{
+						int iClipSizeOnKills = 0;
+						CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iClipSizeOnKills, clipsize_increase_on_kill );
+						if ( iClipSizeOnKills )
+						{
+							m_iKilledDuringRJ++;
+							if ( m_iKilledDuringRJ == 3 )
+							{
+								IncrementCount();
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+private:
+	bool	m_bRocketJumping;
+	int		m_iKilledDuringRJ;
+};
+DECLARE_ACHIEVEMENT( CAchievementTFSoldier_AirstrikeGroupKill, ACHIEVEMENT_TF_SOLDIER_AIRSTRIKE_GROUP_KILL, "TF_SOLDIER_AIRSTRIKE_GROUP_KILL", 5 );
+
+#endif // CLIENT_DLL