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.
 
 
 
 
 
 

1732 lines
51 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_shotgun.h"
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_FirstBlood : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for getting first blood.
if ( event->GetInt( "death_flags" ) & TF_DEATH_FIRST_BLOOD )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FirstBlood, ACHIEVEMENT_TF_SCOUT_FIRST_BLOOD, "TF_SCOUT_FIRST_BLOOD", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_FirstBloodKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 5 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pAttackerPlayer = ToTFPlayer( pAttacker );
// Achievement for accumulating 5 kills over several matches with the first blood crit boost.
bool bFirstBlood = event->GetInt( "death_flags" ) & TF_DEATH_FIRST_BLOOD;
if ( pAttackerPlayer->m_Shared.IsFirstBloodBoosted() &&
pAttackerPlayer->m_Shared.InCond( TF_COND_CRITBOOSTED_FIRST_BLOOD ) &&
!bFirstBlood )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FirstBloodKill, ACHIEVEMENT_TF_SCOUT_FIRST_BLOOD_KILL, "TF_SCOUT_FIRST_BLOOD_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_WellEarlyKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for getting a kill in cp_well during the setup phase.
if ( FStrEq( m_pAchievementMgr->GetMapName(), "cp_well" ) &&
TFGameRules() && (TFGameRules()->State_Get() == GR_STATE_RND_RUNNING) &&
TFGameRules()->InSetup() )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_WellEarlyKill, ACHIEVEMENT_TF_SCOUT_WELL_EARLY_KILL, "TF_SCOUT_WELL_EARLY_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_LifetimeKills : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 2004 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for getting 2004 lifetime kills!
IncrementCount();
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_LifetimeKills, ACHIEVEMENT_TF_SCOUT_LIFETIME_KILLS, "TF_SCOUT_LIFETIME_KILLS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_IronManKills : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
ResetTracking();
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
ResetTracking();
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
FStrEq( pszEventName, "teamplay_round_active" ) )
{
ResetTracking();
}
}
void ResetTracking()
{
m_bKillOnGround = false;
m_bKillInAir = false;
m_bKillInWater = false;
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for getting a kill while on the ground, in the air, and in the water in a single life.
CTFPlayer *pAttackerPlayer = ToTFPlayer( pAttacker );
if ( !pAttackerPlayer )
return;
if ( pAttackerPlayer->GetWaterLevel() == WL_Eyes )
{
m_bKillInWater = true;
}
else if ( !(pAttackerPlayer->GetFlags() & FL_ONGROUND) )
{
m_bKillInAir = true;
}
else
{
m_bKillOnGround = true;
}
if ( m_bKillOnGround && m_bKillInAir && m_bKillInWater )
{
IncrementCount();
}
}
bool m_bKillOnGround;
bool m_bKillInAir;
bool m_bKillInWater;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_IronManKills, ACHIEVEMENT_TF_SCOUT_IRON_MAN_KILLS, "TF_SCOUT_IRON_MAN_KILLS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DestroyTeleporters : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 3 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "object_destroyed" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "object_destroyed" ) == 0 )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pDestroyer == pTFPlayer )
{
// Only count teleporters.
int iType = event->GetInt( "objecttype" );
if ( iType == OBJ_TELEPORTER )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DestroyTeleporters, ACHIEVEMENT_TF_SCOUT_DESTROY_TELEPORTERS, "TF_SCOUT_DESTROY_TELEPORTERS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DestroyBuildingsBeingBuilt : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 3 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "object_destroyed" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "object_destroyed" ) == 0 )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pDestroyer == pTFPlayer )
{
// Only count buildings being built.
if ( event->GetBool( "was_building" ) )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DestroyBuildingsBeingBuilt, ACHIEVEMENT_TF_SCOUT_DESTROY_BUILDINGS_BEING_BUILT, "TF_SCOUT_DESTROY_BUILDINGS_BEING_BUILT", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DestroySentryWithPistol : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "object_destroyed" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "object_destroyed" ) == 0 )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pDestroyer == pTFPlayer )
{
// Only count active sentries destroyed with a pistol.
int iType = event->GetInt( "objecttype" );
int iWeaponID = event->GetInt( "weaponid" );
if ( (iType == OBJ_SENTRYGUN) &&
(iWeaponID == TF_WEAPON_PISTOL_SCOUT) &&
!event->GetBool( "was_building" ) )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DestroySentryWithPistol, ACHIEVEMENT_TF_SCOUT_DESTROY_SENTRY_WITH_PISTOL, "TF_SCOUT_DESTROY_SENTRY_WITH_PISTOL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DoubleJumps : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1000 );
SetStoreProgressInSteam( true );
m_bScoredJump = false;
}
virtual void ListenForEvents()
{
ListenForGameEvent( "air_dash" );
ListenForGameEvent( "landed" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
// Achievement for getting 1000 double jumps.
if ( Q_strcmp( event->GetName(), "air_dash" ) == 0 )
{
int iJumperID = event->GetInt( "player" );
C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( iJumperID ) ) );
if ( pJumper == C_TFPlayer::GetLocalTFPlayer() && !m_bScoredJump )
{
m_bScoredJump = true;
IncrementCount();
}
}
else if ( (Q_strcmp( event->GetName(), "landed" ) == 0) ||
(Q_strcmp( event->GetName(), "localplayer_respawn" ) == 0) ||
(Q_strcmp( event->GetName(), "teamplay_round_active" ) == 0) )
{
m_bScoredJump = false;
}
}
private:
bool m_bScoredJump;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DoubleJumps, ACHIEVEMENT_TF_SCOUT_DOUBLE_JUMPS, "TF_SCOUT_DOUBLE_JUMPS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AssistChargeMedic : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
m_bCharged = false;
m_iAssists = 0;
m_iMedic = -1;
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_chargedeployed" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "player_chargedeployed" ) == 0 )
{
m_iMedic = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
CBaseEntity *pMedic = UTIL_PlayerByIndex( m_iMedic );
int iTarget = engine->GetPlayerForUserID( event->GetInt( "targetid" ) );
CBaseEntity *pTarget = UTIL_PlayerByIndex( iTarget );
if ( pMedic && pTarget && pTarget == C_TFPlayer::GetLocalTFPlayer() )
{
m_bCharged = true;
m_iAssists = 0;
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
if ( iAssisterIndex > 0 && iAssisterIndex == m_iMedic )
{
C_TFPlayer *pMedic = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );
if ( pMedic && pMedic->MedicIsReleasingCharge() )
{
m_iAssists++;
if ( m_iAssists >= 3 )
{
IncrementCount();
}
}
}
}
private:
bool m_bCharged;
int m_iAssists;
int m_iMedic;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AssistChargeMedic, ACHIEVEMENT_TF_SCOUT_ASSIST_MEDIC, "TF_SCOUT_ASSIST_MEDIC", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StealSandwich : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
m_iHeavyID = -1;
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_stealsandvich" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
FStrEq( pszEventName, "teamplay_round_active" ) )
{
// If we died or respawned, reset...
m_iHeavyID = -1;
return;
}
else if ( Q_strcmp( event->GetName(), "player_stealsandvich" ) == 0 )
{
int iOwner = engine->GetPlayerForUserID( event->GetInt( "owner" ) );
if ( iOwner != m_iHeavyID )
return;
int iTarget = engine->GetPlayerForUserID( event->GetInt( "target" ) );
CBaseEntity *pTarget = UTIL_PlayerByIndex( iTarget );
if ( pTarget && pTarget == C_TFPlayer::GetLocalTFPlayer() )
{
IncrementCount();
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for killing a Heavy and taking his sandvich.
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
// Track the heavy: we have to be responsible for his death.
m_iHeavyID = engine->GetPlayerForUserID( pTFVictim->GetUserID() );
}
}
private:
int m_iHeavyID;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StealSandwich, ACHIEVEMENT_TF_SCOUT_STEAL_SANDWICH, "TF_SCOUT_STEAL_SANDWICH", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_KillChargedMedic : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// client fires an event for this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KillChargedMedic, ACHIEVEMENT_TF_SCOUT_KILL_CHARGED_MEDICS, "TF_SCOUT_KILL_CHARGED_MEDICS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_SurviveDamage : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_damaged" );
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
m_iDamageTotal = 0;
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "player_damaged" ) == 0 )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
m_iDamageTotal += event->GetInt( "amount" );
if ( pLocalPlayer && pLocalPlayer->IsAlive() && m_iDamageTotal >= 500 )
{
IncrementCount();
}
}
else if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
{
m_iDamageTotal = 0;
}
else if ( FStrEq( event->GetName(), "localplayer_respawn" ) )
{
m_iDamageTotal = 0;
}
}
private:
int m_iDamageTotal;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_SurviveDamage, ACHIEVEMENT_TF_SCOUT_SURVIVE_DAMAGE, "TF_SCOUT_SURVIVE_DAMAGE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_ThreeFlagCaptures : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "teamplay_flag_event" );
ListenForGameEvent( "teamplay_round_active" );
m_iFlagCaps = 0;
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "teamplay_flag_event" ) == 0 && event->GetInt( "eventtype" ) == TF_FLAGEVENT_CAPTURE )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer->entindex() == event->GetInt( "player" ))
{
m_iFlagCaps++;
if ( m_iFlagCaps >= 3 )
{
IncrementCount();
}
}
}
else if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
{
m_iFlagCaps = 0;
}
}
private:
int m_iFlagCaps;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_ThreeFlagCaptures, ACHIEVEMENT_TF_SCOUT_THREE_FLAGCAPS, "TF_SCOUT_THREE_FLAGCAPS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DoubleJumpKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 20 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
C_TFPlayer *pKiller = ToTFPlayer( pAttacker );
int iDoubleJumpKill = pKiller->m_Shared.GetAirDash();
if ( iDoubleJumpKill > 0 )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DoubleJumpKill, ACHIEVEMENT_TF_SCOUT_DOUBLEJUMP_KILL, "TF_SCOUT_DOUBLEJUMP_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_FlagCapGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 25 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "teamplay_flag_event" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "teamplay_flag_event" ) == 0 && event->GetInt( "eventtype" ) == TF_FLAGEVENT_CAPTURE )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer->entindex() == event->GetInt( "player" ))
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FlagCapGrind, ACHIEVEMENT_TF_SCOUT_FLAG_CAP_GRIND, "TF_SCOUT_FLAG_CAP_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_DodgeDamage : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
m_iDamageDodged = 0;
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_damage_dodged" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
FStrEq( pszEventName, "teamplay_round_active" ) )
{
// If we died or respawned, reset...
m_iDamageDodged = 0;
return;
}
else if ( Q_strcmp( event->GetName(), "player_damage_dodged" ) == 0 )
{
m_iDamageDodged += event->GetInt( "damage" );
if ( m_iDamageDodged > 1000 )
{
IncrementCount();
}
}
}
private:
int m_iDamageDodged;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_DodgeDamage, ACHIEVEMENT_TF_SCOUT_DODGE_DAMAGE, "TF_SCOUT_DODGE_DAMAGE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_KnockIntoTrain : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim )
return;
CTFPlayer *pLocalPlayer = ToTFPlayer( CBasePlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( pTFVictim->m_Shared.GetWeaponKnockbackID() == pLocalPlayer->GetUserID() )
{
int custom = event->GetInt( "customkill" );
int damagebits = event->GetInt( "damagebits" );
if ( ( damagebits & DMG_VEHICLE ) || // They were hit by a freakin' train!
( pAttacker && pAttacker->IsBrushModel() ) || // They were smashed by the world! Gah!
( !pAttacker || (pAttacker == pVictim) ) || // He killed himself!
( custom == TF_DMG_CUSTOM_SUICIDE ) ||
( custom == TF_DMG_CUSTOM_TRIGGER_HURT ) ) // A trigger-hurt got him!
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KnockIntoTrain, ACHIEVEMENT_TF_SCOUT_KNOCK_INTO_TRAIN, "TF_SCOUT_KNOCK_INTO_TRAIN", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_KillStunned : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim )
return;
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( pAttacker != pLocalPlayer )
{
int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
if ( iAssisterIndex <= 0 )
return;
CTFPlayer *pAssister = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );
if ( pAssister != pLocalPlayer )
return;
}
int iStunFlags = event->GetInt( "stun_flags" );
if ( ((iStunFlags & TF_STUN_CONTROLS) != 0) || ((iStunFlags & TF_STUN_LOSER_STATE) != 0) )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KillStunned, ACHIEVEMENT_TF_SCOUT_KILL_STUNNED, "TF_SCOUT_KILL_STUNNED", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StunIntoTrain : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim )
return;
// Achievement for causing someone we stunned to die by the environment.
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
int iStunFlags = event->GetInt( "stun_flags" );
bool bLegalStun = ((iStunFlags & TF_STUN_CONTROLS) != 0) || ((iStunFlags & TF_STUN_LOSER_STATE) != 0);
if ( bLegalStun && (pTFVictim->m_Shared.GetStunner() == pLocalPlayer) )
{
int custom = event->GetInt( "customkill" );
int damagebits = event->GetInt( "damagebits" );
if ( ( damagebits & DMG_VEHICLE ) || // They were hit by a freakin' train!
( pAttacker && pAttacker->IsBrushModel() ) || // They were smashed by the world! Gah!
( !pAttacker || (pAttacker == pVictim) ) || // He killed himself!
( custom == TF_DMG_CUSTOM_SUICIDE ) ||
( custom == TF_DMG_CUSTOM_TRIGGER_HURT ) ) // A trigger-hurt got him!
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunIntoTrain, ACHIEVEMENT_TF_SCOUT_STUN_INTO_TRAIN, "TF_SCOUT_STUN_INTO_TRAIN", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StunUberEnemies : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 2 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_stunned" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( pszEventName, "player_stunned" ) )
{
CTFPlayer *pStunner = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "stunner" ) ) ) );
CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "victim" ) ) ) );
if ( pStunner == pLocalPlayer )
{
if ( pVictim && pVictim->IsPlayerClass( TF_CLASS_MEDIC ) && pVictim->MedicGetChargeLevel() >= 1.0 )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunUberEnemies, ACHIEVEMENT_TF_SCOUT_STUN_UBER_ENEMIES, "TF_SCOUT_STUN_UBER_ENEMIES", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StunCappingEnemies : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_stunned" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( pszEventName, "player_stunned" ) )
{
CTFPlayer *pStunner = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "stunner" ) ) ) );
CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "victim" ) ) ) );
if ( (pStunner == pLocalPlayer) &&
pVictim && event->GetBool( "victim_capping" ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunCappingEnemies, ACHIEVEMENT_TF_SCOUT_STUN_CAPPING_ENEMIES, "TF_SCOUT_STUN_CAPPING_ENEMIES", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_MaxStuns : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_stunned" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( pszEventName, "player_stunned" ) )
{
CTFPlayer *pStunner = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "stunner" ) ) ) );
CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "victim" ) ) ) );
if ( (pStunner == pLocalPlayer) &&
pVictim && event->GetBool( "big_stun" ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_MaxStuns, ACHIEVEMENT_TF_SCOUT_MAX_STUNS, "TF_SCOUT_MAX_STUNS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StunScoutWithTheirBall : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StunScoutWithTheirBall, ACHIEVEMENT_TF_SCOUT_STUN_SCOUT_WITH_THEIR_BALL, "TF_SCOUT_STUN_SCOUT_WITH_THEIR_BALL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_KillInDodgeCooldown : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for killing another scout under the effect Crit-a-Cola
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SCOUT ) && pTFVictim->m_Shared.InCond( TF_COND_ENERGY_BUFF ) )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KillInDodgeCooldown, ACHIEVEMENT_TF_SCOUT_KILL_IN_DODGE_COOLDOWN, "TF_SCOUT_KILL_IN_DODGE_COOLDOWN", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_KillFromBehind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
// Shamelessly stolen from the knife!
float DotProductToTarget( CBaseEntity *pAttacker, CBaseEntity *pTarget )
{
Assert( pTarget );
// Get the forward view vector of the target, ignore Z
Vector vecVictimForward;
AngleVectors( pTarget->EyeAngles(), &vecVictimForward, NULL, NULL );
vecVictimForward.z = 0.0f;
vecVictimForward.NormalizeInPlace();
// Get a vector from my origin to my targets origin
Vector vecToTarget;
vecToTarget = pTarget->WorldSpaceCenter() - pAttacker->WorldSpaceCenter();
vecToTarget.z = 0.0f;
vecToTarget.NormalizeInPlace();
return DotProduct( vecVictimForward, vecToTarget );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for killing a bunch of enemies from behind with the scattergun double.
if ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN )
{
CTFScatterGun *pScattergun = (CTFScatterGun *)ToTFPlayer( C_TFPlayer::GetLocalPlayer() )->Weapon_OwnsThisID( TF_WEAPON_SCATTERGUN );
if ( pScattergun && pScattergun->HasKnockback() &&
( DotProductToTarget( pAttacker, pVictim ) > -0.1 ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_KillFromBehind, ACHIEVEMENT_TF_SCOUT_KILL_FROM_BEHIND, "TF_SCOUT_KILL_FROM_BEHIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_CaptureLastPoint : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
m_bRecentCapper = false;
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_point_captured" );
ListenForGameEvent( "teamplay_round_win" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
{
m_bRecentCapper = false;
int iTeam = event->GetInt( "team" );
if ( iTeam == pLocalPlayer->GetTeamNumber() )
{
const char *cappers = event->GetString( "cappers" );
for ( int i=0; i<Q_strlen( cappers ); i++ )
{
int iPlayerIndex = (int) cappers[i];
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pPlayer == pLocalPlayer )
{
m_bRecentCapper = true;
}
}
}
}
else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
{
// If we're the winners and we were involved in capping the last point, we get this achievement.
int iTeam = event->GetInt( "team" );
if ( (iTeam == pLocalPlayer->GetTeamNumber()) &&
m_bRecentCapper &&
(TFGameRules()->GetGameType() == TF_GAMETYPE_CP) )
{
IncrementCount();
}
m_bRecentCapper = false;
}
}
bool m_bRecentCapper;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CaptureLastPoint, ACHIEVEMENT_TF_SCOUT_CAPTURE_LAST_POINT, "TF_SCOUT_CAPTURE_LAST_POINT", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_CaptureThreePoints : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
m_iPointsCapped = 0;
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_point_captured" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
// only on maps with capture points
if ( TFGameRules() && TFGameRules()->GetGameType() != TF_GAMETYPE_CP && TFGameRules()->GetGameType() != TF_GAMETYPE_ARENA )
return;
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
FStrEq( pszEventName, "teamplay_round_active") )
{
m_iPointsCapped = 0;
}
else if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
{
int iTeam = event->GetInt( "team" );
if ( iTeam == pLocalPlayer->GetTeamNumber() )
{
const char *cappers = event->GetString( "cappers" );
for ( int i=0; i<Q_strlen( cappers ); i++ )
{
int iPlayerIndex = (int) cappers[i];
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pPlayer == pLocalPlayer )
{
m_iPointsCapped++;
}
}
}
if ( m_iPointsCapped == 3 )
{
IncrementCount();
}
}
}
int m_iPointsCapped;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CaptureThreePoints, ACHIEVEMENT_TF_SCOUT_CAPTURE_THREE_POINTS, "TF_SCOUT_CAPTURE_THREE_POINTS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_FastCap : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_point_startcapture" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
// only on maps with capture points
if ( TFGameRules() && TFGameRules()->GetGameType() != TF_GAMETYPE_CP && TFGameRules()->GetGameType() != TF_GAMETYPE_ARENA )
return;
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
{
const char *cappers = event->GetString( "cappers" );
for ( int i=0; i<Q_strlen( cappers ); i++ )
{
int iPlayerIndex = (int) cappers[i];
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pPlayer == pLocalPlayer )
{
if ( event->GetFloat( "captime" ) < 1.0 )
{
IncrementCount();
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_FastCap, ACHIEVEMENT_TF_SCOUT_FAST_CAP, "TF_SCOUT_FAST_CAP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_StartAndFinishCap : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 10 );
SetStoreProgressInSteam( true );
m_Points.Purge();
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_point_startcapture" );
ListenForGameEvent( "teamplay_point_captured" );
ListenForGameEvent( "teamplay_capture_broken" );
ListenForGameEvent( "teamplay_round_active" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
// Achievement for initiating captures that ultimately succeed.
if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
{
const char *cappers = event->GetString( "cappers" );
for ( int i=0; i<Q_strlen( cappers ); i++ )
{
int iPlayerIndex = (int) cappers[i];
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pPlayer == pLocalPlayer ) // Are we one of the cappers?
{
// We started capping this point.
m_Points.AddToTail( event->GetInt( "cp" ) );
}
}
}
else if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
{
int iIndex = m_Points.Find( event->GetInt( "cp" ) );
if ( iIndex > -1 ) // Is the point one we started capping?
{
int iTeam = event->GetInt( "team" );
if ( iTeam == pLocalPlayer->GetTeamNumber() )
{
m_Points.Remove( iIndex );
IncrementCount();
}
}
}
else if ( FStrEq( pszEventName, "teamplay_capture_broken" ) )
{
// Our team failed to complete the capture.
int iIndex = m_Points.Find( event->GetInt( "cp" ) );
if ( iIndex > -1 )
{
m_Points.Remove( iIndex );
}
}
else if ( FStrEq( pszEventName, "teamplay_round_active" ) )
{
// Reset tracking at the start of a new round.
m_Points.Purge();
}
}
CUtlVector< int > m_Points;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_StartAndFinishCap, ACHIEVEMENT_TF_SCOUT_START_AND_FINISH_CAP, "TF_SCOUT_START_AND_FINISH_CAP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_BlockCaps : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_capture_blocked" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
// Achievement for blocking captures!
if ( FStrEq( pszEventName, "teamplay_capture_blocked" ) )
{
int iBlocker = event->GetInt( "blocker" );
if ( (iBlocker == pLocalPlayer->entindex()) &&
((TFGameRules()->GetGameType() == TF_GAMETYPE_CP) ||
(TFGameRules()->GetGameType() == TF_GAMETYPE_ARENA)) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_BlockCaps, ACHIEVEMENT_TF_SCOUT_BLOCK_CAPS, "TF_SCOUT_BLOCK_CAPS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_CarrierKillCarrier : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_flag_event" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
// Achievement for blocking captures!
if ( FStrEq( pszEventName, "teamplay_flag_event" ) )
{
int iType = event->GetInt( "eventtype" );
if ( iType == TF_FLAGEVENT_DEFEND )
{
int iPlayer = event->GetInt( "player" );
if ( (iPlayer == pLocalPlayer->entindex()) && pLocalPlayer->HasTheFlag() )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CarrierKillCarrier, ACHIEVEMENT_TF_SCOUT_CARRIER_KILL_CARRIER, "TF_SCOUT_CARRIER_KILL_CARRIER", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_CapFlagWithoutAttacking : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_flag_event" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
// Achievement for capping the flag without shooting anyone.
if ( FStrEq( pszEventName, "teamplay_flag_event" ) )
{
int iType = event->GetInt( "eventtype" );
if ( iType == TF_FLAGEVENT_CAPTURE )
{
int iPlayer = event->GetInt( "player" );
if ( (iPlayer == pLocalPlayer->entindex()) && !pLocalPlayer->HasFiredWeapon() )
{
IncrementCount();
}
}
else if ( iType == TF_FLAGEVENT_PICKUP )
{
int iPlayer = event->GetInt( "player" );
if ( iPlayer == pLocalPlayer->entindex() )
{
pLocalPlayer->SetFiredWeapon( false );
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_CapFlagWithoutAttacking, ACHIEVEMENT_TF_SCOUT_CAP_FLAG_WITHOUT_ATTACKING, "TF_SCOUT_CAP_FLAG_WITHOUT_ATTACKING", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_LongDistanceRunner : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 25000 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_death" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
// Achievement for running ...
bool bUpdate = false;
if ( FStrEq( pszEventName, "player_death" ) )
{
int iVictimID = event->GetInt( "userid" );
if ( pLocalPlayer && (iVictimID == pLocalPlayer->GetUserID()) )
{
bUpdate = true;
}
}
else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
{
bUpdate = true;
}
if ( bUpdate )
{
float fMeters = pLocalPlayer->GetMetersRan();
IncrementCount( ceil( fMeters ) );
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_LongDistanceRunner, ACHIEVEMENT_TF_SCOUT_LONG_DISTANCE_RUNNER, "TF_SCOUT_LONG_DISTANCE_RUNNER", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_TauntKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
m_iTargetID = 0;
m_vSlamOrigin = Vector(0,0,0);
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "scout_grand_slam" );
ListenForGameEvent( "scout_slamdoll_landed" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
FStrEq( pszEventName, "teamplay_round_active" ) )
{
// If we died or respawned, reset...
m_iTargetID = 0;
m_vSlamOrigin = Vector(0,0,0);
return;
}
else if ( FStrEq( pszEventName, "scout_grand_slam" ) )
{
int iScoutID = event->GetInt( "scout_id" );
if ( pLocalPlayer && (iScoutID == pLocalPlayer->GetUserID()) )
{
m_iTargetID = event->GetInt( "target_id" ); // target_id is a userid
int iTarget = engine->GetPlayerForUserID( m_iTargetID );
CBaseEntity *pTarget = UTIL_PlayerByIndex( iTarget );
if ( pTarget )
{
m_vSlamOrigin = pTarget->GetAbsOrigin();
}
}
}
else if ( FStrEq( pszEventName, "scout_slamdoll_landed" ) )
{
int iTargetIndex = event->GetInt( "target_index" ); // target_index is an entindex
EHANDLE hPlayer = cl_entitylist->GetNetworkableHandle( iTargetIndex );
if ( !hPlayer )
return;
C_TFPlayer *pPlayer = dynamic_cast< C_TFPlayer* >( hPlayer.Get() );
if ( pPlayer && (m_iTargetID == pPlayer->GetUserID()) &&
(m_vSlamOrigin != Vector(0,0,0)) )
{
float x = event->GetFloat( "x" );
float y = event->GetFloat( "y" );
float z = event->GetFloat( "z" );
Vector vHitOrigin = Vector(x,y,z);
float fDist = (vHitOrigin - m_vSlamOrigin).Length();
if ( fDist > 1000 )
{
IncrementCount();
}
}
}
}
int m_iTargetID;
Vector m_vSlamOrigin;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_TauntKill, ACHIEVEMENT_TF_SCOUT_TAUNT_KILL, "TF_SCOUT_TAUNT_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AchieveProgress1 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFScout_AchieveProgress1, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 10, ACHIEVEMENT_TF_SCOUT_START_RANGE, ACHIEVEMENT_TF_SCOUT_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AchieveProgress1, ACHIEVEMENT_TF_SCOUT_ACHIEVE_PROGRESS1, "TF_SCOUT_ACHIEVE_PROGRESS1", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AchieveProgress2 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFScout_AchieveProgress2, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 16, ACHIEVEMENT_TF_SCOUT_START_RANGE, ACHIEVEMENT_TF_SCOUT_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AchieveProgress2, ACHIEVEMENT_TF_SCOUT_ACHIEVE_PROGRESS2, "TF_SCOUT_ACHIEVE_PROGRESS2", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_AchieveProgress3 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFScout_AchieveProgress3, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 22, ACHIEVEMENT_TF_SCOUT_START_RANGE, ACHIEVEMENT_TF_SCOUT_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_AchieveProgress3, ACHIEVEMENT_TF_SCOUT_ACHIEVE_PROGRESS3, "TF_SCOUT_ACHIEVE_PROGRESS3", 5 );
// Receive the DamageDodged user message and send out a clientside event for achievements to hook.
void __MsgFunc_DamageDodged( bf_read &msg )
{
int iDamage = msg.ReadShort();
IGameEvent *event = gameeventmanager->CreateEvent( "player_damage_dodged" );
if ( event )
{
event->SetInt( "damage", iDamage );
gameeventmanager->FireEventClientSide( event );
}
}
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_BackscatterKillSpyGrind : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 20 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) )
{
if ( ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN ) && ( event->GetInt( "damagebits" ) & DMG_CRITICAL ) )
{
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
if ( pTFAttacker )
{
CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
if ( pWeapon )
{
int iMiniCritBackAttack = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
if ( iMiniCritBackAttack > 0 )
{
IncrementCount();
}
}
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_BackscatterKillSpyGrind, ACHIEVEMENT_TF_SCOUT_BACKSCATTER_KILL_SPY_GRIND, "TF_SCOUT_BACKSCATTER_KILL_SPY_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_BackscatterKillHeavyMedicPair : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_LISTEN_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
m_hTargets.Purge();
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
FStrEq( pszEventName, "teamplay_round_active" ) )
{
m_hTargets.Purge();
}
}
int GetTargetIndex( CBaseEntity *pTarget )
{
for ( int i = 0; i < m_hTargets.Count(); i++ )
{
if ( m_hTargets[i].hTarget == pTarget )
return i;
}
return -1;
}
void AddNewTarget( CBaseEntity *pTarget )
{
if ( !pTarget )
return;
// see if the target is already in our list or get a new index
int iTargetIndex = GetTargetIndex( pTarget );
if ( iTargetIndex == -1 )
{
iTargetIndex = m_hTargets.AddToTail();
}
m_hTargets[iTargetIndex].hTarget = pTarget;
m_hTargets[iTargetIndex].flTimeToBeat = gpGlobals->curtime + 20.0f; // 20 seconds to kill the target
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN )
{
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
if ( pTFAttacker )
{
CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
if ( pWeapon )
{
int iMiniCritBackAttack = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
if ( iMiniCritBackAttack > 0 )
{
// is this victim in our list of targets?
int index = GetTargetIndex( pVictim );
if ( index != -1 )
{
// did we beat the time?
if ( m_hTargets[index].flTimeToBeat > gpGlobals->curtime )
{
IncrementCount();
}
}
else
{
CTFPlayer *pNewTarget = NULL;
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pNewTarget = ToTFPlayer( UTIL_PlayerByIndex( i ) );
if ( pNewTarget && pNewTarget->IsPlayerClass( TF_CLASS_MEDIC ) && ( pNewTarget->MedicGetHealTarget() == pTFVictim ) )
{
// add all of his Medics to our list of targets (could be more than one Medic)
AddNewTarget( pNewTarget );
}
}
}
else if ( pTFVictim->IsPlayerClass( TF_CLASS_MEDIC ) )
{
pNewTarget = ToTFPlayer( pTFVictim->MedicGetHealTarget() );
if ( pNewTarget && ( pNewTarget->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) ) )
{
AddNewTarget( pNewTarget );
}
}
}
}
}
}
}
}
// is this victim in our list of targets?
int index = GetTargetIndex( pVictim );
if ( index != -1 )
{
m_hTargets.Remove( index );
}
}
private:
struct targets_t
{
EHANDLE hTarget;
float flTimeToBeat;
};
CUtlVector<targets_t> m_hTargets;
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_BackscatterKillHeavyMedicPair, ACHIEVEMENT_TF_SCOUT_BACKSCATTER_KILL_HEAVY_MEDIC_PAIR, "TF_SCOUT_BACKSCATTER_KILL_HEAVY_MEDIC_PAIR", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFScout_BackscatterKillFriendsGrind : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 20 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
{
if ( ( event->GetInt( "weaponid" ) == TF_WEAPON_SCATTERGUN ) && ( event->GetInt( "damagebits" ) & DMG_CRITICAL ) )
{
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
if ( pTFAttacker )
{
CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
if ( pWeapon )
{
int iMiniCritBackAttack = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
if ( iMiniCritBackAttack > 0 )
{
if ( !steamapicontext->SteamFriends() || !steamapicontext->SteamUtils() || !g_pGameRules->IsMultiplayer() )
return;
player_info_t pi;
if ( !engine->GetPlayerInfo( pVictim->entindex(), &pi ) )
return;
if ( !pi.friendsID )
return;
// check and see if they're on the local player's friends list
CSteamID steamID( pi.friendsID, 1, GetUniverse(), k_EAccountTypeIndividual );
if ( steamapicontext->SteamFriends()->HasFriend( steamID, k_EFriendFlagImmediate ) )
{
IncrementCount();
}
}
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFScout_BackscatterKillFriendsGrind, ACHIEVEMENT_TF_SCOUT_BACKSCATTER_KILL_FRIENDS_GRIND, "TF_SCOUT_BACKSCATTER_KILL_FRIENDS_GRIND", 5 );
#endif // CLIENT_DLL