Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1885 lines
55 KiB

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