1456 lines
42 KiB
C++
1456 lines
42 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
|
|
#include "cbase.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
#include "achievementmgr.h"
|
|
#include "baseachievement.h"
|
|
#include "tf_hud_statpanel.h"
|
|
#include "c_tf_team.h"
|
|
#include "c_tf_player.h"
|
|
#include "c_tf_playerresource.h"
|
|
#include "tf_gamerules.h"
|
|
#include "achievements_tf.h"
|
|
#include "c_team_objectiveresource.h"
|
|
|
|
|
|
//======================================================================================================================================
|
|
// FOUNDRY ACHIEVEMENT PACK
|
|
//======================================================================================================================================
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_KillCappingEnemy : public CBaseTFAchievementSimple
|
|
{
|
|
public:
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
}
|
|
|
|
// server awards this achievement, no other code within achievement necessary
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_KillCappingEnemy, ACHIEVEMENT_TF_MAPS_FOUNDRY_KILL_CAPPING_ENEMY, "TF_MAPS_FOUNDRY_KILL_CAPPING_ENEMY", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_PlayGameFriends : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
}
|
|
|
|
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 5 friends in the game? (at least 6 players total)
|
|
if ( CalcPlayersOnFriendsList( 5 ) )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PlayGameFriends, ACHIEVEMENT_TF_MAPS_FOUNDRY_PLAY_GAME_FRIENDS, "TF_MAPS_FOUNDRY_PLAY_GAME_FRIENDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_WinMinTime : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
|
|
{
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
|
|
{
|
|
float flRoundTime = event->GetFloat( "round_time", 0 );
|
|
if ( flRoundTime > 0 && flRoundTime < 2 * 60 )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_WinMinTime, ACHIEVEMENT_TF_MAPS_FOUNDRY_WIN_MINTIME, "TF_MAPS_FOUNDRY_WIN_MINTIME", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_WinRounds : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 137 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( 0 == Q_strcmp( 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( CAchievementTFFoundry_WinRounds, ACHIEVEMENT_TF_MAPS_FOUNDRY_WIN_ROUNDS, "TF_MAPS_FOUNDRY_WIN_ROUNDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_FastFinalCap : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
|
|
ResetCounts();
|
|
}
|
|
|
|
void ResetCounts()
|
|
{
|
|
m_bRecentCapper = false;
|
|
iCapCount = 0;
|
|
iCapTimes[0] = 0.0f;
|
|
iCapTimes[1] = 0.0f;
|
|
}
|
|
|
|
virtual void ListenForEvents( void )
|
|
{
|
|
ListenForGameEvent( "teamplay_point_captured" );
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( !pLocalPlayer )
|
|
return;
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
|
|
{
|
|
m_bRecentCapper = false;
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) )
|
|
{
|
|
iCapTimes[iCapCount%2] = gpGlobals->curtime;
|
|
iCapCount++;
|
|
|
|
const char *cappers = event->GetString( "cappers" );
|
|
for ( int i = 0 ; i < Q_strlen( cappers ) ; i++ )
|
|
{
|
|
int iPlayerIndex = (int) cappers[i];
|
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
|
|
if ( pPlayer == pLocalPlayer )
|
|
{
|
|
m_bRecentCapper = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
|
|
{
|
|
// If we're the winners and we were involved in capping the last point, we get this achievement.
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) && m_bRecentCapper )
|
|
{
|
|
if ( fabs( iCapTimes[1] - iCapTimes[0] ) <= 5.0f )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
|
|
ResetCounts();
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
|
|
{
|
|
ResetCounts();
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_bRecentCapper;
|
|
int iCapCount;
|
|
float iCapTimes[2];
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_FastFinalCap, ACHIEVEMENT_TF_MAPS_FOUNDRY_FAST_FINAL_CAP, "TF_MAPS_FOUNDRY_FAST_FINAL_CAP", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_TeleportAndCap : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
}
|
|
|
|
virtual void ListenForEvents( void )
|
|
{
|
|
ListenForGameEvent( "teamplay_point_captured" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( !pLocalPlayer )
|
|
return;
|
|
|
|
if ( !pLocalPlayer->m_Shared.InCond( TF_COND_TELEPORTED ) )
|
|
return;
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
|
|
{
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) )
|
|
{
|
|
const char *cappers = event->GetString( "cappers" );
|
|
for ( int i = 0 ; i < Q_strlen( cappers ) ; i++ )
|
|
{
|
|
int iPlayerIndex = (int) cappers[i];
|
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
|
|
if ( pPlayer == pLocalPlayer )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_TeleportAndCap, ACHIEVEMENT_TF_MAPS_FOUNDRY_TELEPORT_AND_CAP, "TF_MAPS_FOUNDRY_TELEPORT_AND_CAP", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_PushIntoCauldron : public CBaseTFAchievementSimple
|
|
{
|
|
public:
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
}
|
|
|
|
// server awards this achievement, no other code within achievement necessary
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PushIntoCauldron, ACHIEVEMENT_TF_MAPS_FOUNDRY_PUSH_INTO_CAULDRON, "TF_MAPS_FOUNDRY_PUSH_INTO_CAULDRON", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_PushBackAndWin : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
|
|
m_bFinalPointContested = false;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
ListenForGameEvent( "teamplay_point_startcapture" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
ListenForGameEvent( "localplayer_changeteam" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_round_win" ) )
|
|
{
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
|
|
{
|
|
if ( m_bFinalPointContested )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
|
|
{
|
|
if ( ObjectiveResource() && ( ObjectiveResource()->GetBaseControlPointForTeam( GetLocalPlayerTeam() ) == event->GetInt( "cp" ) ) )
|
|
{
|
|
m_bFinalPointContested = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) || FStrEq( pszEventName, "localplayer_changeteam" ) )
|
|
{
|
|
m_bFinalPointContested = false;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_bFinalPointContested;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PushBackAndWin, ACHIEVEMENT_TF_MAPS_FOUNDRY_PUSH_BACK_AND_WIN, "TF_MAPS_FOUNDRY_PUSH_BACK_AND_WIN", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_PlayEachClass : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
|
|
m_iClassesPlayed = 0;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
|
{
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && ( pVictim != pAttacker ) && ( pLocalPlayer->m_Shared.GetDesiredPlayerClassIndex() > TF_CLASS_UNDEFINED ) )
|
|
{
|
|
m_iClassesPlayed |= ( 1 << pLocalPlayer->m_Shared.GetDesiredPlayerClassIndex() );
|
|
|
|
if ( m_iClassesPlayed == 1022 )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( FStrEq( event->GetName(), "teamplay_round_start" ) )
|
|
{
|
|
m_iClassesPlayed = 0;
|
|
}
|
|
}
|
|
|
|
private:
|
|
int m_iClassesPlayed;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_PlayEachClass, ACHIEVEMENT_TF_MAPS_FOUNDRY_PLAY_EACH_CLASS, "TF_MAPS_FOUNDRY_PLAY_EACH_CLASS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_KillEnemyOnRoof : public CBaseTFAchievementSimple
|
|
{
|
|
public:
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
|
|
iKillCount = 0;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
ListenForGameEvent( "player_killed_achievement_zone" );
|
|
}
|
|
|
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
|
{
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( pLocalPlayer && ( pLocalPlayer == pVictim ) )
|
|
{
|
|
iKillCount = 0;
|
|
}
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_round_start" ) )
|
|
{
|
|
iKillCount = 0;
|
|
}
|
|
else if ( FStrEq( pszEventName, "player_killed_achievement_zone" ) )
|
|
{
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "attacker" ) ) );
|
|
CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "victim" ) ) );
|
|
|
|
if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && pVictim && ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
|
|
{
|
|
iKillCount++;
|
|
if ( iKillCount >= 2 )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
int iKillCount;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_KillEnemyOnRoof, ACHIEVEMENT_TF_MAPS_FOUNDRY_KILL_ENEMY_ON_ROOF, "TF_MAPS_FOUNDRY_KILL_ENEMY_ON_ROOF", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_BackAndForthBattle : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_foundry" );
|
|
|
|
m_iCapCount = 0;
|
|
}
|
|
|
|
virtual void ListenForEvents( void )
|
|
{
|
|
ListenForGameEvent( "teamplay_point_captured" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( !pLocalPlayer )
|
|
return;
|
|
|
|
if ( pLocalPlayer->GetTeamNumber() < FIRST_GAME_TEAM )
|
|
return;
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
|
|
{
|
|
// we don't care which team is capping or which point is capped for this achievement
|
|
m_iCapCount++;
|
|
|
|
if ( m_iCapCount >= 15 )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
|
|
{
|
|
m_iCapCount = 0;
|
|
}
|
|
}
|
|
|
|
private:
|
|
int m_iCapCount;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_BackAndForthBattle, ACHIEVEMENT_TF_MAPS_FOUNDRY_BACK_AND_FORTH_BATTLE, "TF_MAPS_FOUNDRY_BACK_AND_FORTH_BATTLE", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFFoundry_AchieveProgress1 : public CAchievement_AchievedCount
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CAchievementTFFoundry_AchieveProgress1, CAchievement_AchievedCount );
|
|
void Init()
|
|
{
|
|
BaseClass::Init();
|
|
SetAchievementsRequired( 7, ACHIEVEMENT_TF_MAPS_FOUNDRY_START_RANGE, ACHIEVEMENT_TF_MAPS_FOUNDRY_END_RANGE );
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFFoundry_AchieveProgress1, ACHIEVEMENT_TF_MAPS_FOUNDRY_ACHIEVE_PROGRESS1, "TF_MAPS_FOUNDRY_ACHIEVE_PROGRESS1", 5 );
|
|
|
|
|
|
//======================================================================================================================================
|
|
// DOOMSDAY ACHIEVEMENT PACK
|
|
//======================================================================================================================================
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_SoloCapture : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "sd_doomsday" );
|
|
|
|
m_bCarriedFromHome = false;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_flag_event" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_flag_event" ) )
|
|
{
|
|
int iPlayer = event->GetInt( "player" );
|
|
int iType = event->GetInt( "eventtype" );
|
|
bool bHome = ( event->GetInt( "home", 0 ) == 1 );
|
|
|
|
switch( iType )
|
|
{
|
|
case TF_FLAGEVENT_PICKUP:
|
|
if ( ( iPlayer == GetLocalPlayerIndex() ) && bHome )
|
|
{
|
|
m_bCarriedFromHome = true;
|
|
}
|
|
else
|
|
{
|
|
m_bCarriedFromHome = false;
|
|
}
|
|
break;
|
|
case TF_FLAGEVENT_CAPTURE:
|
|
if ( ( iPlayer == GetLocalPlayerIndex() ) && m_bCarriedFromHome )
|
|
{
|
|
IncrementCount();
|
|
}
|
|
break;
|
|
default:
|
|
m_bCarriedFromHome = false;
|
|
break;
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
|
|
{
|
|
m_bCarriedFromHome = false;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_bCarriedFromHome;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_SoloCapture, ACHIEVEMENT_TF_MAPS_DOOMSDAY_SOLO_CAPTURE, "TF_MAPS_DOOMSDAY_SOLO_CAPTURE", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_PlayGameFriends : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "sd_doomsday" );
|
|
}
|
|
|
|
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 5 friends in the game? (at least 6 players total)
|
|
if ( CalcPlayersOnFriendsList( 5 ) )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PlayGameFriends, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PLAY_GAME_FRIENDS, "TF_MAPS_DOOMSDAY_PLAY_GAME_FRIENDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_WinRounds : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 138 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "sd_doomsday" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( 0 == Q_strcmp( 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( CAchievementTFDoomsday_WinRounds, ACHIEVEMENT_TF_MAPS_DOOMSDAY_WIN_ROUNDS, "TF_MAPS_DOOMSDAY_WIN_ROUNDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_PlayEachClass : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL | ACH_HAS_COMPONENTS );
|
|
SetGoal( ( TF_LAST_NORMAL_CLASS - 1 ) - TF_FIRST_NORMAL_CLASS + 1 ); //( TF_LAST_NORMAL_CLASS - 1 ) to exclude the new civilian class
|
|
SetMapNameFilter( "sd_doomsday" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_flag_event" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( FStrEq( event->GetName(), "teamplay_flag_event" ) )
|
|
{
|
|
int iPlayer = event->GetInt( "player" );
|
|
int iType = event->GetInt( "eventtype" );
|
|
|
|
switch( iType )
|
|
{
|
|
case TF_FLAGEVENT_CAPTURE:
|
|
if ( iPlayer == GetLocalPlayerIndex() )
|
|
{
|
|
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 );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PlayEachClass, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PLAY_EACH_CLASS, "TF_MAPS_DOOMSDAY_PLAY_EACH_CLASS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_KillEnemiesOnElevator : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "sd_doomsday" );
|
|
|
|
m_flTimeWindow = 10.0f;
|
|
m_nKillsToAchieve = 3;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "player_killed_achievement_zone" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( FStrEq( event->GetName(), "player_killed_achievement_zone" ) )
|
|
{
|
|
int iZoneID = event->GetInt( "zone_id" );
|
|
if ( iZoneID == 1 ) // capture zone
|
|
{
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "attacker" ) ) );
|
|
CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "victim" ) ) );
|
|
|
|
if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && pVictim && ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
|
|
{
|
|
int index = m_History.AddToHead();
|
|
m_History[index] = gpGlobals->curtime;
|
|
Evaluate();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Evaluate( void )
|
|
{
|
|
// remove any times that are older than the window
|
|
float flTimeDiscard = gpGlobals->curtime - m_flTimeWindow;
|
|
for ( int i = 0 ; i < m_History.Count() ; i++ )
|
|
{
|
|
if ( m_History[i] < flTimeDiscard )
|
|
{
|
|
m_History.RemoveMultiple( i, m_History.Count() - i );
|
|
break;
|
|
}
|
|
}
|
|
|
|
// have we killed enough players in the time window?
|
|
if ( m_History.Count() >= m_nKillsToAchieve )
|
|
{
|
|
IncrementCount();
|
|
}
|
|
}
|
|
|
|
private:
|
|
CUtlVector< float > m_History;
|
|
float m_flTimeWindow;
|
|
int m_nKillsToAchieve;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_KillEnemiesOnElevator, ACHIEVEMENT_TF_MAPS_DOOMSDAY_KILL_ENEMIES_ON_ELEVATOR, "TF_MAPS_DOOMSDAY_KILL_ENEMIES_ON_ELEVATOR", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_PushBackAndWin : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "sd_doomsday" );
|
|
|
|
m_bRocketOpenedByEnemyTeam = false;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
ListenForGameEvent( "doomsday_rocket_open" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_round_win" ) )
|
|
{
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
|
|
{
|
|
if ( m_bRocketOpenedByEnemyTeam )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "doomsday_rocket_open" ) )
|
|
{
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam != GetLocalPlayerTeam() ) )
|
|
{
|
|
m_bRocketOpenedByEnemyTeam = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
|
|
{
|
|
m_bRocketOpenedByEnemyTeam = false;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_bRocketOpenedByEnemyTeam;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PushBackAndWin, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PUSH_BACK_AND_WIN, "TF_MAPS_DOOMSDAY_PUSH_BACK_AND_WIN", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_KillCarriers : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "sd_doomsday" );
|
|
m_iKillCount = 0;
|
|
}
|
|
|
|
virtual void ListenForEvents( void )
|
|
{
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( !pLocalPlayer )
|
|
return;
|
|
|
|
if ( pLocalPlayer->GetTeamNumber() < FIRST_GAME_TEAM )
|
|
return;
|
|
|
|
if ( FStrEq( event->GetName(), "teamplay_round_start" ) )
|
|
{
|
|
m_iKillCount = 0;
|
|
}
|
|
}
|
|
|
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
|
{
|
|
if ( !pVictim || !pVictim->IsPlayer() )
|
|
return;
|
|
|
|
if ( pAttacker == C_BasePlayer::GetLocalPlayer() && pVictim != C_BasePlayer::GetLocalPlayer() )
|
|
{
|
|
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
|
|
|
|
if ( pTFVictim && pTFVictim->HasTheFlag() )
|
|
{
|
|
m_iKillCount++;
|
|
if ( m_iKillCount >= 6 )
|
|
{
|
|
IncrementCount();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
int m_iKillCount;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_KillCarriers, ACHIEVEMENT_TF_MAPS_DOOMSDAY_KILL_CARRIERS, "TF_MAPS_DOOMSDAY_KILL_CARRIERS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_RideTheElevator : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
}
|
|
|
|
// server awards this achievement, no other code within achievement necessary
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_RideTheElevator, ACHIEVEMENT_TF_MAPS_DOOMSDAY_RIDE_THE_ELEVATOR, "TF_MAPS_DOOMSDAY_RIDE_THE_ELEVATOR", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_DenyNeutralPickup : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
}
|
|
|
|
// server awards this achievement, no other code within achievement necessary
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_DenyNeutralPickup, ACHIEVEMENT_TF_MAPS_DOOMSDAY_DENY_NEUTRAL_PICKUP, "TF_MAPS_DOOMSDAY_DENY_NEUTRAL_PICKUP", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_PushIntoExhaust : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
}
|
|
|
|
// server awards this achievement, no other code within achievement necessary
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_PushIntoExhaust, ACHIEVEMENT_TF_MAPS_DOOMSDAY_PUSH_INTO_EXHAUST, "TF_MAPS_DOOMSDAY_PUSH_INTO_EXHAUST", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_DefendCarrier : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
}
|
|
|
|
// server awards this achievement, no other code within achievement necessary
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_DefendCarrier, ACHIEVEMENT_TF_MAPS_DOOMSDAY_DEFEND_CARRIER, "TF_MAPS_DOOMSDAY_DEFEND_CARRIER", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFDoomsday_AchieveProgress1 : public CAchievement_AchievedCount
|
|
{
|
|
public:
|
|
DECLARE_CLASS( CAchievementTFDoomsday_AchieveProgress1, CAchievement_AchievedCount );
|
|
void Init()
|
|
{
|
|
BaseClass::Init();
|
|
SetAchievementsRequired( 7, ACHIEVEMENT_TF_MAPS_DOOMSDAY_START_RANGE, ACHIEVEMENT_TF_MAPS_DOOMSDAY_END_RANGE );
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFDoomsday_AchieveProgress1, ACHIEVEMENT_TF_MAPS_DOOMSDAY_ACHIEVE_PROGRESS1, "TF_MAPS_DOOMSDAY_ACHIEVE_PROGRESS1", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFStandin_WinRounds : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 139 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_standin_final" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( 0 == Q_strcmp( 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( CAchievementTFStandin_WinRounds, ACHIEVEMENT_TF_MAPS_STANDIN_WIN_ROUNDS, "TF_MAPS_STANDIN_WIN_ROUNDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFProcess_WinRounds : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 140 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_process_final" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( 0 == Q_strcmp( 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( CAchievementTFProcess_WinRounds, ACHIEVEMENT_TF_MAPS_PROCESS_WIN_ROUNDS, "TF_MAPS_PROCESS_WIN_ROUNDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFSnakewater_WinRounds : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 141 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_snakewater_final1" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( 0 == Q_strcmp( 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( CAchievementTFSnakewater_WinRounds, ACHIEVEMENT_TF_MAPS_SNAKEWATER_WIN_ROUNDS, "TF_MAPS_SNAKEWATER_WIN_ROUNDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFSnakewater_PushBackAndWin : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_snakewater_final1" );
|
|
|
|
m_bFinalPointContested = false;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
ListenForGameEvent( "teamplay_point_startcapture" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_round_win" ) )
|
|
{
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
|
|
{
|
|
if ( m_bFinalPointContested )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
|
|
{
|
|
if ( ObjectiveResource() && ( ObjectiveResource()->GetBaseControlPointForTeam( GetLocalPlayerTeam() ) == event->GetInt( "cp" ) ) )
|
|
{
|
|
m_bFinalPointContested = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
|
|
{
|
|
m_bFinalPointContested = false;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_bFinalPointContested;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_PushBackAndWin, ACHIEVEMENT_TF_MAPS_SNAKEWATER_PUSH_BACK_AND_WIN, "TF_MAPS_SNAKEWATER_PUSH_BACK_AND_WIN", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFSnakewater_TeamKill : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_PLAYER_KILL_ENEMY_EVENTS );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_snakewater_final1" );
|
|
}
|
|
|
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
|
{
|
|
if ( TFGameRules() && ( TFGameRules()->State_Get() == GR_STATE_RND_RUNNING ) )
|
|
{
|
|
if ( pAttacker && ( pAttacker->GetTeamNumber() == GetLocalPlayerTeam() ) )
|
|
{
|
|
C_TFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
|
|
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
|
|
|
|
if ( pTFAttacker && pTFAttacker->GetTeam() && pTFVictim && pTFVictim->GetTeam() )
|
|
{
|
|
// must have 12 or more players on the server
|
|
if ( pTFAttacker->GetTeam()->GetNumPlayers() + pTFVictim->GetTeam()->GetNumPlayers() >= 12 )
|
|
{
|
|
bool bSomeAlive = false;
|
|
int nTeamCount = pTFVictim->GetTeam()->GetNumPlayers();
|
|
for ( int i = 0; i < nTeamCount; i++ )
|
|
{
|
|
C_BasePlayer *pTemp = pTFVictim->GetTeam()->GetPlayer( i );
|
|
if ( pTemp && ( pTemp != pTFVictim ) && pTemp->IsAlive() )
|
|
{
|
|
// Found one
|
|
bSomeAlive = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bSomeAlive )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_TeamKill, ACHIEVEMENT_TF_MAPS_SNAKEWATER_TEAM_KILL, "TF_MAPS_SNAKEWATER_TEAM_KILL", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFSnakewater_DoubleAirDeaths : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_EVENTS );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_snakewater_final1" );
|
|
ResetTracking();
|
|
}
|
|
|
|
void ResetTracking()
|
|
{
|
|
m_PotentialPartners.RemoveAll();
|
|
m_nKilledLocalPlayer = -1;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "localplayer_respawn" );
|
|
ListenForGameEvent( "player_spawn" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEvent = event->GetName();
|
|
|
|
if ( FStrEq( pszEvent, "localplayer_respawn" ) )
|
|
{
|
|
ResetTracking();
|
|
}
|
|
else if ( FStrEq( pszEvent, "player_spawn" ) )
|
|
{
|
|
int nUserId = event->GetInt( "userid" );
|
|
if ( nUserId > 0 )
|
|
{
|
|
int iIndex = m_PotentialPartners.Find( nUserId );
|
|
if ( iIndex != m_PotentialPartners.InvalidIndex() )
|
|
{
|
|
m_PotentialPartners.Remove( iIndex );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
|
{
|
|
C_TFPlayer *pTFAttacker = ToTFPlayer( pAttacker );
|
|
C_TFPlayer *pTFVictim = ToTFPlayer( pVictim );
|
|
C_TFPlayer *pTFLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
|
|
// was the victim rocket jumping?
|
|
if ( event->GetBool( "rocket_jump" ) )
|
|
{
|
|
if ( pTFAttacker && pTFVictim && ( pTFAttacker != pTFVictim ) && ( ( pTFAttacker == pTFLocalPlayer ) || ( pTFVictim == pTFLocalPlayer ) ) )
|
|
{
|
|
int iWeaponID = event->GetInt( "weaponid" );
|
|
if ( ( iWeaponID == TF_WEAPON_ROCKETLAUNCHER ) || ( iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT ) )
|
|
{
|
|
if ( pTFAttacker == pTFLocalPlayer )
|
|
{
|
|
if ( m_PotentialPartners.Find( pTFVictim->GetUserID() ) == m_PotentialPartners.InvalidIndex() )
|
|
{
|
|
m_PotentialPartners.AddToTail( pTFVictim->GetUserID() );
|
|
}
|
|
}
|
|
else if ( pTFVictim == pTFLocalPlayer )
|
|
{
|
|
m_nKilledLocalPlayer = pTFAttacker->GetUserID();
|
|
}
|
|
|
|
// evaluate the achievement
|
|
if ( ( m_nKilledLocalPlayer > -1 ) && ( m_PotentialPartners.Find( m_nKilledLocalPlayer ) != m_PotentialPartners.InvalidIndex() ) )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CUtlVector< int > m_PotentialPartners; // userIDs of the players the localPlayer killed
|
|
int m_nKilledLocalPlayer; // userID of the player who killed the localPlayer
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_DoubleAirDeaths, ACHIEVEMENT_TF_MAPS_SNAKEWATER_DOUBLE_AIR_DEATHS, "TF_MAPS_SNAKEWATER_DOUBLE_AIR_DEATHS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFSnakewater_KillEnemiesInMiddle : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 15 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_snakewater_final1" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "player_killed_achievement_zone" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( FStrEq( event->GetName(), "player_killed_achievement_zone" ) )
|
|
{
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
CTFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "attacker" ) ) );
|
|
CTFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( event->GetInt( "victim" ) ) );
|
|
|
|
if ( pLocalPlayer && ( pLocalPlayer == pAttacker ) && pVictim && ( pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
|
|
{
|
|
IncrementCount();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFSnakewater_KillEnemiesInMiddle, ACHIEVEMENT_TF_MAPS_SNAKEWATER_KILL_ENEMIES_IN_MIDDLE, "TF_MAPS_SNAKEWATER_KILL_ENEMIES_IN_MIDDLE", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFPowerhouse_WinRounds : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 142 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_powerhouse" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( 0 == Q_strcmp( 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( CAchievementTFPowerhouse_WinRounds, ACHIEVEMENT_TF_MAPS_POWERHOUSE_WIN_ROUNDS, "TF_MAPS_POWERHOUSE_WIN_ROUNDS", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFPowerhouse_PushBackAndWin : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_powerhouse" );
|
|
|
|
m_bFinalPointContested = false;
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
ListenForGameEvent( "teamplay_point_startcapture" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
ListenForGameEvent( "localplayer_changeteam" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_round_win" ) )
|
|
{
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == GetLocalPlayerTeam() ) )
|
|
{
|
|
if ( m_bFinalPointContested )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_point_startcapture" ) )
|
|
{
|
|
if ( ObjectiveResource() && ( ObjectiveResource()->GetBaseControlPointForTeam( GetLocalPlayerTeam() ) == event->GetInt( "cp" ) ) )
|
|
{
|
|
m_bFinalPointContested = true;
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) || FStrEq( pszEventName, "localplayer_changeteam" ) )
|
|
{
|
|
m_bFinalPointContested = false;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_bFinalPointContested;
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_PushBackAndWin, ACHIEVEMENT_TF_MAPS_POWERHOUSE_PUSH_BACK_AND_WIN, "TF_MAPS_POWERHOUSE_PUSH_BACK_AND_WIN", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFPowerhouse_FastFinalCap : public CBaseTFAchievementSimple
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 1 );
|
|
SetMapNameFilter( "cp_powerhouse" );
|
|
|
|
ResetCounts();
|
|
}
|
|
|
|
void ResetCounts()
|
|
{
|
|
m_bRecentCapper = false;
|
|
iCapCount = 0;
|
|
iCapTimes[0] = 0.0f;
|
|
iCapTimes[1] = 0.0f;
|
|
}
|
|
|
|
virtual void ListenForEvents( void )
|
|
{
|
|
ListenForGameEvent( "teamplay_point_captured" );
|
|
ListenForGameEvent( "teamplay_round_win" );
|
|
ListenForGameEvent( "teamplay_round_start" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
|
|
CTFPlayer *pLocalPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
|
|
if ( !pLocalPlayer )
|
|
return;
|
|
|
|
if ( FStrEq( pszEventName, "teamplay_point_captured" ) )
|
|
{
|
|
m_bRecentCapper = false;
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) )
|
|
{
|
|
iCapTimes[iCapCount % 2] = gpGlobals->curtime;
|
|
iCapCount++;
|
|
|
|
const char *cappers = event->GetString( "cappers" );
|
|
for ( int i = 0; i < Q_strlen( cappers ); i++ )
|
|
{
|
|
int iPlayerIndex = (int)cappers[i];
|
|
CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
|
|
if ( pPlayer == pLocalPlayer )
|
|
{
|
|
m_bRecentCapper = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_win" ) )
|
|
{
|
|
// If we're the winners and we were involved in capping the last point, we get this achievement.
|
|
int iTeam = event->GetInt( "team" );
|
|
if ( ( iTeam >= FIRST_GAME_TEAM ) && ( iTeam == pLocalPlayer->GetTeamNumber() ) && m_bRecentCapper )
|
|
{
|
|
if ( fabs( iCapTimes[1] - iCapTimes[0] ) <= 15.0f )
|
|
{
|
|
AwardAchievement();
|
|
}
|
|
}
|
|
|
|
ResetCounts();
|
|
}
|
|
else if ( FStrEq( pszEventName, "teamplay_round_start" ) )
|
|
{
|
|
ResetCounts();
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool m_bRecentCapper;
|
|
int iCapCount;
|
|
float iCapTimes[2];
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_FastFinalCap, ACHIEVEMENT_TF_MAPS_POWERHOUSE_FAST_FINAL_CAP, "TF_MAPS_POWERHOUSE_FAST_FINAL_CAP", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFPowerhouse_KillCappingPlayer : public CBaseTFAchievement
|
|
{
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL );
|
|
SetGoal( 15 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_powerhouse" );
|
|
}
|
|
|
|
virtual void ListenForEvents()
|
|
{
|
|
ListenForGameEvent( "killed_capping_player" );
|
|
}
|
|
|
|
void FireGameEvent_Internal( IGameEvent *event )
|
|
{
|
|
if ( FStrEq( event->GetName(), "killed_capping_player" ) )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer )
|
|
{
|
|
int iKiller = event->GetInt( "killer", 0 );
|
|
if ( iKiller == pLocalPlayer->entindex() )
|
|
{
|
|
IncrementCount();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_KillCappingPlayer, ACHIEVEMENT_TF_MAPS_POWERHOUSE_KILL_CAPPING_PLAYER, "TF_MAPS_POWERHOUSE_KILL_CAPPING_PLAYER", 5 );
|
|
|
|
//----------------------------------------------------------------------------------------------------------------
|
|
class CAchievementTFPowerhouse_KillEnemyInWater : public CBaseTFAchievementSimple
|
|
{
|
|
public:
|
|
void Init()
|
|
{
|
|
SetFlags( ACH_SAVE_GLOBAL | ACH_LISTEN_KILL_ENEMY_EVENTS );
|
|
SetGoal( 5 );
|
|
SetStoreProgressInSteam( true );
|
|
SetMapNameFilter( "cp_powerhouse" );
|
|
}
|
|
|
|
virtual void Event_EntityKilled( CBaseEntity *pVictim, CBaseEntity *pAttacker, CBaseEntity *pInflictor, IGameEvent *event )
|
|
{
|
|
if ( !pVictim || !pVictim->IsPlayer() )
|
|
return;
|
|
|
|
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
|
|
|
|
if ( pAttacker == pLocalPlayer && pVictim != pLocalPlayer )
|
|
{
|
|
if ( pVictim->GetWaterLevel() != WL_NotInWater )
|
|
{
|
|
IncrementCount();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DECLARE_ACHIEVEMENT( CAchievementTFPowerhouse_KillEnemyInWater, ACHIEVEMENT_TF_MAPS_POWERHOUSE_KILL_ENEMY_IN_WATER, "TF_MAPS_POWERHOUSE_KILL_ENEMY_IN_WATER", 5 );
|
|
|
|
#endif // CLIENT_DLL
|