tf2/tf2_src/game/shared/tf/achievements_tf_scout.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"
#include "tf_weapon_shotgun.h"

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_FirstBlood : 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 ) 
	{
		// Achievement for getting first blood.
		if ( event->GetInt( "death_flags" ) & TF_DEATH_FIRST_BLOOD )
		{
			IncrementCount();
		}
	}

};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FirstBlood, ACHIEVEMENT_TF_SCOUT_FIRST_BLOOD, "TF_SCOUT_FIRST_BLOOD", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		CTFPlayer *pAttackerPlayer = ToTFPlayer( pAttacker );

		// Achievement for accumulating 5 kills over several matches with the first blood crit boost.
		bool bFirstBlood = event->GetInt( "death_flags" ) & TF_DEATH_FIRST_BLOOD;
		if ( pAttackerPlayer->m_Shared.IsFirstBloodBoosted() &&
			 pAttackerPlayer->m_Shared.InCond( TF_COND_CRITBOOSTED_FIRST_BLOOD ) &&
			 !bFirstBlood )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FirstBloodKill, ACHIEVEMENT_TF_SCOUT_FIRST_BLOOD_KILL, "TF_SCOUT_FIRST_BLOOD_KILL", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_WellEarlyKill : 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 ) 
	{
		// Achievement for getting a kill in cp_well during the setup phase.
		if ( FStrEq( m_pAchievementMgr->GetMapName(), "cp_well" ) &&
			 TFGameRules() && (TFGameRules()->State_Get() == GR_STATE_RND_RUNNING) &&
			 TFGameRules()->InSetup() )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_WellEarlyKill, ACHIEVEMENT_TF_SCOUT_WELL_EARLY_KILL, "TF_SCOUT_WELL_EARLY_KILL", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// Achievement for getting 2004 lifetime kills!
		IncrementCount();
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_LifetimeKills, ACHIEVEMENT_TF_SCOUT_LIFETIME_KILLS, "TF_SCOUT_LIFETIME_KILLS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_IronManKills : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
		SetGoal( 1 );

		ResetTracking();
	}

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

		ResetTracking();
	}

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

		if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
			FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			ResetTracking();
		}
	}
	
	void ResetTracking()
	{
		m_bKillOnGround = false;
		m_bKillInAir = false;
		m_bKillInWater = false;

	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// Achievement for getting a kill while on the ground, in the air, and in the water in a single life.
		CTFPlayer *pAttackerPlayer = ToTFPlayer( pAttacker );
		if ( !pAttackerPlayer )
			return;

		if ( pAttackerPlayer->GetWaterLevel() == WL_Eyes )
		{
			m_bKillInWater = true;
		}
		else if ( !(pAttackerPlayer->GetFlags() & FL_ONGROUND) )
		{
			m_bKillInAir = true;
		}
		else
		{
			m_bKillOnGround = true;
		}

		if ( m_bKillOnGround && m_bKillInAir && m_bKillInWater )
		{
			IncrementCount();
		}
	}
	
	bool m_bKillOnGround;
	bool m_bKillInAir;
	bool m_bKillInWater;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_IronManKills, ACHIEVEMENT_TF_SCOUT_IRON_MAN_KILLS, "TF_SCOUT_IRON_MAN_KILLS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DestroyTeleporters : 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" ) );
			CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
			C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pDestroyer == pTFPlayer )
			{
				// Only count teleporters.
				int iType = event->GetInt( "objecttype" );
				if ( iType == OBJ_TELEPORTER )
				{
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DestroyTeleporters, ACHIEVEMENT_TF_SCOUT_DESTROY_TELEPORTERS, "TF_SCOUT_DESTROY_TELEPORTERS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DestroyBuildingsBeingBuilt : 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" ) );
			CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
			C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pDestroyer == pTFPlayer )
			{
				// Only count buildings being built.
				if ( event->GetBool( "was_building" ) )
				{
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DestroyBuildingsBeingBuilt, ACHIEVEMENT_TF_SCOUT_DESTROY_BUILDINGS_BEING_BUILT, "TF_SCOUT_DESTROY_BUILDINGS_BEING_BUILT", 5 );

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

	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" ) );
			CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
			C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pDestroyer == pTFPlayer )
			{
				// Only count active sentries destroyed with a pistol.
				int iType = event->GetInt( "objecttype" );
				int iWeaponID = event->GetInt( "weaponid" );
				if ( (iType == OBJ_SENTRYGUN) &&
					(iWeaponID == TF_WEAPON_PISTOL_SCOUT) &&
					!event->GetBool( "was_building" ) )
				{
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DestroySentryWithPistol, ACHIEVEMENT_TF_SCOUT_DESTROY_SENTRY_WITH_PISTOL, "TF_SCOUT_DESTROY_SENTRY_WITH_PISTOL", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DoubleJumps : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1000 );
		SetStoreProgressInSteam( true );

		m_bScoredJump = false;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		// Achievement for getting 1000 double jumps.
		if ( Q_strcmp( event->GetName(), "air_dash" ) == 0 )
		{
			int iJumperID = event->GetInt( "player" );
			C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( iJumperID ) ) );
			if ( pJumper == C_TFPlayer::GetLocalTFPlayer() && !m_bScoredJump )
			{
				m_bScoredJump = true;
				IncrementCount();
			}
		}
		else if ( (Q_strcmp( event->GetName(), "landed" ) == 0) ||
		          (Q_strcmp( event->GetName(), "localplayer_respawn" ) == 0) ||
				  (Q_strcmp( event->GetName(), "teamplay_round_active" ) == 0) )
		{
			m_bScoredJump = false;
		}
	}

private:
	bool	m_bScoredJump;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DoubleJumps, ACHIEVEMENT_TF_SCOUT_DOUBLE_JUMPS, "TF_SCOUT_DOUBLE_JUMPS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AssistChargeMedic : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
		SetGoal( 1 );
		m_bCharged = false;
		m_iAssists = 0;
		m_iMedic = -1;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( Q_strcmp( event->GetName(), "player_chargedeployed" ) == 0 )
		{
			m_iMedic = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
			CBaseEntity *pMedic = UTIL_PlayerByIndex( m_iMedic );
			int iTarget = engine->GetPlayerForUserID( event->GetInt( "targetid" ) );
			CBaseEntity *pTarget = UTIL_PlayerByIndex( iTarget );

			if ( pMedic && pTarget && pTarget == C_TFPlayer::GetLocalTFPlayer() )
			{
				m_bCharged = true;
				m_iAssists = 0;
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
		if ( iAssisterIndex > 0 && iAssisterIndex == m_iMedic )
		{
			C_TFPlayer *pMedic = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );
			if ( pMedic && pMedic->MedicIsReleasingCharge() )
			{
				m_iAssists++;
				if ( m_iAssists >= 3 )
				{
					IncrementCount();
				}
			}
		}
	}

private:
	bool	m_bCharged;
	int		m_iAssists;
	int		m_iMedic;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AssistChargeMedic, ACHIEVEMENT_TF_SCOUT_ASSIST_MEDIC, "TF_SCOUT_ASSIST_MEDIC", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		const char *pszEventName = event->GetName();
		if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
			FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			// If we died or respawned, reset...
			m_iHeavyID = -1;
			return;
		}
		else if ( Q_strcmp( event->GetName(), "player_stealsandvich" ) == 0 )
		{
			int iOwner = engine->GetPlayerForUserID( event->GetInt( "owner" ) );
			if ( iOwner != m_iHeavyID )
				return;

			int iTarget = engine->GetPlayerForUserID( event->GetInt( "target" ) );
			CBaseEntity *pTarget = UTIL_PlayerByIndex( iTarget );

			if ( pTarget && pTarget == C_TFPlayer::GetLocalTFPlayer() )
			{
				IncrementCount();
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// Achievement for killing a Heavy and taking his sandvich.
		C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
		{
			// Track the heavy: we have to be responsible for his death.
			m_iHeavyID = engine->GetPlayerForUserID( pTFVictim->GetUserID() );
		}
	}

private:
	int		m_iHeavyID;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StealSandwich, ACHIEVEMENT_TF_SCOUT_STEAL_SANDWICH, "TF_SCOUT_STEAL_SANDWICH", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_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( CAchievementTFScout_KillChargedMedic, ACHIEVEMENT_TF_SCOUT_KILL_CHARGED_MEDICS, "TF_SCOUT_KILL_CHARGED_MEDICS", 5 );

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

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "player_damaged" );
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "localplayer_respawn" );
		m_iDamageTotal = 0;
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( Q_strcmp( event->GetName(), "player_damaged" ) == 0 )
		{
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

			m_iDamageTotal += event->GetInt( "amount" );

			if ( pLocalPlayer && pLocalPlayer->IsAlive() && m_iDamageTotal >= 500 )
			{
				IncrementCount();
			}
		}
		else if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
		{
			m_iDamageTotal = 0;
		}
		else if ( FStrEq( event->GetName(), "localplayer_respawn" ) )
		{
			m_iDamageTotal = 0;
		}
	}

private:
	int		m_iDamageTotal;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_SurviveDamage, ACHIEVEMENT_TF_SCOUT_SURVIVE_DAMAGE, "TF_SCOUT_SURVIVE_DAMAGE", 5 );

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

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "teamplay_flag_event" );
		ListenForGameEvent( "teamplay_round_active" );
		m_iFlagCaps = 0;
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( Q_strcmp( event->GetName(), "teamplay_flag_event" ) == 0 && event->GetInt( "eventtype" ) == TF_FLAGEVENT_CAPTURE )
		{
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

			if ( pLocalPlayer && pLocalPlayer->entindex() == event->GetInt( "player" ))
			{
				m_iFlagCaps++;

				if ( m_iFlagCaps >= 3 )
				{
					IncrementCount();
				}
			}
		}
		else if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
		{
			m_iFlagCaps = 0;
		}
	}

private:
	int		m_iFlagCaps;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_ThreeFlagCaptures, ACHIEVEMENT_TF_SCOUT_THREE_FLAGCAPS, "TF_SCOUT_THREE_FLAGCAPS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DoubleJumpKill : 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 ) 
	{
		C_TFPlayer *pKiller = ToTFPlayer( pAttacker );
		int iDoubleJumpKill = pKiller->m_Shared.GetAirDash();

		if ( iDoubleJumpKill > 0 )
		{
			IncrementCount(); 
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DoubleJumpKill, ACHIEVEMENT_TF_SCOUT_DOUBLEJUMP_KILL, "TF_SCOUT_DOUBLEJUMP_KILL", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( Q_strcmp( event->GetName(), "teamplay_flag_event" ) == 0 && event->GetInt( "eventtype" ) == TF_FLAGEVENT_CAPTURE )
		{
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

			if ( pLocalPlayer && pLocalPlayer->entindex() == event->GetInt( "player" ))
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FlagCapGrind, ACHIEVEMENT_TF_SCOUT_FLAG_CAP_GRIND, "TF_SCOUT_FLAG_CAP_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DodgeDamage : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		m_iDamageDodged = 0;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		const char *pszEventName = event->GetName();
		if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
			FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			// If we died or respawned, reset...
			m_iDamageDodged = 0;
			return;
		}
		else if ( Q_strcmp( event->GetName(), "player_damage_dodged" ) == 0 )
		{
			m_iDamageDodged += event->GetInt( "damage" );

			if ( m_iDamageDodged > 1000 )
			{
				IncrementCount();
			}
		}
	}

private:
	int		m_iDamageDodged;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DodgeDamage, ACHIEVEMENT_TF_SCOUT_DODGE_DAMAGE, "TF_SCOUT_DODGE_DAMAGE", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_KnockIntoTrain : 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 ) 
	{
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( !pTFVictim )
			return;

		CTFPlayer *pLocalPlayer = ToTFPlayer( CBasePlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( pTFVictim->m_Shared.GetWeaponKnockbackID() == pLocalPlayer->GetUserID() )
		{
			int custom = event->GetInt( "customkill" );
			int damagebits = event->GetInt( "damagebits" );
			if ( ( damagebits & DMG_VEHICLE ) || // They were hit by a freakin' train!
				 ( pAttacker && pAttacker->IsBrushModel() ) || // They were smashed by the world! Gah!
				 ( !pAttacker || (pAttacker == pVictim) ) || // He killed himself!
				 ( custom == TF_DMG_CUSTOM_SUICIDE ) ||
				 ( custom == TF_DMG_CUSTOM_TRIGGER_HURT ) ) // A trigger-hurt got him! 
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KnockIntoTrain, ACHIEVEMENT_TF_SCOUT_KNOCK_INTO_TRAIN, "TF_SCOUT_KNOCK_INTO_TRAIN", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_KillStunned : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
		SetGoal( 50 );
		SetStoreProgressInSteam( true );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( !pTFVictim )
			return;

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( pAttacker != pLocalPlayer )
		{
			int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
			if ( iAssisterIndex <= 0 )
				return;

			CTFPlayer *pAssister = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );
			if ( pAssister != pLocalPlayer )
				return;
		}

		int iStunFlags = event->GetInt( "stun_flags" );
		if ( ((iStunFlags & TF_STUN_CONTROLS) != 0) || ((iStunFlags & TF_STUN_LOSER_STATE) != 0) )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KillStunned, ACHIEVEMENT_TF_SCOUT_KILL_STUNNED, "TF_SCOUT_KILL_STUNNED", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StunIntoTrain : 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 ) 
	{
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( !pTFVictim )
			return;

		// Achievement for causing someone we stunned to die by the environment.
		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		int iStunFlags = event->GetInt( "stun_flags" );
		bool bLegalStun = ((iStunFlags & TF_STUN_CONTROLS) != 0) || ((iStunFlags & TF_STUN_LOSER_STATE) != 0);
		if ( bLegalStun && (pTFVictim->m_Shared.GetStunner() == pLocalPlayer) )
		{
			int custom = event->GetInt( "customkill" );
			int damagebits = event->GetInt( "damagebits" );
			if ( ( damagebits & DMG_VEHICLE ) || // They were hit by a freakin' train!
				( pAttacker && pAttacker->IsBrushModel() ) || // They were smashed by the world! Gah!
				( !pAttacker || (pAttacker == pVictim) ) || // He killed himself!
				( custom == TF_DMG_CUSTOM_SUICIDE ) ||
				( custom == TF_DMG_CUSTOM_TRIGGER_HURT ) ) // A trigger-hurt got him! 
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunIntoTrain, ACHIEVEMENT_TF_SCOUT_STUN_INTO_TRAIN, "TF_SCOUT_STUN_INTO_TRAIN", 5 );

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

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

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( FStrEq( pszEventName, "player_stunned" ) )
		{
			CTFPlayer *pStunner = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "stunner" ) ) ) );
			CTFPlayer *pVictim  = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "victim" ) ) ) );

			if ( pStunner == pLocalPlayer )
			{
				if ( pVictim && pVictim->IsPlayerClass( TF_CLASS_MEDIC ) && pVictim->MedicGetChargeLevel() >= 1.0 )
				{
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunUberEnemies, ACHIEVEMENT_TF_SCOUT_STUN_UBER_ENEMIES, "TF_SCOUT_STUN_UBER_ENEMIES", 5 );

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

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

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( FStrEq( pszEventName, "player_stunned" ) )
		{
			CTFPlayer *pStunner = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "stunner" ) ) ) );
			CTFPlayer *pVictim  = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "victim" ) ) ) );

			if ( (pStunner == pLocalPlayer) &&
				pVictim && event->GetBool( "victim_capping" ) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunCappingEnemies, ACHIEVEMENT_TF_SCOUT_STUN_CAPPING_ENEMIES, "TF_SCOUT_STUN_CAPPING_ENEMIES", 5 );

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

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

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( FStrEq( pszEventName, "player_stunned" ) )
		{
			CTFPlayer *pStunner = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "stunner" ) ) ) );
			CTFPlayer *pVictim  = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "victim" ) ) ) );

			if ( (pStunner == pLocalPlayer) &&
				 pVictim && event->GetBool( "big_stun" ) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_MaxStuns, ACHIEVEMENT_TF_SCOUT_MAX_STUNS, "TF_SCOUT_MAX_STUNS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StunScoutWithTheirBall : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}
	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunScoutWithTheirBall, ACHIEVEMENT_TF_SCOUT_STUN_SCOUT_WITH_THEIR_BALL, "TF_SCOUT_STUN_SCOUT_WITH_THEIR_BALL", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// Achievement for killing another scout under the effect Crit-a-Cola
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );

		if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SCOUT ) && pTFVictim->m_Shared.InCond( TF_COND_ENERGY_BUFF ) )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KillInDodgeCooldown, ACHIEVEMENT_TF_SCOUT_KILL_IN_DODGE_COOLDOWN, "TF_SCOUT_KILL_IN_DODGE_COOLDOWN", 5 );

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

	// Shamelessly stolen from the knife!
	float DotProductToTarget( CBaseEntity *pAttacker, CBaseEntity *pTarget )
	{
		Assert( pTarget );

		// Get the forward view vector of the target, ignore Z
		Vector vecVictimForward;
		AngleVectors( pTarget->EyeAngles(), &vecVictimForward, NULL, NULL );
		vecVictimForward.z = 0.0f;
		vecVictimForward.NormalizeInPlace();

		// Get a vector from my origin to my targets origin
		Vector vecToTarget;
		vecToTarget = pTarget->WorldSpaceCenter() - pAttacker->WorldSpaceCenter();
		vecToTarget.z = 0.0f;
		vecToTarget.NormalizeInPlace();

		return DotProduct( vecVictimForward, vecToTarget );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// Achievement for killing a bunch of enemies from behind with the scattergun double.
		if ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN )
		{
			CTFScatterGun *pScattergun = (CTFScatterGun *)ToTFPlayer( C_TFPlayer::GetLocalPlayer() )->Weapon_OwnsThisID( TF_WEAPON_SCATTERGUN );
			if ( pScattergun && pScattergun->HasKnockback() &&
				( DotProductToTarget( pAttacker, pVictim ) > -0.1 ) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KillFromBehind, ACHIEVEMENT_TF_SCOUT_KILL_FROM_BEHIND, "TF_SCOUT_KILL_FROM_BEHIND", 5 );

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

		m_bRecentCapper = false;
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_point_captured" );
		ListenForGameEvent( "teamplay_round_win" );
	}

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
		{
			m_bRecentCapper = false;
			int iTeam = event->GetInt( "team" );
			if ( iTeam == pLocalPlayer->GetTeamNumber() )
			{
				const char *cappers = event->GetString( "cappers" );
				for ( int i=0; i<Q_strlen( cappers ); i++ )
				{
					int iPlayerIndex = (int) cappers[i];
					CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
					if ( pPlayer == pLocalPlayer )
					{
						m_bRecentCapper = true;
					}
				}
			}
		}
		else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
		{
			// If we're the winners and we were involved in capping the last point, we get this achievement.
			int iTeam = event->GetInt( "team" );
			if ( (iTeam == pLocalPlayer->GetTeamNumber()) &&
				 m_bRecentCapper &&
				 (TFGameRules()->GetGameType() == TF_GAMETYPE_CP) )
			{
				IncrementCount();
			}
			m_bRecentCapper = false;
		}
	}

	bool m_bRecentCapper;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CaptureLastPoint, ACHIEVEMENT_TF_SCOUT_CAPTURE_LAST_POINT, "TF_SCOUT_CAPTURE_LAST_POINT", 5 );

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

		m_iPointsCapped = 0;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		// only on maps with capture points
		if ( TFGameRules() && TFGameRules()->GetGameType() != TF_GAMETYPE_CP && TFGameRules()->GetGameType() != TF_GAMETYPE_ARENA )
			return;

		const char *pszEventName = event->GetName();

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
			 FStrEq( pszEventName, "teamplay_round_active") )
		{
			m_iPointsCapped = 0;
		}
		else if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
		{
			int iTeam = event->GetInt( "team" );
			if ( iTeam == pLocalPlayer->GetTeamNumber() )
			{
				const char *cappers = event->GetString( "cappers" );
				for ( int i=0; i<Q_strlen( cappers ); i++ )
				{
					int iPlayerIndex = (int) cappers[i];
					CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
					if ( pPlayer == pLocalPlayer )
					{
						m_iPointsCapped++;
					}
				}
			}

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

	int m_iPointsCapped;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CaptureThreePoints, ACHIEVEMENT_TF_SCOUT_CAPTURE_THREE_POINTS, "TF_SCOUT_CAPTURE_THREE_POINTS", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		// only on maps with capture points
		if ( TFGameRules() && TFGameRules()->GetGameType() != TF_GAMETYPE_CP && TFGameRules()->GetGameType() != TF_GAMETYPE_ARENA )
			return;

		const char *pszEventName = event->GetName();

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
		{
			const char *cappers = event->GetString( "cappers" );
			for ( int i=0; i<Q_strlen( cappers ); i++ )
			{
				int iPlayerIndex = (int) cappers[i];
				CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
				if ( pPlayer == pLocalPlayer )
				{
					if ( event->GetFloat( "captime" ) < 1.0 )
					{
						IncrementCount();
					}
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FastCap, ACHIEVEMENT_TF_SCOUT_FAST_CAP, "TF_SCOUT_FAST_CAP", 5 );

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

		m_Points.Purge();
	}

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_point_startcapture" );
		ListenForGameEvent( "teamplay_point_captured" );
		ListenForGameEvent( "teamplay_capture_broken" );
		ListenForGameEvent( "teamplay_round_active" );
	}

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		// Achievement for initiating captures that ultimately succeed.
		if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
		{
			const char *cappers = event->GetString( "cappers" );
			for ( int i=0; i<Q_strlen( cappers ); i++ )
			{
				int iPlayerIndex = (int) cappers[i];
				CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
				if ( pPlayer == pLocalPlayer ) // Are we one of the cappers?
				{
					// We started capping this point.
					m_Points.AddToTail( event->GetInt( "cp" ) );
				}
			}
		}
		else if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
		{
			int iIndex = m_Points.Find( event->GetInt( "cp" ) );
			if ( iIndex > -1 ) // Is the point one we started capping?
			{
				int iTeam = event->GetInt( "team" );
				if ( iTeam == pLocalPlayer->GetTeamNumber() )
				{
					m_Points.Remove( iIndex );
					IncrementCount();					
				}
			}
		}
		else if ( FStrEq( pszEventName, "teamplay_capture_broken" ) )
		{
			// Our team failed to complete the capture.
			int iIndex = m_Points.Find( event->GetInt( "cp" ) );
			if ( iIndex > -1 )
			{
				m_Points.Remove( iIndex );
			}
		}
		else if ( FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			// Reset tracking at the start of a new round.
			m_Points.Purge();
		}
	}

	CUtlVector< int >	m_Points;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StartAndFinishCap, ACHIEVEMENT_TF_SCOUT_START_AND_FINISH_CAP, "TF_SCOUT_START_AND_FINISH_CAP", 5 );

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

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

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		// Achievement for blocking captures!
		if ( FStrEq( pszEventName, "teamplay_capture_blocked" ) )
		{
			int iBlocker = event->GetInt( "blocker" );
			if ( (iBlocker == pLocalPlayer->entindex()) &&
				 ((TFGameRules()->GetGameType() == TF_GAMETYPE_CP) ||
				  (TFGameRules()->GetGameType() == TF_GAMETYPE_ARENA)) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_BlockCaps, ACHIEVEMENT_TF_SCOUT_BLOCK_CAPS, "TF_SCOUT_BLOCK_CAPS", 5 );

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

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

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		// Achievement for blocking captures!
		if ( FStrEq( pszEventName, "teamplay_flag_event" ) )
		{
			int iType = event->GetInt( "eventtype" );
			if ( iType == TF_FLAGEVENT_DEFEND )
			{
				int iPlayer = event->GetInt( "player" );
				if ( (iPlayer == pLocalPlayer->entindex()) && pLocalPlayer->HasTheFlag() )
				{
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CarrierKillCarrier, ACHIEVEMENT_TF_SCOUT_CARRIER_KILL_CARRIER, "TF_SCOUT_CARRIER_KILL_CARRIER", 5 );

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

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

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		// Achievement for capping the flag without shooting anyone.
		if ( FStrEq( pszEventName, "teamplay_flag_event" ) )
		{
			int iType = event->GetInt( "eventtype" );
			if ( iType == TF_FLAGEVENT_CAPTURE )
			{
				int iPlayer = event->GetInt( "player" );
				if ( (iPlayer == pLocalPlayer->entindex()) && !pLocalPlayer->HasFiredWeapon() )
				{
					IncrementCount();
				}
			}
			else if ( iType == TF_FLAGEVENT_PICKUP )
			{
				int iPlayer = event->GetInt( "player" );
				if ( iPlayer == pLocalPlayer->entindex() )
				{
					pLocalPlayer->SetFiredWeapon( false );
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CapFlagWithoutAttacking, ACHIEVEMENT_TF_SCOUT_CAP_FLAG_WITHOUT_ATTACKING, "TF_SCOUT_CAP_FLAG_WITHOUT_ATTACKING", 5 );

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

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

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

		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		// Achievement for running ...
		bool bUpdate = false;
		if ( FStrEq( pszEventName, "player_death" ) )
		{
			int iVictimID = event->GetInt( "userid" );
			if ( pLocalPlayer && (iVictimID == pLocalPlayer->GetUserID()) )
			{
				bUpdate = true;
			}
		}
		else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
		{
			bUpdate = true;
		}

		if ( bUpdate )
		{
			float fMeters = pLocalPlayer->GetMetersRan();
			IncrementCount( ceil( fMeters ) );
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_LongDistanceRunner, ACHIEVEMENT_TF_SCOUT_LONG_DISTANCE_RUNNER, "TF_SCOUT_LONG_DISTANCE_RUNNER", 5 );

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

		m_iTargetID = 0;
		m_vSlamOrigin = Vector(0,0,0);
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		const char *pszEventName = event->GetName();
		if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
			FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			// If we died or respawned, reset...
			m_iTargetID = 0;
			m_vSlamOrigin = Vector(0,0,0);
			return;
		}
		else if ( FStrEq( pszEventName, "scout_grand_slam" ) )
		{
			int iScoutID = event->GetInt( "scout_id" );
			if ( pLocalPlayer && (iScoutID == pLocalPlayer->GetUserID()) )
			{
				m_iTargetID = event->GetInt( "target_id" ); // target_id is a userid
				int iTarget = engine->GetPlayerForUserID( m_iTargetID );
				CBaseEntity *pTarget = UTIL_PlayerByIndex( iTarget );
				if ( pTarget )
				{
					m_vSlamOrigin = pTarget->GetAbsOrigin();
				}
			}
		}
		else if ( FStrEq( pszEventName, "scout_slamdoll_landed" ) )
		{
			int iTargetIndex = event->GetInt( "target_index" ); // target_index is an entindex
			EHANDLE hPlayer = cl_entitylist->GetNetworkableHandle( iTargetIndex );
			if ( !hPlayer )
				return;
			C_TFPlayer *pPlayer = dynamic_cast< C_TFPlayer* >( hPlayer.Get() );
			if ( pPlayer && (m_iTargetID == pPlayer->GetUserID()) &&
				 (m_vSlamOrigin != Vector(0,0,0)) )
			{
				float x = event->GetFloat( "x" );
				float y = event->GetFloat( "y" );
				float z = event->GetFloat( "z" );
				Vector vHitOrigin = Vector(x,y,z);
				float fDist = (vHitOrigin - m_vSlamOrigin).Length();
				if ( fDist > 1000 )
				{
					IncrementCount();
				}
			}
		}
	}

	int	m_iTargetID;
	Vector m_vSlamOrigin;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_TauntKill, ACHIEVEMENT_TF_SCOUT_TAUNT_KILL, "TF_SCOUT_TAUNT_KILL", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AchieveProgress1 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFScout_AchieveProgress1, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 10, ACHIEVEMENT_TF_SCOUT_START_RANGE, ACHIEVEMENT_TF_SCOUT_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AchieveProgress1, ACHIEVEMENT_TF_SCOUT_ACHIEVE_PROGRESS1, "TF_SCOUT_ACHIEVE_PROGRESS1", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AchieveProgress2 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFScout_AchieveProgress2, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 16, ACHIEVEMENT_TF_SCOUT_START_RANGE, ACHIEVEMENT_TF_SCOUT_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AchieveProgress2, ACHIEVEMENT_TF_SCOUT_ACHIEVE_PROGRESS2, "TF_SCOUT_ACHIEVE_PROGRESS2", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AchieveProgress3 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFScout_AchieveProgress3, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 22, ACHIEVEMENT_TF_SCOUT_START_RANGE, ACHIEVEMENT_TF_SCOUT_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AchieveProgress3, ACHIEVEMENT_TF_SCOUT_ACHIEVE_PROGRESS3, "TF_SCOUT_ACHIEVE_PROGRESS3", 5 );

// Receive the DamageDodged user message and send out a clientside event for achievements to hook.
void __MsgFunc_DamageDodged( bf_read &msg )
{
	int iDamage = msg.ReadShort();

	IGameEvent *event = gameeventmanager->CreateEvent( "player_damage_dodged" );
	if ( event )
	{
		event->SetInt( "damage", iDamage );
		gameeventmanager->FireEventClientSide( event );
	}
}

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_BackscatterKillSpyGrind : public CBaseTFAchievement
{
public:
	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 )
	{
		if ( pVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
		{
			CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
			if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) )
			{
				if ( ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN ) && ( event->GetInt( "damagebits" ) & DMG_CRITICAL ) )
				{
					CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
					if ( pTFAttacker )
					{
						CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
						if ( pWeapon )
						{
							int iMiniCritBackAttack = 0;
							CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
							if ( iMiniCritBackAttack > 0 )
							{
								IncrementCount();
							}
						}
					}
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_BackscatterKillSpyGrind, ACHIEVEMENT_TF_SCOUT_BACKSCATTER_KILL_SPY_GRIND, "TF_SCOUT_BACKSCATTER_KILL_SPY_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_BackscatterKillHeavyMedicPair : public CBaseTFAchievement
{
public:
	void Init()
	{
		SetFlags( ACH_LISTEN_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
		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 + 20.0f; // 20 seconds to kill the target
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
	{
		if ( pVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
		{
			if ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN )
			{
				CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
				if ( pTFAttacker )
				{
					CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
					if ( pWeapon )
					{
						int iMiniCritBackAttack = 0;
						CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
						if ( iMiniCritBackAttack > 0 )
						{
							// 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
							{
								CTFPlayer *pNewTarget = NULL;
								CTFPlayer *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( CAchievementTFScout_BackscatterKillHeavyMedicPair, ACHIEVEMENT_TF_SCOUT_BACKSCATTER_KILL_HEAVY_MEDIC_PAIR, "TF_SCOUT_BACKSCATTER_KILL_HEAVY_MEDIC_PAIR", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_BackscatterKillFriendsGrind : public CBaseTFAchievement
{
public:
	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 )
	{
		if ( pVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
		{
			if ( ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN ) && ( event->GetInt( "damagebits" ) & DMG_CRITICAL ) )
			{
				CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
				if ( pTFAttacker )
				{
					CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
					if ( pWeapon )
					{
						int iMiniCritBackAttack = 0;
						CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
						if ( iMiniCritBackAttack > 0 )
						{
							if ( !steamapicontext->SteamFriends() || !steamapicontext->SteamUtils() || !g_pGameRules->IsMultiplayer() )
								return;

							player_info_t pi;
							if ( !engine->GetPlayerInfo( pVictim->entindex(), &pi ) )
								return;

							if ( !pi.friendsID )
								return;

							// check and see if they're on the local player's friends list
							CSteamID steamID( pi.friendsID, 1, GetUniverse(), k_EAccountTypeIndividual );
							if ( steamapicontext->SteamFriends()->HasFriend( steamID, k_EFriendFlagImmediate ) )
							{
								IncrementCount();
							}
						}
					}
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_BackscatterKillFriendsGrind, ACHIEVEMENT_TF_SCOUT_BACKSCATTER_KILL_FRIENDS_GRIND, "TF_SCOUT_BACKSCATTER_KILL_FRIENDS_GRIND", 5 );

#endif // CLIENT_DLL