1HEADmaster

1 files changed, 793 insertions, 0 deletions

diff --git a/game/server/cstrike/funfact_cs.cpp b/game/server/cstrike/funfact_cs.cpp
new file mode 100644
index 0000000..e880359
--- /dev/null
+++ b/game/server/cstrike/funfact_cs.cpp
@@ -0,0 +1,793 @@
+//========= 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);