source-engine/game/shared/tf/achievements_tf_sniper.cpp

//========= 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"

//======================================================================================================================================
// SNIPER ACHIEVEMENT PACK
//======================================================================================================================================

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_JarateDominated : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// Jarate an enemy that you're dominating

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "player_jarated" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "player_jarated" ) )
		{
			CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( !pLocalPlayer )
				return;

			int iVictim = event->GetInt( "victim_entindex" );
			if ( pLocalPlayer->m_Shared.IsPlayerDominated(iVictim) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_JarateDominated, ACHIEVEMENT_TF_SNIPER_JARATE_DOMINATED, "TF_SNIPER_JARATE_DOMINATED", 5 );

//----------------------------------------------------------------------------------------------------------------
//Capture the flag as a sniper.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_CaptureTheFlag : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_flag_event" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_flag_event" ) )
		{
			int iCapper = event->GetInt( "player" );
			int iType = event->GetInt( "eventtype" );

			if ( iCapper == GetLocalPlayerIndex() && iType == TF_FLAGEVENT_CAPTURE )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_CaptureTheFlag, ACHIEVEMENT_TF_SNIPER_CAPTURE_FLAG, "TF_SNIPER_CAPTURE_FLAG", 5 );


//----------------------------------------------------------------------------------------------------------------
//Kill an invisible spy.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_InvisibleSpyKill : 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;

		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );

		if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) && pTFVictim->m_Shared.InCond( TF_COND_STEALTHED ) )
		{
			if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
			{
				if ( pTFVictim->GetPercentInvisible() == 1.0f )
				{
					IncrementCount(); 
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_InvisibleSpyKill, ACHIEVEMENT_TF_SNIPER_KILL_INVIS_SPY, "TF_SNIPER_KILL_INVIS_SPY", 5 );

//----------------------------------------------------------------------------------------------------------------
//Headshot X enemy snipers
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_HeadShotSnipers: 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 ) 
	{
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );

		if ( pTFVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) && ( IsHeadshot( event->GetInt( "customkill" ) ) ) && pTFVictim->IsPlayerClass( TF_CLASS_SNIPER ) )
		{
			IncrementCount();
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_HeadShotSnipers, ACHIEVEMENT_TF_SNIPER_HEADSHOT_SNIPERS, "TF_SNIPER_HEADSHOT_SNIPERS", 5 );

//----------------------------------------------------------------------------------------------------------------
//Headshot an enemy demoman
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_HeadShotDemoman: 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 );

		if ( pTFVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) && ( IsHeadshot( event->GetInt( "customkill" ) ) ) && pTFVictim->IsPlayerClass( TF_CLASS_DEMOMAN ) )
		{
			IncrementCount();
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_HeadShotDemoman, ACHIEVEMENT_TF_SNIPER_HEADSHOT_DEMOMAN, "TF_SNIPER_HEADSHOT_DEMOMAN", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill X spies with the kukri
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_SpyKukriKills: 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 ) 
	{
		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
		if ( pAttacker == pLocalPlayer )
		{
			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );

			if ( pTFVictim && pTFVictim->IsPlayerClass(TF_CLASS_SPY) && event->GetInt( "weaponid" ) == TF_WEAPON_CLUB )
			{
				IncrementCount();
			}
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_SpyKukriKills, ACHIEVEMENT_TF_SNIPER_KILL_SPIES_MELEE, "TF_SNIPER_KILL_SPIES_MELEE", 5 );


//----------------------------------------------------------------------------------------------------------------
//Kill a scout in midair
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_ScoutMidairKill: 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() )
		{
			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );

			if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SCOUT ) && WeaponID_IsSniperRifleOrBow( event->GetInt( "weaponid" ) ) )
			{
				if ( !(pTFVictim->GetFlags() & FL_ONGROUND) )
				{
					IncrementCount();
				}
			}
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_ScoutMidairKill, ACHIEVEMENT_TF_SNIPER_KILL_MIDAIR_SCOUT, "TF_SNIPER_KILL_MIDAIR_SCOUT", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill a fully charged medic
//----------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillChargedMedic : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}
	// client fires an event for this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillChargedMedic, ACHIEVEMENT_TF_SNIPER_KILL_CHARGED_MEDIC, "TF_SNIPER_KILL_CHARGED_MEDIC", 5 );


//----------------------------------------------------------------------------------------------------------------
//Consolation prize for getting backstabbed
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_Consolation_Backstabs: public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
		SetGoal( 50 );	
		SetStoreProgressInSteam( true );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pVictim == C_BasePlayer::GetLocalPlayer() )
		{
			C_TFPlayer *pTFAttacker = ToTFPlayer( pAttacker );

			if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_SPY ) && ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_BACKSTAB ) )
			{
				IncrementCount();
			}
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_Consolation_Backstabs, ACHIEVEMENT_TF_SNIPER_GET_BACKSTABBED, "TF_SNIPER_GET_BACKSTABBED", 5 );

//----------------------------------------------------------------------------------------------------------------
//Dominate an enemy sniper - NOTE: This will probably be iffy if the player you dominated just switched to sniper for that death
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_DominateEnemySniper : 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 );
		bool bDomination = event->GetInt( "death_flags" ) & TF_DEATH_DOMINATION;

		if ( pTFVictim && pAttacker == C_TFPlayer::GetLocalTFPlayer() && pTFVictim->IsPlayerClass( TF_CLASS_SNIPER ) && bDomination == true )
		{
			IncrementCount();
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_DominateEnemySniper, ACHIEVEMENT_TF_SNIPER_DOMINATE_SNIPER, "TF_SNIPER_DOMINATE_SNIPER", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill a rocket jumping soldier/demo
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillRocketJumper : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}
	// client fires an event for this achievement, no other code within achievement necessary
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillRocketJumper, ACHIEVEMENT_TF_SNIPER_KILL_RJER, "TF_SNIPER_KILL_RJER", 5 );

//----------------------------------------------------------------------------------------------------------------
//No scope, bro
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillNoScope : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 5 );
		SetStoreProgressInSteam( true );
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillNoScope, ACHIEVEMENT_TF_SNIPER_KILL_UNSCOPED, "TF_SNIPER_KILL_UNSCOPED", 5 );


//----------------------------------------------------------------------------------------------------------------
//Kill an enemy while you're dead
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillWhileDead: 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 );

		if ( pTFVictim && pAttacker == C_TFPlayer::GetLocalTFPlayer() && pAttacker->IsAlive() == false )
		{
			IncrementCount();
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillWhileDead, ACHIEVEMENT_TF_SNIPER_BOW_KILL_WHILEDEAD, "TF_SNIPER_BOW_KILL_WHILEDEAD", 5 );

//----------------------------------------------------------------------------------------------------------------
//Extinguish a burning team mate with the jarate
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_JarateExtinguish : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "player_extinguished" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "player_extinguished" ) )
		{
			CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( !pLocalPlayer )
				return;

			int iTargetIndex = event->GetInt( "victim" );
			int iHealerIndex = event->GetInt( "healer" );

			//Extinguishing myself doesn't count.
			if ( pLocalPlayer->entindex() == iHealerIndex && pLocalPlayer->entindex() != iTargetIndex )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_JarateExtinguish, ACHIEVEMENT_TF_SNIPER_JARATE_EXTINGUISH, "TF_SNIPER_JARATE_EXTINGUISH", 5 );

//----------------------------------------------------------------------------------------------------------------
//Topped the scoreboard
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_TopScoreboard : public CAchievementTopScoreboard
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_FILTER_FULL_ROUND_ONLY );
		SetGoal( 10 );
		SetStoreProgressInSteam( true );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_TopScoreboard, ACHIEVEMENT_TF_SNIPER_TOP_SCOREBOARD_GRIND, "TF_SNIPER_TOP_SCOREBOARD_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill an opponent within the first second of a round.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillRoundStart: public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
		SetGoal( 1 );		
		m_flRoundStartTime = -1;
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_setup_finished" );
		ListenForGameEvent( "arena_round_start" );
		
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_setup_finished" ) || FStrEq( event->GetName(), "arena_round_start" ) )
		{
			m_flRoundStartTime = gpGlobals->curtime + 1.0f;
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() )
		{
			if ( m_flRoundStartTime > 0.0f && m_flRoundStartTime >= gpGlobals->curtime )
			{
				IncrementCount();
			}
		}
	}

private:
	float m_flRoundStartTime;
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillRoundStart, ACHIEVEMENT_TF_SNIPER_KILL_AT_ROUNDSTART, "TF_SNIPER_KILL_AT_ROUNDSTART", 5 );

class CAchievementTFSniper_FreezecamHat : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_FreezecamHat, ACHIEVEMENT_TF_SNIPER_FREEZECAM_HAT, "TF_SNIPER_FREEZECAM_HAT", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_FreezecamWave : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_FreezecamWave, ACHIEVEMENT_TF_SNIPER_FREEZECAM_WAVE, "TF_SNIPER_FREEZECAM_WAVE", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill an opponent with 3 different weapons in one round
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_DifferentWeaponsKill: public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
		SetGoal( 1 );		
		m_Weapons.Purge();
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_round_active" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
		{
			m_Weapons.Purge();
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() )
		{
			int iWeaponID = event->GetInt( "weaponid" );
			
			if ( m_Weapons.Find( iWeaponID ) == -1 )
			{
				m_Weapons.AddToTail( iWeaponID );

				if ( m_Weapons.Count() == 3 )
				{
					IncrementCount();
				}
			}
		}
	}

private:
	CUtlVector< int >	m_Weapons;
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_DifferentWeaponsKill, ACHIEVEMENT_TF_SNIPER_KILL_WEAPONS, "TF_SNIPER_KILL_WEAPONS", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill grind
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillEnemyGrind: public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
		SetGoal( 1000 );		
		SetStoreProgressInSteam( true );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() && pVictim && pVictim->IsPlayer() )
		{
			IncrementCount();
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillEnemyGrind, ACHIEVEMENT_TF_SNIPER_KILL_GRIND, "TF_SNIPER_KILL_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
//Destroy 3 enemy sentries
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_DestroySentry : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 3 );
		SetStoreProgressInSteam( true );
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "object_destroyed" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( Q_strcmp( event->GetName(), "object_destroyed" ) == 0 )
		{
			int iIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
		
			if ( UTIL_PlayerByIndex( iIndex ) == C_TFPlayer::GetLocalTFPlayer() )
			{
				if ( event->GetInt( "objecttype" ) == OBJ_SENTRYGUN )
				{
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_DestroySentry, ACHIEVEMENT_TF_SNIPER_DESTROY_SENTRYGUNS, "TF_SNIPER_DESTROY_SENTRYGUNS", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill enemies doing important stuff.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillEnemiesImportant : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		m_iObjectivesDefended = 0;
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_flag_event" );
		ListenForGameEvent( "localplayer_respawn" );
		ListenForGameEvent( "teamplay_capture_blocked" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "localplayer_respawn" ) )
		{
			m_iObjectivesDefended = 0;
			return;
		}

		if ( FStrEq( event->GetName(), "teamplay_capture_blocked" ) )
		{
			int iBlocker = event->GetInt( "blocker" );

			if ( iBlocker == GetLocalPlayerIndex() )
			{
				m_iObjectivesDefended++;
			}
		}

		if ( FStrEq( event->GetName(), "teamplay_flag_event" ) && event->GetInt( "eventtype" ) == TF_FLAGEVENT_DEFEND )
		{
			int iIndex = event->GetInt( "player" );

			if ( GetLocalPlayerIndex() == iIndex )
			{
				m_iObjectivesDefended++;
			}
		}

		if ( m_iObjectivesDefended >= 3 )
		{
			IncrementCount();
		}
	}

private:
	int m_iObjectivesDefended;
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillEnemiesImportant, ACHIEVEMENT_TF_SNIPER_KILL_OBJECTIVES, "TF_SNIPER_KILL_OBJECTIVES", 5 );


//----------------------------------------------------------------------------------------------------------------
//Kill someone the moment they leave invul
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_HeadShotPostInvuln: 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 );

		if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() && pTFVictim && IsHeadshot ( event->GetInt( "customkill" ) ) )
		{
			if ( pTFVictim->m_Shared.GetInvulOffTime() > 0.0f && (gpGlobals->curtime - pTFVictim->m_Shared.GetInvulOffTime() ) <= 1.0f )
			{
				IncrementCount();
			}
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_HeadShotPostInvuln, ACHIEVEMENT_TF_SNIPER_HEADSHOT_POST_INVULN, "TF_SNIPER_HEADSHOT_POST_INVULN", 5 );

//----------------------------------------------------------------------------------------------------------------
//Baseclass for jarate/group related stuff
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_BaseJarateGroup : public CBaseTFAchievement
{

public:

	DECLARE_CLASS( CAchievementTFSniper_BaseJarateGroup, CBaseTFAchievement );

	void Init() 
	{
		m_flJarateTime = 0.0f;
		m_JaratedPlayers.Purge();
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "player_jarated" );
		ListenForGameEvent( "player_jarated_fade" );
	}

	virtual void AddedJaratedPlayer( void )
	{

	}

	virtual void RemoveJaratedPlayer( void )
	{

	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "player_jarated_fade" ) )
		{
			int iThrower = event->GetInt( "thrower_entindex" );
			int iVictim = event->GetInt( "victim_entindex" );

			if ( GetLocalPlayerIndex() != iThrower )
				return;

			m_JaratedPlayers.FindAndRemove( iVictim );

			RemoveJaratedPlayer();
		}
		else if ( FStrEq( event->GetName(), "player_jarated" ) )
		{
			int iThrower = event->GetInt( "thrower_entindex" );
			int iVictim = event->GetInt( "victim_entindex" );

			if ( GetLocalPlayerIndex() != iThrower )
				return;

			if ( m_flJarateTime <= gpGlobals->curtime )
			{
				m_flJarateTime = gpGlobals->curtime + 0.5;
				m_JaratedPlayers.Purge();
			}

			if ( m_JaratedPlayers.Find( iVictim ) == m_JaratedPlayers.InvalidIndex() )
			{
				m_JaratedPlayers.AddToTail( iVictim );
			}

			AddedJaratedPlayer();
		}
	}

	CUtlVector< int > m_JaratedPlayers;
	float m_flJarateTime;
};

//----------------------------------------------------------------------------------------------------------------
//Jarate 4 players with the same jar.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_JaratePack : public CAchievementTFSniper_BaseJarateGroup
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		m_flJarateTime = 0.0f;
		m_JaratedPlayers.Purge();
	}

	virtual void AddedJaratedPlayer( void )
	{
		if ( m_JaratedPlayers.Count() == 4 )
		{
			IncrementCount();
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_JaratePack, ACHIEVEMENT_TF_SNIPER_JARATE_GROUP, "TF_SNIPER_JARATE_GROUP", 5 );


//----------------------------------------------------------------------------------------------------------------
//Jarate a medic and his heal target
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_JarateMedicPair : public CAchievementTFSniper_BaseJarateGroup
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_flJarateTime = 0.0f;
		m_JaratedPlayers.Purge();
	}

	virtual void AddedJaratedPlayer( void )
	{
		for ( int i = 0; i < m_JaratedPlayers.Count(); i++ )
		{
			CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( m_JaratedPlayers[i] ) );

			if ( pPlayer && pPlayer->IsPlayerClass( TF_CLASS_MEDIC ) )
			{
				CTFPlayer *pHealTarget = ToTFPlayer( pPlayer->MedicGetHealTarget() );

				if ( pHealTarget && m_JaratedPlayers.Find( pHealTarget->entindex() ) != -1 )
				{
					IncrementCount();
				}
			}
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_JarateMedicPair, ACHIEVEMENT_TF_SNIPER_JARATE_MEDIC_PAIR, "TF_SNIPER_JARATE_MEDIC_PAIR", 5 );


//----------------------------------------------------------------------------------------------------------------
//Jarated an invisible spy
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_JarateReveal : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );		
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_JarateReveal, ACHIEVEMENT_TF_SNIPER_JARATE_REVEAL_SPY, "TF_SNIPER_JARATE_REVEAL_SPY", 5 );

//----------------------------------------------------------------------------------------------------------------
//Pin heavy by the head
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_PinHeavy : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );	
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "player_pinned" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "player_pinned" ) )
		{
			IncrementCount();	
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_PinHeavy, ACHIEVEMENT_TF_SNIPER_BOW_PIN_HEAVY, "TF_SNIPER_BOW_PIN_HEAVY", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill 3 jarated enemies with your kukri
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_JarateKillMelee : public CAchievementTFSniper_BaseJarateGroup
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
		SetGoal( 1 );	
		m_JaratedPlayers.Purge();
		m_iKilled = 0;
	}

	void RemoveJaratedPlayer( void )
	{
		if ( m_JaratedPlayers.Count() == 0 )
		{
			m_iKilled = 0;
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pVictim && pAttacker == C_TFPlayer::GetLocalTFPlayer() && event->GetInt( "weaponid" ) == TF_WEAPON_CLUB )
		{
			if ( m_JaratedPlayers.Find( pVictim->entindex() ) != m_JaratedPlayers.InvalidIndex() )
			{
				m_iKilled++;

				if ( m_iKilled == 3 )
				{
					IncrementCount();
				}
			}
		}
	}

private:
	int m_iKilled;
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_JarateKillMelee, ACHIEVEMENT_TF_SNIPER_JARATE_KILL_MELEE, "TF_SNIPER_JARATE_KILL_MELEE", 5 );


//----------------------------------------------------------------------------------------------------------------
//Kill a spy that just failed a backstab because of the shield
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_ShieldFailedSpy : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
		SetGoal( 1 );	

		m_iAttackerIndex = 0;
		m_flAttackTime = 0.0f;
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "player_shield_blocked" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "player_shield_blocked" ) )
		{
			int iAttacker = event->GetInt( "attacker_entindex" );
			int iBlocker = event->GetInt( "blocker_entindex" );

			if ( GetLocalPlayerIndex() != iBlocker )
				return;

			m_iAttackerIndex = iAttacker;
			m_flAttackTime = gpGlobals->curtime + 10.0f;
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( m_flAttackTime <= gpGlobals->curtime )
		{
			m_iAttackerIndex = 0;
		}

		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );

		if ( pTFVictim && pTFVictim->entindex() == m_iAttackerIndex && pAttacker == C_TFPlayer::GetLocalTFPlayer() )
		{
			IncrementCount();
		}
	}

private:
	int m_iAttackerIndex;
	float m_flAttackTime;
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_ShieldFailedSpy, ACHIEVEMENT_TF_SNIPER_KILL_FAILED_SPY, "TF_SNIPER_KILL_FAILED_SPY", 5 );


//----------------------------------------------------------------------------------------------------------------
// Kill a medic/heavy pair with the bow.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillMedicPair : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL  | ACH_LISTEN_KILL_ENEMY_EVENTS );
		SetGoal( 1 );
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "localplayer_respawn" );
		ListenForGameEvent( "teamplay_round_active" );

		m_hTargets.Purge();
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		const char *pszEventName = event->GetName();

		if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
			FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			m_hTargets.Purge();
		}
	}

	int	GetTargetIndex( CBaseEntity *pTarget )
	{
		for ( int i = 0; i < m_hTargets.Count(); i++ )
		{
			if ( m_hTargets[i].hTarget == pTarget )
				return i;
		}
		return -1;
	}

	void AddNewTarget( CBaseEntity *pTarget )
	{
		if ( !pTarget )
			return;

		// see if the target is already in our list or get a new index
		int iTargetIndex = GetTargetIndex( pTarget );
		if ( iTargetIndex == -1 )
		{
			iTargetIndex = m_hTargets.AddToTail();
		}

		m_hTargets[iTargetIndex].hTarget = pTarget;
		m_hTargets[iTargetIndex].flTimeToBeat = gpGlobals->curtime + 15.0f; // 15 seconds to kill the target
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( !pVictim || !pVictim->IsPlayer() )
			return;

		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();

		if ( pLocalPlayer == pAttacker && event->GetInt( "weaponid" ) == TF_WEAPON_COMPOUND_BOW )
		{
			// is this victim in our list of targets?
			int index = GetTargetIndex( pVictim );
			if ( index != -1 )
			{
				// did we beat the time?
				if ( m_hTargets[index].flTimeToBeat > gpGlobals->curtime )
				{
					IncrementCount();
				}
			}
			else
			{
				C_TFPlayer *pNewTarget = NULL;
				C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
				if ( pTFVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
				{
					for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
					{
						pNewTarget = ToTFPlayer( UTIL_PlayerByIndex( i ) );
						if ( pNewTarget && pNewTarget->IsPlayerClass( TF_CLASS_MEDIC ) && pNewTarget->MedicGetHealTarget() == pTFVictim )
						{
							// add all of his Medics to our list of targets (could be more than one Medic)
							AddNewTarget( pNewTarget );
						}
					}
				}
				else if ( pTFVictim->IsPlayerClass( TF_CLASS_MEDIC ) )
				{
					pNewTarget = ToTFPlayer( pTFVictim->MedicGetHealTarget() );
					if ( pNewTarget && pNewTarget->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
					{	
						AddNewTarget( pNewTarget );
					}
				}
			}
		}

		// is this victim in our list of targets?
		int index_ = GetTargetIndex( pVictim );
		if ( index_ != -1 )
		{
			m_hTargets.Remove( index_ );
		}
	}

private:
	struct targets_t
	{
		EHANDLE hTarget;
		float flTimeToBeat;
	};

	CUtlVector<targets_t> m_hTargets;
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillMedicPair, ACHIEVEMENT_TF_SNIPER_BOW_KILL_MEDIC_PAIR, "TF_SNIPER_BOW_KILL_MEDIC_PAIR", 5 );


//----------------------------------------------------------------------------------------------------------------
//Kill 3 jarated enemies with your kukri
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_JarateAssists : public CAchievementTFSniper_BaseJarateGroup
{
	DECLARE_CLASS( CAchievementTFSniper_JarateAssists, CAchievementTFSniper_BaseJarateGroup );

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
		SetGoal( 1 );	
		m_JaratedPlayers.Purge();
		m_iAssists = 0;
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_round_active" );

		BaseClass::ListenForEvents();
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
		{
			m_JaratedPlayers.Purge();
			m_iAssists = 0;
		}

		BaseClass::FireGameEvent_Internal( event );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );

		if ( iAssisterIndex > 0 )
		{
			C_TFPlayer *pTFAssister = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );

			if ( pVictim && pTFAssister == C_TFPlayer::GetLocalTFPlayer() )
			{
				if ( m_JaratedPlayers.Find( pVictim->entindex() ) != m_JaratedPlayers.InvalidIndex() )
				{
					m_iAssists++;

					if ( m_iAssists == 5 )
					{
						IncrementCount();
					}
				}
			}
		}
	}

private:
	int m_iAssists;
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_JarateAssists, ACHIEVEMENT_TF_SNIPER_JARATE_ASSISTS, "TF_SNIPER_JARATE_ASSISTS", 5 );

//----------------------------------------------------------------------------------------------------------------
//Kill an enemy carrying your flag with the bow
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_KillFlagCarrierBow : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// server awards this achievement, no other code within achievement necessary
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_KillFlagCarrierBow, ACHIEVEMENT_TF_SNIPER_BOW_KILL_FLAGCARRIER, "TF_SNIPER_BOW_KILL_FLAGCARRIER", 5 );

//----------------------------------------------------------------------------------------------------------------
//Boromir someone
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_Pincushion : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
		SetGoal( 1 );	
		m_hTargets.Purge();
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "arrow_impact" );
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "localplayer_respawn" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) || FStrEq( event->GetName(), "localplayer_respawn" ) )
		{
			 m_hTargets.Purge();
		}
		else if ( FStrEq( event->GetName(), "arrow_impact" ) )
		{
			int iEntity = event->GetInt( "attachedEntity" );
			int iShooter = event->GetInt( "shooter" );

			if ( iShooter == GetLocalPlayerIndex() )
			{
				int iTargetIndex = GetTargetIndex( UTIL_PlayerByIndex( iEntity ) );

				if ( iTargetIndex == -1 )
				{
					AddNewTarget( UTIL_PlayerByIndex( iEntity ) );
				}
				else
				{
					 m_hTargets[iTargetIndex].iArrows++;

					 if ( m_hTargets[iTargetIndex].iArrows >= 3 )
					 {
						 IncrementCount();
						 m_hTargets.Purge();
					 }
				}
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() )
		{
			int iTargetIndex = GetTargetIndex( pVictim );

			if ( iTargetIndex != -1 )
			{
				m_hTargets.Remove( iTargetIndex );
			}
		}
	}

	int	GetTargetIndex( CBaseEntity *pTarget )
	{
		for ( int i = 0; i < m_hTargets.Count(); i++ )
		{
			if ( m_hTargets[i].hTarget == pTarget )
				return i;
		}
		return -1;
	}

	void AddNewTarget( CBaseEntity *pTarget )
	{
		if ( !pTarget )
			return;

		if ( pTarget->IsAlive() == false )
			return;

		// see if the target is already in our list or get a new index
		int iTargetIndex = GetTargetIndex( pTarget );
		if ( iTargetIndex == -1 )
		{
			iTargetIndex = m_hTargets.AddToTail();
		}

		m_hTargets[iTargetIndex].hTarget = pTarget;
		m_hTargets[iTargetIndex].iArrows = 1;
	}

private:
	struct targets_t
	{
		EHANDLE hTarget;
		int iArrows;
		float flRemoveTime;
	};

	CUtlVector<targets_t> m_hTargets;
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_Pincushion, ACHIEVEMENT_TF_SNIPER_BOW_PINCUSHION, "TF_SNIPER_BOW_PINCUSHION", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_SniperTauntKill : 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 ( pAttacker == C_BasePlayer::GetLocalPlayer() )
		{
			// we already know we killed a player because of the ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS flag
			// was this a taunt kill?
			if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_TAUNTATK_ARROW_STAB )
			{
				IncrementCount();
			}
		}
	}
};

DECLARE_ACHIEVEMENT( CAchievementTFSniper_SniperTauntKill, ACHIEVEMENT_TF_SNIPER_TAUNT_KILL, "TF_SNIPER_TAUNT_KILL", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_SniperRifleNoMissing : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_SniperRifleNoMissing, ACHIEVEMENT_TF_SNIPER_RIFLE_NO_MISSING, "TF_SNIPER_RIFLE_NO_MISSING", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_AchieveProgress1 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFSniper_AchieveProgress1, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 5, ACHIEVEMENT_TF_SNIPER_START_RANGE, ACHIEVEMENT_TF_SNIPER_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_AchieveProgress1, ACHIEVEMENT_TF_SNIPER_ACHIEVE_PROGRESS1, "TF_SNIPER_ACHIEVE_PROGRESS1", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_AchieveProgress2 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFSniper_AchieveProgress2, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 11, ACHIEVEMENT_TF_SNIPER_START_RANGE, ACHIEVEMENT_TF_SNIPER_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_AchieveProgress2, ACHIEVEMENT_TF_SNIPER_ACHIEVE_PROGRESS2, "TF_SNIPER_ACHIEVE_PROGRESS2", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_AchieveProgress3 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFSniper_AchieveProgress3, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 17, ACHIEVEMENT_TF_SNIPER_START_RANGE, ACHIEVEMENT_TF_SNIPER_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_AchieveProgress3, ACHIEVEMENT_TF_SNIPER_ACHIEVE_PROGRESS3, "TF_SNIPER_ACHIEVE_PROGRESS3", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_ClassicRifleNoScopeHeadshot : public CBaseTFAchievement
{
public:
	void Init()
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 10 );
		SetStoreProgressInSteam( true );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_ClassicRifleNoScopeHeadshot, ACHIEVEMENT_TF_SNIPER_CLASSIC_RIFLE_NOSCOPE_HEADSHOT, "TF_SNIPER_CLASSIC_RIFLE_NOSCOPE_HEADSHOT", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_ClassicRifleHeadshotJumper : public CBaseTFAchievement
{
public:
	void Init()
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_ClassicRifleHeadshotJumper, ACHIEVEMENT_TF_SNIPER_CLASSIC_RIFLE_HEADSHOT_JUMPER, "TF_SNIPER_CLASSIC_RIFLE_HEADSHOT_JUMPER", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_ClassicRifleGibGrind : public CBaseTFAchievement
{
public:
	void Init()
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		m_iClassesKilled = 0;
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_round_active" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
		{
			m_iClassesKilled = 0;
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
	{
		if ( pVictim && ( pAttacker == CBasePlayer::GetLocalPlayer() ) )
		{
			if ( event->GetInt( "weaponid" ) == TF_WEAPON_SNIPERRIFLE_CLASSIC )
			{
				if ( event->GetInt( "death_flags" ) & TF_DEATH_GIBBED )
				{
					CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
					if ( pTFVictim && pTFVictim->GetPlayerClass() )
					{
						int iClass = pTFVictim->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 );
							m_iClassesKilled |= ( 1 << iBitNumber );

							if ( m_iClassesKilled == 511 )
							{
								IncrementCount();
							}
						}
					}
				}
			}
		}
	}

private:
	int m_iClassesKilled;
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_ClassicRifleGibGrind, ACHIEVEMENT_TF_SNIPER_CLASSIC_RIFLE_GIB_GRIND, "TF_SNIPER_CLASSIC_RIFLE_GIB_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSniper_ParachuteGrind : public CBaseTFAchievement
{
public:
	void Init()
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
		SetGoal( 25 );
		SetStoreProgressInSteam( true );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
	{
		if ( pVictim && ( pAttacker == CBasePlayer::GetLocalPlayer() ) )
		{
			CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
			if ( pTFVictim && 
				( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) && 
				( IsHeadshot( event->GetInt( "customkill" ) ) ) && 
				( event->GetInt( "damagebits" ) & DMG_CRITICAL ) && 
				( pTFVictim->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) ) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSniper_ParachuteGrind, ACHIEVEMENT_TF_SNIPER_PARACHUTE_GRIND, "TF_SNIPER_PARACHUTE_GRIND", 5 );

#endif // CLIENT_DLL