BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/shared/tf/achievements_tf.cpp

1496 lines
43 KiB
C++
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 "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
Reference in New Issue View Git Blame Copy Permalink