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

1885 lines
55 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_objective_resource.h"
#include "tf_weapon_shovel.h"
#include "movevars_shared.h"
//======================================================================================================================================
// DEMOMAN ACHIEVEMENT PACK
//======================================================================================================================================
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillSoldierGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 500 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !pVictim || !pVictim->IsPlayer() )
return;
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
// no friendly fire kills
if ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SOLDIER ) )
{
// we killed a soldier
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillSoldierGrind, ACHIEVEMENT_TF_DEMOMAN_KILL_SOLDIER_GRIND, "TF_DEMOMAN_KILL_SOLDIER_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DestroyBuildingsWithMedic : public CBaseTFAchievement
{
DECLARE_CLASS( CAchievementTFDemoman_DestroyBuildingsWithMedic, CBaseTFAchievement );
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
m_iBuildingsDestroyed = 0;
}
virtual void ListenForEvents()
{
BaseClass::ListenForEvents();
ListenForGameEvent( "player_invulned" );
ListenForGameEvent( "object_destroyed" );
}
virtual void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "player_invulned" ) )
{
int iTarget = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
CBaseEntity *pPlayer = UTIL_PlayerByIndex( iTarget );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pPlayer == pLocalPlayer )
{
m_iBuildingsDestroyed = 0;
}
}
else if ( Q_strcmp( event->GetName(), "object_destroyed" ) == 0 )
{
int iAttackerIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
if ( iAttackerIndex > 0 )
{
CBaseEntity *pAttacker = UTIL_PlayerByIndex( iAttackerIndex );
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pTFPlayer && pTFPlayer == pAttacker )
{
if ( pTFPlayer->m_Shared.InCond( TF_COND_INVULNERABLE ) || pTFPlayer->m_Shared.InCond( TF_COND_CRITBOOSTED ) ||
pTFPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
{
m_iBuildingsDestroyed++;
if ( m_iBuildingsDestroyed >= 5 )
{
IncrementCount();
}
}
}
}
}
else
{
BaseClass::FireGameEvent_Internal( event );
}
}
private:
int m_iBuildingsDestroyed;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DestroyBuildingsWithMedic, ACHIEVEMENT_TF_DEMOMAN_DESTROY_BUILDINGS_WITH_MEDIC, "TF_DEMOMAN_DESTROY_BUILDINGS_WITH_MEDIC", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DecapitateCloakedSpy : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim )
return;
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) && pTFVictim->m_Shared.InCond( TF_COND_STEALTHED ) )
{
int customdmg = event->GetInt( "customkill" );
if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitateCloakedSpy, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_CLOAKED_SPY, "TF_DEMOMAN_DECAPITATE_CLOAKED_SPY", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillWithDirectPipe : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
// Kill 50 enemies with direct hits from the pipebomb launcher
// The server (tf_player) awards this achievement - no code necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillWithDirectPipe, ACHIEVEMENT_TF_DEMOMAN_KILL_X_WITH_DIRECTPIPE, "TF_DEMOMAN_KILL_X_WITH_DIRECTPIPE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_BounceAndKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
SetDefLessFunc( m_BouncedPlayers );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "player_hurt" );
m_BouncedPlayers.RemoveAll();
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
FStrEq( event->GetName(), "localplayer_respawn" ) )
{
m_BouncedPlayers.RemoveAll();
}
else if ( FStrEq( event->GetName(), "player_hurt" ) )
{
int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
CBasePlayer *pAttacker = UTIL_PlayerByIndex( iAttacker );
if ( pAttacker == C_TFPlayer::GetLocalTFPlayer() )
{
int iVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
CBasePlayer *pVictim = UTIL_PlayerByIndex( iVictim );
if ( pVictim )
{
bool bVictimGrounded = pVictim->GetFlags() & FL_ONGROUND;
if ( bVictimGrounded )
{
int iIndex = m_BouncedPlayers.Find( pVictim->GetUserID() );
if ( iIndex != m_BouncedPlayers.InvalidIndex() )
{
// they're already in our list
m_BouncedPlayers[iIndex] = gpGlobals->curtime;
}
else
{
// we need to add them
m_BouncedPlayers.Insert( pVictim->GetUserID(), gpGlobals->curtime );
}
}
}
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pVictim == C_BasePlayer::GetLocalPlayer() )
{
m_BouncedPlayers.RemoveAll();
return;
}
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && !( pTFVictim->GetFlags() & FL_ONGROUND ) )
{
int iIndex = m_BouncedPlayers.Find( pTFVictim->GetUserID() );
if ( iIndex != m_BouncedPlayers.InvalidIndex() )
{
if ( gpGlobals->curtime < m_BouncedPlayers[iIndex] + 4.0f )
{
IncrementCount();
}
}
}
}
}
CUtlMap< int, float > m_BouncedPlayers; // userID and most recent time they were bounced
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_BounceAndKill, ACHIEVEMENT_TF_DEMOMAN_BOUNCE_AND_KILL, "TF_DEMOMAN_BOUNCE_AND_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DecapitatePlayers : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( pLocalPlayer != pAttacker )
return;
int customdmg = event->GetInt( "customkill" );
if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitatePlayers, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_PLAYERS, "TF_DEMOMAN_DECAPITATE_PLAYERS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DecapitatePlayersFast : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
m_iTimelyDecapitations = 0;
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
FStrEq( event->GetName(), "localplayer_respawn" ) )
{
m_iTimelyDecapitations = 0;
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( pLocalPlayer != pAttacker )
return;
int customdmg = event->GetInt( "customkill" );
if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
{
if ( (m_iTimelyDecapitations == 0) || ((m_iTimelyDecapitations > 0) && (gpGlobals->curtime < m_flLastDecapTime + 10.f)) )
{
m_iTimelyDecapitations++;
}
else
{
m_iTimelyDecapitations = 1;
}
m_flLastDecapTime = gpGlobals->curtime;
if ( m_iTimelyDecapitations == 4 )
{
IncrementCount();
}
}
}
int m_iTimelyDecapitations;
float m_flLastDecapTime;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitatePlayersFast, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_PLAYERS_FAST, "TF_DEMOMAN_DECAPITATE_PLAYERS_FAST", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFSoldier_DuoDemomanKills : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 10 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_death" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "player_death" ) )
{
int iAttackerIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
if ( iAttackerIndex == 0 )
return;
CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( iAttackerIndex ) );
if ( !pAttacker )
return;
int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
if ( iAssisterIndex == 0 )
return;
CTFPlayer *pAssister = ToTFPlayer( UTIL_PlayerByIndex( iAssisterIndex ) );
if ( !pAssister )
return;
if ( pAttacker == C_BasePlayer::GetLocalPlayer() && pAssister->IsPlayerClass( TF_CLASS_DEMOMAN ) )
{
// We are the attacker and the assist is from a demoman.
IncrementCount();
return;
}
if ( pAssister == C_BasePlayer::GetLocalPlayer() && pAttacker->IsPlayerClass( TF_CLASS_DEMOMAN ) )
{
// We are the assister and the kill is from a demoman.
IncrementCount();
return;
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFSoldier_DuoDemomanKills, ACHIEVEMENT_TF_DEMOMAN_DUO_DEMOMAN_KILLS, "TF_DEMOMAN_DUO_DEMOMAN_KILLS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillTwoDuringStickyJump : public CBaseTFAchievement
{
// While airborne after a sticky-jump, kill at least two enemy players
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "sticky_jump" );
ListenForGameEvent( "sticky_jump_landed" );
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
m_iKilledDuringStickyJump = 0;
m_bStickyJumping = false;
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
FStrEq( event->GetName(), "localplayer_respawn" ) )
{
m_iKilledDuringStickyJump = 0;
m_bStickyJumping = false;
}
else if ( FStrEq( event->GetName(), "sticky_jump_landed" ) )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
if ( iIndex > 0 )
{
C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );
if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
{
m_iKilledDuringStickyJump = 0;
m_bStickyJumping = false;
}
}
return;
}
else if ( FStrEq( event->GetName(), "sticky_jump" ) )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
if ( iIndex > 0 )
{
C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );
if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
{
m_iKilledDuringStickyJump = 0;
m_bStickyJumping = true;
}
}
return;
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !pVictim || !pVictim->IsPlayer() )
return;
if ( pAttacker && ( pAttacker == C_BasePlayer::GetLocalPlayer() ) )
{
if ( m_bStickyJumping )
{
m_iKilledDuringStickyJump++;
if ( m_iKilledDuringStickyJump == 2 )
{
IncrementCount();
}
}
}
}
private:
bool m_bStickyJumping;
int m_iKilledDuringStickyJump;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillTwoDuringStickyJump, ACHIEVEMENT_TF_DEMOMAN_KILL_TWO_DURING_STICKYJUMP, "TF_DEMOMAN_KILL_TWO_DURING_STICKYJUMP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillPlayerAfterTeleport : public CBaseTFAchievement
{
// Kill an enemy player within X seconds of them teleporting in
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( !pVictim || !pVictim->IsPlayer() )
return;
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
{
if ( pTFVictim->m_Shared.InCond( TF_COND_TELEPORTED ) && ( gpGlobals->curtime - pTFVictim->m_Shared.GetTimeTeleEffectAdded() <= 5.0 ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillPlayerAfterTeleport, ACHIEVEMENT_TF_DEMOMAN_KILL_PLAYER_AFTER_TP, "TF_DEMOMAN_KILL_PLAYER_AFTER_TP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DominateEngineerThreeTimes : public CBaseTFAchievement
{
// Dominate three Engineers
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 3 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( !pVictim || !pVictim->IsPlayer() )
return;
bool bDomination = event->GetInt( "death_flags" ) & TF_DEATH_DOMINATION;
if ( bDomination == true )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DominateEngineerThreeTimes, ACHIEVEMENT_TF_DEMOMAN_DOMINATE_THREE_ENGINEERS, "TF_DEMOMAN_DOMINATE_THREE_ENGINEERS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillBuildingDirectHit : public CBaseTFAchievement
{
// Kill an Engineer building that you can't see with a direct hit from your Grenade Launcher
// Server awards this achievement (tf_obj.cpp) - no other code necessary
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillBuildingDirectHit, ACHIEVEMENT_TF_DEMOMAN_KILL_BUILDING_DIRECT_HIT, "TF_DEMOMAN_KILL_BUILDING_DIRECT_HIT", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_MeleeKillWhileJumping : public CBaseTFAchievement
{
// Get a melee kill while in sticky jump
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "sticky_jump" );
ListenForGameEvent( "sticky_jump_landed" );
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
m_bStickyJumping = false;
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
FStrEq( event->GetName(), "localplayer_respawn" ) )
{
m_bStickyJumping = false;
}
else if ( FStrEq( event->GetName(), "sticky_jump_landed" ) )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
if ( iIndex > 0 )
{
C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );
if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
{
m_bStickyJumping = false;
}
}
return;
}
else if ( FStrEq( event->GetName(), "sticky_jump" ) )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
if ( iIndex > 0 )
{
C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );
if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
{
m_bStickyJumping = true;
}
}
return;
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !pVictim || !pVictim->IsPlayer() )
return;
if ( pAttacker && ( pAttacker == C_BasePlayer::GetLocalPlayer() ) )
{
if ( m_bStickyJumping )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_BOTTLE || event->GetInt( "weaponid" ) == TF_WEAPON_SWORD )
{
IncrementCount();
}
}
}
}
private:
bool m_bStickyJumping;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_MeleeKillWhileJumping, ACHIEVEMENT_TF_DEMOMAN_MELEE_KILL_WHILE_STICKYJUMPING, "TF_DEMOMAN_MELEE_KILL_WHILE_STICKYJUMPING", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillEngiSentryDispenser : public CBaseTFAchievement
{
// Kill an Engineer, his Sentry and Dispenser, with one sticky detonation
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
SetDefLessFunc( m_Engineers );
SetDefLessFunc( m_SentryDestroyed );
SetDefLessFunc( m_DispenserDestroyed );
ResetTracking();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "object_destroyed" );
ResetTracking();
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
FStrEq( event->GetName(), "localplayer_respawn" ) )
{
ResetTracking();
}
else if ( FStrEq( event->GetName(), "object_destroyed" ) )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
{
int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
CBaseEntity *pAttacker = UTIL_PlayerByIndex( iAttacker );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
if ( pLocalPlayer != pAttacker )
return;
int iEngineer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
int iObject = event->GetInt( "objecttype" );
if ( iObject == OBJ_SENTRYGUN )
{
int iIndex = m_SentryDestroyed.Find( iEngineer );
if ( iIndex != m_SentryDestroyed.InvalidIndex() )
{
// already tracking them, update the time
m_SentryDestroyed[iIndex] = gpGlobals->curtime;
}
else
{
m_SentryDestroyed.Insert( iEngineer, gpGlobals->curtime );
}
CheckGoalMet();
}
if ( iObject == OBJ_DISPENSER )
{
int iIndex = m_DispenserDestroyed.Find( iEngineer );
if ( iIndex != m_DispenserDestroyed.InvalidIndex() )
{
// already tracking them, update the time
m_DispenserDestroyed[iIndex] = gpGlobals->curtime;
}
else
{
m_DispenserDestroyed.Insert( iEngineer, gpGlobals->curtime );
}
CheckGoalMet();
}
}
}
}
void ResetTracking( void )
{
m_Engineers.RemoveAll();
m_SentryDestroyed.RemoveAll();
m_DispenserDestroyed.RemoveAll();
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( !pVictim || !pVictim->IsPlayer() )
return;
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_ENGINEER ) )
{
int iEngineer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
m_Engineers.InsertOrReplace( iEngineer, gpGlobals->curtime );
CheckGoalMet();
}
}
}
void CheckGoalMet( void )
{
FOR_EACH_MAP_FAST ( m_Engineers, numEngineers )
{
int iEngineer = m_Engineers.Key( numEngineers );
// Destroyed their Sentry?
int iSentry = m_SentryDestroyed.Find( iEngineer );
if ( iSentry != m_SentryDestroyed.InvalidIndex() )
{
// Destroyed their Dispenser?
int iDispenser = m_DispenserDestroyed.Find( iEngineer );
if ( iDispenser != m_DispenserDestroyed.InvalidIndex() )
{
// All three at the same time?
// if ( ( m_Engineers[numEngineers] == m_SentryDestroyed[iSentry] ) &&
// ( m_Engineers[numEngineers] == m_DispenserDestroyed[iDispenser] ) )
if ( ( gpGlobals->curtime < m_SentryDestroyed[iSentry] + 0.1f ) &&
( gpGlobals->curtime < m_DispenserDestroyed[iDispenser] + 0.1f ) &&
( gpGlobals->curtime < m_Engineers[numEngineers] + 0.1f ) )
{
IncrementCount();
}
}
}
}
}
private:
CUtlMap< int, float > m_SentryDestroyed; // Engineer userID and time sentry was destroyed
CUtlMap< int, float > m_DispenserDestroyed; // Engineer userID and time dispenser was destroyed
CUtlMap< int, float > m_Engineers; // Engineers we've killed and the time
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillEngiSentryDispenser, ACHIEVEMENT_TF_DEMOMAN_KILL_ENGI_SENTRY_DISPENSER, "TF_DEMOMAN_KILL_ENGI_SENTRY_DISPENSER", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DecapitateEqualizer : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim )
return;
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SOLDIER ) )
{
CTFShovel *pShovel = dynamic_cast<CTFShovel*>( pTFVictim->GetActiveTFWeapon() );
if ( pShovel && (pShovel->GetShovelType() == SHOVEL_DAMAGE_BOOST) )
{
int customdmg = event->GetInt( "customkill" );
if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
{
IncrementCount();
}
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitateEqualizer, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_EQUALIZER, "TF_DEMOMAN_DECAPITATE_EQUALIZER", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DecapitateNemesis : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim )
return;
if ( pTFVictim && pTFVictim->IsNemesisOfLocalPlayer() )
{
int customdmg = event->GetInt( "customkill" );
if ( customdmg == TF_DMG_CUSTOM_DECAPITATION )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DecapitateNemesis, ACHIEVEMENT_TF_DEMOMAN_DECAPITATE_NEMESIS, "TF_DEMOMAN_DECAPITATE_NEMESIS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DamageGrind : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1000000 );
SetStoreProgressInSteam( true );
}
void OnPlayerStatsUpdate()
{
ClassStats_t &classStats = CTFStatPanel::GetClassStats( TF_CLASS_DEMOMAN );
int iOldCount = m_iCount;
m_iCount = classStats.accumulated.m_iStat[TFSTAT_BLASTDAMAGE];
if ( m_iCount != iOldCount )
{
m_pAchievementMgr->SetDirty( true );
}
if ( IsLocalTFPlayerClass( TF_CLASS_DEMOMAN ) )
{
EvaluateNewAchievement();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DamageGrind, ACHIEVEMENT_TF_DEMOMAN_DAMAGE_GRIND, "TF_DEMOMAN_DAMAGE_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXCapping : public CBaseTFAchievement
{
// Kill "x" players that are capping or pushing the cart with one detonation, "y" times
// Server checks for this achievement - no code necessary
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 3 );
SetStoreProgressInSteam( true );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXCapping, ACHIEVEMENT_TF_DEMOMAN_KILL_X_CAPPING_ONEDET, "TF_DEMOMAN_KILL_X_CAPPING_ONEDET", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXDefending : public CBaseTFAchievement
{
// Kill "x" players that are defending
// Server checks for this achievement - no code necessary
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 25 );
SetStoreProgressInSteam( true );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXDefending, ACHIEVEMENT_TF_DEMOMAN_KILL_X_DEFENDING, "TF_DEMOMAN_KILL_X_DEFENDING", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DestroyBuildings : public CBaseTFAchievement
{
// Destroy "x" buildings
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 50 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "object_destroyed" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "object_destroyed" ) )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
CBaseEntity *pDestroyer = UTIL_PlayerByIndex( iIndex );
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pDestroyer == pTFPlayer )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DestroyBuildings, ACHIEVEMENT_TF_DEMOMAN_DESTROY_BUILDINGS_GRIND, "TF_DEMOMAN_DESTROY_BUILDINGS_GRIND", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXHeaviesAtFull : public CBaseTFAchievement
{
// Kill 3 Heavies from full health with a single Sticky detonation
// Server checks for this achievement - no code necessary
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 3 );
SetStoreProgressInSteam( true );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXHeaviesAtFull, ACHIEVEMENT_TF_DEMOMAN_KILL_X_HEAVIES_FULLHP_ONEDET, "TF_DEMOMAN_KILL_X_HEAVIES_FULLHP_ONEDET", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXScoutsPyros : public CBaseTFAchievement
{
// Kill 25 Scouts or Pyros with the grenade launcher
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 25 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( !pVictim || !pVictim->IsPlayer() )
return;
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim->IsPlayerClass( TF_CLASS_PYRO ) || pTFVictim->IsPlayerClass( TF_CLASS_SCOUT ) )
{
if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_DEMOMAN )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXScoutsPyros, ACHIEVEMENT_TF_DEMOMAN_KILL_X_SCOUTS_PYROS, "TF_DEMOMAN_KILL_X_SCOUTS_PYROS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_TauntKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// was this a taunt kill?
if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_TauntKill, ACHIEVEMENT_TF_DEMOMAN_TAUNT_KILL, "TF_DEMOMAN_TAUNT_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_ChargeKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// was this a taunt kill?
if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_CHARGE_IMPACT )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ChargeKill, ACHIEVEMENT_TF_DEMOMAN_CHARGE_KILL, "TF_DEMOMAN_CHARGE_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_CritSwordKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER );
SetGoal( 5 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// was this a charge kill with the sword?
int nDamageBits = event->GetInt( "damagebits" );
if ( (nDamageBits & DMG_CRITICAL) && (event->GetInt( "customkill" ) == TF_DMG_CUSTOM_DECAPITATION) )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_CritSwordKill, ACHIEVEMENT_TF_DEMOMAN_CRIT_SWORD_KILL, "TF_DEMOMAN_CRIT_SWORD_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_AirBurstKills : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER );
SetGoal( 30 );
SetStoreProgressInSteam( true );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// was this an air burst kill?
if ( event->GetInt( "customkill" ) == TF_DMG_CUSTOM_AIR_STICKY_BURST )
{
IncrementCount();
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AirBurstKills, ACHIEVEMENT_TF_DEMOMAN_AIR_BURST_KILLS, "TF_DEMOMAN_AIR_BURST_KILLS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_StickyJumpCap : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_FILTER_ATTACKER_IS_PLAYER );
SetGoal( 1 );
}
virtual void ListenForEvents( void )
{
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "teamplay_point_startcapture" );
ListenForGameEvent( "controlpoint_endtouch" );
ListenForGameEvent( "teamplay_point_captured" );
ListenForGameEvent( "sticky_jump_landed" );
ResetTracking();
}
void CheckGoalMet( void )
{
// If sticky_jump_landed and startcapture times occurred roughly together...
float fTemp1 = 0;
float fTemp2 = 0;
if ( m_fLandTime > m_fCapStartTime )
{
fTemp1 = m_fLandTime;
fTemp2 = m_fCapStartTime;
}
else
{
fTemp1 = m_fCapStartTime;
fTemp2 = m_fLandTime;
}
float fDelta = fTemp1 - fTemp2;
if ( fDelta <= 0.5f )
{
// Check if we successfully capped the point we landed on
if ( m_bCapped )
{
IncrementCount();
}
}
}
void ResetTracking( void )
{
m_bCapped = false;
m_fLandTime = 0;
m_fCapStartTime = 0;
m_iCapID = -1;
}
void FireGameEvent_Internal( IGameEvent *event )
{
// Only check CP maps
if ( TFGameRules() && TFGameRules()->GetGameType() != TF_GAMETYPE_CP && TFGameRules()->GetGameType() != TF_GAMETYPE_ARENA )
return;
// Capture the time we land
if ( FStrEq( event->GetName(), "sticky_jump_landed" ) )
{
int iIndex = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
if ( iIndex > 0 )
{
C_TFPlayer *pJumper = ToTFPlayer( UTIL_PlayerByIndex( iIndex ) );
if ( pJumper && ( pJumper == C_BasePlayer::GetLocalPlayer() ) )
{
m_fLandTime = gpGlobals->curtime;
CheckGoalMet();
}
}
return;
}
// Capture the time we start capping
else if ( FStrEq( event->GetName(), "teamplay_point_startcapture" ) )
{
const char *cappers = event->GetString( "cappers" );
for ( int i = 0; i < Q_strlen( cappers ); i++ )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
int iPlayerIndex = (int) cappers[i];
CTFPlayer *pCapper = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pCapper && ( pCapper == C_BasePlayer::GetLocalPlayer() ) )
{
m_fCapStartTime = gpGlobals->curtime;
m_iCapID = event->GetInt( "cp" );
CheckGoalMet();
}
}
}
else if ( FStrEq( event->GetName(), "teamplay_point_captured" ) )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
int iTeam = event->GetInt( "team" );
if ( iTeam == pLocalPlayer->GetTeamNumber() )
{
const char *cappers = event->GetString( "cappers" );
for ( int i = 0; i < Q_strlen( cappers ); i++ )
{
int iPlayerIndex = (int) cappers[i];
CTFPlayer *pCapper = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pCapper && ( pCapper == C_BasePlayer::GetLocalPlayer() ) )
{
if ( m_iCapID == event->GetInt( "cp" ) )
{
m_bCapped = true;
CheckGoalMet();
}
}
}
}
}
else if ( FStrEq( event->GetName(), "controlpoint_endtouch" ) )
{
int iPlayerIndex = event->GetInt( "player", 0 );
if ( iPlayerIndex == GetLocalPlayerIndex() )
{
// We failed to take the point
ResetTracking();
}
}
else if ( FStrEq( event->GetName(), "teamplay_round_active" ) )
{
// Reset tracking at the start of a new round
ResetTracking();
}
}
private:
float m_fLandTime;
float m_fCapStartTime;
bool m_bCapped;
int m_iCapID;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_StickyJumpCap, ACHIEVEMENT_TF_DEMOMAN_STICKYJUMP_CAP, "TF_DEMOMAN_STICKYJUMP_CAP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_FreezeTaunt : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// Give opponents freezecams of you taunting
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_FreezeTaunt, ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE, "TF_DEMOMAN_FREEZECAM_SMILE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_FreezeTauntRump : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// Give opponents freezecams of you taunting
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_FreezeTauntRump, ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP, "TF_DEMOMAN_FREEZECAM_RUMP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_EnvironmentalKill : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( !pTFVictim )
return;
CTFPlayer *pLocalPlayer = ToTFPlayer( CBasePlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( pTFVictim->m_Shared.GetWeaponKnockbackID() == pLocalPlayer->GetUserID() )
{
int custom = event->GetInt( "customkill" );
int damagebits = event->GetInt( "damagebits" );
if ( ( damagebits & DMG_VEHICLE ) || // They were hit by a freakin' train!
( pAttacker && pAttacker->IsBrushModel() ) || // They were smashed by the world! Gah!
( !pAttacker || (pAttacker == pVictim) ) || // He killed himself!
( custom == TF_DMG_CUSTOM_SUICIDE ) ||
( custom == TF_DMG_CUSTOM_TRIGGER_HURT ) ) // A trigger-hurt got him!
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_EnvironmentalKill, ACHIEVEMENT_TF_DEMOMAN_ENVIRONMENTAL_KILL, "TF_DEMOMAN_ENVIRONMENTAL_KILL", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_DestroyStickyBombs : public CBaseTFAchievement
{
// Destroy X stickybombs with the Scottish Defender
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 100 );
SetStoreProgressInSteam( true );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_DestroyStickyBombs, ACHIEVEMENT_TF_DEMOMAN_DESTROY_X_STICKYBOMBS, "TF_DEMOMAN_DESTROY_X_STICKYBOMBS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_StickyJumpDistance : public CBaseTFAchievement
{
DECLARE_CLASS( CAchievementTFDemoman_StickyJumpDistance, CBaseTFAchievement );
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
SetGoal( 1 );
ResetTracking();
}
virtual bool IsActive()
{
return BaseClass::IsActive();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "teamplay_round_active" );
ListenForGameEvent( "localplayer_respawn" );
ListenForGameEvent( "sticky_jump" );
ListenForGameEvent( "sticky_jump_landed" );
ResetTracking();
}
void ResetTracking( void )
{
ClearThink();
m_vecStartJump = vec3_origin;
}
void CheckJump( void )
{
CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( pLocalTFPlayer )
{
// someone has messed with gravity, so reset our tracking
if ( GetCurrentGravity() != 800.0f )
{
ResetTracking();
return;
}
Vector vecCurrent = pLocalTFPlayer->GetAbsOrigin();
vecCurrent.z = 0;
float flDistSqr = (vecCurrent - m_vecStartJump).Length2DSqr();
if ( flDistSqr > (2048 * 2048) )
{
IncrementCount();
}
}
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEvent = event->GetName();
if ( FStrEq( pszEvent, "teamplay_round_active" ) ||
FStrEq( pszEvent, "localplayer_respawn" ) )
{
ResetTracking();
}
else if ( FStrEq( pszEvent, "sticky_jump" ) )
{
int iUserID = event->GetInt( "userid" );
CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( pLocalTFPlayer && pLocalTFPlayer->GetUserID() == iUserID )
{
m_vecStartJump = pLocalTFPlayer->GetAbsOrigin();
m_vecStartJump.z = 0;
SetNextThink( 0.1 );
}
}
else if ( FStrEq( pszEvent, "sticky_jump_landed" ) )
{
int iUserID = event->GetInt( "userid" );
CTFPlayer *pLocalTFPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( pLocalTFPlayer && pLocalTFPlayer->GetUserID() == iUserID )
{
CheckJump();
ResetTracking();
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( !pVictim || !pVictim->IsPlayer() )
return;
if ( pVictim == C_BasePlayer::GetLocalPlayer() )
{
ResetTracking();
}
}
virtual void Think( void )
{
CheckJump();
SetNextThink( 0.1 );
}
private:
Vector m_vecStartJump;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_StickyJumpDistance, ACHIEVEMENT_TF_DEMOMAN_STICKJUMP_DISTANCE, "TF_DEMOMAN_STICKJUMP_DISTANCE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_Kill3WithDetonation : public CBaseTFAchievement
{
// Destroy 3 players with a single pipebomb
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_Kill3WithDetonation, ACHIEVEMENT_TF_DEMOMAN_KILL3_WITH_DETONATION, "TF_DEMOMAN_KILL3_WITH_DETONATION", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillXSappingSpies : public CBaseTFAchievement
{
void Init()
{
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
SetGoal( 20 );
SetStoreProgressInSteam( true );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "player_sapped_object" );
m_hTargets.Purge();
}
int FindSpyInList( int iUserID )
{
for ( int i = m_hTargets.Count() - 1; i >= 0; i-- )
{
if ( m_hTargets[i].flTime < gpGlobals->curtime )
{
// time has run out on this one
m_hTargets.Remove( i );
continue;
}
if ( m_hTargets[i].nSpyUserID == iUserID )
return i;
}
return -1;
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFVictim && pTFVictim->IsPlayerClass( TF_CLASS_SPY ) )
{
int iIndex = FindSpyInList( pTFVictim->GetUserID() );
if ( iIndex != -1 )
{
IncrementCount();
m_hTargets.Remove( iIndex );
}
}
}
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEventName = event->GetName();
if ( FStrEq( pszEventName, "player_sapped_object" ) )
{
int nUserID = event->GetInt( "userid" );
int iIndex = FindSpyInList( nUserID );
if ( iIndex == -1 )
{
iIndex = m_hTargets.AddToTail();
m_hTargets[iIndex].nSpyUserID = nUserID;
}
m_hTargets[iIndex].flTime = gpGlobals->curtime + 5.0;
}
}
private:
struct targets_t
{
int nSpyUserID;
float flTime;
};
CUtlVector<targets_t> m_hTargets;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillXSappingSpies, ACHIEVEMENT_TF_DEMOMAN_KILLXSAPPINGSPIES, "TF_DEMOMAN_KILLXSAPPINGSPIES", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_Kill3WithPipeSetup : public CBaseTFAchievement
{
// Kill 3 players in separate explosions without placing new sticky bombs
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_FILTER_ATTACKER_IS_PLAYER | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ResetCounts();
}
void ResetCounts()
{
m_iConsecutiveKillsWithoutRefiring = 0;
m_flPrevKillTime = 0;
m_iPipebombCount = 0;
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
if ( event->GetInt( "weaponid" ) == TF_WEAPON_GRENADE_PIPEBOMB )
{
if ( !m_iConsecutiveKillsWithoutRefiring )
{
// We're starting.
m_iConsecutiveKillsWithoutRefiring = 1;
m_flPrevKillTime = gpGlobals->curtime;
m_iPipebombCount = pLocalPlayer->GetNumActivePipebombs();
SetNextThink( 0.1 );
}
else if ( (gpGlobals->curtime - m_flPrevKillTime) > 0.2 ) // Make sure it wasn't in the same detonation
{
m_iConsecutiveKillsWithoutRefiring++;
m_flPrevKillTime = gpGlobals->curtime;
if ( m_iConsecutiveKillsWithoutRefiring >= 3 )
{
IncrementCount();
}
}
}
}
virtual void Think( void )
{
CTFPlayer *pLocalPlayer = ToTFPlayer( C_TFPlayer::GetLocalPlayer() );
if ( !pLocalPlayer )
return;
int nPipes = pLocalPlayer->GetNumActivePipebombs();
if ( m_iPipebombCount < nPipes )
{
// They laid new pipes. We're done.
ResetCounts();
}
else
{
m_iPipebombCount = nPipes;
SetNextThink( 0.1 );
}
}
private:
int m_iPipebombCount;
int m_iConsecutiveKillsWithoutRefiring;
float m_flPrevKillTime;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_Kill3WithPipeSetup, ACHIEVEMENT_TF_DEMOMAN_KILL3_WITH_PIPE_SETUPS, "TF_DEMOMAN_KILL3_WITH_PIPE_SETUPS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_AchieveProgress1 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFDemoman_AchieveProgress1, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 5, ACHIEVEMENT_TF_DEMOMAN_START_RANGE, ACHIEVEMENT_TF_DEMOMAN_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AchieveProgress1, ACHIEVEMENT_TF_DEMOMAN_ACHIEVE_PROGRESS1, "TF_DEMOMAN_ACHIEVE_PROGRESS1", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_AchieveProgress2 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFDemoman_AchieveProgress2, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 11, ACHIEVEMENT_TF_DEMOMAN_START_RANGE, ACHIEVEMENT_TF_DEMOMAN_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AchieveProgress2, ACHIEVEMENT_TF_DEMOMAN_ACHIEVE_PROGRESS2, "TF_DEMOMAN_ACHIEVE_PROGRESS2", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_AchieveProgress3 : public CAchievement_AchievedCount
{
public:
DECLARE_CLASS( CAchievementTFDemoman_AchieveProgress3, CAchievement_AchievedCount );
void Init()
{
BaseClass::Init();
SetAchievementsRequired( 17, ACHIEVEMENT_TF_DEMOMAN_START_RANGE, ACHIEVEMENT_TF_DEMOMAN_END_RANGE );
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_AchieveProgress3, ACHIEVEMENT_TF_DEMOMAN_ACHIEVE_PROGRESS3, "TF_DEMOMAN_ACHIEVE_PROGRESS3", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_ParachuteKillGroup : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
ResetTracking();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "parachute_deploy" );
ListenForGameEvent( "parachute_holster" );
}
void ResetTracking( void )
{
m_nKills = 0;
m_bParachuteDeployed = false;
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEvent = event->GetName();
if ( FStrEq( pszEvent, "parachute_deploy" ) )
{
if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
{
ResetTracking();
m_bParachuteDeployed = true;
}
}
else if ( FStrEq( pszEvent, "parachute_holster" ) )
{
if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
{
ResetTracking();
}
}
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
if ( pVictim )
{
// Local player died
if ( pVictim == C_BasePlayer::GetLocalPlayer() )
{
ResetTracking();
}
else if ( pAttacker == C_BasePlayer::GetLocalPlayer() )
{
if ( m_bParachuteDeployed )
{
m_nKills++;
if ( m_nKills >= 3 )
{
IncrementCount();
}
}
}
}
}
private:
int m_nKills;
bool m_bParachuteDeployed;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ParachuteKillGroup, ACHIEVEMENT_TF_DEMOMAN_PARACHUTE_KILL_GROUP, "TF_DEMOMAN_PARACHUTE_KILL_GROUP", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_ParachuteDistance : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1233619 );
SetStoreProgressInSteam( true );
ResetTracking();
}
virtual void ListenForEvents()
{
ListenForGameEvent( "parachute_deploy" );
ListenForGameEvent( "parachute_holster" );
}
void ResetTracking( void )
{
ClearThink();
m_flLastZ = 0.0;
}
void CheckHeight( void )
{
CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
if ( pLocalPlayer )
{
float flCurrentZ = pLocalPlayer->GetAbsOrigin().z;
float flDela = m_flLastZ - flCurrentZ;
// make sure we've fallen....we may have been pushed upwards
if ( flDela > 0.0f )
{
IncrementCount( ( int )( flDela ) );
}
m_flLastZ = flCurrentZ;
}
}
void FireGameEvent_Internal( IGameEvent *event )
{
const char *pszEvent = event->GetName();
if ( FStrEq( pszEvent, "parachute_deploy" ) )
{
if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
{
CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
if ( pLocalPlayer )
{
m_flLastZ = pLocalPlayer->GetAbsOrigin().z;
SetNextThink( 0.1 );
}
}
}
else if ( FStrEq( pszEvent, "parachute_holster" ) )
{
if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
{
ResetTracking();
}
}
}
virtual void Think( void )
{
CheckHeight();
SetNextThink( 0.1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
// Local player died
if ( pVictim == C_BasePlayer::GetLocalPlayer() )
{
ResetTracking();
}
}
private:
float m_flLastZ;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ParachuteDistance, ACHIEVEMENT_TF_DEMOMAN_PARACHUTE_DISTANCE, "TF_DEMOMAN_PARACHUTE_DISTANCE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_ParachuteKillParachute : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFAttacker && pTFVictim && ( pTFAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
{
if ( ( pTFAttacker->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) ) && ( pTFVictim->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ParachuteKillParachute, ACHIEVEMENT_TF_DEMOMAN_PARACHUTE_KILL_PARACHUTE, "TF_DEMOMAN_PARACHUTE_KILL_PARACHUTE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_KillPlayerYouDidntSee : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
// server awards this achievement, no other code within achievement necessary
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_KillPlayerYouDidntSee, ACHIEVEMENT_TF_DEMOMAN_KILL_PLAYER_YOU_DIDNT_SEE, "TF_DEMOMAN_KILL_PLAYER_YOU_DIDNT_SEE", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_QuickKills : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void ListenForEvents()
{
ListenForGameEvent( "kill_refills_meter" );
}
void FireGameEvent_Internal( IGameEvent *event )
{
if ( FStrEq( event->GetName(), "kill_refills_meter" ) )
{
if ( event->GetInt( "index" ) == GetLocalPlayerIndex() )
{
int iNewIndex = m_Times.AddToTail();
m_Times[iNewIndex] = gpGlobals->curtime;
// we only care about the last three times we killed someone
if ( m_Times.Count() > 3 )
{
m_Times.Remove( 0 );
}
if ( m_Times.Count() == 3 )
{
if ( m_Times.Tail() - m_Times.Head() <= 6.0 )
{
IncrementCount();
}
}
}
}
}
private:
CUtlVector< float > m_Times;
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_QuickKills, ACHIEVEMENT_TF_DEMOMAN_QUICK_KILLS, "TF_DEMOMAN_QUICK_KILLS", 5 );
//----------------------------------------------------------------------------------------------------------------
class CAchievementTFDemoman_ChargeKillChargingDemo : public CBaseTFAchievement
{
public:
void Init()
{
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
SetGoal( 1 );
}
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
{
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
if ( pTFAttacker && pTFVictim && ( pTFAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
{
if ( pTFAttacker->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) && pTFVictim->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) )
{
IncrementCount();
}
}
}
};
DECLARE_ACHIEVEMENT( CAchievementTFDemoman_ChargeKillChargingDemo, ACHIEVEMENT_TF_DEMOMAN_CHARGE_KILL_CHARGING_DEMO, "TF_DEMOMAN_CHARGE_KILL_CHARGING_DEMO", 5 );
#endif // CLIENT_DLL