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.
104 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: d651c2b38d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd651c2b38d'
${ noResults }
source-engine/game/shared/tf/achievements_tf_spy.cpp

1773 lines
49 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_tf_playerresource.h"
#include "tf_weapon_invis.h"
//======================================================================================================================================
// SPY ACHIEVEMENT PACK
//======================================================================================================================================
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabSnipers : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
}
void ResetTracking()
{
m_iSnipersKilled = 0;
}
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();
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Achievement for backstabbing 3 snipers in a single life.
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SNIPER ) )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
m_iSnipersKilled++;
if ( m_iSnipersKilled == 3 )
{
IncrementCount();
}
}
}
}
int m_iSnipersKilled;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabSnipers, ACHIEVEMENT_TF_SPY_BACKSTAB_SNIPERS, "TF_SPY_BACKSTAB_SNIPERS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_FreezecamFlick : public CBaseTFAchievement
{
// Achievement for freeze camming on a cig flick w/ enemy corpse on screen.
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_FreezecamFlick, ACHIEVEMENT_TF_SPY_FREEZECAM_FLICK, "TF_SPY_FREEZECAM_FLICK", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabDisguisedSpy : 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 backstabbing a disguised spy.
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
if ( pTFVictim->m_Shared.InCond( TF_COND_DISGUISED ) )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabDisguisedSpy, ACHIEVEMENT_TF_SPY_BACKSTAB_DISGUISED_SPY, "TF_SPY_BACKSTAB_DISGUISED_SPY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabDisguiseTarget : 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 backstabbing the player you are disguised as.
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
if ( pTFAttacker && pTFVictim && pTFVictim == pTFAttacker->m_Shared.GetDisguiseTarget().Get() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabDisguiseTarget, ACHIEVEMENT_TF_SPY_BACKSTAB_DISGUISE_TARGET, "TF_SPY_BACKSTAB_DISGUISE_TARGET", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyFastCap : 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( CAchievementTFSpy_SpyFastCap, ACHIEVEMENT_TF_SPY_FAST_CAP, "TF_SPY_FAST_CAP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyDominateSniper : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
bool bDomination = event->GetInt( "death_flags" ) & TF_DEATH_DOMINATION;
if ( bDomination == true )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SNIPER ) )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyDominateSniper, ACHIEVEMENT_TF_SPY_DOMINATE_SNIPER, "TF_SPY_DOMINATE_SNIPER", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBumpCloakedSpy : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBumpCloakedSpy, ACHIEVEMENT_TF_SPY_BUMP_CLOAKED_SPY, "TF_SPY_BUMP_CLOAKED_SPY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyKillSpyWithKnife : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) && pTFVictim->GetActiveTFWeapon() )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_KNIFE )
{
if ( pTFVictim->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_REVOLVER )
{
IncrementCount();
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyKillSpyWithKnife, ACHIEVEMENT_TF_SPY_KILL_SPY_WITH_KNIFE, "TF_SPY_KILL_SPY_WITH_KNIFE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyRevengeBackstab : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
bool bRevenge = event->GetInt( "death_flags" ) & TF_DEATH_REVENGE;
if ( bRevenge == true )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyRevengeBackstab, ACHIEVEMENT_TF_SPY_REVENGE_WITH_BACKSTAB, "TF_SPY_REVENGE_WITH_BACKSTAB", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyKnifeKillWhileJarated : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_KNIFE )
{
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
if ( pTFAttacker && pTFAttacker->m_Shared.InCond( TF_COND_URINE ) )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyKnifeKillWhileJarated, ACHIEVEMENT_TF_SPY_KNIFE_KILL_WHILE_JARATED, "TF_SPY_KNIFE_KILL_WHILE_JARATED", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1000 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabGrind, ACHIEVEMENT_TF_SPY_BACKSTAB_GRIND, "TF_SPY_BACKSTAB_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabMedicCharged : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabMedicCharged, ACHIEVEMENT_TF_SPY_BACKSTAB_MEDIC_CHARGED, "TF_SPY_BACKSTAB_MEDIC_CHARGED", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabDominatingEnemy : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim )
{
int nDominationsNeeded = ( event->GetInt( "revenge" ) > 0 ) ? 4 : 3;
if ( g_TF_PR && g_TF_PR->GetActiveDominations( pTFVictim->entindex() ) >= nDominationsNeeded )
{
IncrementCount();
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabDominatingEnemy, ACHIEVEMENT_TF_SPY_BACKSTAB_DOMINATING_ENEMY, "TF_SPY_BACKSTAB_DOMINATING_ENEMY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabFriends : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
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( CAchievementTFSpy_SpyBackstabFriends, ACHIEVEMENT_TF_SPY_BACKSTAB_FRIENDS, "TF_SPY_BACKSTAB_FRIENDS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyAmbassadorGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_REVOLVER )
{
if ( FStrEq( event->GetString( "weapon_logclassname", "" ), "ambassador" ) )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyAmbassadorGrind, ACHIEVEMENT_TF_SPY_AMBASSADOR_GRIND, "TF_SPY_AMBASSADOR_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyAmbassadorSniperGrind : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SNIPER ) )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_REVOLVER )
{
if ( FStrEq( event->GetString( "weapon_logclassname", "" ), "ambassador" ) )
{
if ( IsHeadshot( event->GetInt( "customkill" ) ) )
{
IncrementCount();
}
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyAmbassadorSniperGrind, ACHIEVEMENT_TF_SPY_AMBASSADOR_SNIPER_GRIND, "TF_SPY_AMBASSADOR_SNIPER_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyAmbassadorScoutGrind : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SCOUT ) )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_REVOLVER )
{
if ( FStrEq( event->GetString( "weapon_logclassname", "" ), "ambassador" ) )
{
if ( IsHeadshot( event->GetInt( "customkill" ) ) )
{
IncrementCount();
}
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyAmbassadorScoutGrind, ACHIEVEMENT_TF_SPY_AMBASSADOR_SCOUT_GRIND, "TF_SPY_AMBASSADOR_SCOUT_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyMedicHealingKillEnemy : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
{
CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
// can't kill the enemy medic that's healing you for this one...should be a different enemy
if ( pTFPlayer && ( pTFPlayer != pAttacker ) && ( pTFPlayer != pVictim ) )
{
// make sure they're not on our team
if ( pAttacker->GetTeamNumber() != pTFPlayer->GetTeamNumber() )
{
// are they a medic that's healing me?
if ( pTFPlayer->IsPlayerClass( TF_CLASS_MEDIC ) && pTFPlayer->MedicGetHealTarget() == pAttacker )
{
IncrementCount();
}
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyMedicHealingKillEnemy, ACHIEVEMENT_TF_SPY_MEDIC_HEALING_KILL_ENEMY, "TF_SPY_MEDIC_HEALING_KILL_ENEMY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabQuickKills : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
int iNewIndex = m_Times.AddToTail();
m_Times[iNewIndex] = gpGlobals->curtime;
// we only care about the last three times we backstabbed someone
if ( m_Times.Count() > 3 )
{
m_Times.Remove( 0 );
}
if ( m_Times.Count() == 3 )
{
if ( m_Times.Tail() - m_Times.Head() <= 10.0 )
{
IncrementCount();
}
}
}
}
}
private:
CUtlVector< float > m_Times;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabQuickKills, ACHIEVEMENT_TF_SPY_BACKSTAB_QUICK_KILLS, "TF_SPY_BACKSTAB_QUICK_KILLS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyTauntKill : 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 )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
// we already know we killed a player because of the ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS flag
// was this a taunt kill?
if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_TAUNTATK_FENCING )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyTauntKill, ACHIEVEMENT_TF_SPY_TAUNT_KILL, "TF_SPY_TAUNT_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabCappingEnemies : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabCappingEnemies, ACHIEVEMENT_TF_SPY_BACKSTAB_CAPPING_ENEMIES, "TF_SPY_BACKSTAB_CAPPING_ENEMIES", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyKillCPDefenders : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 15 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyKillCPDefenders, ACHIEVEMENT_TF_SPY_KILL_CP_DEFENDERS, "TF_SPY_KILL_CP_DEFENDERS", 5 );
//----------------------------------------------------------------------------------------------------------------
//FYI I'm a spy
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_FYIMedic : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
SetGoal( 1 );
m_hTargets.Purge();
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_healedbymedic" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "player_healedbymedic" ) )
{
int iEntity = event->GetInt( "medic" );
int iMedic = GetTargetIndex( UTIL_PlayerByIndex( iEntity ) );
if ( iMedic == -1 )
{
AddNewTarget( UTIL_PlayerByIndex( iEntity ) );
}
else
{
m_hTargets[iMedic].flRemoveTime = gpGlobals->curtime + 5.0f;
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() )
{
int iMedic = GetTargetIndex( pVictim );
if ( iMedic != -1 )
{
if ( m_hTargets[iMedic].flRemoveTime >= gpGlobals->curtime )
{
IncrementCount();
}
m_hTargets.Remove( iMedic );
}
}
}
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 iMedic = GetTargetIndex( pTarget );
if ( iMedic == -1 )
{
iMedic = m_hTargets.AddToTail();
}
m_hTargets[iMedic].hTarget = pTarget;
m_hTargets[iMedic].flRemoveTime = gpGlobals->curtime + 5.0f;
}
private:
struct targets_t
{
EHANDLE hTarget;
float flRemoveTime;
};
CUtlVector<targets_t> m_hTargets;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_FYIMedic, ACHIEVEMENT_TF_SPY_BACKSTAB_MEDIC_HEALING_YOU, "TF_SPY_BACKSTAB_MEDIC_HEALING_YOU", 5 );
//----------------------------------------------------------------------------------------------------------------
// Backstab a medic/heavy pair
// NOTE: Enough of this, this should be a shared achievement class.
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_KillMedicPair : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
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 + 10.0f; // 10 seconds to kill the target
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !pVictim || !pVictim->IsPlayer() )
return;
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
int customkill = event->GetInt( "customkill" );
if ( pLocalPlayer == pAttacker && customkill == TF_DMG_CUSTOM_BACKSTAB )
{
// 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
{
C_TFPlayer *pNewTarget = NULL;
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim->IsPlayerClass( TF_CLASS_MEDIC ) )
{
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
{
pNewTarget = ToTFPlayer( pTFVictim->MedicGetHealTarget() );
if ( pNewTarget )
{
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( CAchievementTFSpy_KillMedicPair, ACHIEVEMENT_TF_SPY_BACKSTAB_MEDIC_PAIR, "TF_SPY_BACKSTAB_MEDIC_PAIR", 5 );
//----------------------------------------------------------------------------------------------------------------
//Destroy 3 enemy sentries
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SapBuildingGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1000 );
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" ) );
if ( iIndex == GetLocalPlayerIndex() )
{
const char *pWeapon = event->GetString( "weapon" );
if ( FStrEq( "obj_attachment_sapper", pWeapon ) )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SapBuildingGrind, ACHIEVEMENT_TF_SPY_SAPPER_GRIND, "TF_SPY_SAPPER_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
//Kill whoever triggered your feign death
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_FeignDeathKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
m_iKillerIndex = 0;
m_flTriggerTime = gpGlobals->curtime;
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_death" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( Q_strcmp( event->GetName(), "player_death" ) == 0 )
{
int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
int iVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
if ( iVictim == GetLocalPlayerIndex() )
{
//Someone popped my feign death
if ( event->GetInt( "death_flags" ) & TF_DEATH_FEIGN_DEATH )
{
m_iKillerIndex = iAttacker;
m_flTriggerTime = gpGlobals->curtime + 20.0f;
}
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->entindex() == m_iKillerIndex && m_flTriggerTime >= gpGlobals->curtime )
{
IncrementCount();
}
}
}
private:
int m_iKillerIndex;
float m_flTriggerTime;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_FeignDeathKill, ACHIEVEMENT_TF_SPY_FEIGN_DEATH_KILL, "TF_SPY_FEIGN_DEATH_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
//Kill a sniper after breaking his shield
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_ShieldKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
m_iBlockerIndex = 0;
m_flAttackTime = 0.0f;
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "player_shield_blocked" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "player_shield_blocked" ) )
{
int iAttacker = event->GetInt( "attacker_entindex" );
int iBlocker = event->GetInt( "blocker_entindex" );
if ( GetLocalPlayerIndex() != iAttacker )
return;
m_iBlockerIndex = iBlocker;
m_flAttackTime = gpGlobals->curtime + 10.0f;
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( m_flAttackTime <= gpGlobals->curtime )
{
m_iBlockerIndex = 0;
return;
}
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->entindex() == m_iBlockerIndex && pAttacker == C_TFPlayer::GetLocalTFPlayer() )
{
IncrementCount();
}
}
private:
int m_iBlockerIndex;
float m_flAttackTime;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_ShieldKill, ACHIEVEMENT_TF_SPY_BREAK_SHIELD_KILL_SNIPER, "TF_SPY_BREAK_SHIELD_KILL_SNIPER", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_KillWorkingEngineer : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
SetStoreProgressInSteam( true );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_KillWorkingEngineer, ACHIEVEMENT_TF_SPY_KILL_WORKING_ENGY, "TF_SPY_KILL_WORKING_ENGY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_TFSpySurviveBurning : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
m_bIsThinking = false;
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_damaged" );
ListenForGameEvent( "teamplay_round_start" );
ListenForGameEvent( "localplayer_respawn" );
m_bIsThinking = false;
}
void FireGameEvent_Internal( IGameEvent *event )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "localplayer_respawn" ) || FStrEq( pszEventName, "teamplay_round_active" ) )
{
ClearThink();
m_bIsThinking = false;
return;
}
// Have I taken damage?
if ( FStrEq( pszEventName, "player_damaged" ))
{
int iDmgType = event->GetInt( "type" );
// Did I survive the damage event?
if ( pLocalPlayer->IsAlive() && !m_bIsThinking )
{
// Am I on fire?
if ( (iDmgType & DMG_IGNITE) )
{
// Am I cloaked?
if ( pLocalPlayer->m_Shared.InCond ( TF_COND_STEALTHED ) )
{
SetNextThink( 30 );
m_bIsThinking = true;
}
}
}
}
}
virtual void Think( void )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer->IsAlive())
{
IncrementCount();
}
}
private:
bool m_bIsThinking;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_TFSpySurviveBurning, ACHIEVEMENT_TF_SPY_SURVIVE_BURNING, "TF_SPY_SURVIVE_BURNING", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabEnemySwitchPyro : public CBaseTFAchievementSimple
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
ResetBackstabbedPlayers();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_spawn" );
ListenForGameEvent( "localplayer_changeclass" );
ListenForGameEvent( "localplayer_changeteam" );
}
void ResetBackstabbedPlayers( void )
{
m_BackstabbedPlayers.Purge();
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// no progress in endround
if ( !GameRulesAllowsAchievements() )
return;
if ( !IsLocalTFPlayerClass( TF_CLASS_SPY ) )
return;
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && !pTFVictim->IsPlayerClass( TF_CLASS_PYRO ) ) // they can't already be a pyro for this one
{
int nUserID = pTFVictim->GetUserID();
if ( m_BackstabbedPlayers.Find( nUserID ) == m_BackstabbedPlayers.InvalidIndex() )
{
// they're not in our list yet, add them
m_BackstabbedPlayers.AddToTail( nUserID );
}
}
}
}
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_spawn" ) )
{
// no progress in endround
if ( !GameRulesAllowsAchievements() )
return;
if ( !IsLocalTFPlayerClass( TF_CLASS_SPY ) )
return;
const int nUserID = event->GetInt( "userid" );
int iIndex = m_BackstabbedPlayers.Find( nUserID );
if ( iIndex != m_BackstabbedPlayers.InvalidIndex() )
{
const int nTeam = event->GetInt( "team" );
if ( nTeam != GetLocalPlayerTeam() )
{
const int nClass = event->GetInt( "class" );
if ( nClass == TF_CLASS_PYRO )
{
IncrementCount();
}
}
m_BackstabbedPlayers.Remove( iIndex );
}
}
else if ( FStrEq( pszEventName, "localplayer_changeclass" ) ||
FStrEq( pszEventName, "localplayer_changeteam" ) )
{
ResetBackstabbedPlayers();
}
}
private:
CUtlVector< int > m_BackstabbedPlayers;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabEnemySwitchPyro, ACHIEVEMENT_TF_SPY_BACKSTAB_ENEMY_SWITCH_PYRO, "TF_SPY_BACKSTAB_ENEMY_SWITCH_PYRO", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyBackstabEngySapBuilding : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
m_hTargets.Purge();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_sapped_object" );
}
int FindEngyInList( CBaseEntity *pTarget )
{
for ( int i = 0; i < m_hTargets.Count(); i++ )
{
if ( m_hTargets[i].hEngy == pTarget )
return i;
}
return -1;
}
int CountSappedObjects( int iIndex )
{
int nCount = 0;
if ( m_hTargets.IsValidIndex( iIndex ) )
{
if ( m_hTargets[iIndex].bSentry )
{
nCount++;
}
if ( m_hTargets[iIndex].bDispenser )
{
nCount++;
}
if ( m_hTargets[iIndex].bTele )
{
nCount++;
}
}
return nCount;
}
void SetObjectSapped( int iIndex, int nType )
{
if ( m_hTargets.IsValidIndex( iIndex ) )
{
switch( nType )
{
case OBJ_SENTRYGUN:
m_hTargets[iIndex].bSentry = true;
break;
case OBJ_DISPENSER:
m_hTargets[iIndex].bDispenser = true;
break;
case OBJ_TELEPORTER:
m_hTargets[iIndex].bTele = true;
break;
}
}
}
void CheckAchievementEarned( void )
{
for ( int i = m_hTargets.Count() - 1; i >= 0; i-- )
{
if ( m_hTargets[i].flTimeToBeat < gpGlobals->curtime )
{
// time has run out on this one
m_hTargets.Remove( i );
}
else
{
if ( CountSappedObjects( i ) >= 3 )
{
IncrementCount();
m_hTargets.Purge();
return;
}
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
int iIndex = FindEngyInList( pVictim );
if ( iIndex == -1 )
{
iIndex = m_hTargets.AddToTail();
}
m_hTargets[iIndex].hEngy = pVictim;
m_hTargets[iIndex].bSentry = false;
m_hTargets[iIndex].bDispenser = false;
m_hTargets[iIndex].bTele = false;
m_hTargets[iIndex].flTimeToBeat = gpGlobals->curtime + 10.0;
}
}
CheckAchievementEarned(); // checks the achievement list, but also cleans out old entries (based on flTimeToBeat)
}
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_sapped_object" ) )
{
int nUserID = event->GetInt( "userid" );
CBasePlayer *pPlayer = UTIL_PlayerByIndex( engine->GetPlayerForUserID( nUserID ) );
if ( pPlayer == C_BasePlayer::GetLocalPlayer() )
{
CBasePlayer *pEngy = UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "ownerid" ) ) );
int iIndex = FindEngyInList( pEngy );
if ( iIndex != -1 )
{
SetObjectSapped( iIndex, event->GetInt( "object" ) );
}
CheckAchievementEarned(); // checks the achievement list, but also cleans out old entries (based on flTimeToBeat)
}
}
}
private:
struct targets_t
{
EHANDLE hEngy;
bool bSentry;
bool bDispenser;
bool bTele;
float flTimeToBeat;
};
CUtlVector<targets_t> m_hTargets;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyBackstabEngySapBuilding, ACHIEVEMENT_TF_SPY_BACKSTAB_ENGY_SAP_BUILDING, "TF_SPY_BACKSTAB_ENGY_SAP_BUILDING", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpySapBuildingBackstabEngy : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
m_hTargets.Purge();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_sapped_object" );
}
int FindEngyInList( CBaseEntity *pTarget )
{
for ( int i = 0; i < m_hTargets.Count(); i++ )
{
if ( m_hTargets[i].hEngy == pTarget )
return i;
}
return -1;
}
void ValidateList( void )
{
for ( int i = m_hTargets.Count() - 1; i >= 0; i-- )
{
if ( m_hTargets[i].flTimeToBeat < gpGlobals->curtime )
{
// time has run out on this one
m_hTargets.Remove( i );
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
int customkill = event->GetInt( "customkill" );
if ( customkill == TF_DMG_CUSTOM_BACKSTAB )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
int iIndex = FindEngyInList( pVictim );
if ( iIndex != -1 )
{
// they're in our list...is the time still valid?
if ( m_hTargets[iIndex].flTimeToBeat > gpGlobals->curtime )
{
IncrementCount();
m_hTargets.Purge();
return;
}
}
}
}
ValidateList();
}
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_sapped_object" ) )
{
int nUserID = event->GetInt( "userid" );
CBasePlayer *pPlayer = UTIL_PlayerByIndex( engine->GetPlayerForUserID( nUserID ) );
if ( pPlayer == C_BasePlayer::GetLocalPlayer() )
{
CBasePlayer *pEngy = UTIL_PlayerByIndex( engine->GetPlayerForUserID( event->GetInt( "ownerid" ) ) );
if ( pEngy )
{
int iIndex = FindEngyInList( pEngy );
if ( iIndex == -1 )
{
iIndex = m_hTargets.AddToTail();
}
m_hTargets[iIndex].hEngy = pEngy;
m_hTargets[iIndex].flTimeToBeat = gpGlobals->curtime + 5.0;
}
ValidateList();
}
}
}
private:
struct targets_t
{
EHANDLE hEngy;
float flTimeToBeat;
};
CUtlVector<targets_t> m_hTargets;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpySapBuildingBackstabEngy, ACHIEVEMENT_TF_SPY_SAP_BUILDING_BACKSTAB_ENGY, "TF_SPY_SAP_BUILDING_BACKSTAB_ENGY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SapperTeamwork : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
ResetData();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_sapped_object" );
ListenForGameEvent( "localplayer_changeteam" );
}
void ResetData( void )
{
m_hTeammates.Purge();
m_nLocalPlayerTarget = -1;
m_flLocalPlayerTime = -1;
}
int FindSpyInList( int userid )
{
for ( int i = 0; i < m_hTeammates.Count(); i++ )
{
if ( m_hTeammates[i].nSpy == userid )
return i;
}
return -1;
}
void CheckAchievementEarned( void )
{
// has the local player sapped anything?
if ( m_nLocalPlayerTarget == -1 && m_flLocalPlayerTime == -1 )
return;
// has it been longer than 3 seconds since the local player sapped something?
if ( gpGlobals->curtime - m_flLocalPlayerTime > 3.0 )
{
// reset the local player target and time, this fixes the local player sapping something and
// then a teammate saps something > 3 seconds later (otherwise, the new entry would be removed in the for loop below)
m_nLocalPlayerTarget = -1;
m_flLocalPlayerTime = -1;
return;
}
for ( int i = m_hTeammates.Count() - 1; i >= 0; i-- )
{
if ( m_hTeammates[i].nTarget != m_nLocalPlayerTarget ) // different guns
{
if ( fabs( m_hTeammates[i].flTime - m_flLocalPlayerTime ) <= 3.0 )
{
IncrementCount();
ResetData();
return;
}
else
{
m_hTeammates.Remove( i );
}
}
}
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_sapped_object" ) )
{
if ( event->GetInt( "object" ) == OBJ_SENTRYGUN )
{
int nUserID = event->GetInt( "userid" );
CTFPlayer *pSpy = ToTFPlayer( UTIL_PlayerByIndex( engine->GetPlayerForUserID( nUserID ) ) );
if ( pSpy && pSpy->GetTeamNumber() == GetLocalPlayerTeam() )
{
if ( pSpy == C_BasePlayer::GetLocalPlayer() )
{
m_nLocalPlayerTarget = event->GetInt( "ownerid" );
m_flLocalPlayerTime = gpGlobals->curtime;
}
else
{
int iIndex = FindSpyInList( nUserID );
if ( iIndex == -1 )
{
iIndex = m_hTeammates.AddToTail();
}
m_hTeammates[iIndex].nSpy = nUserID;
m_hTeammates[iIndex].nTarget = event->GetInt( "ownerid" );
m_hTeammates[iIndex].flTime = gpGlobals->curtime;
}
CheckAchievementEarned(); // checks the achievement list, but also cleans out old entries (based on time)
}
}
}
else if ( FStrEq( pszEventName, "localplayer_changeteam" ) )
{
ResetData();
}
}
private:
struct teammates_t
{
int nSpy; // who built the sapper
int nTarget; // owner of the gun
float flTime; // time it was sapped
};
CUtlVector<teammates_t> m_hTeammates; // list of teammates who have sapped guns
int m_nLocalPlayerTarget; // owner of the gun
float m_flLocalPlayerTime; // time it was sapped
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SapperTeamwork, ACHIEVEMENT_TF_SPY_SAPPER_TEAMWORK, "TF_SPY_SAPPER_TEAMWORK", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_SpyCampPosition : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
ResetData();
}
void ResetData()
{
m_hTargets.Purge();
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "teamplay_round_active" );
ResetData();
}
int FindEnemyInList( CBaseEntity *pTarget )
{
for ( int i = 0; i < m_hTargets.Count(); i++ )
{
if ( m_hTargets[i].hEnemy == pTarget )
return i;
}
return -1;
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "localplayer_respawn" ) ||
FStrEq( pszEventName, "teamplay_round_active" ) )
{
ResetData();
}
}
bool LocalPlayerHasMotionCloakEquipped( void )
{
CTFPlayer *pPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
if ( pPlayer )
{
CTFWeaponInvis *pWeapon = (CTFWeaponInvis *) pPlayer->Weapon_OwnsThisID( TF_WEAPON_INVIS );
if ( pWeapon && pWeapon->HasMotionCloak() )
{
return true;
}
}
return false;
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
if ( LocalPlayerHasMotionCloakEquipped() )
{
int iIndex = FindEnemyInList( pVictim );
if ( iIndex != -1 )
{
// they're already in our list
Vector vecOrigin = pVictim->GetAbsOrigin();
if ( ( m_hTargets[iIndex].vecOrigin - vecOrigin ).LengthSqr() > (1024*1024) )
{
// we killed them too far away from our last position, so reset
m_hTargets[iIndex].nKillCount = 1;
m_hTargets[iIndex].vecOrigin = vecOrigin;
}
else
{
// they were close enough, so add to our kill count
m_hTargets[iIndex].nKillCount++;
}
}
else
{
// they're new to our list
iIndex = m_hTargets.AddToTail();
m_hTargets[iIndex].hEnemy = pVictim;
m_hTargets[iIndex].nKillCount = 1;
m_hTargets[iIndex].vecOrigin = pVictim->GetAbsOrigin();
}
if ( m_hTargets[iIndex].nKillCount >= 3 )
{
IncrementCount();
ResetData();
}
}
else
{
// Not using motion cloak anymore
ResetData();
}
}
}
private:
struct targets_t
{
EHANDLE hEnemy;
int nKillCount;
Vector vecOrigin;
};
CUtlVector<targets_t> m_hTargets;
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_SpyCampPosition, ACHIEVEMENT_TF_SPY_CAMP_POSITION, "TF_SPY_CAMP_POSITION", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_AchieveProgress1 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFSpy_AchieveProgress1, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 5, ACHIEVEMENT_TF_SPY_START_RANGE, ACHIEVEMENT_TF_SPY_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_AchieveProgress1, ACHIEVEMENT_TF_SPY_ACHIEVE_PROGRESS1, "TF_SPY_ACHIEVE_PROGRESS1", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_AchieveProgress2 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFSpy_AchieveProgress2, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 11, ACHIEVEMENT_TF_SPY_START_RANGE, ACHIEVEMENT_TF_SPY_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_AchieveProgress2, ACHIEVEMENT_TF_SPY_ACHIEVE_PROGRESS2, "TF_SPY_ACHIEVE_PROGRESS2", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_AchieveProgress3 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFSpy_AchieveProgress3, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 17, ACHIEVEMENT_TF_SPY_START_RANGE, ACHIEVEMENT_TF_SPY_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_AchieveProgress3, ACHIEVEMENT_TF_SPY_ACHIEVE_PROGRESS3, "TF_SPY_ACHIEVE_PROGRESS3", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSpy_KillBackScatterScout : 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 *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SCOUT ) && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
{
if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_BACKSTAB )
{
CTFWeaponBase *pWeapon = pTFVictim->GetActiveTFWeapon();
if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_SCATTERGUN ) )
{
int iMiniCritBackAttack = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
if ( iMiniCritBackAttack > 0 )
{
IncrementCount();
}
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSpy_KillBackScatterScout, ACHIEVEMENT_TF_SPY_KILL_BACKSCATTER_SCOUT, "TF_SPY_KILL_BACKSCATTER_SCOUT", 5 );
#endif // CLIENT_DLL