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.
1496 lines
43 KiB
1496 lines
43 KiB
![]()
4 years ago
|
//========= 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 "econ_wearable.h"
|
||
|
#include "achievements_tf.h"
|
||
|
|
||
|
// NVNT include for tf2 damage
|
||
|
#include "haptics/haptic_utils.h"
|
||
|
|
||
|
CAchievementMgr g_AchievementMgrTF; // global achievement mgr for TF
|
||
|
|
||
|
bool CheckWinNoEnemyCaps( IGameEvent *event, int iRole );
|
||
|
|
||
|
// Grace period that we allow a player to start after level init and still consider them to be participating for the full round. This is fairly generous
|
||
|
// because it can in some cases take a client several minutes to connect with respect to when the server considers the game underway
|
||
|
#define TF_FULL_ROUND_GRACE_PERIOD ( 4 * 60.0f )
|
||
|
|
||
|
bool IsLocalTFPlayerClass( int iClass );
|
||
|
|
||
|
|
||
|
bool CBaseTFAchievementSimple::LocalPlayerCanEarn( void )
|
||
|
{
|
||
|
if ( TFGameRules() )
|
||
|
{
|
||
|
bool bMVMAchievement = ( m_iAchievementID >= ACHIEVEMENT_TF_MVM_START_RANGE && m_iAchievementID <= ACHIEVEMENT_TF_MVM_END_RANGE );
|
||
|
|
||
|
if ( bMVMAchievement )
|
||
|
{
|
||
|
if ( !TFGameRules()->IsMannVsMachineMode() || ( GetLocalPlayerTeam() != TF_TEAM_PVE_DEFENDERS ) )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( TFGameRules()->IsMannVsMachineMode() )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return BaseClass::LocalPlayerCanEarn();
|
||
|
}
|
||
|
|
||
|
void CBaseTFAchievementSimple::FireGameEvent( IGameEvent *event )
|
||
|
{
|
||
|
if ( !LocalPlayerCanEarn() )
|
||
|
return;
|
||
|
|
||
|
BaseClass::FireGameEvent( event );
|
||
|
}
|
||
|
|
||
|
|
||
|
bool CBaseTFAchievement::LocalPlayerCanEarn( void )
|
||
|
{
|
||
|
// Swallow game events if we're not allowed to earn achievements, or if the local player isn't the right class
|
||
|
if ( !GameRulesAllowsAchievements() )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Determine class & check it
|
||
|
if ( m_iAchievementID >= ACHIEVEMENT_START_CLASS_SPECIFIC && m_iAchievementID <= ACHIEVEMENT_END_CLASS_SPECIFIC )
|
||
|
{
|
||
|
int iClass = floor( (m_iAchievementID - ACHIEVEMENT_START_CLASS_SPECIFIC) / 100.0f ) + 1;
|
||
|
if ( !IsLocalTFPlayerClass( iClass ) )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return BaseClass::LocalPlayerCanEarn();
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFAchievementFullRound::Init()
|
||
|
{
|
||
|
m_iFlags |= ACH_FILTER_FULL_ROUND_ONLY;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFAchievementFullRound::ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void CTFAchievementFullRound::FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
|
||
|
{
|
||
|
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
|
||
|
if ( pLocalPlayer )
|
||
|
{
|
||
|
// is the player currently on a game team?
|
||
|
int iTeam = pLocalPlayer->GetTeamNumber();
|
||
|
if ( iTeam >= FIRST_GAME_TEAM )
|
||
|
{
|
||
|
float flRoundTime = event->GetFloat( "round_time", 0 );
|
||
|
if ( flRoundTime > 0 )
|
||
|
{
|
||
|
Event_OnRoundComplete( flRoundTime, event );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CTFAchievementFullRound::PlayerWasInEntireRound( float flRoundTime )
|
||
|
{
|
||
|
float flTeamplayStartTime = m_pAchievementMgr->GetTeamplayStartTime();
|
||
|
if ( flTeamplayStartTime > 0 )
|
||
|
{
|
||
|
// has the player been present and on a game team since the start of this round (minus a grace period)?
|
||
|
if ( flTeamplayStartTime < ( gpGlobals->curtime - flRoundTime ) + TF_FULL_ROUND_GRACE_PERIOD )
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
class CAchievementTFPlayGameEveryClass : public CTFAchievementFullRound
|
||
|
{
|
||
|
DECLARE_CLASS( CAchievementTFPlayGameEveryClass, CTFAchievementFullRound );
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS | ACH_FILTER_FULL_ROUND_ONLY );
|
||
|
SetGoal( ( TF_LAST_NORMAL_CLASS - 1 ) - TF_FIRST_NORMAL_CLASS + 1 ); //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class
|
||
|
BaseClass::Init();
|
||
|
}
|
||
|
|
||
|
virtual void Event_OnRoundComplete( float flRoundTime, IGameEvent *event )
|
||
|
{
|
||
|
float flLastClassChangeTime = m_pAchievementMgr->GetLastClassChangeTime();
|
||
|
if ( flLastClassChangeTime > 0 )
|
||
|
{
|
||
|
// has the player been present and not changed class since the start of this round (minus a grace period)?
|
||
|
if ( flLastClassChangeTime < ( gpGlobals->curtime - flRoundTime ) + TF_FULL_ROUND_GRACE_PERIOD )
|
||
|
{
|
||
|
C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
if ( pTFPlayer )
|
||
|
{
|
||
|
int iClass = pTFPlayer->GetPlayerClass()->GetClassIndex();
|
||
|
if ( iClass >= TF_FIRST_NORMAL_CLASS && iClass <= ( TF_LAST_NORMAL_CLASS - 1 ) ) //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class
|
||
|
{
|
||
|
// yes, the achievement is satisfied for this class, set the corresponding bit
|
||
|
int iBitNumber =( iClass - TF_FIRST_NORMAL_CLASS );
|
||
|
EnsureComponentBitSetAndEvaluate( iBitNumber );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFPlayGameEveryClass, ACHIEVEMENT_TF_PLAY_GAME_EVERYCLASS, "TF_PLAY_GAME_EVERYCLASS", 5 );
|
||
|
|
||
|
class CAchievementTFPlayGameEveryMap : public CTFAchievementFullRound
|
||
|
{
|
||
|
DECLARE_CLASS( CAchievementTFPlayGameEveryMap, CTFAchievementFullRound );
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS | ACH_FILTER_FULL_ROUND_ONLY );
|
||
|
|
||
|
static const char *szComponents[] =
|
||
|
{
|
||
|
"cp_dustbowl", "cp_granary", "cp_gravelpit", "cp_well", "ctf_2fort", "tc_hydro"
|
||
|
};
|
||
|
m_pszComponentNames = szComponents;
|
||
|
m_iNumComponents = ARRAYSIZE( szComponents );
|
||
|
SetGoal( m_iNumComponents );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
virtual void Event_OnRoundComplete( float flRoundTime, IGameEvent *event )
|
||
|
{
|
||
|
float flTeamplayStartTime = m_pAchievementMgr->GetTeamplayStartTime();
|
||
|
if ( flTeamplayStartTime > 0 )
|
||
|
{
|
||
|
// has the player been present and on a game team since the start of this round (minus a grace period)?
|
||
|
if ( flTeamplayStartTime < ( gpGlobals->curtime - flRoundTime ) + TF_FULL_ROUND_GRACE_PERIOD )
|
||
|
{
|
||
|
// yes, the achievement is satisfied for this map, set the corresponding bit
|
||
|
OnComponentEvent( m_pAchievementMgr->GetMapName() );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFPlayGameEveryMap, ACHIEVEMENT_TF_PLAY_GAME_EVERYMAP, "TF_PLAY_GAME_EVERYMAP", 5 );
|
||
|
|
||
|
class CAchievementTFGetHealPoints : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 25000 );
|
||
|
}
|
||
|
|
||
|
void OnPlayerStatsUpdate()
|
||
|
{
|
||
|
ClassStats_t &classStats = CTFStatPanel::GetClassStats( TF_CLASS_MEDIC );
|
||
|
int iOldCount = m_iCount;
|
||
|
m_iCount = classStats.accumulated.m_iStat[TFSTAT_HEALING];
|
||
|
if ( m_iCount != iOldCount )
|
||
|
{
|
||
|
m_pAchievementMgr->SetDirty( true );
|
||
|
}
|
||
|
|
||
|
if ( IsLocalTFPlayerClass( TF_CLASS_MEDIC ) )
|
||
|
{
|
||
|
EvaluateNewAchievement();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFGetHealPoints, ACHIEVEMENT_TF_GET_HEALPOINTS, "TF_GET_HEALPOINTS", 5 );
|
||
|
|
||
|
class CAchievementTFBurnPlayersInMinimumTime : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFBurnPlayersInMinimumTime, ACHIEVEMENT_TF_BURN_PLAYERSINMINIMIMTIME, "TF_BURN_PLAYERSINMINIMUMTIME", 5 );
|
||
|
|
||
|
class CAchievementTFGetTurretKills : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFGetTurretKills, ACHIEVEMENT_TF_GET_TURRETKILLS, "TF_GET_TURRETKILLS", 5 );
|
||
|
|
||
|
class CAchievementTFGetHeadshots: public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 25 );
|
||
|
}
|
||
|
|
||
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
||
|
{
|
||
|
// was this a headshot by this player?
|
||
|
if ( ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) && ( IsHeadshot(event->GetInt( "customkill" ) ) ) )
|
||
|
{
|
||
|
// Increment count. Count will also get slammed whenever we get a stats update from server. They should generally agree,
|
||
|
// but server is authoritative.
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void OnPlayerStatsUpdate()
|
||
|
{
|
||
|
// when stats are updated by server, use most recent stat value
|
||
|
ClassStats_t &classStats = CTFStatPanel::GetClassStats( TF_CLASS_SNIPER );
|
||
|
int iOldCount = m_iCount;
|
||
|
m_iCount = classStats.accumulated.m_iStat[TFSTAT_HEADSHOTS];
|
||
|
if ( m_iCount != iOldCount )
|
||
|
{
|
||
|
m_pAchievementMgr->SetDirty( true );
|
||
|
}
|
||
|
|
||
|
if ( IsLocalTFPlayerClass( TF_CLASS_SNIPER ) )
|
||
|
{
|
||
|
EvaluateNewAchievement();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFGetHeadshots, ACHIEVEMENT_TF_GET_HEADSHOTS, "TF_GET_HEADSHOTS", 5 );
|
||
|
|
||
|
class CAchievementTFKillNemesis : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 5 );
|
||
|
}
|
||
|
|
||
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
||
|
{
|
||
|
if ( ( ( event->GetInt( "death_flags" ) & TF_DEATH_REVENGE ) ) && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
|
||
|
{
|
||
|
// local player got revenge as primary killer
|
||
|
IncrementCount();
|
||
|
}
|
||
|
else if ( event->GetInt( "death_flags" ) & TF_DEATH_ASSISTER_REVENGE )
|
||
|
{
|
||
|
int iAssisterIndex = engine->GetPlayerForUserID( event->GetInt( "assister" ) );
|
||
|
if ( iAssisterIndex > 0 )
|
||
|
{
|
||
|
CBaseEntity *pAssister = UTIL_PlayerByIndex( iAssisterIndex );
|
||
|
if ( pAssister && ( pAssister == C_TFPlayer::GetLocalTFPlayer() ) )
|
||
|
{
|
||
|
// local player got revenge as assister
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFKillNemesis, ACHIEVEMENT_TF_KILL_NEMESIS, "TF_KILL_NEMESIS", 5 );
|
||
|
|
||
|
class CAchievementTFGetConsecutiveKillsNoDeaths : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
m_iConsecutiveKills = 0;
|
||
|
}
|
||
|
|
||
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
||
|
{
|
||
|
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
|
||
|
if ( pLocalPlayer == pVictim )
|
||
|
{
|
||
|
m_iConsecutiveKills = 0;
|
||
|
}
|
||
|
else if ( pLocalPlayer == pAttacker )
|
||
|
{
|
||
|
m_iConsecutiveKills++;
|
||
|
if ( 5 == m_iConsecutiveKills )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
int m_iConsecutiveKills;
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFGetConsecutiveKillsNoDeaths, ACHIEVEMENT_TF_GET_CONSECUTIVEKILLS_NODEATHS, "TF_GET_CONSECUTIVEKILLS_NODEATHS", 10 );
|
||
|
|
||
|
class CAchievementTFGetHealedByEnemy: public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFGetHealedByEnemy, ACHIEVEMENT_TF_GET_HEALED_BYENEMY, "TF_GET_HEALED_BYENEMY", 15 );
|
||
|
|
||
|
class CAchievementTFPlayGameFriendsOnly : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_FILTER_FULL_ROUND_ONLY );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
|
||
|
{
|
||
|
// Are there at least 7 friends in the game? (at least 8 players total)
|
||
|
if ( CalcPlayersOnFriendsList( 7 ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFPlayGameFriendsOnly, ACHIEVEMENT_TF_PLAY_GAME_FRIENDSONLY, "TF_PLAY_GAME_FRIENDSONLY", 10 );
|
||
|
|
||
|
class CAchievementTFWinMultipleGames : public CTFAchievementFullRound
|
||
|
{
|
||
|
DECLARE_CLASS( CAchievementTFWinMultipleGames, CTFAchievementFullRound );
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_FILTER_FULL_ROUND_ONLY );
|
||
|
SetGoal( 20 );
|
||
|
BaseClass::Init();
|
||
|
}
|
||
|
|
||
|
virtual void Event_OnRoundComplete( float flRoundTime, IGameEvent *event )
|
||
|
{
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
if ( pLocalPlayer )
|
||
|
{
|
||
|
// was the player on the winning team?
|
||
|
int iPlayerTeam = pLocalPlayer->GetTeamNumber();
|
||
|
int iWinningTeam = event->GetInt( "team" );
|
||
|
if ( ( iWinningTeam >= FIRST_GAME_TEAM ) && ( iPlayerTeam == iWinningTeam ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFWinMultipleGames, ACHIEVEMENT_TF_WIN_MULTIPLEGAMES, "TF_WIN_MULTIPLEGAMES", 10 );
|
||
|
|
||
|
class CAchievementTFGetMultipleKills : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
// listen for player kill enemy events, base class will increment count each time that happens
|
||
|
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1000 );
|
||
|
}
|
||
|
|
||
|
void OnPlayerStatsUpdate()
|
||
|
{
|
||
|
// when stats are updated by server, use most recent stat values
|
||
|
|
||
|
int iKills = 0;
|
||
|
// get sum of kills per class across all classes to get total kills
|
||
|
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass <= ( TF_LAST_NORMAL_CLASS - 1 ); iClass++ ) //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class
|
||
|
{
|
||
|
ClassStats_t &classStats = CTFStatPanel::GetClassStats( iClass );
|
||
|
iKills += classStats.accumulated.m_iStat[TFSTAT_KILLS];
|
||
|
}
|
||
|
|
||
|
int iOldCount = m_iCount;
|
||
|
m_iCount = iKills;
|
||
|
if ( m_iCount != iOldCount )
|
||
|
{
|
||
|
m_pAchievementMgr->SetDirty( true );
|
||
|
}
|
||
|
|
||
|
EvaluateNewAchievement();
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFGetMultipleKills, ACHIEVEMENT_TF_GET_MULTIPLEKILLS, "TF_GET_MULTIPLEKILLS", 15 );
|
||
|
|
||
|
class CAchievementTFWin2FortNoEnemyCaps : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
SetMapNameFilter( "ctf_2fort" );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
|
||
|
{
|
||
|
if ( event->GetBool( "was_sudden_death" ) == false )
|
||
|
{
|
||
|
if ( event->GetInt( "team" ) == GetLocalPlayerTeam() )
|
||
|
{
|
||
|
// did the enemy team get any flag captures?
|
||
|
C_TFTeam *pEnemyTeam = GetGlobalTFTeam( TF_TEAM_BLUE + TF_TEAM_RED - GetLocalPlayerTeam() );
|
||
|
if ( 0 == pEnemyTeam->GetFlagCaptures() )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFWin2FortNoEnemyCaps, ACHIEVEMENT_TF_WIN_2FORT_NOENEMYCAPS, "TF_WIN_2FORT_NOENEMYCAPS", 5 );
|
||
|
|
||
|
class CAchievementTFWinWellMinimumTime : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
SetMapNameFilter( "cp_well" );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
|
||
|
{
|
||
|
if ( event->GetInt( "team" ) == GetLocalPlayerTeam() )
|
||
|
{
|
||
|
float flRoundTime = event->GetFloat( "round_time", 0 );
|
||
|
if ( flRoundTime > 0 && flRoundTime < 5 * 60 )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFWinWellMinimumTime, ACHIEVEMENT_TF_WIN_WELL_MINIMUMTIME, "TF_WIN_WELL_MINIMUMTIME", 10 );
|
||
|
|
||
|
class CAchievementTFWinHydroNoEnemyCaps : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_FILTER_FULL_ROUND_ONLY );
|
||
|
SetGoal( 1 );
|
||
|
SetMapNameFilter( "tc_hydro" );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
// winning hydro with no enemy caps means there were 2 previous minirounds completed (3 total for a shutout)
|
||
|
// and local player's team won the final round
|
||
|
if ( ( 2 == m_pAchievementMgr->GetMiniroundsCompleted() ) && ( CheckWinNoEnemyCaps( event, TEAM_ROLE_NONE ) ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFWinHydroNoEnemyCaps, ACHIEVEMENT_TF_WIN_HYDRO_NOENEMYCAPS, "TF_WIN_HYDRO_NOENEMYCAPS", 20 );
|
||
|
|
||
|
class CAchievementTFWinDustbowlNoEnemyCaps : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_FILTER_FULL_ROUND_ONLY );
|
||
|
SetGoal( 1 );
|
||
|
SetMapNameFilter( "cp_dustbowl" );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
// defending dustbowl with no enemy caps means there were no previous minirounds completed (that would be an attacker capture),
|
||
|
// the player was on the defending team and they won with no enemy caps
|
||
|
if ( ( 0 == m_pAchievementMgr->GetMiniroundsCompleted() ) && CheckWinNoEnemyCaps( event, TEAM_ROLE_DEFENDERS ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFWinDustbowlNoEnemyCaps, ACHIEVEMENT_TF_WIN_DUSTBOWL_NOENEMYCAPS, "TF_WIN_DUSTBOWL_NOENEMYCAPS", 10 );
|
||
|
|
||
|
class CAchievementTFWinGravelPitNoEnemyCaps : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
SetMapNameFilter( "cp_gravelpit" );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
// Was player on defenders and won with no enemy caps?
|
||
|
if ( CheckWinNoEnemyCaps( event, TEAM_ROLE_DEFENDERS ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFWinGravelPitNoEnemyCaps, ACHIEVEMENT_TF_WIN_GRAVELPIT_NOENEMYCAPS, "TF_WIN_GRAVELPIT_NOENEMYCAPS", 30 );
|
||
|
|
||
|
class CAchievementTFKillEnemiesAfterTeleporting : public CTFAchievementTeleporterTimingKills<CBaseAchievement>
|
||
|
{
|
||
|
// stub -- all code in parent class
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFKillEnemiesAfterTeleporting, ACHIEVEMENT_TF_GENERAL_KILL_ENEMIES_AFTER_TELEPORTING, "TF_GENERAL_KILL_ENEMIES_AFTER_TELEPORTING", 10 );
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: see if a round win was a win for the local player with no enemy caps
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool CheckWinNoEnemyCaps( IGameEvent *event, int iRole )
|
||
|
{
|
||
|
if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
|
||
|
{
|
||
|
if ( event->GetInt( "team" ) == GetLocalPlayerTeam() )
|
||
|
{
|
||
|
int iLosingTeamCaps = event->GetInt( "losing_team_num_caps" );
|
||
|
if ( 0 == iLosingTeamCaps )
|
||
|
{
|
||
|
C_TFTeam *pLocalTeam = GetGlobalTFTeam( GetLocalPlayerTeam() );
|
||
|
if ( pLocalTeam )
|
||
|
{
|
||
|
int iRolePlayer = pLocalTeam->GetRole();
|
||
|
if ( iRole > TEAM_ROLE_NONE && ( iRolePlayer != iRole ) )
|
||
|
return false;
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Helper function to determine if local player is specified class
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool IsLocalTFPlayerClass( int iClass )
|
||
|
{
|
||
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
||
|
return( pLocalPlayer && pLocalPlayer->IsPlayerClass( iClass ) );
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose: Query if the gamerules allows achievement progress at this time
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool GameRulesAllowsAchievements( void )
|
||
|
{
|
||
|
bool bRetVal = false;
|
||
|
|
||
|
if ( ( TFGameRules()->State_Get() < GR_STATE_TEAM_WIN ) ||
|
||
|
( TFGameRules()->State_Get() == GR_STATE_STALEMATE ) )
|
||
|
{
|
||
|
bRetVal = true;
|
||
|
}
|
||
|
|
||
|
return bRetVal;
|
||
|
}
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
// Receive the PlayerIgnitedInv user message and send out a clientside event for achievements to hook.
|
||
|
void __MsgFunc_PlayerIgnitedInv( bf_read &msg )
|
||
|
{
|
||
|
int iPyroEntIndex = (int) msg.ReadByte();
|
||
|
int iVictimEntIndex = (int) msg.ReadByte();
|
||
|
int iMedicEntIndex = (int) msg.ReadByte();
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_ignited_inv" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "pyro_entindex", iPyroEntIndex );
|
||
|
event->SetInt( "victim_entindex", iVictimEntIndex );
|
||
|
event->SetInt( "medic_entindex", iMedicEntIndex );
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Receive the PlayerIgnited user message and send out a clientside event for achievements to hook.
|
||
|
void __MsgFunc_PlayerIgnited( bf_read &msg )
|
||
|
{
|
||
|
int iPyroEntIndex = (int) msg.ReadByte();
|
||
|
int iVictimEntIndex = (int) msg.ReadByte();
|
||
|
int iWeaponID = (int) msg.ReadByte();
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_ignited" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "pyro_entindex", iPyroEntIndex );
|
||
|
event->SetInt( "victim_entindex", iVictimEntIndex );
|
||
|
event->SetInt( "weaponid", iWeaponID );
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Receive the Damage user message and send out a clientside event for achievements to hook.
|
||
|
void __MsgFunc_Damage( bf_read &msg )
|
||
|
{
|
||
|
int iDamage = msg.ReadShort();
|
||
|
int iDmgBits = msg.ReadLong();
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_damaged" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "amount", iDamage );
|
||
|
event->SetInt( "type", iDmgBits );
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
// NVNT START implementing rest of message for damage directions
|
||
|
if(iDamage == 0)
|
||
|
return; // no damage forces for no damage.
|
||
|
|
||
|
// get the local player.
|
||
|
C_TFPlayer *pLocal = C_TFPlayer::GetLocalTFPlayer();
|
||
|
if(!pLocal)
|
||
|
return;// if we dont have a local player ignore this message.
|
||
|
|
||
|
Vector attackerPosition(0,0,0);
|
||
|
if(msg.ReadOneBit())
|
||
|
{
|
||
|
// if we read one bit then that means we have shooters origin.
|
||
|
msg.ReadBitVec3Coord( attackerPosition );
|
||
|
}else{
|
||
|
// if it is non origin, just set the origin below the player
|
||
|
attackerPosition = pLocal->GetAbsOrigin() + Vector(0,0,-10);
|
||
|
}
|
||
|
// get the direction in world
|
||
|
Vector attackDirectionLocal(vec3_origin);
|
||
|
// rotate the direction to the local players view
|
||
|
pLocal->WorldToEntitySpace(attackerPosition, &attackDirectionLocal);
|
||
|
|
||
|
if ( haptics )
|
||
|
{
|
||
|
Vector hapticSpace( attackDirectionLocal.y, -attackDirectionLocal.z, attackDirectionLocal.x );
|
||
|
|
||
|
hapticSpace.NormalizeInPlace();
|
||
|
|
||
|
haptics->ApplyDamageEffect((float)iDamage, iDmgBits, hapticSpace);
|
||
|
}
|
||
|
// NVNT END
|
||
|
}
|
||
|
|
||
|
// Receive the UpdateAchievement user message and send out a clientside event for achievements to hook.
|
||
|
void __MsgFunc_UpdateAchievement( bf_read &msg )
|
||
|
{
|
||
|
int iIndex = (int) msg.ReadShort();
|
||
|
int nData = (int) msg.ReadShort();
|
||
|
|
||
|
g_AchievementMgrTF.UpdateAchievement( iIndex, nData );
|
||
|
}
|
||
|
|
||
|
// Receive the PlayerJarated user message and send out a clientside event for achievements to hook.
|
||
|
void __MsgFunc_PlayerJarated( bf_read &msg )
|
||
|
{
|
||
|
int iThrowerEntIndex = (int) msg.ReadByte();
|
||
|
int iVictimEntIndex = (int) msg.ReadByte();
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_jarated" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "thrower_entindex", iThrowerEntIndex );
|
||
|
event->SetInt( "victim_entindex", iVictimEntIndex );
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void __MsgFunc_PlayerJaratedFade( bf_read &msg )
|
||
|
{
|
||
|
int iThrowerEntIndex = (int) msg.ReadByte();
|
||
|
int iVictimEntIndex = (int) msg.ReadByte();
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_jarated_fade" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "thrower_entindex", iThrowerEntIndex );
|
||
|
event->SetInt( "victim_entindex", iVictimEntIndex );
|
||
|
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
}
|
||
|
//This is so dumb.
|
||
|
void __MsgFunc_PlayerShieldBlocked( bf_read &msg )
|
||
|
{
|
||
|
int iAttacker = (int) msg.ReadByte();
|
||
|
int iBlocker = (int) msg.ReadByte();
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_shield_blocked" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "attacker_entindex", iAttacker );
|
||
|
event->SetInt( "blocker_entindex", iBlocker );
|
||
|
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Receive the PlayerExtinguished user message and send out a clientside event for achievements to hook.
|
||
|
void __MsgFunc_PlayerExtinguished( bf_read &msg )
|
||
|
{
|
||
|
int iMedicEntIndex = (int) msg.ReadByte();
|
||
|
int iVictimEntIndex = (int) msg.ReadByte();
|
||
|
|
||
|
IGameEvent *event = gameeventmanager->CreateEvent( "player_extinguished" );
|
||
|
if ( event )
|
||
|
{
|
||
|
event->SetInt( "victim", iVictimEntIndex );
|
||
|
event->SetInt( "healer", iMedicEntIndex );
|
||
|
|
||
|
gameeventmanager->FireEventClientSide( event );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CAchievementTopScoreboard::Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_FILTER_FULL_ROUND_ONLY );
|
||
|
SetGoal(1);
|
||
|
}
|
||
|
|
||
|
void CAchievementTopScoreboard::ListenForEvents()
|
||
|
{
|
||
|
BaseClass::ListenForEvents();
|
||
|
ListenForGameEvent( "teamplay_round_active" );
|
||
|
}
|
||
|
|
||
|
void CAchievementTopScoreboard::Event_OnRoundComplete( float flRoundTime, IGameEvent *event )
|
||
|
{
|
||
|
if ( PlayerWasInEntireRound( flRoundTime ) )
|
||
|
{
|
||
|
int iLocalTeam = C_TFPlayer::GetLocalTFPlayer()->GetTeamNumber();
|
||
|
|
||
|
if ( GetGlobalTFTeam(iLocalTeam) && GetGlobalTFTeam(iLocalTeam)->GetNumPlayers() >= 6 )
|
||
|
{
|
||
|
if ( g_TF_PR )
|
||
|
{
|
||
|
bool bHighest = true;
|
||
|
int iLocalScore = g_TF_PR->GetTotalScore( C_TFPlayer::GetLocalTFPlayer()->entindex() );
|
||
|
|
||
|
// See if the player's on the top of the scoreboard
|
||
|
for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
|
||
|
{
|
||
|
if ( !g_PR->IsConnected( playerIndex ) || g_PR->IsLocalPlayer( playerIndex ) )
|
||
|
continue;
|
||
|
|
||
|
if ( g_PR->GetTeam(playerIndex) != iLocalTeam )
|
||
|
continue;
|
||
|
|
||
|
if ( g_TF_PR->GetTotalScore(playerIndex) > iLocalScore )
|
||
|
{
|
||
|
bHighest = false;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( bHighest )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
// Purpose:
|
||
|
//-----------------------------------------------------------------------------
|
||
|
extern int Training_GetNumCourses();
|
||
|
extern int Training_GetProgressCount();
|
||
|
class CAchievementTFCompleteTraining : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
DECLARE_CLASS( CAchievementTFCompleteTraining, CBaseAchievement );
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS );
|
||
|
SetGoal( Training_GetNumCourses() );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
SetCount( Training_GetProgressCount() );
|
||
|
BaseClass::Init();
|
||
|
}
|
||
|
|
||
|
virtual void UpdateAchievement( int nData )
|
||
|
{
|
||
|
SetCount( nData );
|
||
|
EvaluateNewAchievement();
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFCompleteTraining, ACHIEVEMENT_TF_COMPLETE_TRAINING, "TF_COMPLETE_TRAINING", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_FireWaterJump : public CBaseTFAchievement
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_FireWaterJump, ACHIEVEMENT_TF_FIRE_WATERJUMP, "TF_FIRE_WATERJUMP", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTFChristmasCollectGifts : public CBaseTFAchievementSimple
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 3 );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "christmas_gift_grab" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( !TFGameRules()->IsHolidayActive( kHoliday_Christmas ) )
|
||
|
return;
|
||
|
|
||
|
if ( Q_strcmp( event->GetName(), "christmas_gift_grab" ) == 0 )
|
||
|
{
|
||
|
int iPlayer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
|
||
|
CBaseEntity *pPlayer = UTIL_PlayerByIndex( iPlayer );
|
||
|
|
||
|
if ( pPlayer && pPlayer == C_TFPlayer::GetLocalTFPlayer() )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFChristmasCollectGifts, ACHIEVEMENT_TF_CHRISTMAS_COLLECT_GIFTS, "TF_CHRISTMAS_COLLECT_GIFTS", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_KillBalloonicornOwners : public CBaseTFAchievement
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 79 );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
}
|
||
|
|
||
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
||
|
{
|
||
|
CSchemaItemDefHandle pItemDef_Balloonicorn( "Pet Balloonicorn" );
|
||
|
CSchemaItemDefHandle pItemDef_BalloonicornPromo( "Pet Balloonicorn Promo" );
|
||
|
CSchemaItemDefHandle pItemDef_BalloonicornPlushPromo( "Pet Balloonicorn Plush Promo" );
|
||
|
CSchemaItemDefHandle pItemDef_Reindoonicorn( "Pet Reindoonicorn" );
|
||
|
|
||
|
C_TFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
||
|
if ( pLocalPlayer )
|
||
|
{
|
||
|
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
|
||
|
|
||
|
if ( pTFVictim && ( pAttacker == pLocalPlayer ) && ( pTFVictim->GetTeamNumber() != pLocalPlayer->GetTeamNumber() ) )
|
||
|
{
|
||
|
int nVisionOptInFlags = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalPlayer, nVisionOptInFlags, vision_opt_in_flags );
|
||
|
|
||
|
// Does the local player have PyroVision on?
|
||
|
if ( nVisionOptInFlags & TF_VISION_FILTER_PYRO )
|
||
|
{
|
||
|
// Is the victim wearing the Balloonicorn?
|
||
|
for ( int i = 0 ; i < pTFVictim->GetNumWearables() ; ++i )
|
||
|
{
|
||
|
C_EconWearable *pWearable = pTFVictim->GetWearable( i );
|
||
|
if ( pWearable && pWearable->GetAttributeContainer() )
|
||
|
{
|
||
|
CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem();
|
||
|
if ( pItem && pItem->IsValid() )
|
||
|
{
|
||
|
if ( pItem->GetItemDefinition() == pItemDef_Balloonicorn ||
|
||
|
pItem->GetItemDefinition() == pItemDef_BalloonicornPromo ||
|
||
|
pItem->GetItemDefinition() == pItemDef_BalloonicornPlushPromo ||
|
||
|
pItem->GetItemDefinition() == pItemDef_Reindoonicorn )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_KillBalloonicornOwners, ACHIEVEMENT_TF_KILL_BALLOONICORN_OWNERS, "TF_KILL_BALLOONICORN_OWNERS", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_MultipleBFF : public CBaseTFAchievement
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_LISTEN_KILL_EVENTS | ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents( void )
|
||
|
{
|
||
|
ListenForGameEvent( "remove_nemesis_relationships" );
|
||
|
|
||
|
// clear data on level init
|
||
|
m_hBFFs.Purge();
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( FStrEq( event->GetName(), "remove_nemesis_relationships" ) )
|
||
|
{
|
||
|
int iPlayerIndex = event->GetInt( "player" );
|
||
|
if ( iPlayerIndex == GetLocalPlayerIndex() )
|
||
|
{
|
||
|
// this is the local player, clear our list
|
||
|
m_hBFFs.Purge();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// is this player in our list?
|
||
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
|
||
|
|
||
|
int index = m_hBFFs.Find( pPlayer );
|
||
|
if ( index != m_hBFFs.InvalidIndex() )
|
||
|
{
|
||
|
m_hBFFs.Remove( index );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void ValidateList( void )
|
||
|
{
|
||
|
// remove anyone on the local player's team to clean up changing teams, getting
|
||
|
// team balanced, etc., if they're still on the other team, we're fine.
|
||
|
for ( int i = m_hBFFs.Count() - 1 ; i >= 0 ; i-- )
|
||
|
{
|
||
|
C_TFPlayer *pPlayer = m_hBFFs[i];
|
||
|
if ( pPlayer->GetTeamNumber() == GetLocalPlayerTeam() )
|
||
|
{
|
||
|
m_hBFFs.Remove( i );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
||
|
{
|
||
|
C_TFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
||
|
if ( pLocalPlayer )
|
||
|
{
|
||
|
CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
|
||
|
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
|
||
|
int iDeathFlags = event->GetInt( "death_flags" );
|
||
|
bool bDomination = ( iDeathFlags & TF_DEATH_DOMINATION ) || ( iDeathFlags & TF_DEATH_ASSISTER_DOMINATION );
|
||
|
bool bRevenge = ( iDeathFlags & TF_DEATH_REVENGE ) || ( iDeathFlags & TF_DEATH_ASSISTER_REVENGE );
|
||
|
|
||
|
if ( pTFVictim && ( pTFAttacker == pLocalPlayer ) && bDomination )
|
||
|
{
|
||
|
ValidateList();
|
||
|
|
||
|
int nVisionOptInFlags = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalPlayer, nVisionOptInFlags, vision_opt_in_flags );
|
||
|
|
||
|
if ( nVisionOptInFlags & TF_VISION_FILTER_PYRO )
|
||
|
{
|
||
|
int index = m_hBFFs.Find( pTFVictim );
|
||
|
if ( index == m_hBFFs.InvalidIndex() )
|
||
|
{
|
||
|
m_hBFFs.AddToHead( pTFVictim );
|
||
|
}
|
||
|
|
||
|
if ( m_hBFFs.Count() >= 2 )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else if ( pTFAttacker && ( pTFVictim == pLocalPlayer ) && bRevenge )
|
||
|
{
|
||
|
ValidateList();
|
||
|
|
||
|
int index = m_hBFFs.Find( pTFAttacker );
|
||
|
if ( index != m_hBFFs.InvalidIndex() )
|
||
|
{
|
||
|
m_hBFFs.Remove( index );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
CUtlVector< CHandle<C_TFPlayer> > m_hBFFs;
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_MultipleBFF, ACHIEVEMENT_TF_MULTIPLE_BFF, "TF_MULTIPLE_BFF", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_TeamPyrovision : public CBaseTFAchievement
|
||
|
{
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
|
||
|
SetNextThink( 1.0 );
|
||
|
}
|
||
|
|
||
|
virtual void Think( void )
|
||
|
{
|
||
|
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
|
||
|
if ( pLocalPlayer && ( pLocalPlayer->GetTeamNumber() >= FIRST_GAME_TEAM ) )
|
||
|
{
|
||
|
int nVisionOptInFlags = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalPlayer, nVisionOptInFlags, vision_opt_in_flags );
|
||
|
|
||
|
if ( nVisionOptInFlags & TF_VISION_FILTER_PYRO )
|
||
|
{
|
||
|
int nCount = 0;
|
||
|
|
||
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
|
||
|
{
|
||
|
C_BasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
||
|
if ( !pPlayer )
|
||
|
continue;
|
||
|
|
||
|
if ( pPlayer == pLocalPlayer )
|
||
|
{
|
||
|
nCount++;
|
||
|
}
|
||
|
else if ( pPlayer->GetTeamNumber() == pLocalPlayer->GetTeamNumber() )
|
||
|
{
|
||
|
int nTempFlags = 0;
|
||
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, nTempFlags, vision_opt_in_flags );
|
||
|
|
||
|
if ( nTempFlags & TF_VISION_FILTER_PYRO )
|
||
|
{
|
||
|
nCount++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( nCount >= 6 )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
ClearThink();
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
SetNextThink( 1.0 );
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_TeamPyrovision, ACHIEVEMENT_TF_TEAM_PYROVISION, "TF_TEAM_PYROVISION", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_DominateForGoggles : public CBaseTFAchievement
|
||
|
{
|
||
|
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 );
|
||
|
bool bDomination = event->GetInt( "death_flags" ) & TF_DEATH_DOMINATION;
|
||
|
|
||
|
if ( pTFVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) && ( bDomination == true ) )
|
||
|
{
|
||
|
// are they wearing the PyroVision goggles?
|
||
|
for ( int i = 0 ; i < pTFVictim->GetNumWearables() ; ++i )
|
||
|
{
|
||
|
C_EconWearable *pWearable = pTFVictim->GetWearable( i );
|
||
|
if ( pWearable && pWearable->GetAttributeContainer() )
|
||
|
{
|
||
|
CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem();
|
||
|
if ( pItem && pItem->IsValid() )
|
||
|
{
|
||
|
if ( ( pItem->GetItemDefIndex() == 743 ) || // Autogrant PyroVision Goggles
|
||
|
( pItem->GetItemDefIndex() == 744 ) ) // PyroVision Goggles
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_DominateForGoggles, ACHIEVEMENT_TF_DOMINATE_FOR_GOGGLES, "TF_DOMINATE_FOR_GOGGLES", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_ParachuteKillGrind : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS | ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 10 );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
}
|
||
|
|
||
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
||
|
{
|
||
|
CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
|
||
|
if ( pTFVictim && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
|
||
|
{
|
||
|
if ( pTFVictim->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_ParachuteKillGrind, ACHIEVEMENT_TF_PARACHUTE_KILL_GRIND, "TF_PARACHUTE_KILL_GRIND", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_MeleeKillClassicRifleSniper : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 10 );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
}
|
||
|
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_MeleeKillClassicRifleSniper, ACHIEVEMENT_TF_MELEE_KILL_CLASSIC_RIFLE_SNIPER, "TF_MELEE_KILL_CLASSIC_RIFLE_SNIPER", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_KillChargingDemo : 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 && ( pAttacker == C_TFPlayer::GetLocalTFPlayer() ) )
|
||
|
{
|
||
|
if ( pTFVictim->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_KillChargingDemo, ACHIEVEMENT_TF_KILL_CHARGING_DEMO, "TF_KILL_CHARGING_DEMO", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTFTaunt_CongaKill : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents( void )
|
||
|
{
|
||
|
ListenForGameEvent( "conga_kill" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( FStrEq( event->GetName(), "conga_kill" ) )
|
||
|
{
|
||
|
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() <= 5.0 )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
CUtlVector< float > m_Times;
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFTaunt_CongaKill, ACHIEVEMENT_TF_TAUNT_CONGA_KILL, "TF_TAUNT_CONGA_KILL", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTFTaunt_CongaLine : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFTaunt_CongaLine, ACHIEVEMENT_TF_TAUNT_CONGA_LINE, "TF_TAUNT_CONGA_LINE", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTFTaunt_RPSRock : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
m_iCount = 0;
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents( void )
|
||
|
{
|
||
|
ListenForGameEvent( "rps_taunt_event" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( FStrEq( event->GetName(), "rps_taunt_event" ) )
|
||
|
{
|
||
|
if ( event->GetInt( "winner" ) == GetLocalPlayerIndex() )
|
||
|
{
|
||
|
m_iCount = 0;
|
||
|
}
|
||
|
else if ( event->GetInt( "loser" ) == GetLocalPlayerIndex() )
|
||
|
{
|
||
|
if ( event->GetInt( "loser_rps" ) == 0 ) // 0:rock 1:paper 2:scissors
|
||
|
{
|
||
|
m_iCount++;
|
||
|
if ( m_iCount >= 3 )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_iCount = 0;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
int m_iCount;
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFTaunt_RPSRock, ACHIEVEMENT_TF_TAUNT_RPS_ROCK, "TF_TAUNT_RPS_ROCK", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTFTaunt_RPSScissors : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
m_iCount = 0;
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents( void )
|
||
|
{
|
||
|
ListenForGameEvent( "rps_taunt_event" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( FStrEq( event->GetName(), "rps_taunt_event" ) )
|
||
|
{
|
||
|
if ( event->GetInt( "winner" ) == GetLocalPlayerIndex() )
|
||
|
{
|
||
|
if ( event->GetInt( "winner_rps" ) == 2 ) // 0:rock 1:paper 2:scissors
|
||
|
{
|
||
|
m_iCount++;
|
||
|
if ( m_iCount >= 3 )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_iCount = 0;
|
||
|
}
|
||
|
}
|
||
|
else if ( event->GetInt( "loser" ) == GetLocalPlayerIndex() )
|
||
|
{
|
||
|
m_iCount = 0;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
int m_iCount;
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFTaunt_RPSScissors, ACHIEVEMENT_TF_TAUNT_RPS_SCISSORS, "TF_TAUNT_RPS_SCISSORS", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTFTaunt_DosidoMeleeKill : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 10 );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
}
|
||
|
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFTaunt_DosidoMeleeKill, ACHIEVEMENT_TF_TAUNT_DOSIDO_MELLE_KILL, "TF_TAUNT_DOSIDO_MELLE_KILL", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTFTaunt_TauntWhileCapping : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 10 );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
}
|
||
|
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTFTaunt_TauntWhileCapping, ACHIEVEMENT_TF_TAUNT_WHILE_CAPPING, "TF_TAUNT_WHILE_CAPPING", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_PassTimeHat : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 1 );
|
||
|
}
|
||
|
|
||
|
// server awards this achievement, no other code within achievement necessary
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_PassTimeHat, ACHIEVEMENT_TF_PASS_TIME_HAT, "TF_PASS_TIME_HAT", 5 );
|
||
|
|
||
|
//----------------------------------------------------------------------------------------------------------------
|
||
|
class CAchievementTF_PassTimeGrind : public CBaseTFAchievement
|
||
|
{
|
||
|
public:
|
||
|
void Init()
|
||
|
{
|
||
|
SetFlags( ACH_SAVE_GLOBAL );
|
||
|
SetGoal( 10 );
|
||
|
SetStoreProgressInSteam( true );
|
||
|
}
|
||
|
|
||
|
virtual void ListenForEvents()
|
||
|
{
|
||
|
ListenForGameEvent( "teamplay_round_win" );
|
||
|
}
|
||
|
|
||
|
void FireGameEvent_Internal( IGameEvent *event )
|
||
|
{
|
||
|
if ( TFGameRules() && TFGameRules()->IsPasstimeMode() )
|
||
|
{
|
||
|
if ( FStrEq( event->GetName(), "teamplay_round_win" ) )
|
||
|
{
|
||
|
// Were we on the winning team?
|
||
|
int iTeam = event->GetInt( "team" );
|
||
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
|
||
|
{
|
||
|
IncrementCount();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
DECLARE_ACHIEVEMENT( CAchievementTF_PassTimeGrind, ACHIEVEMENT_TF_PASS_TIME_GRIND, "TF_PASS_TIME_GRIND", 5 );
|
||
|
|
||
|
#endif // CLIENT_DLL
|