d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
91 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 31586ce622
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '31586ce622'
${ noResults }
source-engine/game/shared/tf/achievements_tf_engineer.cpp

1099 lines
36 KiB
Raw Blame History

//========= 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_obj_sentrygun.h"
//======================================================================================================================================
// ENGINEER ACHIEVEMENT PACK
//======================================================================================================================================
//----------------------------------------------------------------------------------------------------------------
// Use a revenge crit to kill the player that destroyed your sentry.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_RevengeCritForSentryKiller : public CBaseTFAchievement
{
protected:
CBaseEntity* m_pSentryKiller;
public:
DECLARE_CLASS( CAchievementTFEngineer_RevengeCritForSentryKiller, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
ListenForGameEvent( "object_destroyed" );
ResetTracking();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "object_destroyed" );
ResetTracking();
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !m_pSentryKiller || !pVictim || !pAttacker )
return;
// if the local player has killed the thing that killed it's sentry,
// give the achievement
if ( pAttacker == C_BasePlayer::GetLocalPlayer() &&
pVictim == m_pSentryKiller &&
event->GetInt( "customkill" ) == TF_DMG_CUSTOM_SHOTGUN_REVENGE_CRIT )
{
AwardAchievement();
}
}
virtual void FireGameEvent_Internal( IGameEvent *event )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
// if the object getting killed is the local player's sentry gun,
// store away who the killer was
if ( FStrEq( event->GetName(), "object_destroyed" ) )
{
int iObject = event->GetInt( "objecttype" );
if ( iObject == OBJ_SENTRYGUN )
{
int iEngineerIdx = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
CBaseEntity *pOwner = UTIL_PlayerByIndex( iEngineerIdx );
if ( pOwner == pLocalPlayer )
{
int iAttackerIdx = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
CBaseEntity *pKiller = UTIL_PlayerByIndex( iAttackerIdx );
if ( pKiller != NULL )
{
m_pSentryKiller = pKiller;
}
}
}
}
}
void ResetTracking()
{
m_pSentryKiller = NULL;
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_RevengeCritForSentryKiller, ACHIEVEMENT_TF_ENGINEER_REVENGE_CRIT_SENTRY_KILLER, "TF_ENGINEER_REVENGE_CRIT_SENTRY_KILLER", 5 );
//----------------------------------------------------------------------------------------------------------------
// Kill X enemies outside the normal sentry gun range using manual control.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_ManualSentryKillsBeyondRange : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_ManualSentryKillsBeyondRange, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 10 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_ManualSentryKillsBeyondRange, ACHIEVEMENT_TF_ENGINEER_MANUAL_SENTRY_KILLS_BEYOND_RANGE, "TF_ENGINEER_MANUAL_SENTRY_KILLS_BEYOND_RANGE", 5 );
//----------------------------------------------------------------------------------------------------------------
// Have a manual sentry absorb X amount of damage during the course of its life.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_ManualSentryAbsorbDamage : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_ManualSentryAbsorbDamage, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_ManualSentryAbsorbDamage, ACHIEVEMENT_TF_ENGINEER_MANUAL_SENTRY_ABSORB_DMG, "TF_ENGINEER_MANUAL_SENTRY_ABSORB_DMG", 5 );
//----------------------------------------------------------------------------------------------------------------
// Help a teammate build a structure.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_HelpTeammateBuildStructure : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_HelpTeammateBuildStructure, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_HelpTeammateBuildStructure, ACHIEVEMENT_TF_ENGINEER_HELP_BUILD_STRUCTURE, "TF_ENGINEER_HELP_BUILD_STRUCTURE", 5 );
//----------------------------------------------------------------------------------------------------------------
// Shotgun kill an enemy recently damaged by your sentry gun
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_ShotgunKillPreviousSentryTarget : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_ShotgunKillPreviousSentryTarget, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_ShotgunKillPreviousSentryTarget, ACHIEVEMENT_TF_ENGINEER_SHOTGUN_KILL_PREV_SENTRY_TARGET, "TF_ENGINEER_SHOTGUN_KILL_PREV_SENTRY_TARGET", 5 );
//----------------------------------------------------------------------------------------------------------------
// Have your sentry kill the enemy that just killed you within X seconds.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_SentryAvengesYou : public CBaseTFAchievement
{
protected:
CBaseEntity* m_pPlayerKiller;
float m_flPlayerDeathStartTime;
public:
DECLARE_CLASS( CAchievementTFEngineer_SentryAvengesYou, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
ListenForGameEvent( "object_destroyed" );
ResetTracking();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "object_destroyed" );
ResetTracking();
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !pVictim || !pAttacker || pVictim == pAttacker )
return;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
static const float kRevengeTimeLimit = 10.0f;
// if the local player has been killed (by someone else), keep track of the killer
if ( pVictim == pLocalPlayer )
{
// I was killed by my own sentry while testing, so I figure I meant as well put this check in
if ( pLocalPlayer->GetTeam() == pAttacker->GetTeam() )
{
ResetTracking();
return;
}
m_flPlayerDeathStartTime = gpGlobals->curtime;
m_pPlayerKiller = pAttacker;
}
// if the sentry gun killed the player's killer within 10 seconds of the player's death, award the achievement
else if ( pVictim == m_pPlayerKiller && m_flPlayerDeathStartTime != 0.0f && (gpGlobals->curtime - m_flPlayerDeathStartTime) < kRevengeTimeLimit )
{
int nInflictorEntIndex = event->GetInt( "inflictor_entindex" );
C_BaseEntity *pRealInflictor = ClientEntityList().GetEnt( nInflictorEntIndex );
C_ObjectSentrygun *pSentry = dynamic_cast< C_ObjectSentrygun * >( pRealInflictor );
C_TFProjectile_SentryRocket *pSentryRocket = dynamic_cast< C_TFProjectile_SentryRocket * >( pRealInflictor );
if ( ( pSentry && pSentry->GetOwner() == pLocalPlayer ) ||
( pSentryRocket && pSentryRocket->GetOwnerEntity() == pLocalPlayer ) )
{
ResetTracking();
AwardAchievement();
}
}
}
virtual void FireGameEvent_Internal( IGameEvent *event )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
// if the object getting killed is the local player's sentry gun,
// reset tracking
if ( FStrEq( event->GetName(), "object_destroyed" ) )
{
int iObject = event->GetInt( "objecttype" );
if ( iObject == OBJ_SENTRYGUN )
{
int iEngineerIdx = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
CBaseEntity *pOwner = UTIL_PlayerByIndex( iEngineerIdx );
if ( pOwner == pLocalPlayer )
{
ResetTracking();
}
}
}
}
void ResetTracking()
{
m_pPlayerKiller = NULL;
m_flPlayerDeathStartTime = 0.0f;
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_SentryAvengesYou, ACHIEVEMENT_TF_ENGINEER_SENTRY_AVENGES_YOU, "TF_ENGINEER_SENTRY_AVENGES_YOU", 5 );
//----------------------------------------------------------------------------------------------------------------
// Shotgun kill an enemy recently damaged by your sentry gun
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_RepairRecentlyDamagedSentryWhileBeingHealed : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_RepairRecentlyDamagedSentryWhileBeingHealed, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_RepairRecentlyDamagedSentryWhileBeingHealed, ACHIEVEMENT_TF_ENGINEER_REPAIR_SENTRY_W_MEDIC, "TF_ENGINEER_REPAIR_SENTRY_W_MEDIC", 5 );
//----------------------------------------------------------------------------------------------------------------
// Get X sentry kills on players capturing a point
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_SentryKillPlayersCapturingPoint : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_SentryKillPlayersCapturingPoint, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 25 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_SentryKillPlayersCapturingPoint, ACHIEVEMENT_TF_ENGINEER_SENTRY_KILL_CAPS, "TF_ENGINEER_SENTRY_KILL_CAPS", 5 );
//----------------------------------------------------------------------------------------------------------------
// Destroy X sappers on buildings that you do not own
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_DestroySappersOnNonOwnedBuildings : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_DestroySappersOnNonOwnedBuildings, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 25 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_DestroySappersOnNonOwnedBuildings, ACHIEVEMENT_TF_ENGINEER_DESTROY_SAPPERS, "TF_ENGINEER_DESTROY_SAPPERS", 5 );
//----------------------------------------------------------------------------------------------------------------
// Reload X rounds done to a sentry under manual control by another Engineer. (could be health / metal / something)
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_HelpManualSentry : public CBaseTFAchievement
{
public:
DECLARE_CLASS( CAchievementTFEngineer_HelpManualSentry, CBaseAchievement );
virtual void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_HelpManualSentry, ACHIEVEMENT_TF_ENGINEER_HELP_MANUAL_SENTRY, "TF_ENGINEER_HELP_MANUAL_SENTRY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_RevengeCritLife : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
ResetTracking();
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
FStrEq( event->GetName(), "localplayer_respawn" ) )
{
ResetTracking();
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
int customdmg = event->GetInt( "customkill" );
if ( customdmg == TF_DMG_CUSTOM_SHOTGUN_REVENGE_CRIT )
{
m_iKills++;
if ( m_iKills >= 3 )
{
AwardAchievement();
}
}
}
void ResetTracking()
{
m_iKills = 0;
}
private:
int m_iKills;
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_RevengeCritLife, ACHIEVEMENT_TF_ENGINEER_REVENGE_CRIT_LIFE, "TF_ENGINEER_REVENGE_CRIT_LIFE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_TeleportGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_teleported" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_teleported" ) )
{
int userid = event->GetInt( "userid" );
int builderid = event->GetInt( "builderid" );
float dist = event->GetFloat( "dist" );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer->GetUserID() == builderid && pLocalPlayer->GetUserID() != userid && dist > 1200 )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_TeleportGrind, ACHIEVEMENT_TF_ENGINEER_TELEPORT_GRIND, "TF_ENGINEER_TELEPORT_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievemeentTFEngineer_DispenserExtinguish : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 20 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_extinguished" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_extinguished" ) )
{
int victimid = event->GetInt( "victim" );
int healerid = event->GetInt( "healer" );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer->entindex() == healerid && pLocalPlayer->entindex() != victimid && pLocalPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievemeentTFEngineer_DispenserExtinguish, ACHIEVEMENT_TF_ENGINEER_DISPENSER_EXTINGUISH, "TF_ENGINEER_DISPENSER_EXTINGUISH", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_ManualCloakedSpyKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 3 );
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 ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) && pTFVictim->m_Shared.InCond( TF_COND_STEALTHED ) )
{
int customdmg = event->GetInt( "customkill" );
if ( customdmg == TF_DMG_CUSTOM_PLAYER_SENTRY )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_ManualCloakedSpyKill, ACHIEVEMENT_TF_ENGINEER_MANUAL_CLOAKED_SPY_KILL, "TF_ENGINEER_MANUAL_CLOAKED_SPY_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_UpgradeBuildings : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_upgradedobject" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_upgradedobject" ) )
{
int userid = event->GetInt( "userid" );
bool isbuilder = event->GetInt( "isbuilder" );
CBasePlayer *pPlayer = UTIL_PlayerByUserId( userid );
if ( pPlayer == C_TFPlayer::GetLocalPlayer() && !isbuilder )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_UpgradeBuildings, ACHIEVEMENT_TF_ENGINEER_UPGRADE_BUILDINGS, "TF_ENGINEER_UPGRADE_BUILDINGS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_SentryKillLifetimeGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 5000 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( pAttacker != pLocalPlayer )
return;
const char* killer_weapon_name = event->GetString( "weapon" );
if ( ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_sentryrocket" ) ) ||
( 0 == Q_strncmp( killer_weapon_name, "obj_sentrygun", 13 ) ) ||
( 0 == Q_strcmp( killer_weapon_name, "wrangler_kill" ) ) ||
( 0 == Q_strcmp( killer_weapon_name, "obj_minisentry" ) ) )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_SentryKillLifetimeGrind, ACHIEVEMENT_TF_ENGINEER_SENTRY_KILL_LIFETIME_GRIND, "TF_ENGINEER_SENTRY_KILL_LIFETIME_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_DispenserHealGroup : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_DispenserHealGroup, ACHIEVEMENT_TF_ENGINEER_DISPENSER_HEAL_GROUP, "TF_ENGINEER_DISPENSER_HEAL_GROUP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_WasteMetalGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 10000 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_WasteMetalGrind, ACHIEVEMENT_TF_ENGINEER_WASTE_METAL_GRIND, "TF_ENGINEER_WASTE_METAL_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_KillFlagCarriers : 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 )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim != pAttacker && pTFVictim->HasTheFlag() )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_KillFlagCarriers, ACHIEVEMENT_TF_ENGINEER_KILL_FLAG_CARRIERS, "TF_ENGINEER_KILL_FLAG_CARRIERS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_KillDisguisedSpy : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
}
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_DISGUISED ) &&
event->GetInt( "weaponid" ) == TF_WEAPON_WRENCH )
{
AwardAchievement();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_KillDisguisedSpy, ACHIEVEMENT_TF_ENGINEER_KILL_DISGUISED_SPY, "TF_ENGINEER_KILL_DISGUISED_SPY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_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( CAchievementTFEngineer_FreezeTaunt, ACHIEVEMENT_TF_ENGINEER_FREEZECAM_TAUNT, "TF_ENGINEER_FREEZECAM_TAUNT", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_FreezeWithSentry : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// Give opponents freezecams of you w/ your sentry
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_FreezeWithSentry, ACHIEVEMENT_TF_ENGINEER_FREEZECAM_SENTRY, "TF_ENGINEER_FREEZECAM_SENTRY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_KillSpyTwoSappers : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
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" ) )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( event->GetInt( "objecttype" ) == OBJ_ATTACHMENT_SAPPER &&
event->GetInt( "attacker" ) == pLocalPlayer->GetUserID() )
{
SetTime();
m_iSapperCount++;
CheckCompletion();
}
}
}
void ResetTracking()
{
m_iDeadSpyID = -1;
m_flStartTime = -1;
m_iSapperCount = 0;
}
void SetTime()
{
if ( gpGlobals->curtime - m_flStartTime > 10 )
{
// The player took too long.
ResetTracking();
}
if ( m_flStartTime == -1 )
{
// Start the timer over now.
m_flStartTime = gpGlobals->curtime;
}
}
void CheckCompletion()
{
int iSpyIdx = engine->GetPlayerForUserID( m_iDeadSpyID );
CTFPlayer *pSpy = dynamic_cast<CTFPlayer*>( UTIL_PlayerByIndex( iSpyIdx ) );
if ( !pSpy )
return;
if ( m_iSapperCount < 2 )
return;
AwardAchievement();
}
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 ) )
{
SetTime();
m_iDeadSpyID = pTFVictim->GetUserID();
CheckCompletion();
}
}
float m_flStartTime;
int m_iDeadSpyID;
int m_iSapperCount;
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_KillSpyTwoSappers, ACHIEVEMENT_TF_ENGINEER_KILL_SPY_TWO_SAPPERS, "TF_ENGINEER_KILL_SPY_TWO_SAPPERS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_RemoveSapperLongDist : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
ListenForGameEvent( "object_destroyed" );
ListenForGameEvent( "player_sapped_object" );
ResetTracking();
}
void ResetTracking()
{
iSapperIndex = -1;
}
void FireGameEvent_Internal( IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( event->GetName(), "player_sapped_object" ) )
{
if ( pLocalPlayer->GetUserID() == event->GetInt( "ownerid" ) )
{
m_vecStart = pLocalPlayer->GetAbsOrigin();
iSapperIndex = event->GetInt( "sapperid" );
}
}
else if ( FStrEq( event->GetName(), "object_destroyed" ) )
{
if ( event->GetInt( "objecttype" ) == OBJ_ATTACHMENT_SAPPER &&
event->GetInt( "attacker" ) == pLocalPlayer->GetUserID() &&
event->GetInt( "index" ) == iSapperIndex )
{
float flDist = pLocalPlayer->GetAbsOrigin().DistTo( m_vecStart );
if ( flDist > 700 )
{
AwardAchievement();
}
}
}
}
Vector m_vecStart;
int iSapperIndex;
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_RemoveSapperLongDist, ACHIEVEMENT_TF_ENGINEER_REMOVE_SAPPER_LONG_DIST, "TF_ENGINEER_REMOVE_SAPPER_LONG_DIST", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_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 )
{
int iEvent = event->GetInt( "customkill" );
if ( ( iEvent == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_GUITAR_SMASH ) || ( iEvent == TF_DMG_CUSTOM_TAUNTATK_ALLCLASS_GUITAR_RIFF ) )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_TauntKill, ACHIEVEMENT_TF_ENGINEER_TAUNT_KILL, "TF_ENGINEER_TAUNT_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_DestroyStickies : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_DestroyStickies, ACHIEVEMENT_TF_ENGINEER_DESTROY_STICKIES, "TF_ENGINEER_DESTROY_STICKIES", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_KillSnipersSentry : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 10 );
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 ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SNIPER ) &&
event->GetInt( "customkill" ) == TF_DMG_CUSTOM_PLAYER_SENTRY )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_KillSnipersSentry, ACHIEVEMENT_TF_ENGINEER_KILL_SNIPERS_SENTRY, "TF_ENGINEER_KILL_SNIPERS_SENTRY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_KillSentryWithSentry : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
ListenForGameEvent( "object_destroyed" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( FStrEq( event->GetName(), "object_destroyed" ) )
{
const char* weaponstr = event->GetString( "weapon" );
if ( event->GetInt( "objecttype" ) == OBJ_SENTRYGUN &&
event->GetInt( "attacker" ) == pLocalPlayer->GetUserID() &&
FStrEq( weaponstr, "wrangler_kill" ) )
{
AwardAchievement();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_KillSentryWithSentry, ACHIEVEMENT_TF_ENGINEER_KILL_SENTRY_WITH_SENTRY, "TF_ENGINEER_KILL_SENTRY_WITH_SENTRY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_MoveSentryGetKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_MoveSentryGetKill, ACHIEVEMENT_TF_ENGINEER_MOVE_SENTRY_GET_KILL, "TF_ENGINEER_MOVE_SENTRY_GET_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_BuildingCarry : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1000 );
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 carrying buildings ...
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( CAchievementTFEngineer_BuildingCarry, ACHIEVEMENT_TF_ENGINEER_BUILDING_CARRY, "TF_ENGINEER_BUILDING_CARRY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_KillAssist : 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;
// A sentry gun must have been the killing weapon.
const char* killer_weapon_name = event->GetString( "weapon" );
if ( ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_sentryrocket" ) ) ||
( 0 == Q_strncmp( killer_weapon_name, "obj_sentrygun", 13 ) ) ||
( 0 == Q_strcmp( killer_weapon_name, "wrangler_kill" ) ) ||
( 0 == Q_strcmp( killer_weapon_name, "obj_minisentry" ) ) )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() && pAssister->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
// We are the attacker and the assist is from a engineer.
IncrementCount();
return;
}
if ( pAssister == C_BasePlayer::GetLocalPlayer() && pAttacker->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
// We are the assister and the kill is from a engineer.
IncrementCount();
return;
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_KillAssist, ACHIEVEMENT_TF_ENGINEER_KILL_ASSIST, "TF_ENGINEER_KILL_ASSIST", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_DispenserHealGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100000 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_DispenserHealGrind, ACHIEVEMENT_TF_ENGINEER_DISPENSER_HEAL_GRIND, "TF_ENGINEER_DISPENSER_HEAL_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_RepairTeamGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50000 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_RepairTeamGrind, ACHIEVEMENT_TF_ENGINEER_REPAIR_TEAM_GRIND, "TF_ENGINEER_REPAIR_TEAM_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_TankDamage : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_TankDamage, ACHIEVEMENT_TF_ENGINEER_TANK_DAMAGE, "TF_ENGINEER_TANK_DAMAGE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_HeavyAssist : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_HeavyAssist, ACHIEVEMENT_TF_ENGINEER_HEAVY_ASSIST, "TF_ENGINEER_HEAVY_ASSIST", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_AchieveProgress1 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFEngineer_AchieveProgress1, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 5, ACHIEVEMENT_TF_ENGINEER_START_RANGE, ACHIEVEMENT_TF_ENGINEER_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_AchieveProgress1, ACHIEVEMENT_TF_ENGINEER_ACHIEVE_PROGRESS1, "TF_ENGINEER_ACHIEVE_PROGRESS1", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_AchieveProgress2 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFEngineer_AchieveProgress2, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 11, ACHIEVEMENT_TF_ENGINEER_START_RANGE, ACHIEVEMENT_TF_ENGINEER_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_AchieveProgress2, ACHIEVEMENT_TF_ENGINEER_ACHIEVE_PROGRESS2, "TF_ENGINEER_ACHIEVE_PROGRESS2", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFEngineer_AchieveProgress3 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFEngineer_AchieveProgress3, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 17, ACHIEVEMENT_TF_ENGINEER_START_RANGE, ACHIEVEMENT_TF_ENGINEER_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFEngineer_AchieveProgress3, ACHIEVEMENT_TF_ENGINEER_ACHIEVE_PROGRESS3, "TF_ENGINEER_ACHIEVE_PROGRESS3", 5 );
#endif // CLIENT_DLL