H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 14:46:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c36cfccdf0
source-engine/game/server/cstrike/funfact_cs.cpp

794 lines
29 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
#include "cbase.h"
#include "cs_gamerules.h"
#include "cs_gamestats.h"
#include "funfactmgr_cs.h"
#include "funfact_cs.h"
#include "../../game/shared/cstrike/weapon_csbase.h"
#include "cs_achievement_constants.h"
#define FIRST_BLOOD_TIME 45.0f
#define FIRST_KILL_TIME 45.0f
#define SHORT_ROUND_TIME 30.0f
#define MIN_SHOTS_FOR_ACCURACY 10
enum FunFactId
{
FUNFACT_CT_WIN_NO_KILLS,
FUNFACT_T_WIN_NO_KILLS,
FUNFACT_KILL_DEFUSER,
FUNFACT_KILL_RESCUER,
FUNFACT_T_WIN_NO_CASUALTIES,
FUNFACT_CT_WIN_NO_CASUALTIES,
FUNFACT_DAMAGE_WITH_GRENADES,
FUNFACT_KILLS_WITH_GRENADES,
FUNFACT_KILLS_WITH_SINGLE_GRENADE,
FUNFACT_DAMAGE_NO_KILLS,
FUNFACT_KILLED_ENEMIES,
FUNFACT_FIRST_KILL,
FUNFACT_FIRST_BLOOD,
FUNFACT_SHORT_ROUND,
FUNFACT_BEST_ACCURACY,
FUNFACT_KNIFE_KILLS,
FUNFACT_BLIND_KILLS,
FUNFACT_KILLS_WITH_LAST_ROUND,
FUNFACT_DONATED_WEAPONS,
FUNFACT_POSTHUMOUS_KILLS_WITH_GRENADE,
FUNFACT_KNIFE_IN_GUNFIGHT,
FUNFACT_NUM_TIMES_JUMPED,
FUNFACT_FALL_DAMAGE,
FUNFACT_ITEMS_PURCHASED,
FUNFACT_WON_AS_LAST_MEMBER,
FUNFACT_NUMBER_OF_OVERKILLS,
FUNFACT_SHOTS_FIRED,
FUNFACT_MONEY_SPENT,
FUNFACT_SURVIVED_MULTIPLE_ATTACKERS,
FUNFACT_DIED_FROM_MULTIPLE_ATTACKERS,
FUNFACT_DAMAGE_MULTIPLE_ENEMIES,
FUNFACT_GRENADES_THROWN,
FUNFACT_USED_ALL_AMMO,
FUNFACT_DEFENDED_BOMB,
FUNFACT_ITEMS_DROPPED_VALUE,
FUNFACT_KILL_WOUNDED_ENEMIES,
FUNFACT_USED_MULTIPLE_WEAPONS,
FUNFACT_TERRORIST_ACCURACY,
FUNFACT_CT_ACCURACY,
FUNFACT_SAME_UNIFORM_TERRORIST,
FUNFACT_SAME_UNIFORM_CT,
FUNFACT_BEST_TERRORIST_ACCURACY,
FUNFACT_BEST_COUNTERTERRORIST_ACCURACY,
FUNFACT_FALLBACK1,
FUNFACT_FALLBACK2,
FUNFACT_KILLS_HEADSHOTS,
FUNFACT_BROKE_WINDOWS,
FUNFACT_NIGHTVISION_DAMAGE,
FUNFACT_DEFUSED_WITH_DROPPED_KIT,
FUNFACT_KILLED_HALF_OF_ENEMIES,
};
CFunFactHelper *CFunFactHelper::s_pFirst = NULL;
//=============================================================================
// Generic evaluation Fun Fact
// This fun fact will evaluate the specified function to determine when it is
// valid. This is basically just a glue class for simple evaluation functions.
//=============================================================================
// Function type that we use to evaluate our fun facts. The data is returned as ints then floats that are passed in as reference parameters
typedef bool (*fFunFactEval)( int &iPlayer, int &data1, int &data2, int &data3 );
class CFunFact_GenericEvalFunction : public FunFactEvaluator
{
public:
CFunFact_GenericEvalFunction(FunFactId id, const char* szLocalizationToken, float fCoolness, fFunFactEval pfnEval ) :
FunFactEvaluator(id, szLocalizationToken, fCoolness),
m_pfnEval(pfnEval)
{}
virtual bool Evaluate( FunFactVector& results ) const
{
FunFact funfact;
if (m_pfnEval(funfact.iPlayer, funfact.iData1, funfact.iData2, funfact.iData3))
{
funfact.id = GetId();
funfact.szLocalizationToken = GetLocalizationToken();
funfact.fMagnitude = 0.0f;
results.AddToTail(funfact);
return true;
}
else
return false;
}
private:
fFunFactEval m_pfnEval;
};
#define DECLARE_FUNFACT_EVALFUNC(funfactId, szLocalizationToken, fCoolness, pfnEval) \
static FunFactEvaluator *CreateFunFact_##funfactId( void ) \
{ \
return new CFunFact_GenericEvalFunction(funfactId, szLocalizationToken, fCoolness, pfnEval);\
}; \
static CFunFactHelper g_##funfactId##_Helper( CreateFunFact_##funfactId );
//=============================================================================
// Per-player evaluation Fun Fact
// Evaluate the function per player and generate a fun fact for each valid or
// highest valid player
//=============================================================================
namespace EvalFlags
{
enum Type
{
All = 0x00,
TeamCT = 0x01,
TeamTerrorist = 0x02,
HighestOnly = 0x04, // when not set, generates fun facts for all valid testees
Alive = 0x08,
Dead = 0x10,
WinningTeam = 0x20,
LosingTeam = 0x40,
};
};
bool PlayerQualifies( const CBasePlayer* pPlayer, int flags )
{
if ( (flags & EvalFlags::TeamCT) && pPlayer->GetTeamNumber() != TEAM_CT )
return false;
if ( (flags & EvalFlags::TeamTerrorist) && pPlayer->GetTeamNumber() != TEAM_TERRORIST )
return false;
if ( (flags & EvalFlags::Dead) && const_cast<CBasePlayer*>(pPlayer)->IsAlive() ) // IsAlive() really isn't const correct
return false;
if ( (flags & EvalFlags::Alive) && !const_cast<CBasePlayer*>(pPlayer)->IsAlive() )
return false;
if ( (flags & EvalFlags::WinningTeam) && pPlayer->GetTeamNumber() != CSGameRules()->m_iRoundWinStatus )
return false;
if ( (flags & EvalFlags::LosingTeam) && pPlayer->GetTeamNumber() == CSGameRules()->m_iRoundWinStatus )
return false;
return true;
}
typedef int (*PlayerEvalFunction)(CCSPlayer* pPlayer);
class CFunFact_PlayerEvalFunction : public FunFactEvaluator
{
public:
CFunFact_PlayerEvalFunction(FunFactId id, const char* szLocalizationToken, float fCoolness, PlayerEvalFunction pfnEval,
int iMin, int flags ) :
FunFactEvaluator(id, szLocalizationToken, fCoolness),
m_pfnEval(pfnEval),
m_min(iMin),
m_flags(flags)
{}
virtual bool Evaluate( FunFactVector& results ) const
{
int iBestValue = 0;
int iBestPlayer = 0;
bool bResult = false;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer* pPlayer = ToCSPlayer(UTIL_PlayerByIndex( i ) );
if ( pPlayer )
{
if (!PlayerQualifies(pPlayer, m_flags))
continue;
int iValue = m_pfnEval(pPlayer);
if (m_flags & EvalFlags::HighestOnly)
{
if ( iValue > iBestValue )
{
iBestValue = iValue;
iBestPlayer = i;
}
}
else
{
// generate fun facts for any player who meets the validation requirement
if ( iValue >= m_min )
{
FunFact funfact;
funfact.id = GetId();
funfact.szLocalizationToken = GetLocalizationToken();
funfact.iPlayer = i;
funfact.iData1 = iValue;
funfact.fMagnitude = 1.0f - ((float)m_min / iValue);
results.AddToTail(funfact);
bResult = true;
}
}
}
}
if ( (m_flags & EvalFlags::HighestOnly) && iBestValue >= m_min )
{
FunFact funfact;
funfact.id = GetId();
funfact.szLocalizationToken = GetLocalizationToken();
funfact.iPlayer = iBestPlayer;
funfact.iData1 = iBestValue;
funfact.fMagnitude = 1.0f - ((float)m_min / iBestValue);
results.AddToTail(funfact);
bResult = true;
}
return bResult;
}
private:
PlayerEvalFunction m_pfnEval;
int m_min;
int m_flags;
};
#define DECLARE_FUNFACT_PLAYERFUNC(funfactId, szLocalizationToken, fCoolness, pfnEval, iMin, iFlags) \
static FunFactEvaluator *CreateFunFact_##funfactId( void ) \
{ \
return new CFunFact_PlayerEvalFunction(funfactId, szLocalizationToken, fCoolness, pfnEval, iMin, iFlags); \
}; \
static CFunFactHelper g_##funfactId##_Helper( CreateFunFact_##funfactId );
//=============================================================================
// Per-team evaluation Fun Fact
//=============================================================================
typedef bool (*TeamEvalFunction)(int iTeam, int &data1, int &data2, int &data3);
class CFunFact_TeamEvalFunction : public FunFactEvaluator
{
public:
CFunFact_TeamEvalFunction(FunFactId id, const char* szLocalizationToken, float fCoolness, TeamEvalFunction pfnEval, int iTeam ) :
FunFactEvaluator(id, szLocalizationToken, fCoolness),
m_pfnEval(pfnEval),
m_team(iTeam)
{}
virtual bool Evaluate( FunFactVector& results ) const
{
int iData1, iData2, iData3;
if ( m_pfnEval(m_team, iData1, iData2, iData3) )
{
FunFact funfact;
funfact.id = GetId();
funfact.szLocalizationToken = GetLocalizationToken();
funfact.fMagnitude = 0.0f;
results.AddToTail(funfact);
return true;
}
return false;
}
private:
TeamEvalFunction m_pfnEval;
int m_team;
};
#define DECLARE_FUNFACT_TEAMFUNC(funfactId, szLocalizationToken, fCoolness, pfnEval, iTeam) \
static FunFactEvaluator *CreateFunFact_##funfactId( void ) \
{ \
return new CFunFact_TeamEvalFunction(funfactId, szLocalizationToken, fCoolness, pfnEval, iTeam);\
}; \
static CFunFactHelper g_##funfactId##_Helper( CreateFunFact_##funfactId );
//=============================================================================
// High Stat-based Fun Fact
// This fun fact will find the player with the highest value for a particular
// stat, and validate when that stat exceeds a specified minimum
//=============================================================================
class CFunFact_StatBest : public FunFactEvaluator
{
public:
CFunFact_StatBest(FunFactId id, const char* szLocalizationToken, float fCoolness, CSStatType_t statId, int iMin, int flags ) :
FunFactEvaluator(id, szLocalizationToken, fCoolness),
m_statId(statId),
m_min(iMin),
m_flags(flags)
{
V_strncpy(m_singularLocalizationToken, szLocalizationToken, sizeof(m_singularLocalizationToken));
if (m_min == 1)
{
V_strncat(m_singularLocalizationToken, "_singular", sizeof(m_singularLocalizationToken));
}
}
virtual bool Evaluate( FunFactVector& results ) const
{
int iBestValue = 0;
int iBestPlayer = 0;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer )
{
if (!PlayerQualifies(pPlayer, m_flags))
continue;
int iValue = CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[m_statId];
if ( iValue > iBestValue )
{
iBestValue = iValue;
iBestPlayer = i;
}
}
}
if ( iBestValue >= m_min )
{
FunFact funfact;
funfact.id = GetId();
funfact.szLocalizationToken = iBestValue == 1 ? m_singularLocalizationToken : GetLocalizationToken();
funfact.iPlayer = iBestPlayer;
funfact.iData1 = iBestValue;
funfact.fMagnitude = 1.0f - ((float)m_min / iBestValue);
results.AddToTail(funfact);
return true;
}
return false;
}
private:
CSStatType_t m_statId;
int m_min;
char m_singularLocalizationToken[128];
int m_flags;
};
#define DECLARE_FUNFACT_STATBEST(funfactId, szLocalizationToken, fCoolness, statId, iMin, flags) \
static FunFactEvaluator *CreateFunFact_##funfactId( void ) \
{ \
return new CFunFact_StatBest(funfactId, szLocalizationToken, fCoolness, statId, iMin, flags); \
}; \
static CFunFactHelper g_##funfactId##_Helper( CreateFunFact_##funfactId );
//=============================================================================
// Sum-based Fun Fact
// This fun fact will add up a stat for all players, and is valid when the
// sum exceeds a threshold
//=============================================================================
class CFunFact_StatSum : public FunFactEvaluator
{
public:
CFunFact_StatSum(FunFactId id, const char* szLocalizationToken, float fCoolness, CSStatType_t statId, int iMin, EvalFlags::Type flags ) :
FunFactEvaluator(id, szLocalizationToken, fCoolness),
m_statId(statId),
m_min(iMin),
m_flags(flags)
{}
virtual bool Evaluate( FunFactVector& results ) const
{
int iSum = 0;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer )
{
if (!PlayerQualifies(pPlayer, m_flags))
continue;
iSum += CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[m_statId];
}
}
if ( iSum >= m_min )
{
FunFact funfact;
funfact.id = GetId();
funfact.szLocalizationToken = GetLocalizationToken();
funfact.iPlayer = 0;
funfact.iData1 = iSum;
funfact.fMagnitude = 1.0f - ((float)m_min / iSum);
results.AddToTail(funfact);
return true;
}
return false;
}
private:
CSStatType_t m_statId;
int m_min;
int m_flags;
};
#define DECLARE_FUNFACT_STATSUM(funfactId, szLocalizationToken, fCoolness, statId, iMin, flags) \
static FunFactEvaluator *CreateFunFact_##funfactId( void ) \
{ \
return new CFunFact_StatSum(funfactId, szLocalizationToken, fCoolness, statId, iMin, flags); \
}; \
static CFunFactHelper g_##funfactId##_Helper( CreateFunFact_##funfactId );
//=============================================================================
// Helper function to calculate team accuracy
//=============================================================================
float GetTeamAccuracy( int teamNumber )
{
int teamShots = 0;
int teamHits = 0;
//Add up hits and shots
CBasePlayer *pPlayer = NULL;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pPlayer = UTIL_PlayerByIndex( i );
if (pPlayer)
{
if (pPlayer->GetTeamNumber() == teamNumber)
{
teamShots += CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_FIRED];;
teamHits += CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_HIT];;
}
}
}
if (teamShots > MIN_SHOTS_FOR_ACCURACY)
return (float)teamHits / teamShots;
return 0.0f;
}
//=============================================================================
// fun fact explicit evaluation functions
//=============================================================================
bool FFEVAL_ALWAYS_TRUE( int &iPlayer, int &data1, int &data2, int &data3 )
{
return true;
}
bool FFEVAL_CT_WIN_NO_KILLS( int &iPlayer, int &data1, int &data2, int &data3 )
{
return ( CSGameRules()->m_iRoundWinStatus == WINNER_CT && CSGameRules()->m_bNoTerroristsKilled );
}
bool FFEVAL_T_WIN_NO_KILLS( int &iPlayer, int &data1, int &data2, int &data3 )
{
return ( CSGameRules()->m_iRoundWinStatus == WINNER_TER && CSGameRules()->m_bNoCTsKilled );
}
bool FFEVAL_T_WIN_NO_CASUALTIES( int &iPlayer, int &data1, int &data2, int &data3 )
{
return ( CSGameRules()->m_iRoundWinStatus == WINNER_TER && CSGameRules()->m_bNoTerroristsKilled );
}
bool FFEVAL_CT_WIN_NO_CASUALTIES( int &iPlayer, int &data1, int &data2, int &data3 )
{
return ( CSGameRules()->m_iRoundWinStatus == WINNER_CT && CSGameRules()->m_bNoCTsKilled );
}
int FFEVAL_KILLED_DEFUSER( CCSPlayer* pPlayer )
{
return pPlayer->GetKilledDefuser() ? 1 : 0;
}
int FFEVAL_KILLED_RESCUER( CCSPlayer* pPlayer )
{
return pPlayer->GetKilledRescuer() ? 1 : 0;
}
int FFEVAL_KILLS_WITH_GRENADE( CCSPlayer* pPlayer )
{
return pPlayer->GetMaxGrenadeKills();
}
int FFEVAL_DAMAGE_NO_KILLS( CCSPlayer* pPlayer )
{
if (CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_KILLS] == 0)
return CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_DAMAGE];
else
return 0;
}
int FFEVAL_FIRST_KILL( CCSPlayer* pPlayer )
{
if ( pPlayer == CSGameRules()->m_pFirstKill && CSGameRules()->m_firstKillTime < FIRST_KILL_TIME )
return CSGameRules()->m_firstKillTime;
else
return 0;
}
int FFEVAL_FIRST_BLOOD( CCSPlayer* pPlayer )
{
if ( pPlayer == CSGameRules()->m_pFirstBlood && CSGameRules()->m_firstBloodTime < FIRST_BLOOD_TIME )
return CSGameRules()->m_firstBloodTime;
else
return 0;
}
bool FFEVAL_SHORT_ROUND( int &iPlayer, int &data1, int &data2, int &data3 )
{
if ( CSGameRules()->GetRoundLength() - CSGameRules()->GetRoundRemainingTime() < SHORT_ROUND_TIME )
{
data1 = CSGameRules()->GetRoundLength() - CSGameRules()->GetRoundRemainingTime();
return true;
}
return false;
}
int FFEVAL_ACCURACY( CCSPlayer* pPlayer )
{
float shots = CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_FIRED];
float hits = CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_HIT];
if (shots >= MIN_SHOTS_FOR_ACCURACY)
return RoundFloatToInt(100.0f * hits / shots);
return 0;
}
int FFEVAL_KILLED_HALF_OF_ENEMIES( CCSPlayer* pPlayer )
{
return pPlayer->GetPercentageOfEnemyTeamKilled();
}
bool FFEVAL_WON_AS_LAST_MEMBER( int &iPlayer, int &data1, int &data2, int &data3 )
{
CCSPlayer *pCSPlayer = NULL;
int winningTeam = CSGameRules()->m_iRoundWinStatus;
if (winningTeam != TEAM_TERRORIST && winningTeam != TEAM_CT)
{
return false;
}
int losingTeam = (winningTeam == TEAM_TERRORIST) ? TEAM_CT : TEAM_TERRORIST;
CCSGameRules::TeamPlayerCounts playerCounts[TEAM_MAXCOUNT];
CSGameRules()->GetPlayerCounts(playerCounts);
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pCSPlayer = ToCSPlayer(UTIL_PlayerByIndex( i ) );
if( pCSPlayer && pCSPlayer->GetTeamNumber() == winningTeam && pCSPlayer->IsAlive())
{
//Check if the player is still the only living member of his team ( on the off chance that a player joins late)
//This check is a little hacky. We make sure that there are no enemies alive. Since the bomb causes the round to end before exploding,
//the only way for only 1 person to be alive at round win time is extermination or defuse (in both cases, the last living player caused the win)
if (playerCounts[winningTeam].totalAlivePlayers == 1 && playerCounts[losingTeam].totalAlivePlayers == 0)
{
const PlayerStats_t& playerStats = CCS_GameStats.FindPlayerStats( pCSPlayer );
iPlayer = i;
data1 = playerStats.statsCurrentRound[CSSTAT_KILLS_WHILE_LAST_PLAYER_ALIVE];
if (data1 >= 2)
{
return true;
}
}
}
}
return false;
}
int FFEVAL_KNIFE_IN_GUNFIGHT( CCSPlayer* pPlayer )
{
return pPlayer->WasWieldingKnifeAndKilledByGun() ? 1 : 0;
}
int FFEVAL_MULTIPLE_ATTACKER_COUNT( CCSPlayer* pPlayer )
{
return pPlayer->GetNumEnemyDamagers();
}
int FFEVAL_USED_ALL_AMMO( CCSPlayer* pPlayer )
{
CWeaponCSBase *pRifleWeapon = dynamic_cast< CWeaponCSBase * >(pPlayer->Weapon_GetSlot( WEAPON_SLOT_RIFLE ));
CWeaponCSBase *pHandgunWeapon = dynamic_cast< CWeaponCSBase * >(pPlayer->Weapon_GetSlot( WEAPON_SLOT_PISTOL ));
if ( pRifleWeapon && !pRifleWeapon->HasAmmo() && pHandgunWeapon && !pHandgunWeapon->HasAmmo() )
return 1;
else
return 0;
}
int FFEVAL_DAMAGE_MULTIPLE_ENEMIES( CCSPlayer* pPlayer )
{
return pPlayer->GetNumEnemiesDamaged();
}
int FFEVAL_USED_MULTIPLE_WEAPONS( CCSPlayer* pPlayer )
{
return pPlayer->GetNumFirearmsUsed();
}
int FFEVAL_DEFUSED_WITH_DROPPED_KIT( CCSPlayer* pPlayer )
{
return pPlayer->GetDefusedWithPickedUpKit() ? 1 : 0;
}
bool FFEVAL_TERRORIST_ACCURACY( int &iPlayer, int &data1, int &data2, int &data3 )
{
float terroristAccuracy = GetTeamAccuracy(TEAM_TERRORIST);
float ctAccuracy = GetTeamAccuracy(TEAM_CT);
if (terroristAccuracy > 0.2f && terroristAccuracy > ctAccuracy)
{
data1 = RoundFloatToInt(terroristAccuracy * 100.0f);
return true;
}
return false;
}
bool FFEVAL_CT_ACCURACY( int &iPlayer, int &data1, int &data2, int &data3 )
{
float terroristAccuracy = GetTeamAccuracy(TEAM_TERRORIST);
float ctAccuracy = GetTeamAccuracy(TEAM_CT);
if (ctAccuracy > 0.2f && ctAccuracy > terroristAccuracy)
{
data1 = RoundFloatToInt(ctAccuracy * 100.0f);
return true;
}
return false;
}
bool FFEVAL_SAME_UNIFORM( int iTeam, int &iData1, int &iData2, int &iData3 )
{
int numberInUniform = 0;
int iUniform = -1;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CCSPlayer *pCSPlayer = ToCSPlayer(UTIL_PlayerByIndex( i ) );
if ( pCSPlayer && pCSPlayer->GetTeamNumber() == iTeam && pCSPlayer->State_Get() != STATE_PICKINGCLASS)
{
if (iUniform == -1)
{
iUniform = pCSPlayer->PlayerClass();
}
else if (pCSPlayer->PlayerClass() != iUniform)
{
return false;
}
++numberInUniform;
}
}
return numberInUniform >= 3;
}
bool FFEVAL_BEST_TERRORIST_ACCURACY( int &iPlayer, int &data1, int &data2, int &data3 )
{
float fAccuracy = 0.0f, fBestAccuracy = 0.0f;
CBasePlayer *pPlayer = NULL;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pPlayer = UTIL_PlayerByIndex( i );
// Look only at terrorist players
if ( pPlayer && pPlayer->GetTeamNumber() == TEAM_TERRORIST )
{
// Calculate accuracy the terrorist
float shots = CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_FIRED];
float hits = CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_HIT];
if (shots > MIN_SHOTS_FOR_ACCURACY)
{
fAccuracy = (float)hits / shots;
}
// Track the most accurate terrorist
if ( fAccuracy > fBestAccuracy )
{
fBestAccuracy = fAccuracy;
iPlayer = i;
}
}
}
if ( fBestAccuracy - GetTeamAccuracy( TEAM_TERRORIST ) >= 0.10f )
{
data1 = RoundFloatToInt(fBestAccuracy * 100.0f);
data2 = RoundFloatToInt(GetTeamAccuracy( TEAM_TERRORIST ) * 100.0f);
return true;
}
return false;
}
bool FFEVAL_BEST_COUNTERTERRORIST_ACCURACY( int &iPlayer, int &data1, int &data2, int &data3 )
{
float fAccuracy = 0.0f, fBestAccuracy = 0.0f;
CBasePlayer *pPlayer = NULL;
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
pPlayer = UTIL_PlayerByIndex( i );
// Look only at counter-terrorist players
if ( pPlayer && pPlayer->GetTeamNumber() == TEAM_CT )
{
// Calculate accuracy the counter-terrorist
float shots = CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_FIRED];
float hits = CCS_GameStats.FindPlayerStats(pPlayer).statsCurrentRound[CSSTAT_SHOTS_HIT];
if (shots > MIN_SHOTS_FOR_ACCURACY)
{
fAccuracy = (float)hits / shots;
}
// Track the most accurate counter-terrorist
if ( fAccuracy > fBestAccuracy )
{
fBestAccuracy = fAccuracy;
iPlayer = i;
}
}
}
if ( fBestAccuracy - GetTeamAccuracy( TEAM_CT ) >= 0.10f )
{
data1 = RoundFloatToInt(fBestAccuracy * 100.0f);
data2 = RoundFloatToInt(GetTeamAccuracy( TEAM_CT ) * 100.0f);
return true;
}
return false;
}
//=============================================================================
// Fun Fact Declarations
//=============================================================================
DECLARE_FUNFACT_STATBEST( FUNFACT_DAMAGE_WITH_GRENADES, "#funfact_damage_with_grenade", 0.5f, CSSTAT_GRENADE_DAMAGE, 200, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_KNIFE_KILLS, "#funfact_knife_kills", 0.5f, CSSTAT_KILLS_KNIFE, 1, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_KILLS_WITH_GRENADES, "#funfact_kills_grenades", 0.7f, CSSTAT_KILLS_HEGRENADE, 2, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_BLIND_KILLS, "#funfact_blind_kills", 0.9f, CSSTAT_KILLS_WHILE_BLINDED, 1, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_KILLED_ENEMIES, "#funfact_killed_enemies", 0.6f, CSSTAT_KILLS, 3, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_KILLS_WITH_LAST_ROUND, "#funfact_kills_with_last_round", 0.6f, CSSTAT_KILLS_WITH_LAST_ROUND, 1, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_DONATED_WEAPONS, "#funfact_donated_weapons", 0.3f, CSSTAT_WEAPONS_DONATED, 2, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_NUM_TIMES_JUMPED, "#funfact_num_times_jumped", 0.2f, CSSTAT_TOTAL_JUMPS, 10, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_FALL_DAMAGE, "#funfact_fall_damage", 0.2f, CSSTAT_FALL_DAMAGE, 50, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_POSTHUMOUS_KILLS_WITH_GRENADE, "#funfact_posthumous_kills_with_grenade", 1.0f, CSSTAT_GRENADE_POSTHUMOUSKILLS, 1, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_ITEMS_PURCHASED, "#funfact_items_purchased", 0.2f, CSSTAT_ITEMS_PURCHASED, 5, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_NUMBER_OF_OVERKILLS, "#funfact_number_of_overkills", 0.5f, CSSTAT_DOMINATION_OVERKILLS, 2, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_MONEY_SPENT, "#funfact_money_spent", 0.2f, CSSTAT_MONEY_SPENT, 5000, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_GRENADES_THROWN, "#funfact_grenades_thrown", 0.3f, CSSTAT_GRENADES_THROWN, 2, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_DEFENDED_BOMB, "#funfact_defended_bomb", 0.5f, CSSTAT_KILLS_WHILE_DEFENDING_BOMB, 2, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_ITEMS_DROPPED_VALUE, "#funfact_items_dropped_value", 0.5f, CSTAT_ITEMS_DROPPED_VALUE, 10000, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_KILL_WOUNDED_ENEMIES, "#funfact_kill_wounded_enemies", 0.4f, CSSTAT_KILLS_ENEMY_WOUNDED, 3, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_KILLS_HEADSHOTS, "#funfact_kills_headshots", 0.7f, CSSTAT_KILLS_HEADSHOT, 3, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_BROKE_WINDOWS, "#funfact_broke_windows", 0.3f, CSSTAT_NUM_BROKEN_WINDOWS, 5, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATBEST( FUNFACT_NIGHTVISION_DAMAGE, "#funfact_nightvision_damage", 0.5f, CSSTAT_NIGHTVISION_DAMAGE, 100, EvalFlags::HighestOnly);
DECLARE_FUNFACT_STATSUM( FUNFACT_SHOTS_FIRED, "#funfact_shots_fired", 0.1f, CSSTAT_SHOTS_FIRED, 200, EvalFlags::All);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_KILL_DEFUSER, "#funfact_kill_defuser", 0.6f, FFEVAL_KILLED_DEFUSER, 1, EvalFlags::TeamTerrorist | EvalFlags::WinningTeam);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_KILL_RESCUER, "#funfact_kill_rescuer", 0.6f, FFEVAL_KILLED_RESCUER, 1, EvalFlags::TeamTerrorist);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_KILLS_WITH_SINGLE_GRENADE, "#funfact_kills_with_single_grenade", 0.8f, FFEVAL_KILLS_WITH_GRENADE, 2, EvalFlags::HighestOnly);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_DAMAGE_NO_KILLS, "#funfact_damage_no_kills", 0.4f, FFEVAL_DAMAGE_NO_KILLS, 200, EvalFlags::HighestOnly);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_FIRST_KILL, "#funfact_first_kill", 0.2f, FFEVAL_FIRST_KILL, 1, EvalFlags::HighestOnly);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_FIRST_BLOOD, "#funfact_first_blood", 0.2f, FFEVAL_FIRST_BLOOD, 1, EvalFlags::HighestOnly);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_BEST_ACCURACY, "#funfact_best_accuracy", 0.4f, FFEVAL_ACCURACY, 20, EvalFlags::HighestOnly);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_KNIFE_IN_GUNFIGHT, "#funfact_knife_in_gunfight", 0.6f, FFEVAL_KNIFE_IN_GUNFIGHT , 1, EvalFlags::All);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_SURVIVED_MULTIPLE_ATTACKERS, "#funfact_survived_multiple_attackers", 0.3f, FFEVAL_MULTIPLE_ATTACKER_COUNT, 3, EvalFlags::HighestOnly | EvalFlags::Alive);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_DIED_FROM_MULTIPLE_ATTACKERS, "#funfact_died_from_multiple_attackers", 0.5f, FFEVAL_MULTIPLE_ATTACKER_COUNT, 3, EvalFlags::HighestOnly | EvalFlags::Dead);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_USED_ALL_AMMO, "#funfact_used_all_ammo", 0.5f, FFEVAL_USED_ALL_AMMO, 1, EvalFlags::All );
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_DAMAGE_MULTIPLE_ENEMIES, "#funfact_damage_multiple_enemies", 0.5f, FFEVAL_DAMAGE_MULTIPLE_ENEMIES, 3, EvalFlags::HighestOnly);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_USED_MULTIPLE_WEAPONS, "#funfact_used_multiple_weapons", 0.5f, FFEVAL_USED_MULTIPLE_WEAPONS, 4, EvalFlags::HighestOnly);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_DEFUSED_WITH_DROPPED_KIT, "#funfact_defused_with_dropped_kit", 0.4f, FFEVAL_DEFUSED_WITH_DROPPED_KIT, 1, EvalFlags::TeamCT);
DECLARE_FUNFACT_PLAYERFUNC( FUNFACT_KILLED_HALF_OF_ENEMIES, "#funfact_killed_half_of_enemies", 0.5f, FFEVAL_KILLED_HALF_OF_ENEMIES, 50, EvalFlags::WinningTeam | EvalFlags::HighestOnly);
DECLARE_FUNFACT_EVALFUNC( FUNFACT_CT_WIN_NO_KILLS, "#funfact_ct_win_no_kills", 0.4f, FFEVAL_CT_WIN_NO_KILLS);
DECLARE_FUNFACT_EVALFUNC( FUNFACT_T_WIN_NO_KILLS, "#funfact_t_win_no_kills", 0.4f, FFEVAL_T_WIN_NO_KILLS );
DECLARE_FUNFACT_EVALFUNC( FUNFACT_T_WIN_NO_CASUALTIES, "#funfact_t_win_no_casualties", 0.2f, FFEVAL_T_WIN_NO_CASUALTIES );
DECLARE_FUNFACT_EVALFUNC( FUNFACT_CT_WIN_NO_CASUALTIES, "#funfact_ct_win_no_casualties", 0.2f, FFEVAL_CT_WIN_NO_CASUALTIES );
DECLARE_FUNFACT_EVALFUNC( FUNFACT_SHORT_ROUND, "#funfact_short_round", 0.3f, FFEVAL_SHORT_ROUND );
DECLARE_FUNFACT_EVALFUNC( FUNFACT_WON_AS_LAST_MEMBER, "#funfact_won_as_last_member", 0.6f, FFEVAL_WON_AS_LAST_MEMBER );
DECLARE_FUNFACT_EVALFUNC( FUNFACT_TERRORIST_ACCURACY, "#funfact_terrorist_accuracy", 0.2f, FFEVAL_TERRORIST_ACCURACY);
DECLARE_FUNFACT_EVALFUNC( FUNFACT_CT_ACCURACY, "#funfact_ct_accuracy", 0.2f, FFEVAL_CT_ACCURACY);
DECLARE_FUNFACT_EVALFUNC( FUNFACT_BEST_TERRORIST_ACCURACY, "#funfact_best_terrorist_accuracy", 0.3f, FFEVAL_BEST_TERRORIST_ACCURACY);
DECLARE_FUNFACT_EVALFUNC( FUNFACT_BEST_COUNTERTERRORIST_ACCURACY, "#funfact_best_counterterrorist_accuracy", 0.3f, FFEVAL_BEST_COUNTERTERRORIST_ACCURACY);
DECLARE_FUNFACT_EVALFUNC( FUNFACT_FALLBACK1, "#funfact_fallback1", 0.0f, FFEVAL_ALWAYS_TRUE);
DECLARE_FUNFACT_EVALFUNC( FUNFACT_FALLBACK2, "#funfact_fallback2", 0.0f, FFEVAL_ALWAYS_TRUE);
DECLARE_FUNFACT_TEAMFUNC( FUNFACT_SAME_UNIFORM_TERRORIST, "#funfact_same_uniform_terrorist", 0.5f, FFEVAL_SAME_UNIFORM, TEAM_TERRORIST);
DECLARE_FUNFACT_TEAMFUNC( FUNFACT_SAME_UNIFORM_CT, "#funfact_same_uniform_ct", 0.5f, FFEVAL_SAME_UNIFORM, TEAM_CT);
Reference in New Issue Copy Permalink