//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================


#include "cbase.h"

#ifdef CLIENT_DLL

#include "achievementmgr.h"
#include "baseachievement.h"
#include "tf_hud_statpanel.h"
#include "c_tf_team.h"
#include "c_tf_player.h"
#include "c_tf_playerresource.h"
#include "tf_gamerules.h"
#include "achievements_tf.h"
#include "c_tf_objective_resource.h"
#include "tf_weapon_shovel.h"
#include "movevars_shared.h"

//======================================================================================================================================
// DEMOMAN ACHIEVEMENT PACK
//======================================================================================================================================

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

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

		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
		{
			// no friendly fire kills
			if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
			{
				CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
				if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SOLDIER ) )
				{
					// we killed a soldier
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillSoldierGrind, ACHIEVEMENT_TF_DEMOMAN_KILL_SOLDIER_GRIND, "TF_DEMOMAN_KILL_SOLDIER_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DestroyBuildingsWithMedic : public CBaseTFAchievement
{
	DECLARE_CLASS( CAchievementTFDemoman_DestroyBuildingsWithMedic, CBaseTFAchievement );

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		m_iBuildingsDestroyed = 0;
	}

	virtual void ListenForEvents()
	{
		BaseClass::ListenForEvents();
		ListenForGameEvent( "player_invulned" );
		ListenForGameEvent( "object_destroyed" );
	}

	virtual void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "player_invulned" ) )
		{
			int iTarget = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
			CBaseEntity *pPlayer = UTIL_PlayerByIndex( iTarget );
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pPlayer == pLocalPlayer )
			{
				m_iBuildingsDestroyed = 0;
			}
		}
		else if ( Q_strcmp( event->GetName(), "object_destroyed" ) == 0 )
		{
			int iAttackerIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
			if ( iAttackerIndex > 0 )
			{
				CBaseEntity *pAttacker = UTIL_PlayerByIndex( iAttackerIndex );
				C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
				if ( pTFPlayer && pTFPlayer == pAttacker )
				{
					if ( pTFPlayer->m_Shared.InCond( TF_COND_INVULNERABLE ) || pTFPlayer->m_Shared.InCond( TF_COND_CRITBOOSTED ) ||
						pTFPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
					{
						m_iBuildingsDestroyed++;
						if ( m_iBuildingsDestroyed >= 5 )
						{
							IncrementCount();
						}
					}
				}
			}
		}
		else
		{
			BaseClass::FireGameEvent_Internal( event );
		}
	}

private:
	int		m_iBuildingsDestroyed;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DestroyBuildingsWithMedic, ACHIEVEMENT_TF_DEMOMAN_DESTROY_BUILDINGS_WITH_MEDIC, "TF_DEMOMAN_DESTROY_BUILDINGS_WITH_MEDIC", 5 );

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

	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 ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) && pTFVictim->m_Shared.InCond( TF_COND_STEALTHED ) )
		{
			int customdmg = event->GetInt( "customkill" );
			if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitateCloakedSpy, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_CLOAKED_SPY, "TF_DEMOMAN_DECAPITATE_CLOAKED_SPY", 5 );

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

	// Kill 50 enemies with direct hits from the pipebomb launcher
	// The server (tf_player) awards this achievement - no code necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillWithDirectPipe, ACHIEVEMENT_TF_DEMOMAN_KILL_X_WITH_DIRECTPIPE, "TF_DEMOMAN_KILL_X_WITH_DIRECTPIPE", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_BounceAndKill : public CBaseTFAchievement
{
	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
		SetGoal( 1 );		
		SetDefLessFunc( m_BouncedPlayers );
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "localplayer_respawn" );
		ListenForGameEvent( "player_hurt" );
		m_BouncedPlayers.RemoveAll();
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
			FStrEq( event->GetName(), "localplayer_respawn" ) )
		{
			m_BouncedPlayers.RemoveAll();
		}
		else if ( FStrEq( event->GetName(), "player_hurt" ) )
		{
			int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
			CBasePlayer *pAttacker = UTIL_PlayerByIndex( iAttacker );
			if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() )
			{
				int iVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
				CBasePlayer *pVictim = UTIL_PlayerByIndex( iVictim );
				if ( pVictim )
				{
					bool bVictimGrounded = pVictim->GetFlags() & FL_ONGROUND;
					if ( bVictimGrounded )
					{
						int iIndex = m_BouncedPlayers.Find( pVictim->GetUserID() );
						if ( iIndex != m_BouncedPlayers.InvalidIndex() )
						{
							// they're already in our list
							m_BouncedPlayers[iIndex] = gpGlobals->curtime;
						}
						else
						{
							// we need to add them
							m_BouncedPlayers.Insert( pVictim->GetUserID(), gpGlobals->curtime );
						}
					}
				}
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pVictim == C_BasePlayer::GetLocalPlayer() )
		{
			m_BouncedPlayers.RemoveAll();
			return;
		}
		
		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
		{
			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
			if ( pTFVictim && !( pTFVictim->GetFlags() & FL_ONGROUND ) )
			{
				int iIndex = m_BouncedPlayers.Find( pTFVictim->GetUserID() );
				if ( iIndex != m_BouncedPlayers.InvalidIndex() )
				{
					if ( gpGlobals->curtime < m_BouncedPlayers[iIndex] + 4.0f )
					{
						IncrementCount();
					}
				}
			}
		}
	}

	CUtlMap< int, float > m_BouncedPlayers; // userID and most recent time they were bounced
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_BounceAndKill, ACHIEVEMENT_TF_DEMOMAN_BOUNCE_AND_KILL, "TF_DEMOMAN_BOUNCE_AND_KILL", 5 );

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

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

		if ( pLocalPlayer != pAttacker )
			return;

		int customdmg = event->GetInt( "customkill" );
		if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitatePlayers, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_PLAYERS, "TF_DEMOMAN_DECAPITATE_PLAYERS", 5 );

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

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

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

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

		if ( pLocalPlayer != pAttacker )
			return;

		int customdmg = event->GetInt( "customkill" );
		if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
		{
			if ( (m_iTimelyDecapitations == 0) || ((m_iTimelyDecapitations > 0) && (gpGlobals->curtime < m_flLastDecapTime + 10.f)) )
			{
				m_iTimelyDecapitations++;
			}
			else
			{
				m_iTimelyDecapitations = 1;
			}

			m_flLastDecapTime = gpGlobals->curtime;

			if ( m_iTimelyDecapitations == 4 )
			{
				IncrementCount();
			}
		}
	}

	int m_iTimelyDecapitations;
	float m_flLastDecapTime;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitatePlayersFast, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_PLAYERS_FAST, "TF_DEMOMAN_DECAPITATE_PLAYERS_FAST", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "player_death" ) )
		{
			int iAttackerIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
			if ( iAttackerIndex == 0 )
				return;
			CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( iAttackerIndex ) );
			if ( !pAttacker )
				return;

			int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
			if ( iAssisterIndex == 0 )
				return;
			CTFPlayer *pAssister = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );
			if ( !pAssister )
				return;

			if ( pAttacker == C_BasePlayer::GetLocalPlayer() && pAssister->IsPlayerClass( TF_CLASS_DEMOMAN ) )
			{
				// We are the attacker and the assist is from a demoman.
				IncrementCount();
				return;
			}

			if ( pAssister == C_BasePlayer::GetLocalPlayer() && pAttacker->IsPlayerClass( TF_CLASS_DEMOMAN ) )
			{
				// We are the assister and the kill is from a demoman.
				IncrementCount();
				return;
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFSoldier_DuoDemomanKills, ACHIEVEMENT_TF_DEMOMAN_DUO_DEMOMAN_KILLS, "TF_DEMOMAN_DUO_DEMOMAN_KILLS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillTwoDuringStickyJump : public CBaseTFAchievement
{
	// While airborne after a sticky-jump, kill at least two enemy players

	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "sticky_jump" );
		ListenForGameEvent( "sticky_jump_landed" );
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "localplayer_respawn" );
		m_iKilledDuringStickyJump = 0;
		m_bStickyJumping = false;
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
			FStrEq( event->GetName(), "localplayer_respawn" ) )
		{
			m_iKilledDuringStickyJump = 0;
			m_bStickyJumping = false;
		}
		else if ( FStrEq( event->GetName(), "sticky_jump_landed" ) )
		{
			int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
			if ( iIndex > 0 )
			{
				C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );

				if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
				{
					m_iKilledDuringStickyJump = 0;
					m_bStickyJumping = false;
				}
			}
			
			return;
		}
		else if ( FStrEq( event->GetName(), "sticky_jump" ) )
		{
			int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
			if ( iIndex > 0 )
			{
				C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );

				if (  pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
				{
					m_iKilledDuringStickyJump = 0;
					m_bStickyJumping = true;
				}
			}

			return;
		}
	}

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

		if ( pAttacker && ( pAttacker == C_BasePlayer::GetLocalPlayer() ) )
		{
			if ( m_bStickyJumping )
			{
				m_iKilledDuringStickyJump++;

				if ( m_iKilledDuringStickyJump == 2 )
				{
					IncrementCount();
				}
			}
		}
	}

private:
	bool	m_bStickyJumping;
	int		m_iKilledDuringStickyJump;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillTwoDuringStickyJump, ACHIEVEMENT_TF_DEMOMAN_KILL_TWO_DURING_STICKYJUMP, "TF_DEMOMAN_KILL_TWO_DURING_STICKYJUMP", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillPlayerAfterTeleport : public CBaseTFAchievement
{
	// Kill an enemy player within X seconds of them teleporting in

	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

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

		if ( !pVictim || !pVictim->IsPlayer() )
			return;
		
		C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
		{
			if ( pTFVictim->m_Shared.InCond( TF_COND_TELEPORTED ) && ( gpGlobals->curtime - pTFVictim->m_Shared.GetTimeTeleEffectAdded() <= 5.0 ) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillPlayerAfterTeleport, ACHIEVEMENT_TF_DEMOMAN_KILL_PLAYER_AFTER_TP, "TF_DEMOMAN_KILL_PLAYER_AFTER_TP", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DominateEngineerThreeTimes : public CBaseTFAchievement
{
	// Dominate three Engineers

	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
		SetGoal( 3 );
		SetStoreProgressInSteam( true );
	}

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

		if ( !pVictim || !pVictim->IsPlayer() )
			return;

		bool bDomination = event->GetInt( "death_flags" ) & TF_DEATH_DOMINATION;
		if ( bDomination == true )
		{
			CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
			if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_ENGINEER ) )
			{
				IncrementCount(); 
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DominateEngineerThreeTimes, ACHIEVEMENT_TF_DEMOMAN_DOMINATE_THREE_ENGINEERS, "TF_DEMOMAN_DOMINATE_THREE_ENGINEERS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillBuildingDirectHit : public CBaseTFAchievement
{
	// Kill an Engineer building that you can't see with a direct hit from your Grenade Launcher
	// Server awards this achievement (tf_obj.cpp) - no other code necessary

	void Init()
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillBuildingDirectHit, ACHIEVEMENT_TF_DEMOMAN_KILL_BUILDING_DIRECT_HIT, "TF_DEMOMAN_KILL_BUILDING_DIRECT_HIT", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_MeleeKillWhileJumping : public CBaseTFAchievement
{
	// Get a melee kill while in sticky jump

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
		SetGoal( 1 );
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "sticky_jump" );
		ListenForGameEvent( "sticky_jump_landed" );
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "localplayer_respawn" );
		m_bStickyJumping = false;
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
			FStrEq( event->GetName(), "localplayer_respawn" ) )
		{
			m_bStickyJumping = false;
		}
		else if ( FStrEq( event->GetName(), "sticky_jump_landed" ) )
		{
			int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
			if ( iIndex > 0 )
			{
				C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );

				if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
				{
					m_bStickyJumping = false;
				}
			}

			return;
		}
		else if ( FStrEq( event->GetName(), "sticky_jump" ) )
		{
			int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
			if ( iIndex > 0 )
			{
				C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );

				if (  pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
				{
					m_bStickyJumping = true;
				}
			}

			return;
		}
	}

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

		if ( pAttacker && ( pAttacker == C_BasePlayer::GetLocalPlayer() ) )
		{
			if ( m_bStickyJumping )
			{
				if ( event->GetInt( "weaponid" ) == TF_WEAPON_BOTTLE || event->GetInt( "weaponid" ) == TF_WEAPON_SWORD )
				{
					IncrementCount();
				}
			}
		}
	}

private:
	bool	m_bStickyJumping;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_MeleeKillWhileJumping, ACHIEVEMENT_TF_DEMOMAN_MELEE_KILL_WHILE_STICKYJUMPING, "TF_DEMOMAN_MELEE_KILL_WHILE_STICKYJUMPING", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillEngiSentryDispenser : public CBaseTFAchievement
{
	// Kill an Engineer, his Sentry and Dispenser, with one sticky detonation

	void Init()
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		SetDefLessFunc( m_Engineers );
		SetDefLessFunc( m_SentryDestroyed );
		SetDefLessFunc( m_DispenserDestroyed );
		ResetTracking();
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
			FStrEq( event->GetName(), "localplayer_respawn" ) )
		{
			ResetTracking();
		}
		else if ( FStrEq( event->GetName(), "object_destroyed" ) )
		{
			if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
			{
				int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
				CBaseEntity *pAttacker = UTIL_PlayerByIndex( iAttacker );
				C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();

				if ( !pLocalPlayer )
					return;

				if ( pLocalPlayer != pAttacker )
					return;

				int iEngineer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
				int iObject = event->GetInt( "objecttype" );

				if ( iObject == OBJ_SENTRYGUN )
				{
					int iIndex = m_SentryDestroyed.Find( iEngineer );
					if ( iIndex != m_SentryDestroyed.InvalidIndex() )
					{
						// already tracking them, update the time
						m_SentryDestroyed[iIndex] = gpGlobals->curtime;
					}
					else
					{
						m_SentryDestroyed.Insert( iEngineer, gpGlobals->curtime );
					}

					CheckGoalMet();
				}
				if ( iObject == OBJ_DISPENSER )
				{
					int iIndex = m_DispenserDestroyed.Find( iEngineer );
					if ( iIndex != m_DispenserDestroyed.InvalidIndex() )
					{
						// already tracking them, update the time
						m_DispenserDestroyed[iIndex] = gpGlobals->curtime;
					}
					else
					{
						m_DispenserDestroyed.Insert( iEngineer, gpGlobals->curtime );
					}

					CheckGoalMet();
				}
			}
		}
	}

	void ResetTracking( void )
	{
		m_Engineers.RemoveAll();
		m_SentryDestroyed.RemoveAll();
		m_DispenserDestroyed.RemoveAll();
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
		{
			CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
			if ( !pLocalPlayer )
				return;

			if ( !pVictim || !pVictim->IsPlayer() )
				return;

			CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
			if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_ENGINEER ) )
			{
				int iEngineer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
				m_Engineers.InsertOrReplace( iEngineer, gpGlobals->curtime );

				CheckGoalMet();
			}
		}
	}

	void CheckGoalMet( void )
	{
		FOR_EACH_MAP_FAST ( m_Engineers, numEngineers )
		{
			int iEngineer = m_Engineers.Key( numEngineers );

			// Destroyed their Sentry?
			int iSentry = m_SentryDestroyed.Find( iEngineer );
			if ( iSentry != m_SentryDestroyed.InvalidIndex() )
			{
				// Destroyed their Dispenser?
				int iDispenser = m_DispenserDestroyed.Find( iEngineer );
				if ( iDispenser != m_DispenserDestroyed.InvalidIndex() )
				{
					// All three at the same time?
// 					if ( ( m_Engineers[numEngineers] == m_SentryDestroyed[iSentry] ) &&
// 						( m_Engineers[numEngineers] == m_DispenserDestroyed[iDispenser] ) )
					if ( ( gpGlobals->curtime < m_SentryDestroyed[iSentry] + 0.1f ) &&
						( gpGlobals->curtime < m_DispenserDestroyed[iDispenser] + 0.1f ) && 
						( gpGlobals->curtime < m_Engineers[numEngineers] + 0.1f ) )
					{
						IncrementCount();
					}
				}
			}
		}
	}

private:
	CUtlMap< int, float > m_SentryDestroyed;	// Engineer userID and time sentry was destroyed
	CUtlMap< int, float > m_DispenserDestroyed;	// Engineer userID and time dispenser was destroyed
	CUtlMap< int, float > m_Engineers;			// Engineers we've killed and the time
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillEngiSentryDispenser, ACHIEVEMENT_TF_DEMOMAN_KILL_ENGI_SENTRY_DISPENSER, "TF_DEMOMAN_KILL_ENGI_SENTRY_DISPENSER", 5 );

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

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

		if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SOLDIER ) )
		{
			CTFShovel *pShovel = dynamic_cast<CTFShovel*>( pTFVictim->GetActiveTFWeapon() );
			if ( pShovel && (pShovel->GetShovelType() == SHOVEL_DAMAGE_BOOST) )
			{
				int customdmg = event->GetInt( "customkill" );
				if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
				{
					IncrementCount();
				}
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitateEqualizer, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_EQUALIZER, "TF_DEMOMAN_DECAPITATE_EQUALIZER", 5 );

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

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

		if ( pTFVictim && pTFVictim->IsNemesisOfLocalPlayer() )
		{
			int customdmg = event->GetInt( "customkill" );
			if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitateNemesis, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_NEMESIS, "TF_DEMOMAN_DECAPITATE_NEMESIS", 5 );

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

	void OnPlayerStatsUpdate()
	{
		ClassStats_t &classStats = CTFStatPanel::GetClassStats( TF_CLASS_DEMOMAN );
		int iOldCount = m_iCount;
		m_iCount = classStats.accumulated.m_iStat[TFSTAT_BLASTDAMAGE];
		if ( m_iCount != iOldCount )
		{
			m_pAchievementMgr->SetDirty( true );
		}

		if ( IsLocalTFPlayerClass( TF_CLASS_DEMOMAN ) )
		{
			EvaluateNewAchievement();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DamageGrind, ACHIEVEMENT_TF_DEMOMAN_DAMAGE_GRIND, "TF_DEMOMAN_DAMAGE_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXCapping : public CBaseTFAchievement
{
	// Kill "x" players that are capping or pushing the cart with one detonation, "y" times
	// Server checks for this achievement - no code necessary
	
	void Init()
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 3 );
		SetStoreProgressInSteam( true );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXCapping, ACHIEVEMENT_TF_DEMOMAN_KILL_X_CAPPING_ONEDET, "TF_DEMOMAN_KILL_X_CAPPING_ONEDET", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXDefending : public CBaseTFAchievement
{
	// Kill "x" players that are defending
	// Server checks for this achievement - no code necessary

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 25 );
		SetStoreProgressInSteam( true );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXDefending, ACHIEVEMENT_TF_DEMOMAN_KILL_X_DEFENDING, "TF_DEMOMAN_KILL_X_DEFENDING", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DestroyBuildings : public CBaseTFAchievement
{
	// Destroy "x" buildings

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 50 );
		SetStoreProgressInSteam( true );
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "object_destroyed" ) )
		{
			int iIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
			CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
			C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pDestroyer == pTFPlayer )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DestroyBuildings, ACHIEVEMENT_TF_DEMOMAN_DESTROY_BUILDINGS_GRIND, "TF_DEMOMAN_DESTROY_BUILDINGS_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXHeaviesAtFull : public CBaseTFAchievement
{
	// Kill 3 Heavies from full health with a single Sticky detonation
	// Server checks for this achievement - no code necessary

	void Init()
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 3 );
		SetStoreProgressInSteam( true );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXHeaviesAtFull, ACHIEVEMENT_TF_DEMOMAN_KILL_X_HEAVIES_FULLHP_ONEDET, "TF_DEMOMAN_KILL_X_HEAVIES_FULLHP_ONEDET", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXScoutsPyros : public CBaseTFAchievement
{
	// Kill 25 Scouts or Pyros with the grenade launcher

	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
		SetGoal( 25 );
		SetStoreProgressInSteam( true );
	}

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

		if ( !pVictim || !pVictim->IsPlayer() )
			return;

		C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( pTFVictim->IsPlayerClass( TF_CLASS_PYRO ) || pTFVictim->IsPlayerClass( TF_CLASS_SCOUT ) )
		{
			if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_DEMOMAN )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXScoutsPyros, ACHIEVEMENT_TF_DEMOMAN_KILL_X_SCOUTS_PYROS, "TF_DEMOMAN_KILL_X_SCOUTS_PYROS", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// was this a taunt kill?
		if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_TauntKill, ACHIEVEMENT_TF_DEMOMAN_TAUNT_KILL, "TF_DEMOMAN_TAUNT_KILL", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// was this a taunt kill?
		if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_CHARGE_IMPACT )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ChargeKill, ACHIEVEMENT_TF_DEMOMAN_CHARGE_KILL, "TF_DEMOMAN_CHARGE_KILL", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// was this a charge kill with the sword?
		int nDamageBits = event->GetInt( "damagebits" );
		if ( (nDamageBits & DMG_CRITICAL) && (event->GetInt( "customkill" ) == TF_DMG_CUSTOM_DECAPITATION) )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_CritSwordKill, ACHIEVEMENT_TF_DEMOMAN_CRIT_SWORD_KILL, "TF_DEMOMAN_CRIT_SWORD_KILL", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		// was this an air burst kill?
		if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_AIR_STICKY_BURST )
		{
			IncrementCount();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AirBurstKills, ACHIEVEMENT_TF_DEMOMAN_AIR_BURST_KILLS, "TF_DEMOMAN_AIR_BURST_KILLS", 5 );

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

	virtual void ListenForEvents( void )
	{
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "teamplay_point_startcapture" );
		ListenForGameEvent( "controlpoint_endtouch" );
		ListenForGameEvent( "teamplay_point_captured" );
		ListenForGameEvent( "sticky_jump_landed" );
		ResetTracking();
	}

	void CheckGoalMet( void )
	{
		// If sticky_jump_landed and startcapture times occurred roughly together...
		float fTemp1 = 0;
		float fTemp2 = 0;
		if ( m_fLandTime > m_fCapStartTime )
		{
			fTemp1 = m_fLandTime;
			fTemp2 = m_fCapStartTime;
		}
		else
		{
			fTemp1 = m_fCapStartTime;
			fTemp2 = m_fLandTime;
		}

		float fDelta = fTemp1 - fTemp2;
		if ( fDelta <= 0.5f )
		{
			// Check if we successfully capped the point we landed on
			if ( m_bCapped )
			{
				IncrementCount();
			}
		}
	}

	void ResetTracking( void )
	{
		m_bCapped = false;
		m_fLandTime = 0;
		m_fCapStartTime = 0;
		m_iCapID = -1;
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		// Only check CP maps
		if ( TFGameRules() && TFGameRules()->GetGameType() != TF_GAMETYPE_CP && TFGameRules()->GetGameType() != TF_GAMETYPE_ARENA )
			return;
		
		// Capture the time we land
		if ( FStrEq( event->GetName(), "sticky_jump_landed" ) )
		{
			int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
			if ( iIndex > 0 )
			{
				C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );

				if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
				{
					m_fLandTime = gpGlobals->curtime;
					CheckGoalMet();
				}
			}

			return;
		}
		// Capture the time we start capping
		else if ( FStrEq( event->GetName(), "teamplay_point_startcapture" ) )
		{
			const char *cappers = event->GetString( "cappers" );
			for ( int i = 0; i < Q_strlen( cappers ); i++ )
			{
				C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
				if ( !pLocalPlayer )
					return;

				int iPlayerIndex = (int) cappers[i];
				CTFPlayer *pCapper = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
				if ( pCapper && ( pCapper == C_BasePlayer::GetLocalPlayer() ) )
				{
					m_fCapStartTime = gpGlobals->curtime;
					m_iCapID = event->GetInt( "cp" );
					CheckGoalMet();
				}
			}
		}
		else if ( FStrEq( event->GetName(), "teamplay_point_captured" ) )
		{
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( !pLocalPlayer )
				return;
			
			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 *pCapper = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
					if ( pCapper && ( pCapper == C_BasePlayer::GetLocalPlayer() ) )
					{
						if ( m_iCapID == event->GetInt( "cp" ) )
						{
							m_bCapped = true;
							CheckGoalMet();
						}
					}
				}
			}
		}
		else if ( FStrEq( event->GetName(), "controlpoint_endtouch" ) )
		{
			int iPlayerIndex = event->GetInt( "player", 0 );
			if ( iPlayerIndex == GetLocalPlayerIndex() )
			{
				// We failed to take the point
				ResetTracking();
			}
		}
		else if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
		{
			// Reset tracking at the start of a new round
			ResetTracking();
		}
	}

private:
	float	m_fLandTime;
	float	m_fCapStartTime;
	bool	m_bCapped;
	int		m_iCapID;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_StickyJumpCap, ACHIEVEMENT_TF_DEMOMAN_STICKYJUMP_CAP, "TF_DEMOMAN_STICKYJUMP_CAP", 5 );

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

	// Give opponents freezecams of you taunting
	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_FreezeTaunt, ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE, "TF_DEMOMAN_FREEZECAM_SMILE", 5 );

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

	// Give opponents freezecams of you taunting
	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_FreezeTauntRump, ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP, "TF_DEMOMAN_FREEZECAM_RUMP", 5 );


//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_EnvironmentalKill : 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( CAchievementTFDemoman_EnvironmentalKill, ACHIEVEMENT_TF_DEMOMAN_ENVIRONMENTAL_KILL, "TF_DEMOMAN_ENVIRONMENTAL_KILL", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DestroyStickyBombs : public CBaseTFAchievement
{
	// Destroy X stickybombs with the Scottish Defender

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 100 );
		SetStoreProgressInSteam( true );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DestroyStickyBombs, ACHIEVEMENT_TF_DEMOMAN_DESTROY_X_STICKYBOMBS, "TF_DEMOMAN_DESTROY_X_STICKYBOMBS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_StickyJumpDistance : public CBaseTFAchievement
{
	DECLARE_CLASS( CAchievementTFDemoman_StickyJumpDistance, CBaseTFAchievement );

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
		SetGoal( 1 );
		ResetTracking();
	}

	virtual bool IsActive()
	{
		return BaseClass::IsActive();
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "localplayer_respawn" );
		ListenForGameEvent( "sticky_jump" );
		ListenForGameEvent( "sticky_jump_landed" );
		ResetTracking();
	}

	void ResetTracking( void )
	{
		ClearThink();
		m_vecStartJump = vec3_origin;
	}

	void CheckJump( void )
	{
		CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( pLocalTFPlayer )
		{
			// someone has messed with gravity, so reset our tracking
			if ( GetCurrentGravity() != 800.0f )
			{
				ResetTracking();
				return;
			}

			Vector vecCurrent = pLocalTFPlayer->GetAbsOrigin();
			vecCurrent.z = 0;
			float flDistSqr = (vecCurrent - m_vecStartJump).Length2DSqr();
			if ( flDistSqr > (2048 * 2048) )
			{
				IncrementCount();
			}
		}
	}

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

		if ( FStrEq( pszEvent, "teamplay_round_active" ) ||
			FStrEq( pszEvent, "localplayer_respawn" ) )
		{
			ResetTracking();
		}
		else if ( FStrEq( pszEvent, "sticky_jump" ) )
		{
			int iUserID = event->GetInt( "userid" );

			CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
			if ( pLocalTFPlayer && pLocalTFPlayer->GetUserID() == iUserID )
			{
				m_vecStartJump = pLocalTFPlayer->GetAbsOrigin();
				m_vecStartJump.z = 0;
				SetNextThink( 0.1 );
			}
		}
		else if ( FStrEq( pszEvent, "sticky_jump_landed" ) )
		{
			int iUserID = event->GetInt( "userid" );

			CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
			if ( pLocalTFPlayer && pLocalTFPlayer->GetUserID() == iUserID )
			{
				CheckJump();
				ResetTracking();
			}
		}
	}

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

		if ( pVictim == C_BasePlayer::GetLocalPlayer() )
		{
			ResetTracking();
		}
	}

	virtual void Think( void )
	{
		CheckJump();
		SetNextThink( 0.1 );
	}

private:
	Vector m_vecStartJump;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_StickyJumpDistance, ACHIEVEMENT_TF_DEMOMAN_STICKJUMP_DISTANCE, "TF_DEMOMAN_STICKJUMP_DISTANCE", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_Kill3WithDetonation : public CBaseTFAchievement
{
	// Destroy 3 players with a single pipebomb

	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_Kill3WithDetonation, ACHIEVEMENT_TF_DEMOMAN_KILL3_WITH_DETONATION, "TF_DEMOMAN_KILL3_WITH_DETONATION", 5 );

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

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "player_sapped_object" );
		m_hTargets.Purge();
	}

	int FindSpyInList( int iUserID )
	{
		for ( int i = m_hTargets.Count() - 1; i >= 0; i-- )
		{
			if ( m_hTargets[i].flTime < gpGlobals->curtime )
			{
				// time has run out on this one
				m_hTargets.Remove( i );
				continue;
			}

			if ( m_hTargets[i].nSpyUserID == iUserID )
				return i;
		}

		return -1;
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
		{
			CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
			if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) )
			{
				int iIndex = FindSpyInList( pTFVictim->GetUserID() );
				if ( iIndex != -1 )
				{
					IncrementCount();
					m_hTargets.Remove( iIndex );
				}
			}
		}
	}

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

		if ( FStrEq( pszEventName, "player_sapped_object" ) )
		{
			int nUserID = event->GetInt( "userid" );
			int iIndex = FindSpyInList( nUserID );
			if ( iIndex == -1 )
			{
				iIndex = m_hTargets.AddToTail();
				m_hTargets[iIndex].nSpyUserID = nUserID;
			}
			m_hTargets[iIndex].flTime = gpGlobals->curtime + 5.0;
		}
	}

private:
	struct targets_t
	{
		int nSpyUserID;
		float flTime;
	};

	CUtlVector<targets_t> m_hTargets;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXSappingSpies, ACHIEVEMENT_TF_DEMOMAN_KILLXSAPPINGSPIES, "TF_DEMOMAN_KILLXSAPPINGSPIES", 5 );


//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_Kill3WithPipeSetup : public CBaseTFAchievement
{
	// Kill 3 players in separate explosions without placing new sticky bombs

	void Init() 
	{
		SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	virtual void ListenForEvents()
	{
		ResetCounts();
	}

	void ResetCounts()
	{
		m_iConsecutiveKillsWithoutRefiring = 0;
		m_flPrevKillTime = 0;
		m_iPipebombCount = 0;
	}

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

		if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
		{
			if ( !m_iConsecutiveKillsWithoutRefiring )
			{
				// We're starting.
				m_iConsecutiveKillsWithoutRefiring = 1;
				m_flPrevKillTime = gpGlobals->curtime;
				m_iPipebombCount = pLocalPlayer->GetNumActivePipebombs();
				SetNextThink( 0.1 );
			}
			else if ( (gpGlobals->curtime - m_flPrevKillTime) > 0.2 )		// Make sure it wasn't in the same detonation
			{
				m_iConsecutiveKillsWithoutRefiring++;
				m_flPrevKillTime = gpGlobals->curtime;
				if ( m_iConsecutiveKillsWithoutRefiring >= 3 )
				{
					IncrementCount();
				}
			}
		}
	}

	virtual void Think( void )
	{
		CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
		if ( !pLocalPlayer )
			return;

		int nPipes = pLocalPlayer->GetNumActivePipebombs();
		if ( m_iPipebombCount < nPipes )
		{
			// They laid new pipes. We're done.
			ResetCounts();
		}
		else
		{
			m_iPipebombCount = nPipes;
			SetNextThink( 0.1 );
		}
	}

private:
	int		m_iPipebombCount;
	int		m_iConsecutiveKillsWithoutRefiring;
	float	m_flPrevKillTime;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_Kill3WithPipeSetup, ACHIEVEMENT_TF_DEMOMAN_KILL3_WITH_PIPE_SETUPS, "TF_DEMOMAN_KILL3_WITH_PIPE_SETUPS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_AchieveProgress1 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFDemoman_AchieveProgress1, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 5, ACHIEVEMENT_TF_DEMOMAN_START_RANGE, ACHIEVEMENT_TF_DEMOMAN_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AchieveProgress1, ACHIEVEMENT_TF_DEMOMAN_ACHIEVE_PROGRESS1, "TF_DEMOMAN_ACHIEVE_PROGRESS1", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_AchieveProgress2 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFDemoman_AchieveProgress2, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 11, ACHIEVEMENT_TF_DEMOMAN_START_RANGE, ACHIEVEMENT_TF_DEMOMAN_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AchieveProgress2, ACHIEVEMENT_TF_DEMOMAN_ACHIEVE_PROGRESS2, "TF_DEMOMAN_ACHIEVE_PROGRESS2", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_AchieveProgress3 : public CAchievement_AchievedCount
{
public:
	DECLARE_CLASS( CAchievementTFDemoman_AchieveProgress3, CAchievement_AchievedCount );
	void Init() 
	{
		BaseClass::Init();
		SetAchievementsRequired( 17, ACHIEVEMENT_TF_DEMOMAN_START_RANGE, ACHIEVEMENT_TF_DEMOMAN_END_RANGE );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AchieveProgress3, ACHIEVEMENT_TF_DEMOMAN_ACHIEVE_PROGRESS3, "TF_DEMOMAN_ACHIEVE_PROGRESS3", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_ParachuteKillGroup : public CBaseTFAchievement
{
public:
	void Init()
	{
		SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		ResetTracking();
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "parachute_deploy" );
		ListenForGameEvent( "parachute_holster" );
	}

	void ResetTracking( void )
	{
		m_nKills = 0;
		m_bParachuteDeployed = false;
	}

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

		if ( FStrEq( pszEvent, "parachute_deploy" ) )
		{
			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
			{
				ResetTracking();
				m_bParachuteDeployed = true;
			}
		}
		else if ( FStrEq( pszEvent, "parachute_holster" ) )
		{
			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
			{
				ResetTracking();
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
	{
		if ( pVictim )
		{
			// Local player died	
			if ( pVictim == C_BasePlayer::GetLocalPlayer() )
			{
				ResetTracking();
			}
			else if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
			{
				if ( m_bParachuteDeployed )
				{
					m_nKills++;
					if ( m_nKills >= 3 )
					{
						IncrementCount();
					}
				}
			}
		}
	}

private:
	int m_nKills;
	bool m_bParachuteDeployed;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ParachuteKillGroup, ACHIEVEMENT_TF_DEMOMAN_PARACHUTE_KILL_GROUP, "TF_DEMOMAN_PARACHUTE_KILL_GROUP", 5 );

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

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "parachute_deploy" );
		ListenForGameEvent( "parachute_holster" );
	}

	void ResetTracking( void )
	{
		ClearThink();
		m_flLastZ = 0.0;
	}

	void CheckHeight( void )
	{
		CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
		if ( pLocalPlayer )
		{
			float flCurrentZ = pLocalPlayer->GetAbsOrigin().z;
			float flDela = m_flLastZ - flCurrentZ;

			// make sure we've fallen....we may have been pushed upwards
			if ( flDela > 0.0f )
			{
				IncrementCount( ( int )( flDela ) );
			}

			m_flLastZ = flCurrentZ;
		}
	}

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

		if ( FStrEq( pszEvent, "parachute_deploy" ) )
		{
			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
			{
				CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
				if ( pLocalPlayer )
				{
					m_flLastZ = pLocalPlayer->GetAbsOrigin().z;
					SetNextThink( 0.1 );
				}
			}
		}
		else if ( FStrEq( pszEvent, "parachute_holster" ) )
		{
			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
			{
				ResetTracking();
			}
		}
	}

	virtual void Think( void )
	{
		CheckHeight();
		SetNextThink( 0.1 );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
	{
		// Local player died	
		if ( pVictim == C_BasePlayer::GetLocalPlayer() )
		{
			ResetTracking();
		}
	}

private:
	float m_flLastZ;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ParachuteDistance, ACHIEVEMENT_TF_DEMOMAN_PARACHUTE_DISTANCE, "TF_DEMOMAN_PARACHUTE_DISTANCE", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
	{
		CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( pTFAttacker && pTFVictim && ( pTFAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
		{
			if ( ( pTFAttacker->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) ) && ( pTFVictim->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) ) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ParachuteKillParachute, ACHIEVEMENT_TF_DEMOMAN_PARACHUTE_KILL_PARACHUTE, "TF_DEMOMAN_PARACHUTE_KILL_PARACHUTE", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillPlayerYouDidntSee, ACHIEVEMENT_TF_DEMOMAN_KILL_PLAYER_YOU_DIDNT_SEE, "TF_DEMOMAN_KILL_PLAYER_YOU_DIDNT_SEE", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "kill_refills_meter" ) )
		{
			if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
			{
				int iNewIndex = m_Times.AddToTail();
				m_Times[iNewIndex] = gpGlobals->curtime;

				// we only care about the last three times we killed someone
				if ( m_Times.Count() > 3 )
				{
					m_Times.Remove( 0 );
				}

				if ( m_Times.Count() == 3 )
				{
					if ( m_Times.Tail() - m_Times.Head() <= 6.0 )
					{
						IncrementCount();
					}
				}
			}
		}
	}

private:
	CUtlVector< float >	m_Times;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_QuickKills, ACHIEVEMENT_TF_DEMOMAN_QUICK_KILLS, "TF_DEMOMAN_QUICK_KILLS", 5 );

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
	{
		CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		
		if ( pTFAttacker && pTFVictim && ( pTFAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
		{
			if ( pTFAttacker->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) && pTFVictim->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) )
			{
				IncrementCount();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ChargeKillChargingDemo, ACHIEVEMENT_TF_DEMOMAN_CHARGE_KILL_CHARGING_DEMO, "TF_DEMOMAN_CHARGE_KILL_CHARGING_DEMO", 5 );

#endif // CLIENT_DLL