tf2/tf2_src/game/shared/tf/achievements_tf_mvm.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 "c_tf_objective_resource.h"
#include "tf_gamerules.h"
#include "achievements_tf.h"
#include "tf_item_powerup_bottle.h"

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_CompletePopFile : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_bPlayedEntireMission = false;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "mvm_mission_complete" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			if ( event->GetInt( "wave_index" ) == 0 )
			{
				m_bPlayedEntireMission = true;
			}
		}
		else if ( FStrEq( pszEventName, "mvm_mission_complete" ) )
		{
			if ( m_bPlayedEntireMission )
			{
				AwardAchievement();
			}
		}
	}

private:
	bool m_bPlayedEntireMission;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_CompletePopFile, ACHIEVEMENT_TF_MVM_COMPLETE_POP_FILE, "TF_MVM_COMPLETE_POP_FILE", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_EarnMoneyBonus : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_bPlayedEntireWave = false;
	}

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

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

		if ( FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			m_bPlayedEntireWave = true;
		}
		else if ( FStrEq( pszEventName, "mvm_creditbonus_wave" ) )
		{
			if ( m_bPlayedEntireWave )
			{
				AwardAchievement();
			}
		}
	}

private:
	bool m_bPlayedEntireWave;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_EarnMoneyBonus, ACHIEVEMENT_TF_MVM_EARN_MONEY_BONUS, "TF_MVM_EARN_MONEY_BONUS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_AdvancedEarnAllBonuses : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_bPlayedEntireMission = false;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "mvm_creditbonus_all_advanced" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			if ( event->GetInt( "wave_index" ) == 0 )
			{
				m_bPlayedEntireMission = true;
			}
		}
		else if ( FStrEq( pszEventName, "mvm_creditbonus_all_advanced" ) )
		{
			if ( m_bPlayedEntireMission )
			{
				AwardAchievement();
			}
		}
	}

private:
	bool m_bPlayedEntireMission;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_AdvancedEarnAllBonuses, ACHIEVEMENT_TF_MVM_ADVANCED_EARN_ALL_BONUSES, "TF_MVM_ADVANCED_EARN_ALL_BONUSES", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_PickupMoneyAboutToExpire, ACHIEVEMENT_TF_MVM_PICKUP_MONEY_ABOUT_TO_EXPIRE, "TF_MVM_PICKUP_MONEY_ABOUT_TO_EXPIRE", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "mvm_pickup_currency" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				IncrementCount( event->GetInt( "currency" ) );
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_CollectMoneyGrind, ACHIEVEMENT_TF_MVM_COLLECT_MONEY_GRIND, "TF_MVM_COLLECT_MONEY_GRIND", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "mvm_mission_complete" ) )
		{
			if ( CalcPlayersOnFriendsList( 5 ) )
			{
				AwardAchievement();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_PlayGameFriends, ACHIEVEMENT_TF_MVM_PLAY_GAME_FRIENDS, "TF_MVM_PLAY_GAME_FRIENDS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_PlayEachClass : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS );
		SetGoal( ( TF_LAST_NORMAL_CLASS - 1 ) - TF_FIRST_NORMAL_CLASS + 1 ); //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class

		m_bChangedClass = true;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "localplayer_changeclass" );
		ListenForGameEvent( "localplayer_changeteam" );
		ListenForGameEvent( "mvm_mission_complete" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			if ( event->GetInt( "wave_index" ) == 0 )
			{
				// beginning the first wave...lock down class changes
				m_bChangedClass = false;
			}
		}
		else if ( FStrEq( pszEventName, "localplayer_changeclass" ) ||	   // can't change class or team after the first round starts
				  FStrEq( pszEventName, "localplayer_changeteam" ) )
		{
			m_bChangedClass = true;
		}
		else if ( FStrEq( pszEventName, "mvm_mission_complete" ) )
		{
			if ( !m_bChangedClass )
			{
				C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
				if ( pTFPlayer )
				{
					int iClass = pTFPlayer->GetPlayerClass()->GetClassIndex();
					if ( iClass >= TF_FIRST_NORMAL_CLASS && iClass <= ( TF_LAST_NORMAL_CLASS - 1 ) ) //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class
					{
						// yes, the achievement is satisfied for this class, set the corresponding bit
						int iBitNumber =( iClass - TF_FIRST_NORMAL_CLASS );
						EnsureComponentBitSetAndEvaluate( iBitNumber );
					}							
				}
			}
		}
	}

private:
	bool m_bChangedClass;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_PlayEachClass, ACHIEVEMENT_TF_MVM_PLAY_EACH_CLASS, "TF_MVM_PLAY_EACH_CLASS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_DestroyTwoTanks : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_flLastTankDestroyedTime = 0.0f;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_tank_destroyed_by_players" );
		ListenForGameEvent( "mvm_begin_wave" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "mvm_tank_destroyed_by_players" ) )
		{
			if ( m_flLastTankDestroyedTime > 0.0f )
			{
				if ( fabs( gpGlobals->curtime - m_flLastTankDestroyedTime ) <= 5.0f )
				{
					AwardAchievement();
				}
			}

			m_flLastTankDestroyedTime = gpGlobals->curtime;
		}

		if ( FStrEq( event->GetName(), "mvm_begin_wave" ) )
		{
			m_flLastTankDestroyedTime = 0.f;
		}
	}

private:
	float m_flLastTankDestroyedTime;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_DestroyTwoTanks, ACHIEVEMENT_TF_MVM_DESTROY_TWO_TANKS, "TF_MVM_DESTROY_TWO_TANKS", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_DestroyTankWhileDeploying, ACHIEVEMENT_TF_MVM_DESTROY_TANK_WHILE_DEPLOYING, "TF_MVM_DESTROY_TANK_WHILE_DEPLOYING", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_DestroyTankQuickly, ACHIEVEMENT_TF_MVM_DESTROY_TANK_QUICKLY, "TF_MVM_DESTROY_TANK_QUICKLY", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_DefendCap : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		iCount = 0;
	}

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

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

		if ( FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			iCount = 0;
		}
		else if ( FStrEq( pszEventName, "mvm_kill_robot_delivering_bomb" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				iCount++;
				if ( iCount >= 10 )
				{
					AwardAchievement();
				}
			}
		}
	}

private:
	int iCount;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_DefendCap, ACHIEVEMENT_TF_MVM_DEFEND_CAP, "TF_MVM_DEFEND_CAP", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_KillBombCarriers : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_nConsecutiveKillCount = 0;
		ACHIEVEMENT_COUNT = 15;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( Q_strcmp( event->GetName(), "mvm_bomb_carrier_killed" ) == 0 )
		{
			if ( GetLocalPlayerTeam() != TF_TEAM_PVE_DEFENDERS )
				return;

			int nLevel = event->GetInt( "level" );
			if ( !nLevel )
			{
				m_nConsecutiveKillCount++;
			}
			else
			{
				m_nConsecutiveKillCount = 0;
			}
		}
		else if ( Q_strcmp( event->GetName(), "teamplay_round_active" ) == 0 )
		{
			m_nConsecutiveKillCount = 0;
		}

		if ( m_nConsecutiveKillCount >= ACHIEVEMENT_COUNT )
		{
			AwardAchievement();
		}
	}

private:
	int m_nConsecutiveKillCount;
	int ACHIEVEMENT_COUNT;

};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_KillBombCarriers, ACHIEVEMENT_TF_MVM_KILL_BOMB_CARRIERS, "TF_MVM_KILL_BOMB_CARRIERS", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_CompleteWaveWithoutDying : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
		SetGoal( 1 );

		bSurvivedEntireWave = false;
	}

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

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

		if ( FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			bSurvivedEntireWave = true;
		}
		else if ( FStrEq( pszEventName, "mvm_wave_complete" ) )
		{
			if ( event->GetBool( "advanced" ) )
			{
				if ( bSurvivedEntireWave )
				{
					AwardAchievement();
				}
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pVictim && ( pVictim == C_BasePlayer::GetLocalPlayer() ) )
		{
			bSurvivedEntireWave = false;
		}
	}

private:
	bool bSurvivedEntireWave;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_CompleteWaveWithoutDying, ACHIEVEMENT_TF_MVM_COMPLETE_WAVE_WITHOUT_DYING, "TF_MVM_COMPLETE_WAVE_WITHOUT_DYING", 5 );
 
//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_CompleteTour : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS );

		static const char *szComponents[] =
		{
			"scripts/population/mvm_decoy.pop", "scripts/population/mvm_coaltown.pop", "scripts/population/mvm_mannworks.pop"
		};		
		m_pszComponentNames = szComponents;
		m_iNumComponents = ARRAYSIZE( szComponents );
		SetGoal( m_iNumComponents );

		m_bPlayedEntireMission = false;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "mvm_mission_complete" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			if ( event->GetInt( "wave_index" ) == 0 )
			{
				m_bPlayedEntireMission = true;
			}
		}
		else if ( FStrEq( pszEventName, "mvm_mission_complete" ) )
		{
			if ( m_bPlayedEntireMission )
			{
				OnComponentEvent( event->GetString( "mission" ) );
			}
		}
	}

private:
	bool m_bPlayedEntireMission;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_CompleteTour, ACHIEVEMENT_TF_MVM_COMPLETE_TOUR, "TF_MVM_COMPLETE_TOUR", 5 );
 
//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_UseTeleportBottle : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_flAchievementEndTime = 0.0f;
	}

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

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

		if ( FStrEq( pszEventName, "player_used_powerup_bottle" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				if ( event->GetInt( "type" ) == POWERUP_BOTTLE_RECALL )
				{
					// defend the bomb within 5 seconds
					m_flAchievementEndTime = gpGlobals->curtime + 5.0f;
				}
			}
		}
		else if ( FStrEq( pszEventName, "teamplay_flag_event" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				if ( event->GetInt( "eventtype" ) == TF_FLAGEVENT_DEFEND )
				{
					if ( gpGlobals->curtime < m_flAchievementEndTime )
					{
						AwardAchievement();
					}
				}
			}
		}
	}

private:
	float m_flAchievementEndTime;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_UseTeleportBottle, ACHIEVEMENT_TF_MVM_USE_TELEPORT_BOTTLE, "TF_MVM_USE_TELEPORT_BOTTLE", 5 );

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

		m_flAchievementEndTime = 0.0f;
	}

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

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

		if ( FStrEq( pszEventName, "player_used_powerup_bottle" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				if ( event->GetInt( "type" ) == POWERUP_BOTTLE_CRITBOOST )
				{
					C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
					if ( pLocalTFPlayer )
					{
						m_flAchievementEndTime = gpGlobals->curtime + event->GetFloat( "time" );
					}
				}
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( gpGlobals->curtime < m_flAchievementEndTime )
		{
			C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
			if ( pTFVictim && pTFVictim->IsMiniBoss() )
			{
				AwardAchievement();
			}
		}
	}

private:
	float m_flAchievementEndTime;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_UseCritBottle, ACHIEVEMENT_TF_MVM_USE_CRIT_BOTTLE, "TF_MVM_USE_CRIT_BOTTLE", 5 );

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

		m_iKillCount = 0;
		m_flAchievementEndTime = 0.0f;
	}

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

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

		if ( FStrEq( pszEventName, "player_used_powerup_bottle" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				if ( event->GetInt( "type" ) == POWERUP_BOTTLE_UBERCHARGE )
				{
					m_flAchievementEndTime = gpGlobals->curtime + event->GetFloat( "time" );
					m_iKillCount = 0;
				}
			}
 		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( gpGlobals->curtime < m_flAchievementEndTime )
		{
			m_iKillCount++;
			if ( m_iKillCount >= 15 )
			{
				AwardAchievement();
			}
		}
	}

private:
	float m_flAchievementEndTime;
	int m_iKillCount;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_UseUberBottle, ACHIEVEMENT_TF_MVM_USE_UBER_BOTTLE, "TF_MVM_USE_UBER_BOTTLE", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_UseBuildBottle : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_flAchievementEndTime = 0.0f;
	}

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

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

		if ( FStrEq( pszEventName, "object_destroyed" ) )
		{
			if ( TFGameRules() && ( TFGameRules()->State_Get() == GR_STATE_RND_RUNNING ) )
			{
				int iObject = event->GetInt( "objecttype" );
				if ( iObject == OBJ_SENTRYGUN )
				{
					int iEngineerIdx = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
					if ( iEngineerIdx == GetLocalPlayerIndex() )
					{
						m_flAchievementEndTime = gpGlobals->curtime + 3.0f;
					}
				}
			}
		}
		else if ( FStrEq( pszEventName, "mvm_quick_sentry_upgrade" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				if ( gpGlobals->curtime < m_flAchievementEndTime )
				{
					AwardAchievement();
				}
			}
		}
	}

private:
	float m_flAchievementEndTime;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_UseBuildBottle, ACHIEVEMENT_TF_MVM_USE_BUILD_BOTTLE, "TF_MVM_USE_BUILD_BOTTLE", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_UseAmmoBottle, ACHIEVEMENT_TF_MVM_USE_AMMO_BOTTLE, "TF_MVM_USE_AMMO_BOTTLE", 5 );
 
//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_MaxPrimaryUpgrades : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_MaxPrimaryUpgrades, ACHIEVEMENT_TF_MVM_MAX_PRIMARY_UPGRADES, "TF_MVM_MAX_PRIMARY_UPGRADES", 5 );
 
//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_MaxPlayerResistances : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_MaxPlayerResistances, ACHIEVEMENT_TF_MVM_MAX_PLAYER_RESISTANCES, "TF_MVM_MAX_PLAYER_RESISTANCES", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_NoAlarmsInFinalWave : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		m_bAlarmTriggered = true;
	}
 
	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "mvm_bomb_alarm_triggered" );
		ListenForGameEvent( "mvm_mission_complete" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			if ( event->GetInt( "advanced" ) > 0 )
			{
				if ( event->GetInt( "wave_index" ) == ( event->GetInt( "max_waves" ) - 1 ) )
				{
					m_bAlarmTriggered = false;
				}
				else
				{
					m_bAlarmTriggered = true;
				}
			}
		}
		else if ( FStrEq( pszEventName, "mvm_bomb_alarm_triggered" ) )
		{
			m_bAlarmTriggered = true;
		}
		else if ( FStrEq( pszEventName, "mvm_mission_complete" ) )
		{
			if ( !m_bAlarmTriggered )
			{
				AwardAchievement();
			}
		}
	}

private:
	bool m_bAlarmTriggered;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_NoAlarmsInFinalWave, ACHIEVEMENT_TF_MVM_NO_ALARMS_IN_FINAL_WAVE, "TF_MVM_NO_ALARMS_IN_FINAL_WAVE", 5 );

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

		iCount = 0;
	}

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

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

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_MEDIC ) && ( pTFVictim->MedicGetChargeLevel() >= 1.0 ) )
		{
			iCount++;

			if ( iCount >= 5 )
			{
				AwardAchievement();
			}
		}
	}

private:
	int iCount;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_KillMedicsCharged, ACHIEVEMENT_TF_MVM_KILL_MEDICS_CHARGED, "TF_MVM_KILL_MEDICS_CHARGED", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_KillRobotGrind : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
		SetGoal( 100000 );
		SetStoreProgressInSteam( true );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		IncrementCount();
	}
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_KillRobotGrind, ACHIEVEMENT_TF_MVM_KILL_ROBOT_GRIND, "TF_MVM_KILL_ROBOT_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_KillRobotMegaGrind : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
		SetGoal( 1000000 );
		SetStoreProgressInSteam( true );
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		IncrementCount();
	}	
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_KillRobotMegaGrind, ACHIEVEMENT_TF_MVM_KILL_ROBOT_MEGA_GRIND, "TF_MVM_KILL_ROBOT_MEGA_GRIND", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_KillSentryBuster, ACHIEVEMENT_TF_MVM_KILL_SENTRY_BUSTER, "TF_MVM_KILL_SENTRY_BUSTER", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_SpySapRobots, ACHIEVEMENT_TF_MVM_SPY_SAP_ROBOTS, "TF_MVM_SPY_SAP_ROBOTS", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_SoldierBuffTeam, ACHIEVEMENT_TF_MVM_SOLDIER_BUFF_TEAM, "TF_MVM_SOLDIER_BUFF_TEAM", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "mvm_bomb_deploy_reset_by_player" ) )
		{
			if ( GetLocalPlayerTeam() != TF_TEAM_PVE_DEFENDERS )
				return;

			C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( !pLocalTFPlayer )
				return;

			if ( !pLocalTFPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
				return;

			if ( !pLocalTFPlayer->m_Shared.IsRageDraining() )
				return;

			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				AwardAchievement();
			}
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_HeavyRagePushDeployingRobot, ACHIEVEMENT_TF_MVM_HEAVY_RAGE_PUSH_DEPLOYING_ROBOT, "TF_MVM_HEAVY_RAGE_PUSH_DEPLOYING_ROBOT", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_MedicShareBottles : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		iCount = 0;
	}

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

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

		if ( FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			iCount = 0;
		}
		else if ( FStrEq( pszEventName, "mvm_medic_powerup_shared" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				iCount++;

				if ( iCount >= 5 )
				{
					AwardAchievement();
				}
			}
		}
	}

private:
	int iCount;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_MedicShareBottles, ACHIEVEMENT_TF_MVM_MEDIC_SHARE_BOTTLES, "TF_MVM_MEDIC_SHARE_BOTTLES", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_DemoGroupKill : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
	}
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_DemoGroupKill, ACHIEVEMENT_TF_MVM_DEMO_GROUP_KILL, "TF_MVM_DEMO_GROUP_KILL", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_ScoutMarkForDeath : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		iCount = 0;
	}

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

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

		if ( FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			iCount = 0;
		}
		else if ( FStrEq( pszEventName, "mvm_scout_marked_for_death" ) )
		{
			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				iCount++;

				if ( iCount >= 15 )
				{
					AwardAchievement();
				}
			}
		}
	}

private:
	int iCount;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_ScoutMarkForDeath, ACHIEVEMENT_TF_MVM_SCOUT_MARK_FOR_DEATH, "TF_MVM_SCOUT_MARK_FOR_DEATH", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_SniperKillGroup, ACHIEVEMENT_TF_MVM_SNIPER_KILL_GROUP, "TF_MVM_SNIPER_KILL_GROUP", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_PyroBombReset : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		RESET_COUNT = 3;
		m_iResetCountInWave = 0;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		const char *pszEventName = event->GetName();
		if ( FStrEq( pszEventName, "mvm_bomb_reset_by_player" ) )
		{
			if ( GetLocalPlayerTeam() != TF_TEAM_PVE_DEFENDERS )
				return;

			C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( !pLocalTFPlayer )
				return;

			if ( !pLocalTFPlayer->IsPlayerClass( TF_CLASS_PYRO ) )
				return;

			if ( event->GetInt( "player" ) == GetLocalPlayerIndex() )
			{
				m_iResetCountInWave++;
			}

			if ( m_iResetCountInWave >= RESET_COUNT )
			{
				AwardAchievement();
			}
		}
		else if ( FStrEq( pszEventName, "mvm_wave_complete" ) || 
				  FStrEq( pszEventName, "teamplay_round_active" ) )
		{
			m_iResetCountInWave = 0;
		}
	}

private:

	int RESET_COUNT;
	int m_iResetCountInWave;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_PyroBombReset, ACHIEVEMENT_TF_MVM_PYRO_BOMB_RESET, "TF_MVM_PYRO_BOMB_RESET", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_EngineerEscapeSentryBuster : public CBaseTFAchievementSimple
{
public:
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );

		ListenForGameEvent( "mvm_sentrybuster_detonate" );
	}

	void FireGameEvent_Internal( IGameEvent *event )
	{
		// We should only be here if the sentry buster thinks it was successful
		// which is to say started to detonate because they were within range
		if ( FStrEq( event->GetName(), "mvm_sentrybuster_detonate" ) )
		{
			if ( GetLocalPlayerTeam() != TF_TEAM_PVE_DEFENDERS )
				return;

			int iTargetIdx = event->GetInt( "player" );

			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( !pLocalPlayer )
				return;

			if ( !pLocalPlayer->IsAlive() )
				return;

			if ( !pLocalPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) )
				return;

			// Where it exploded
			float x, y, z = 0;
			x = event->GetFloat( "det_x" );
			y = event->GetFloat( "det_y" );
			z = event->GetFloat( "det_z" );

			// If we're not the target, but within a reasonable range of the sentry buster, 
			// also give credit, otherwise we give the target credit for still being alive.
			if ( GetLocalPlayerIndex() != iTargetIdx )
			{
				Vector vDist = pLocalPlayer->GetAbsOrigin() - Vector( x, y, z );
				if ( vDist.LengthSqr() > 400 * 400 )
					return;
			}

			AwardAchievement();
		}
	}
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_EngineerEscapeSentryBuster, ACHIEVEMENT_TF_MVM_ENGINEER_ESCAPE_SENTRY_BUSTER, "TF_MVM_ENGINEER_ESCAPE_SENTRY_BUSTER", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Rottenburg_Tank, ACHIEVEMENT_TF_MVM_MAPS_ROTTENBURG_TANK, "TF_MVM_MAPS_ROTTENBURG_TANK", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Maps_Rottenburg_Bomb : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		SetMapNameFilter( "mvm_rottenburg" );
		m_bValidWave = false;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "mvm_wave_complete" );
		ListenForGameEvent( "flag_carried_in_detection_zone" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			m_bValidWave = true;
		}
		else if ( FStrEq( pszEventName, "flag_carried_in_detection_zone" ) )
		{
			m_bValidWave = false;
		}
		else if ( FStrEq( pszEventName, "mvm_wave_complete" ) )
		{
			if ( event->GetBool( "advanced" ) )
			{
				if ( m_bValidWave )
				{
					AwardAchievement();
				}
			}
		}
	}

private:
	bool m_bValidWave;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Rottenburg_Bomb, ACHIEVEMENT_TF_MVM_MAPS_ROTTENBURG_BOMB, "TF_MVM_MAPS_ROTTENBURG_BOMB", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Maps_Rottenburg_PitGrind : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 100 );
		SetStoreProgressInSteam( true );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Rottenburg_PitGrind, ACHIEVEMENT_TF_MVM_MAPS_ROTTENBURG_PIT_GRIND, "TF_MVM_MAPS_ROTTENBURG_PIT_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Maps_Manhattan_Pit : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		SetMapNameFilter( "mvm_mannhattan" );
		m_iCount = 0;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "mvm_mannhattan_pit" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			m_iCount = 0;
		}
		else if ( FStrEq( pszEventName, "mvm_mannhattan_pit" ) )
		{
			m_iCount++;
			if ( m_iCount >= 10 )
			{
				AwardAchievement();
			}
		}
	}

private:
	int m_iCount;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Manhattan_Pit, ACHIEVEMENT_TF_MVM_MAPS_MANNHATTAN_PIT, "TF_MVM_MAPS_MANNHATTAN_PIT", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Manhattan_Mystery, ACHIEVEMENT_TF_MVM_MAPS_MANNHATTAN_MYSTERY, "TF_MVM_MAPS_MANNHATTAN_MYSTERY", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Maps_Manhattan_NoGates : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		SetMapNameFilter( "mvm_mannhattan" );
		m_iWaveBits = 0;
	}

	virtual void ListenForEvents()
	{
		ListenForGameEvent( "mvm_begin_wave" );
		ListenForGameEvent( "mvm_adv_wave_complete_no_gates" );
	}

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

		if ( FStrEq( pszEventName, "mvm_begin_wave" ) )
		{
			if ( event->GetInt( "wave_index" ) == 0 )
			{
				m_iWaveBits = 0;
			}
		}
		else if ( FStrEq( pszEventName, "mvm_adv_wave_complete_no_gates" ) )
		{
			m_iWaveBits |= ( 1 << event->GetInt( "index" ) );

			int iComponentBits = m_iWaveBits;
			int iNumBitsSet = 0;

			while ( iComponentBits > 0 )
			{
				if ( iComponentBits & 1 )
				{
					iNumBitsSet++;
				}
				iComponentBits >>= 1;
			}

			if ( TFObjectiveResource() )
			{
				if ( iNumBitsSet >= TFObjectiveResource()->GetMannVsMachineMaxWaveCount() )
				{
					AwardAchievement();
				}
			}
		}
	}

private:
	int m_iWaveBits;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Manhattan_NoGates, ACHIEVEMENT_TF_MVM_MAPS_MANNHATTAN_NO_GATES, "TF_MVM_MAPS_MANNHATTAN_NO_GATES", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Maps_Manhattan_KillStunRadiowave : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		SetMapNameFilter( "mvm_mannhattan" );
		m_nRobotsKilled = 0;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "mvm_adv_wave_killed_stun_radio" ) )
		{
			m_nRobotsKilled++;
			if ( m_nRobotsKilled >= 50 )
			{
				AwardAchievement();
			}
		}
	}

private: 
	int m_nRobotsKilled;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Manhattan_KillStunRadiowave, ACHIEVEMENT_TF_MVM_MAPS_MANNHATTAN_STUN_RADIOWAVE, "TF_MVM_MAPS_MANNHATTAN_STUN_RADIOWAVE", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Maps_Manhattan_BombBotGrind : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 500 );
		SetStoreProgressInSteam( true );
	}

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Maps_Manhattan_BombBotGrind, ACHIEVEMENT_TF_MVM_MAPS_MANNHATTAN_BOMB_BOT_GRIND, "TF_MVM_MAPS_MANNHATTAN_BOMB_BOT_GRIND", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_SentryBusterFriendlyFire : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
		SetGoal( 1 );

		m_flDetonateTime = 0.f;
		m_pSentryBuster = NULL;
		m_Victims.EnsureCapacity( MAX_PLAYERS );
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "mvm_sentrybuster_killed" ) )
		{
			m_pSentryBuster = UTIL_PlayerByIndex( event->GetInt( "sentry_buster" ) );
			if ( m_pSentryBuster )
			{
				m_flDetonateTime = gpGlobals->curtime;
				SetNextThink( 0.1 );
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( pAttacker && pVictim )
		{
			CBasePlayer *pAttackerPlayer = UTIL_PlayerByIndex( pAttacker->entindex() );
			if ( m_pSentryBuster && m_pSentryBuster == pAttackerPlayer && gpGlobals->curtime <= m_flDetonateTime + 0.25f )
			{
				if ( pVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS )
				{
					if ( m_Victims.Find( pVictim->entindex() ) == m_Victims.InvalidIndex() )
					{
						m_Victims.AddToTail( pVictim->entindex() );
					}
				}
			}
		}
	}

	virtual void Think( void )
	{
		if ( gpGlobals->curtime <= m_flDetonateTime + 0.25f )
		{
			int nVictims = m_Victims.Count();
			if ( nVictims >= 5 )
			{
				AwardAchievement();
			}

			SetNextThink( 0.1 );
			return;
		}

		m_pSentryBuster = NULL;
		m_Victims.RemoveAll();
	}

private:
	CUtlVector< int > m_Victims;
	CBasePlayer *m_pSentryBuster;
	float m_flDetonateTime;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_SentryBusterFriendlyFire, ACHIEVEMENT_TF_MVM_SENTRY_BUSTER_FRIENDLY_FIRE, "TF_MVM_SENTRY_BUSTER_FRIENDLY_FIRE", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Sniper_CollectHeadshotMoney : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		SetMapNameFilter( "mvm_mannhattan" );
		m_nCurrencyCollected = 0;
	}

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "mvm_sniper_headshot_currency" ) )
		{
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pLocalPlayer )
			{
				if ( event->GetInt( "userid" ) == pLocalPlayer->GetUserID() )
				{
					m_nCurrencyCollected += event->GetFloat( "currency" );
					if ( m_nCurrencyCollected >= 500 )
					{
						AwardAchievement();
					}
				}
			}
		}
	}

private: 
	int m_nCurrencyCollected;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Sniper_CollectHeadshotMoney, ACHIEVEMENT_TF_MVM_SNIPER_COLLECT_HEADSHOT_MONEY, "TF_MVM_SNIPER_COLLECT_HEADSHOT_MONEY", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_Medic_ShieldBlockDamage : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL );
		SetGoal( 1 );
		SetMapNameFilter( "mvm_mannhattan" );
		m_flDamage = 0.0f;
	}

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

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

		if ( FStrEq( pszEvent, "teamplay_round_active" ) ||
			 FStrEq( pszEvent, "localplayer_respawn" ) )
		{
			m_flDamage = 0.0f;
		}
		else if ( FStrEq( pszEvent, "medigun_shield_blocked_damage" ) )
		{
			C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
			if ( pLocalPlayer )
			{
				if ( event->GetInt( "userid" ) == pLocalPlayer->GetUserID() )
				{
					m_flDamage += event->GetFloat( "damage" );
					if ( m_flDamage >= 5000.0f )
					{
						AwardAchievement();
					}
				}
			}
		}
	}

private:
	float m_flDamage;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Medic_ShieldBlockDamage, ACHIEVEMENT_TF_MVM_MEDIC_SHIELD_BLOCK_DAMAGE, "TF_MVM_MEDIC_SHIELD_BLOCK_DAMAGE", 5 );

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

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

	void FireGameEvent_Internal( IGameEvent *event )
	{
		if ( FStrEq( event->GetName(), "revive_player_complete" ) )
		{
			if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
			{
				C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
				if ( pLocalPlayer && pLocalPlayer->MedicIsReleasingCharge() )
				{
					if ( event->GetInt( "entindex" ) == GetLocalPlayerIndex() )
					{
						int iNewIndex = m_Times.AddToTail();
						m_Times[iNewIndex] = gpGlobals->curtime;

						// we only care about the last two times we revived someone
						if ( m_Times.Count() > 2 )
						{
							m_Times.Remove( 0 );
						}

						if ( m_Times.Count() == 2 )
						{
							if ( m_Times.Tail() - m_Times.Head() <= 5.0 )
							{
								AwardAchievement();
							}
						}
					}
				}
			}
		}
	}

private:
	CUtlVector< float >	m_Times;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_Medic_ReviveTeammates, ACHIEVEMENT_TF_MVM_MEDIC_REVIVE_TEAMMATES, "TF_MVM_MEDIC_REVIVE_TEAMMATES", 5 );

//----------------------------------------------------------------------------------------------------------------
class CAchievementTF_MvM_RocketSpecialistKillGrind : public CBaseTFAchievementSimple
{
	void Init() 
	{
		SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
		SetGoal( 1 );

		m_flLastDirectTime = 0.f;
		m_Victims.EnsureCapacity( MAX_PLAYERS );
	}

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

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

		// If we hit a bot directly, track player deaths over the next 0.25 seconds and see if we're the attacker
		if ( FStrEq( pszEvent, "player_directhit_stun" ) )
		{
			int iLocalPlayerIndex = C_BasePlayer::GetLocalPlayer()->entindex();
			int iAttackerIndex = event->GetInt( "attacker" );
			CBasePlayer *pVictim = UTIL_PlayerByIndex( event->GetInt( "victim" ) );

			if ( pVictim && pVictim->IsPlayer() && iLocalPlayerIndex == iAttackerIndex )
			{
				m_flLastDirectTime = gpGlobals->curtime;
				SetNextThink( 0.1 );
			}
		}
	}

	virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event ) 
	{
		if ( gpGlobals->curtime <= m_flLastDirectTime + 0.25f )
		{
			if ( pAttacker && pVictim && pAttacker != pVictim  && pAttacker == C_BasePlayer::GetLocalPlayer() )
			{
				CBasePlayer *pPlayerVictim = UTIL_PlayerByIndex( pVictim->entindex() );
				if ( m_Victims.Find( pPlayerVictim ) == m_Victims.InvalidIndex() )
				{
					m_Victims.AddToTail( pPlayerVictim );
				}
			}
		}
	}

	virtual void Think( void )
	{
		int nVictims = m_Victims.Count();
		if ( nVictims )
		{
			if ( gpGlobals->curtime <= m_flLastDirectTime + 0.25f )
			{
				if ( nVictims >= 5 )
				{
					AwardAchievement();
				}
			}
			else
			{
				m_Victims.RemoveAll();
				return;
			}

			SetNextThink( 0.1 );
		}
	}

private:
	CUtlVector< CBasePlayer* > m_Victims;
	float m_flLastDirectTime;
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_RocketSpecialistKillGrind, ACHIEVEMENT_TF_MVM_ROCKET_SPECIALIST_KILL_GRIND, "TF_MVM_ROCKET_SPECIALIST_KILL_GRIND", 5 );

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

	// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTF_MvM_RocketSpecialistStunGrind, ACHIEVEMENT_TF_MVM_ROCKET_SPECIALIST_STUN_GRIND, "TF_MVM_ROCKET_SPECIALIST_STUN_GRIND", 5 );

#endif // CLIENT_DLL