1HEADmaster

1 files changed, 1721 insertions, 0 deletions

diff --git a/game/server/cstrike/cs_gamestats.cpp b/game/server/cstrike/cs_gamestats.cpp
new file mode 100644
index 0000000..afb02a0
--- /dev/null
+++ b/game/server/cstrike/cs_gamestats.cpp
@@ -0,0 +1,1721 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: CS game stats
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Some tricky business here - we don't want to include the precompiled header for the statreader
+// and trying to #ifdef it out does funky things like ignoring the #endif. Define our header file
+// separately and include it based on the switch
+
+#include "cbase.h"
+
+#include <tier0/platform.h>
+#include "cs_gamerules.h"
+#include "cs_gamestats.h"
+#include "weapon_csbase.h"
+#include "props.h"
+#include "cs_achievement_constants.h"
+#include "../../shared/cstrike/weapon_c4.h"
+
+#include <time.h>
+#include "filesystem.h"
+#include "bot_util.h"
+#include "cdll_int.h"
+#include "steamworks_gamestats.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+float	g_flGameStatsUpdateTime = 0.0f;
+short	g_iTerroristVictories[CS_NUM_LEVELS];
+short	g_iCounterTVictories[CS_NUM_LEVELS];
+short	g_iWeaponPurchases[WEAPON_MAX];
+
+short	g_iAutoBuyPurchases = 0;
+short	g_iReBuyPurchases = 0;
+short	g_iAutoBuyM4A1Purchases = 0;
+short	g_iAutoBuyAK47Purchases = 0;
+short	g_iAutoBuyFamasPurchases = 0;
+short	g_iAutoBuyGalilPurchases = 0;
+short	g_iAutoBuyVestHelmPurchases = 0;
+short	g_iAutoBuyVestPurchases = 0;
+
+struct PropModelStats_t
+{
+	const char* szPropModelName;
+	CSStatType_t statType;
+} PropModelStatsTableInit[] =
+{
+	{ "models/props/cs_office/computer_caseb.mdl", CSSTAT_PROPSBROKEN_OFFICEELECTRONICS },
+	{ "models/props/cs_office/computer_monitor.mdl", CSSTAT_PROPSBROKEN_OFFICEELECTRONICS },
+	{ "models/props/cs_office/phone.mdl", CSSTAT_PROPSBROKEN_OFFICEELECTRONICS },
+	{ "models/props/cs_office/projector.mdl", CSSTAT_PROPSBROKEN_OFFICEELECTRONICS },
+	{ "models/props/cs_office/TV_plasma.mdl", CSSTAT_PROPSBROKEN_OFFICEELECTRONICS },
+	{ "models/props/cs_office/computer_keyboard.mdl", CSSTAT_PROPSBROKEN_OFFICEELECTRONICS },
+	{ "models/props/cs_office/radio.mdl", CSSTAT_PROPSBROKEN_OFFICERADIO },
+	{ "models/props/cs_office/trash_can.mdl", CSSTAT_PROPSBROKEN_OFFICEJUNK },
+	{ "models/props/cs_office/file_box.mdl", CSSTAT_PROPSBROKEN_OFFICEJUNK },
+	{ "models/props_junk/watermelon01.mdl", CSSTAT_PROPSBROKEN_ITALY_MELON },
+	// 	models/props/de_inferno/claypot01.mdl
+	// 	models/props/de_inferno/claypot02.mdl
+	//	models/props/de_dust/grainbasket01c.mdl
+	//	models/props_junk/wood_crate001a.mdl 
+	//	models/props/cs_office/file_box_p1.mdl 
+};
+
+
+struct ServerStats_t
+{
+	int achievementId;
+	int statId;
+	int roundRequirement;
+	int matchRequirement;
+	const char* mapFilter;
+
+	bool IsMet(int roundStat, int matchStat)
+	{
+		return roundStat >= roundRequirement && matchStat >= matchRequirement;
+	}
+} ServerStatBasedAchievements[] =
+{
+	{ CSBreakWindows,			    CSSTAT_NUM_BROKEN_WINDOWS,		AchievementConsts::BreakWindowsInOfficeRound_Windows,	0,	"cs_office" },
+	{ CSBreakProps,			        CSSTAT_PROPSBROKEN_ALL,			AchievementConsts::BreakPropsInRound_Props,				0,	NULL },
+	{ CSUnstoppableForce,		    CSSTAT_KILLS,					AchievementConsts::UnstoppableForce_Kills,				0,	NULL },
+	{ CSHeadshotsInRound,	        CSSTAT_KILLS_HEADSHOT,			AchievementConsts::HeadshotsInRound_Kills,				0,	NULL },
+    { CSDominationOverkillsMatch,	CSSTAT_DOMINATION_OVERKILLS,	0,				                                        10,	NULL },
+};
+
+//=============================================================================
+// HPE_BEGIN:
+// [Forrest] Allow nemesis/revenge to be turned off for a server
+//=============================================================================
+static void SvNoNemesisChangeCallback( IConVar *pConVar, const char *pOldValue, float flOldValue )
+{
+	ConVarRef var( pConVar );
+	if ( var.IsValid() && var.GetBool() )
+	{
+		// Clear all nemesis relationships.
+		for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
+		{
+			CCSPlayer *pTemp = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+			if ( pTemp )
+			{
+				pTemp->RemoveNemesisRelationships();
+			}
+		}
+	}
+}
+
+ConVar sv_nonemesis( "sv_nonemesis", "0", 0, "Disable nemesis and revenge.", SvNoNemesisChangeCallback );
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+int GetCSLevelIndex( const char *pLevelName )
+{
+	for ( int i = 0; MapName_StatId_Table[i].statWinsId != CSSTAT_UNDEFINED; i ++ )
+	{
+		if ( Q_strcmp( pLevelName, MapName_StatId_Table[i].szMapName ) == 0 )
+			return i;
+	}
+
+	return -1;
+}
+
+ConVar sv_debugroundstats( "sv_debugroundstats", "0", 0, "A temporary variable that will print extra information about stats upload which may be useful in debugging any problems." );
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Addition of CCS_GameStats class
+//=============================================================================
+ 
+CCSGameStats CCS_GameStats;
+CCSGameStats::StatContainerList_t* CCSGameStats::s_StatLists = new CCSGameStats::StatContainerList_t();
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+// Input  :  - 
+//-----------------------------------------------------------------------------
+CCSGameStats::CCSGameStats()
+{
+	gamestats = this;
+	Clear();
+	m_fDisseminationTimerLow = m_fDisseminationTimerHigh = 0.0f;
+
+	// create table for mapping prop models to stats
+	for ( int i = 0; i < ARRAYSIZE(PropModelStatsTableInit); ++i)
+	{
+		m_PropStatTable.Insert(PropModelStatsTableInit[i].szPropModelName, PropModelStatsTableInit[i].statType);
+	}
+
+	m_numberOfRoundsForDirectAverages = 0;
+	m_numberOfTerroristEntriesForDirectAverages = 0;
+	m_numberOfCounterTerroristEntriesForDirectAverages = 0;
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+// Input  :  - 
+//-----------------------------------------------------------------------------
+CCSGameStats::~CCSGameStats()
+{
+	Clear();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Clear out game stats
+// Input  :  - 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Clear( void )
+{
+	m_PlayerSnipedPosition.Purge();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CCSGameStats::Init( void )
+{
+	ListenForGameEvent( "round_start" );
+	ListenForGameEvent( "round_end" );
+	ListenForGameEvent( "break_prop" );
+	ListenForGameEvent( "player_decal");
+	ListenForGameEvent( "hegrenade_detonate");
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::PostInit( void )
+{
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::LevelShutdownPreClearSteamAPIContext( void )
+{
+	// If we have any unsent round stats we better send them now or we'll lose them
+	UploadRoundStats();
+
+	GetSteamWorksSGameStatsUploader().EndSession();
+}
+
+extern double g_rowCommitTime;
+extern double g_rowWriteTime;
+
+void CCSGameStats::UploadRoundStats( void )
+{
+	CFastTimer totalTimer, purchasesAndDeathsStatTimer, weaponsStatBuildTimer, weaponsStatSubmitTimer, submitTimer, cleanupTimer;
+
+	// Prevent uploading empty data
+	if ( !m_bInRound )
+		return;
+
+	if ( sv_noroundstats.GetBool() )
+	{
+		if ( sv_debugroundstats.GetBool() )
+		{
+			Msg( "sv_noroundstats is enabled. Not uploading round stats.\n" );
+		}
+
+		m_MarketPurchases.PurgeAndDeleteElements();
+		m_WeaponData.PurgeAndDeleteElements();
+		m_DeathData.PurgeAndDeleteElements();
+		return;
+	}
+
+	m_bInRound = false;
+
+	KeyValues *pKV = new KeyValues( "basedata" );
+	if ( !pKV )
+		return;
+
+	totalTimer.Start();
+	purchasesAndDeathsStatTimer.Start();
+
+	const char *pzMapName = gpGlobals->mapname.ToCStr();
+	pKV->SetString( "MapID", pzMapName );
+
+	for ( int k=0 ; k < m_MarketPurchases.Count() ; ++k )
+		SubmitStat( m_MarketPurchases[ k ] );
+
+	for ( int k=0 ; k < m_DeathData.Count() ; ++k )
+		SubmitStat( m_DeathData[ k ] );
+
+	purchasesAndDeathsStatTimer.End();
+	weaponsStatBuildTimer.Start();
+
+	// Now add the weapon stats that HPE collected
+	for (int iWeapon = 0; iWeapon < WEAPON_MAX; ++iWeapon)
+	{
+		CCSWeaponInfo* pInfo = GetWeaponInfo( (CSWeaponID)iWeapon );
+		if ( !pInfo )
+			continue;
+
+		const char* pWeaponName = pInfo->szClassName;
+		if ( !pWeaponName || !pWeaponName[0] || ( m_weaponStats[iWeapon][0].shots == 0 && m_weaponStats[iWeapon][1].shots == 0 ) )
+			continue;
+
+
+		m_WeaponData.AddToTail( new SCSSWeaponData( pWeaponName, m_weaponStats[iWeapon][0] ) );
+
+		// Now add the bot data if we're collecting detailled data
+		if ( GetSteamWorksSGameStatsUploader().IsCollectingDetails() )
+		{
+			char pWeaponNameModified[64];
+			V_snprintf( pWeaponNameModified, ARRAYSIZE(pWeaponNameModified), "%s_bot", pWeaponName );
+			m_WeaponData.AddToTail( new SCSSWeaponData( pWeaponNameModified, m_weaponStats[iWeapon][1] ) );
+		}
+	}
+
+	weaponsStatBuildTimer.End();
+	weaponsStatSubmitTimer.Start();
+
+	for ( int k=0 ; k < m_WeaponData.Count() ; ++k )
+		SubmitStat( m_WeaponData[ k ] );
+
+	weaponsStatSubmitTimer.End();
+
+	// Perform the actual submission
+	submitTimer.Start();
+	SubmitGameStats( pKV );
+	submitTimer.End();
+
+	int iPurchases, iDeathData, iWeaponData;
+	int listCount = s_StatLists->Count();
+	iPurchases = m_MarketPurchases.Count();
+	iDeathData = m_DeathData.Count();
+	iWeaponData = m_WeaponData.Count();
+
+	// Clear out the per round stats
+	cleanupTimer.Start();
+	m_MarketPurchases.Purge();
+	m_WeaponData.Purge();
+	m_DeathData.Purge();
+	pKV->deleteThis();
+	cleanupTimer.End();
+
+	totalTimer.End();
+
+	if ( sv_debugroundstats.GetBool() )
+	{
+		Msg( "**** ROUND STAT DEBUG ****\n" );
+		Msg( "UploadRoundStats completed. %.3f msec. Breakdown:\n a: %.3f msec\n b: %.3f msec\n c: %.3f msec\n d: %.3f msec\n e: %.3f msec\n objects: %d %d %d %d\n commit: %.3fms\n write: %.3fms.\n\n",
+			totalTimer.GetDuration().GetMillisecondsF(),
+			purchasesAndDeathsStatTimer.GetDuration().GetMillisecondsF(),
+			weaponsStatBuildTimer.GetDuration().GetMillisecondsF(),
+			weaponsStatSubmitTimer.GetDuration().GetMillisecondsF(),
+			submitTimer.GetDuration().GetMillisecondsF(),
+			cleanupTimer.GetDuration().GetMillisecondsF(),
+			iPurchases, iDeathData, iWeaponData, listCount,
+			g_rowCommitTime, g_rowWriteTime);
+	}
+}
+
+#ifdef _DEBUG
+CON_COMMAND ( teststats, "Test command" )
+{
+	CFastTimer totalTimer;
+	double uploadTime = 0.0f;
+	g_rowCommitTime = 0.0f;
+	g_rowWriteTime = 0.0f;
+
+
+	for( int i = 0; i < 1000; i++ )
+	{
+		KeyValues *pKV = new KeyValues( "basedata" );
+		if ( !pKV )
+			return;
+
+		pKV->SetName( "foobartest" );
+		pKV->SetUint64( "test1", 1234 );
+		pKV->SetUint64( "test2", 1234 );
+		pKV->SetUint64( "test3", 1234 );
+		pKV->SetUint64( "test4", 1234 );
+		pKV->SetString( "test5", "TEST1234567890TEST1234567890TEST!");
+		/*pKV->SetString( "test6", "TEST1234567890TEST1234567890TEST!");
+		pKV->SetString( "test7", "TEST1234567890TEST1234567890TEST!");
+		pKV->SetString( "test8", "TEST1234567890TEST1234567890TEST!");
+		pKV->SetString( "test9", "TEST1234567890TEST1234567890TEST!");*/
+
+		totalTimer.Start();
+		GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKV, args.ArgC() == 1 );
+		totalTimer.End();
+
+		uploadTime += totalTimer.GetDuration().GetMillisecondsF();
+	}
+
+	Msg( "teststats took %.3f msec   commit: %.3fms   write: %.3fms.\n", uploadTime, g_rowCommitTime, g_rowWriteTime );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::SubmitGameStats( KeyValues *pKV )
+{
+	int listCount = s_StatLists->Count();
+	for( int i=0; i < listCount; ++i )
+	{
+		// Create a master key value that has stats everybody should share (map name, session ID, etc)
+		(*s_StatLists)[i]->SendData(pKV);
+		(*s_StatLists)[i]->Clear();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_ShotFired( CBasePlayer *pPlayer, CBaseCombatWeapon* pWeapon )
+{
+	Assert( pPlayer );
+	CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+
+	CWeaponCSBase* pCSWeapon = dynamic_cast< CWeaponCSBase * >(pWeapon);
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] adding tracking for weapon used fun fact
+    //=============================================================================
+
+    if ( pCSPlayer )
+    {
+        // [dwenger] Update the player's tracking of which weapon type they fired
+        pCSPlayer->PlayerUsedFirearm( pWeapon );
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+	    IncrementStat( pCSPlayer, CSSTAT_SHOTS_FIRED, 1 );
+	    // Increment the individual weapon
+	    if( pCSWeapon )
+	    {
+			CSWeaponID weaponId = pCSWeapon->GetWeaponID();
+		    for (int i = 0; WeaponName_StatId_Table[i].shotStatId != CSSTAT_UNDEFINED; ++i)
+		    {
+			    if ( WeaponName_StatId_Table[i].weaponId == weaponId )
+			    {
+				    IncrementStat( pCSPlayer, WeaponName_StatId_Table[i].shotStatId, 1 );
+					break;
+			    }
+		    }
+
+			int iType = pCSPlayer->IsBot();
+			++m_weaponStats[weaponId][iType].shots;
+	    }
+    }
+}
+
+void CCSGameStats::Event_ShotHit( CBasePlayer *pPlayer, const CTakeDamageInfo &info )
+{
+	Assert( pPlayer );
+	CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+
+	IncrementStat( pCSPlayer, CSSTAT_SHOTS_HIT, 1 );
+
+	CBaseEntity *pInflictor = info.GetInflictor();
+
+	if ( pInflictor )
+	{
+		if ( pInflictor == pPlayer )
+		{			
+			if ( pPlayer->GetActiveWeapon() )
+			{
+				CWeaponCSBase* pCSWeapon = dynamic_cast< CWeaponCSBase * >(pPlayer->GetActiveWeapon());
+				if (pCSWeapon)
+				{
+					CSWeaponID weaponId = pCSWeapon->GetWeaponID();
+					for (int i = 0; WeaponName_StatId_Table[i].shotStatId != CSSTAT_UNDEFINED; ++i)
+					{
+						if ( WeaponName_StatId_Table[i].weaponId == weaponId )
+						{
+							IncrementStat( pCSPlayer, WeaponName_StatId_Table[i].hitStatId, 1 );
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+void CCSGameStats::Event_PlayerKilled( CBasePlayer *pPlayer, const CTakeDamageInfo &info )
+{
+	Assert( pPlayer );
+	CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+	
+	IncrementStat( pCSPlayer, CSSTAT_DEATHS, 1 );
+}
+
+void CCSGameStats::Event_PlayerSprayedDecal( CCSPlayer* pPlayer )
+{
+    IncrementStat( pPlayer, CSSTAT_DECAL_SPRAYS, 1 );
+}
+
+void CCSGameStats::Event_PlayerKilled_PreWeaponDrop( CBasePlayer *pPlayer, const CTakeDamageInfo &info )
+{
+	Assert( pPlayer );
+	CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+	CCSPlayer *pAttacker = ToCSPlayer( info.GetAttacker() );
+	bool victimZoomed = ( pCSPlayer->GetFOV() != pCSPlayer->GetDefaultFOV() );
+
+	if (victimZoomed)
+	{
+		IncrementStat(pAttacker, CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER, 1);
+	}
+
+
+	//Check for knife fight
+	if (pAttacker && pCSPlayer && pAttacker == info.GetInflictor() && pAttacker->GetTeamNumber() != pCSPlayer->GetTeamNumber())
+	{
+		CWeaponCSBase* attackerWeapon = pAttacker->GetActiveCSWeapon();
+		CWeaponCSBase* victimWeapon = pCSPlayer->GetActiveCSWeapon();
+
+		if (attackerWeapon && victimWeapon)
+		{
+			CSWeaponID attackerWeaponID = attackerWeapon->GetWeaponID();
+			CSWeaponID victimWeaponID = victimWeapon->GetWeaponID();
+
+			if (attackerWeaponID == WEAPON_KNIFE && victimWeaponID == WEAPON_KNIFE)
+			{
+				IncrementStat(pAttacker, CSSTAT_KILLS_KNIFE_FIGHT, 1);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_BombPlanted( CCSPlayer* pPlayer)
+{
+    IncrementStat( pPlayer, CSSTAT_NUM_BOMBS_PLANTED, 1 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_BombDefused( CCSPlayer* pPlayer)
+{
+
+    IncrementStat( pPlayer, CSSTAT_NUM_BOMBS_DEFUSED, 1 );
+	IncrementStat( pPlayer, CSSTAT_OBJECTIVES_COMPLETED, 1 );
+	if( pPlayer && pPlayer->HasDefuser() )
+	{
+		IncrementStat( pPlayer, CSSTAT_BOMBS_DEFUSED_WITHKIT, 1 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Increment terrorist team stat
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_BombExploded( CCSPlayer* pPlayer )
+{
+	IncrementStat( pPlayer, CSSTAT_OBJECTIVES_COMPLETED, 1 );
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_HostageRescued( CCSPlayer* pPlayer)
+{
+    IncrementStat( pPlayer, CSSTAT_NUM_HOSTAGES_RESCUED, 1 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Increment counter-terrorist team stat
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_AllHostagesRescued()
+{
+	IncrementTeamStat( TEAM_CT, CSSTAT_OBJECTIVES_COMPLETED, 1 );
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_WindowShattered( CBasePlayer *pPlayer)
+{
+    Assert( pPlayer );
+    CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+
+    IncrementStat( pCSPlayer, CSSTAT_NUM_BROKEN_WINDOWS, 1 );
+}
+
+
+void CCSGameStats::Event_BreakProp( CCSPlayer* pPlayer, CBreakableProp *pProp )
+{
+	if (!pPlayer)
+		return;
+
+	DevMsg("Player %s broke a %s (%i)\n", pPlayer->GetPlayerName(), pProp->GetModelName().ToCStr(), pProp->entindex());
+
+	int iIndex = m_PropStatTable.Find(pProp->GetModelName().ToCStr());
+	if (m_PropStatTable.IsValidIndex(iIndex))
+	{
+		IncrementStat(pPlayer, m_PropStatTable[iIndex], 1);
+	}
+	IncrementStat(pPlayer, CSSTAT_PROPSBROKEN_ALL, 1);
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::UpdatePlayerRoundStats(int winner)
+{	
+    int mapIndex = GetCSLevelIndex(gpGlobals->mapname.ToCStr());
+    CSStatType_t mapStatWinIndex  = CSSTAT_UNDEFINED, mapStatRoundIndex = CSSTAT_UNDEFINED;
+
+    if ( mapIndex != -1 )
+    {
+        mapStatWinIndex = MapName_StatId_Table[mapIndex].statWinsId;
+		mapStatRoundIndex = MapName_StatId_Table[mapIndex].statRoundsId;
+    }
+
+	// increment the team specific stats
+	IncrementTeamStat( winner, CSSTAT_ROUNDS_WON, 1 );
+	if ( mapStatWinIndex != CSSTAT_UNDEFINED )
+	{
+		IncrementTeamStat( winner, mapStatWinIndex, 1 );
+	}
+	if ( CSGameRules()->IsPistolRound() )
+	{
+		IncrementTeamStat( winner, CSSTAT_PISTOLROUNDS_WON, 1 );
+	}
+	IncrementTeamStat( TEAM_TERRORIST, CSSTAT_ROUNDS_PLAYED, 1 );
+	IncrementTeamStat( TEAM_CT, CSSTAT_ROUNDS_PLAYED, 1 );
+	IncrementTeamStat( TEAM_TERRORIST, mapStatRoundIndex, 1 );
+	IncrementTeamStat( TEAM_CT, mapStatRoundIndex, 1 );
+
+	for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+		if ( pPlayer && pPlayer->IsConnected() )
+		{
+			if ( winner == TEAM_CT )
+			{
+				IncrementStat( pPlayer, CSSTAT_CT_ROUNDS_WON, 1, true );
+			}
+			else if ( winner == TEAM_TERRORIST )
+			{
+				IncrementStat( pPlayer, CSSTAT_T_ROUNDS_WON, 1, true );
+			}
+
+			if ( winner == TEAM_CT || winner == TEAM_TERRORIST )
+			{
+				// Increment the win stats if this player is on the winning team
+				if ( pPlayer->GetTeamNumber() == winner )
+				{
+					IncrementStat( pPlayer, CSSTAT_ROUNDS_WON, 1, true );
+
+					if ( CSGameRules()->IsPistolRound() )
+					{
+						IncrementStat( pPlayer, CSSTAT_PISTOLROUNDS_WON, 1, true );
+					}
+
+					if ( mapStatWinIndex != CSSTAT_UNDEFINED )
+					{
+						IncrementStat( pPlayer, mapStatWinIndex, 1, true );
+					}
+				}
+
+				IncrementStat( pPlayer, CSSTAT_ROUNDS_PLAYED, 1 );
+				if ( mapStatWinIndex != CSSTAT_UNDEFINED )
+				{
+					IncrementStat( pPlayer, mapStatRoundIndex, 1, true );
+				}
+
+				// set the play time for the round
+				IncrementStat( pPlayer, CSSTAT_PLAYTIME, (int)CSGameRules()->GetRoundElapsedTime(), true );
+			}
+		}
+	}
+
+	// send a stats update to all players
+	for ( int iPlayerIndex = 1; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+		if ( pPlayer && pPlayer->IsConnected())
+		{
+			SendStatsToPlayer(pPlayer, CSSTAT_PRIORITY_ENDROUND);
+		}
+	}
+}
+
+void CCSGameStats::SendRollingStatsAveragesToAllPlayers()
+{
+	//The most stats we can send at once is the max message size minus the header, divided by the total size of each stat.
+	const int maxStatsPerMessage = (MAX_USER_MSG_DATA - sizeof(CSStatType_t)) / (3 * sizeof(float));
+
+	const int numMessagesNeeded = ((CSSTAT_MAX - CSSTAT_FIRST) / maxStatsPerMessage) + 1;
+
+	for (int batchIndex = 0 ; batchIndex < numMessagesNeeded ; ++batchIndex)
+	{
+		int firstStatInThisBatch = (batchIndex * maxStatsPerMessage) + CSSTAT_FIRST;
+		int lastMessageInThisBatch = firstStatInThisBatch + maxStatsPerMessage - 1;
+
+		CRecipientFilter filter;
+		filter.AddAllPlayers();
+		UserMessageBegin( filter, "MatchStatsUpdate" );  
+
+		WRITE_SHORT(firstStatInThisBatch);
+		
+		for ( int iStat = firstStatInThisBatch; iStat < CSSTAT_MAX && iStat <= lastMessageInThisBatch; ++iStat )
+		{
+			WRITE_FLOAT(m_rollingTStatAverages.m_fStat[iStat]);
+			WRITE_FLOAT(m_rollingCTStatAverages.m_fStat[iStat]);
+			WRITE_FLOAT(m_rollingPlayerStatAverages.m_fStat[iStat]);
+		}
+
+		MessageEnd();
+	}
+}
+
+
+void CCSGameStats::SendDirectStatsAveragesToAllPlayers()
+{
+	//The most stats we can send at once is the max message size minus the header, divided by the total size of each stat.
+	const int maxStatsPerMessage = (MAX_USER_MSG_DATA - sizeof(CSStatType_t)) / (3 * sizeof(float));
+
+	const int numMessagesNeeded = ((CSSTAT_MAX - CSSTAT_FIRST) / maxStatsPerMessage) + 1;
+
+	for (int batchIndex = 0 ; batchIndex < numMessagesNeeded ; ++batchIndex)
+	{
+		int firstStatInThisBatch = (batchIndex * maxStatsPerMessage) + CSSTAT_FIRST;
+		int lastMessageInThisBatch = firstStatInThisBatch + maxStatsPerMessage - 1;
+
+		CRecipientFilter filter;
+		filter.AddAllPlayers();
+		UserMessageBegin( filter, "MatchStatsUpdate" );  
+
+		WRITE_SHORT(firstStatInThisBatch);
+
+		for ( int iStat = firstStatInThisBatch; iStat < CSSTAT_MAX && iStat <= lastMessageInThisBatch; ++iStat )
+		{
+			WRITE_FLOAT(m_directTStatAverages.m_fStat[iStat]);
+			WRITE_FLOAT(m_directCTStatAverages.m_fStat[iStat]);
+			WRITE_FLOAT(m_directPlayerStatAverages.m_fStat[iStat]);
+		}
+
+		MessageEnd();
+	}
+}
+
+void CCSGameStats::ComputeRollingStatAverages()
+{
+    int numPlayers = 0;
+    int numCTs = 0;
+    int numTs = 0;
+
+    RoundStatsRollingAverage_t currentRoundTStatsAverage;
+    RoundStatsRollingAverage_t currentRoundCTStatsAverage;
+    RoundStatsRollingAverage_t currentRoundPlayerStatsAverage;
+
+    currentRoundTStatsAverage.Reset();
+    currentRoundCTStatsAverage.Reset();
+    currentRoundPlayerStatsAverage.Reset();
+    
+    //for ( int iStat = CSSTAT_FIRST; iStat < CSSTAT_MAX; ++iStat )
+    {
+        for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
+        {
+            CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+            if ( pPlayer && pPlayer->IsConnected())
+            {
+                StatsCollection_t &roundStats = m_aPlayerStats[pPlayer->entindex()].statsCurrentRound;
+
+                int teamNumber = pPlayer->GetTeamNumber();
+                if (teamNumber == TEAM_CT)
+                {
+                    numCTs++;                
+                    numPlayers++;
+                    currentRoundCTStatsAverage += roundStats;
+                    currentRoundPlayerStatsAverage += roundStats;
+                }
+                else if (teamNumber == TEAM_TERRORIST)
+                {
+                    numTs++;
+                    numPlayers++;
+                    currentRoundTStatsAverage += roundStats;
+                    currentRoundPlayerStatsAverage += roundStats;
+                }
+            }
+        }
+
+        if (numTs > 0)
+        {
+            currentRoundTStatsAverage /= numTs;
+        }
+
+        if (numCTs > 0)
+        {
+            currentRoundCTStatsAverage /= numCTs;
+        }
+
+        if (numPlayers > 0)
+        {
+            currentRoundPlayerStatsAverage /= numPlayers;
+        }
+
+        m_rollingTStatAverages.RollDataSetIntoAverage(currentRoundTStatsAverage);
+        m_rollingCTStatAverages.RollDataSetIntoAverage(currentRoundCTStatsAverage);
+        m_rollingPlayerStatAverages.RollDataSetIntoAverage(currentRoundPlayerStatsAverage);
+    }
+}
+
+
+void CCSGameStats::ComputeDirectStatAverages()
+{		
+	m_numberOfRoundsForDirectAverages++;
+
+	m_directCTStatAverages.Reset();
+	m_directTStatAverages.Reset();
+	m_directPlayerStatAverages.Reset();
+
+
+	for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+		if ( pPlayer && pPlayer->IsConnected())
+		{
+			StatsCollection_t &matchStats = m_aPlayerStats[pPlayer->entindex()].statsCurrentMatch;
+
+			int teamNumber = pPlayer->GetTeamNumber();
+			if (teamNumber == TEAM_CT)
+			{
+				m_numberOfCounterTerroristEntriesForDirectAverages++;                					
+				m_directCTStatAverages += matchStats;
+				m_directPlayerStatAverages += matchStats;
+			}
+			else if (teamNumber == TEAM_TERRORIST)
+			{
+				m_numberOfTerroristEntriesForDirectAverages++;				
+				m_directTStatAverages += matchStats;
+				m_directPlayerStatAverages += matchStats;
+			}
+		}
+	}
+
+	if (m_numberOfTerroristEntriesForDirectAverages > 0)
+	{
+		m_directTStatAverages /= m_numberOfTerroristEntriesForDirectAverages;
+		m_directTStatAverages *= m_numberOfRoundsForDirectAverages;
+	}
+
+	if (m_numberOfCounterTerroristEntriesForDirectAverages > 0)
+	{
+		m_directCTStatAverages /= m_numberOfCounterTerroristEntriesForDirectAverages;
+		m_directCTStatAverages *= m_numberOfRoundsForDirectAverages;
+	}
+
+	int numPlayers = m_numberOfCounterTerroristEntriesForDirectAverages + m_numberOfTerroristEntriesForDirectAverages;
+
+	if (numPlayers > 0)
+	{
+		m_directPlayerStatAverages /= numPlayers;
+		m_directPlayerStatAverages *= m_numberOfRoundsForDirectAverages;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Log accumulated weapon usage and performance data
+//-----------------------------------------------------------------------------
+void CCSGameStats::DumpMatchWeaponMetrics()
+{
+	//// generate a filename
+	//time_t t = time( NULL );
+	//struct tm *now = localtime( &t );
+	//if ( !now )
+	//	return;
+
+	//int year = now->tm_year + 1900;
+	//int month = now->tm_mon + 1;
+	//int day = now->tm_mday;
+	//int hour = now->tm_hour;
+	//int minute = now->tm_min;
+	//int second = now->tm_sec;
+
+	//char filename[ 128 ];
+	//Q_snprintf( filename, sizeof(filename), "wm_%4d%02d%02d_%02d%02d%02d_%s.csv", 
+	//	year, month, day, hour, minute, second, gpGlobals->mapname.ToCStr());
+
+	//FileHandle_t hLogFile = filesystem->Open( filename, "wt" );
+
+	//if ( hLogFile == FILESYSTEM_INVALID_HANDLE )
+	//	return;
+
+	//filesystem->FPrintf(hLogFile, "%s\n", "WeaponId, Mode, Cost, Bullets, CycleTime, TotalShots, TotalHits, TotalDamage, TotalKills");
+
+	//for (int iWeapon = 0; iWeapon < WEAPON_MAX; ++iWeapon)
+	//{
+	//	CCSWeaponInfo* pInfo = GetWeaponInfo( (CSWeaponID)iWeapon );
+	//	if ( !pInfo )
+	//		continue;
+
+	//	const char* pWeaponName = pInfo->szClassName;
+	//	if ( !pWeaponName )
+	//		continue;
+
+	//	if ( V_strncmp(pWeaponName, "weapon_", 7) == 0 )
+	//		pWeaponName += 7;
+
+	//	for ( int iMode = 0; iMode < WeaponMode_MAX; ++iMode)
+	//	{
+	//		filesystem->FPrintf(hLogFile, "%s, %d, %d, %d, %f, %d, %d, %d, %d\n", 
+	//			pWeaponName,
+	//			iMode,
+	//			pInfo->GetWeaponPrice(),
+	//			pInfo->m_iBullets,
+	//			pInfo->m_flCycleTime,
+	//			m_weaponStats[iWeapon][iMode].shots, 
+	//			m_weaponStats[iWeapon][iMode].hits, 
+	//			m_weaponStats[iWeapon][iMode].damage, 
+	//			m_weaponStats[iWeapon][iMode].kills);
+	//	}
+	//}
+
+	//filesystem->FPrintf(hLogFile, "\n");
+	//filesystem->FPrintf(hLogFile, "weapon_accuracy_model, %d\n", weapon_accuracy_model.GetInt());
+	//filesystem->FPrintf(hLogFile, "bot_difficulty, %d\n", cv_bot_difficulty.GetInt());
+
+	//g_pFullFileSystem->Close(hLogFile);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_PlayerConnected( CBasePlayer *pPlayer )
+{
+	ResetPlayerStats( ToCSPlayer( pPlayer ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_PlayerDisconnected( CBasePlayer *pPlayer )
+{
+	CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+	if ( !pCSPlayer )
+		return;
+
+	ResetPlayerStats( pCSPlayer );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_PlayerKilledOther( CBasePlayer *pAttacker, CBaseEntity *pVictim, const CTakeDamageInfo &info )
+{
+	// This also gets called when the victim is a building.  That gets tracked separately as building destruction, don't count it here
+	if ( !pVictim->IsPlayer() )
+		return;
+
+	CBaseEntity *pInflictor = info.GetInflictor();	
+
+	CCSPlayer *pPlayerAttacker = ToCSPlayer( pAttacker );
+	CCSPlayer *pPlayerVictim = ToCSPlayer( pVictim );	
+
+    // keep track of how many times every player kills every other player
+    TrackKillStats( pPlayerAttacker, pPlayerVictim );
+
+	// Skip rest of stat reporting for friendly fire
+	if ( pPlayerAttacker->GetTeam() == pVictim->GetTeam() )
+		return;
+
+	CSWeaponID weaponId = WEAPON_NONE;
+	
+	if ( pInflictor )
+	{
+		if ( pInflictor == pAttacker )
+		{			
+			if ( pAttacker->GetActiveWeapon() )
+			{
+				CBaseCombatWeapon* weapon = pAttacker->GetActiveWeapon();
+				if (weapon)
+				{
+					CWeaponCSBase* pCSWeapon = static_cast<CWeaponCSBase*>(weapon);
+
+					weaponId = pCSWeapon->GetWeaponID();
+
+					CCSWeaponInfo *info = GetWeaponInfo(weaponId);
+
+					if (info && info->m_iTeam != TEAM_UNASSIGNED && pAttacker->GetTeamNumber() != info->m_iTeam )
+					{
+						IncrementStat(pPlayerAttacker, CSSTAT_KILLS_ENEMY_WEAPON, 1);
+					}
+				}
+			}
+		}		
+		else
+		{
+			//In the case of grenades, the inflictor is the spawned grenade entity.
+			if ( V_strcmp(pInflictor->m_iClassname.ToCStr(), "hegrenade_projectile") == 0 )
+				weaponId = WEAPON_HEGRENADE;
+		}
+	}
+
+	// update weapon stats
+	++m_weaponStats[weaponId][pPlayerAttacker->IsBot()].kills;
+
+	for (int i = 0; WeaponName_StatId_Table[i].killStatId != CSSTAT_UNDEFINED; ++i)
+	{
+		if ( WeaponName_StatId_Table[i].weaponId == weaponId )
+		{
+			IncrementStat( pPlayerAttacker, WeaponName_StatId_Table[i].killStatId, 1 );
+			break;
+		}
+	}
+
+	if (pPlayerVictim && pPlayerVictim->IsBlind())
+	{
+		IncrementStat( pPlayerAttacker, CSSTAT_KILLS_ENEMY_BLINDED, 1 );
+	}
+
+	if (pPlayerVictim && pPlayerAttacker && pPlayerAttacker->IsBlindForAchievement())
+	{
+		IncrementStat( pPlayerAttacker, CSSTAT_KILLS_WHILE_BLINDED, 1 );
+	}
+
+	// [sbodenbender] check for deaths near planted bomb for funfact
+	if (pPlayerVictim && pPlayerAttacker && pPlayerAttacker->GetTeamNumber() == TEAM_TERRORIST && CSGameRules()->m_bBombPlanted)
+	{
+		float bombCheckDistSq = AchievementConsts::KillEnemyNearBomb_MaxDistance * AchievementConsts::KillEnemyNearBomb_MaxDistance;
+		for ( int i=0; i < g_PlantedC4s.Count(); i++ )
+		{
+			CPlantedC4 *pC4 = g_PlantedC4s[i];
+
+			if ( pC4->IsBombActive() )
+			{
+				Vector bombPos = pC4->GetAbsOrigin();
+				Vector victimToBomb = pPlayerVictim->GetAbsOrigin() - bombPos;
+				Vector attackerToBomb = pPlayerAttacker->GetAbsOrigin() - bombPos;
+				if (victimToBomb.LengthSqr() < bombCheckDistSq || attackerToBomb.LengthSqr() < bombCheckDistSq)
+				{
+					IncrementStat(pPlayerAttacker, CSSTAT_KILLS_WHILE_DEFENDING_BOMB, 1);
+					break;	// you only get credit for one kill even if you happen to be by more than one bomb
+				}
+			}
+		}		
+	}
+
+	//Increment stat if this is a headshot.
+	if (info.GetDamageType() & DMG_HEADSHOT)
+	{
+		IncrementStat( pPlayerAttacker, CSSTAT_KILLS_HEADSHOT, 1 );
+	}
+
+	IncrementStat( pPlayerAttacker, CSSTAT_KILLS, 1 );
+
+	// we don't have a simple way (yet) to check if the victim actually just achieved The Unstoppable Force, so we
+	// award this achievement simply if they've met the requirements and would have received it.
+	PlayerStats_t &victimStats = m_aPlayerStats[pVictim->entindex()];
+	if (victimStats.statsCurrentRound[CSSTAT_KILLS] >= AchievementConsts::UnstoppableForce_Kills)
+	{
+		pPlayerAttacker->AwardAchievement(CSImmovableObject);
+	}
+
+	CCSGameRules::TeamPlayerCounts playerCounts[TEAM_MAXCOUNT];
+
+	CSGameRules()->GetPlayerCounts(playerCounts);
+	int iAttackerTeamNumber = pPlayerAttacker->GetTeamNumber() ;
+	if (playerCounts[iAttackerTeamNumber].totalAlivePlayers == 1 && playerCounts[iAttackerTeamNumber].killedPlayers >= 2)
+	{
+		IncrementStat(pPlayerAttacker, CSSTAT_KILLS_WHILE_LAST_PLAYER_ALIVE, 1);
+	}	
+
+	//if they were damaged by more than one person that must mean that someone else did damage before the killer finished them off.
+	if (pPlayerVictim->GetNumEnemyDamagers() > 1)
+	{
+		IncrementStat(pPlayerAttacker, CSSTAT_KILLS_ENEMY_WOUNDED, 1);
+	}
+
+	// Let's check for the "Happy Camper" achievement where we snipe two players while standing in the same spot.
+	if ( pPlayerAttacker && !pPlayerAttacker->IsBot() && weaponId != WEAPON_NONE )
+	{
+		// Were we using a sniper rifle?
+		bool bUsingSniper = (	weaponId == WEAPON_AWP ||
+								weaponId == WEAPON_SCOUT ||
+								weaponId == WEAPON_SG550 ||
+								weaponId == WEAPON_G3SG1 );
+			
+		// If we're zoomed in
+		if ( bUsingSniper && pPlayerAttacker->GetFOV() != pPlayerAttacker->GetDefaultFOV() )
+		{
+			// Get our position
+			 Vector position = pPlayerAttacker->GetAbsOrigin();
+			 int userid = pPlayerAttacker->GetUserID();
+
+			 bool bFoundPlayerEntry = false;
+			 FOR_EACH_LL( m_PlayerSnipedPosition, iElement )
+			 {
+				 sHappyCamperSnipePosition *pSnipePosition = &m_PlayerSnipedPosition[iElement];
+					 
+				 // We've found this player's entry. Next, check to see if they meet the achievement criteria
+				 if ( userid == pSnipePosition->m_iUserID )
+				 {
+					 bFoundPlayerEntry = true;
+					 Vector posDif = position - pSnipePosition->m_vPos;
+
+					 // Give a small epsilon to account for floating point anomalies
+					 if ( posDif.IsLengthLessThan( .01f) )
+					 {
+						 pPlayerAttacker->AwardAchievement( CSSnipeTwoFromSameSpot );
+					 }
+
+					 // Update their position
+					 pSnipePosition->m_vPos = position;
+					 break;
+				 }
+			 }
+
+			 // No entry so add one
+			 if ( !bFoundPlayerEntry )
+			 {
+				m_PlayerSnipedPosition.AddToTail( sHappyCamperSnipePosition( userid, position ) );
+			 }
+		}
+	}
+}
+
+
+void CCSGameStats::CalculateOverkill(CCSPlayer* pAttacker, CCSPlayer* pVictim)
+{
+    //Count domination overkills - Do this before determining domination
+    if (pAttacker->GetTeam() != pVictim->GetTeam())
+    {
+        if (pAttacker->IsPlayerDominated(pVictim->entindex()))
+        {
+            IncrementStat( pAttacker, CSSTAT_DOMINATION_OVERKILLS, 1 );
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Steamworks Gamestats death tracking
+//-----------------------------------------------------------------------------
+void CCSGameStats::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
+{
+	if ( !pVictim )
+		return;
+
+	m_DeathData.AddToTail( new SCSSDeathData( pVictim, info ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stats event for giving damage to player
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_PlayerDamage( CBasePlayer *pBasePlayer, const CTakeDamageInfo &info )
+{
+	CCSPlayer *pAttacker = ToCSPlayer( info.GetAttacker() );
+	if ( pAttacker && pAttacker->GetTeam() != pBasePlayer->GetTeam() )
+	{
+		CSWeaponMode weaponMode = Primary_Mode;
+		IncrementStat( pAttacker, CSSTAT_DAMAGE, info.GetDamage() );
+		
+        if (pAttacker->m_bNightVisionOn)
+        {
+            IncrementStat( pAttacker, CSSTAT_NIGHTVISION_DAMAGE, info.GetDamage() );
+		}
+
+		const char *pWeaponName = NULL;
+
+		if ( info.GetInflictor() == info.GetAttacker() )
+		{
+			if ( pAttacker->GetActiveWeapon() )
+			{
+				CWeaponCSBase* pCSWeapon = dynamic_cast< CWeaponCSBase * >(pAttacker->GetActiveWeapon());
+				if (pCSWeapon)
+				{
+					pWeaponName = pCSWeapon->GetClassname();
+					weaponMode = pCSWeapon->m_weaponMode;
+				}
+			}
+		}
+		// Need to determine the weapon name
+		else
+		{
+			pWeaponName = info.GetInflictor()->GetClassname();
+		}
+
+		// Unknown weapon?!?
+		if ( !pWeaponName )
+			return;
+
+		// Now update the damage this weapon has done
+		CSWeaponID weaponId = AliasToWeaponID( GetTranslatedWeaponAlias( pWeaponName ) );
+		for (int i = 0; WeaponName_StatId_Table[i].shotStatId != CSSTAT_UNDEFINED; ++i)
+		{
+			if ( weaponId == WeaponName_StatId_Table[i].weaponId )
+			{
+				int weaponId = WeaponName_StatId_Table[i].weaponId;
+				int iType = pAttacker->IsBot();
+				++m_weaponStats[weaponId][iType].hits;
+				m_weaponStats[weaponId][iType].damage += info.GetDamage();
+				break;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stats event for giving money to player
+//-----------------------------------------------------------------------------
+void CCSGameStats::Event_MoneyEarned( CCSPlayer* pPlayer, int moneyEarned)
+{
+	if ( pPlayer && moneyEarned > 0)
+	{
+		IncrementStat(pPlayer, CSSTAT_MONEY_EARNED, moneyEarned);
+	}
+}
+
+void CCSGameStats::Event_MoneySpent( CCSPlayer* pPlayer, int moneySpent, const char *pItemName )
+{
+	if ( pPlayer && moneySpent > 0)
+	{
+		IncrementStat(pPlayer, CSSTAT_MONEY_SPENT, moneySpent);
+		if ( pItemName && !pPlayer->IsBot() )
+		{
+			CSteamID steamIDForBuyer;
+			pPlayer->GetSteamID( &steamIDForBuyer );
+			m_MarketPurchases.AddToTail( new SMarketPurchases( steamIDForBuyer.ConvertToUint64(), moneySpent, pItemName ) );
+		}
+	}
+}
+
+void CCSGameStats::Event_PlayerDonatedWeapon (CCSPlayer* pPlayer)
+{
+    if (pPlayer)
+    {
+        IncrementStat(pPlayer, CSSTAT_WEAPONS_DONATED, 1);
+    }
+}
+
+void CCSGameStats::Event_MVPEarned( CCSPlayer* pPlayer )
+{
+	if (pPlayer)
+	{
+		IncrementStat(pPlayer, CSSTAT_MVPS, 1);
+	}
+}
+
+void CCSGameStats::Event_KnifeUse( CCSPlayer* pPlayer, bool bStab, int iDamage )
+{
+	if (pPlayer)
+	{
+		int weaponId = WEAPON_KNIFE;
+		int iType = pPlayer->IsBot();
+
+		IncrementStat( pPlayer, CSSTAT_SHOTS_KNIFE, 1 );
+		++m_weaponStats[weaponId][iType].shots;
+		if ( iDamage )
+		{
+			IncrementStat( pPlayer, CSSTAT_HITS_KNIFE, 1 );
+			++m_weaponStats[weaponId][iType].hits;
+
+			IncrementStat( pPlayer, CSSTAT_DAMAGE_KNIFE, iDamage );
+			m_weaponStats[weaponId][iType].damage += iDamage;
+		}
+	}
+}
+//-----------------------------------------------------------------------------
+// Purpose: Event handler
+//-----------------------------------------------------------------------------
+void CCSGameStats::FireGameEvent( IGameEvent *event )
+{
+	const char *pEventName = event->GetName();
+
+	if ( V_strcmp(pEventName, "round_start") == 0 )
+	{
+		m_PlayerSnipedPosition.Purge();
+		m_bInRound = true;
+	}
+	else if ( V_strcmp(pEventName, "round_end") == 0 )
+	{
+		const int reason = event->GetInt( "reason" );
+
+		if( reason == Game_Commencing )
+		{
+			ResetPlayerClassMatchStats();
+		}
+		else
+		{
+			UpdatePlayerRoundStats(event->GetInt("winner"));
+			ComputeDirectStatAverages();
+			SendDirectStatsAveragesToAllPlayers();
+
+			UploadRoundStats();
+			ResetWeaponStats();
+		}
+		return;
+	}
+	else if ( V_strcmp(pEventName, "break_prop") == 0 )
+	{
+		int userid = event->GetInt("userid", 0);
+		int entindex = event->GetInt("entindex", 0);
+ 		CBreakableProp* pProp = static_cast<CBreakableProp*>(CBaseEntity::Instance(entindex));
+ 		Event_BreakProp(ToCSPlayer(UTIL_PlayerByUserId(userid)), pProp);
+	}
+	else if ( V_strcmp(pEventName, "player_decal") == 0 )
+	{
+		int userid = event->GetInt("userid", 0);
+		Event_PlayerSprayedDecal(ToCSPlayer(UTIL_PlayerByUserId(userid)));
+	}
+	else if ( V_strcmp(pEventName, "hegrenade_detonate") == 0 )
+	{
+		int userid = event->GetInt("userid", 0);
+		IncrementStat( ToCSPlayer(UTIL_PlayerByUserId(userid)), CSSTAT_SHOTS_HEGRENADE, 1 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return stats for the given player
+//-----------------------------------------------------------------------------
+const PlayerStats_t& CCSGameStats::FindPlayerStats( CBasePlayer *pPlayer ) const
+{
+	return m_aPlayerStats[pPlayer->entindex()];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return stats for the given team
+//-----------------------------------------------------------------------------
+const StatsCollection_t& CCSGameStats::GetTeamStats( int iTeamIndex ) const
+{
+	int arrayIndex = iTeamIndex - FIRST_GAME_TEAM;
+	Assert( arrayIndex >= 0 && arrayIndex < TEAM_MAXCOUNT - FIRST_GAME_TEAM );
+	return m_aTeamStats[arrayIndex];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resets the stats for each team
+//-----------------------------------------------------------------------------
+void CCSGameStats::ResetAllTeamStats()
+{
+	for ( int i = 0; i < ARRAYSIZE(m_aTeamStats); ++i )
+	{
+		m_aTeamStats[i].Reset();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resets all stats (including round, match, accumulated and rolling averages
+//-----------------------------------------------------------------------------
+void CCSGameStats::ResetAllStats()
+{
+    for ( int i = 0; i < ARRAYSIZE( m_aPlayerStats ); i++ )
+    {		
+		m_aPlayerStats[i].statsDelta.Reset();
+        m_aPlayerStats[i].statsCurrentRound.Reset();
+        m_aPlayerStats[i].statsCurrentMatch.Reset();
+        m_rollingCTStatAverages.Reset();
+        m_rollingTStatAverages.Reset();
+        m_rollingPlayerStatAverages.Reset();
+		m_numberOfRoundsForDirectAverages = 0;
+		m_numberOfTerroristEntriesForDirectAverages = 0;
+		m_numberOfCounterTerroristEntriesForDirectAverages = 0;
+    }
+}
+
+
+void CCSGameStats::ResetWeaponStats()
+{
+	V_memset(m_weaponStats, 0, sizeof(m_weaponStats));
+}
+
+void CCSGameStats::IncrementTeamStat( int iTeamIndex, int iStatIndex, int iAmount )
+{
+	int arrayIndex = iTeamIndex - TEAM_TERRORIST;
+	Assert( iStatIndex >= 0 && iStatIndex < CSSTAT_MAX );
+	if( arrayIndex >= 0 && arrayIndex < TEAM_MAXCOUNT - TEAM_TERRORIST )
+	{
+		m_aTeamStats[arrayIndex][iStatIndex] += iAmount;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resets all stats for this player
+//-----------------------------------------------------------------------------
+void CCSGameStats::ResetPlayerStats( CBasePlayer* pPlayer )
+{
+	PlayerStats_t &stats = m_aPlayerStats[pPlayer->entindex()];
+	// reset the stats on this player
+	stats.Reset();
+	// reset the matrix of who killed whom with respect to this player
+	ResetKillHistory( pPlayer );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resets the kill history for this player
+//-----------------------------------------------------------------------------
+void CCSGameStats::ResetKillHistory( CBasePlayer* pPlayer )
+{
+	int iPlayerIndex = pPlayer->entindex();
+
+	PlayerStats_t& statsPlayer = m_aPlayerStats[iPlayerIndex];
+
+	// for every other player, set all all the kills with respect to this player to 0
+	for ( int i = 0; i < ARRAYSIZE( m_aPlayerStats ); i++ )
+	{
+		//reset their record of us.
+		PlayerStats_t &statsOther = m_aPlayerStats[i];
+		statsOther.statsKills.iNumKilled[iPlayerIndex] = 0;
+		statsOther.statsKills.iNumKilledBy[iPlayerIndex] = 0;
+		statsOther.statsKills.iNumKilledByUnanswered[iPlayerIndex] = 0;
+
+		//reset our record of them
+		statsPlayer.statsKills.iNumKilled[i] = 0;
+		statsPlayer.statsKills.iNumKilledBy[i] = 0;
+		statsPlayer.statsKills.iNumKilledByUnanswered[i] = 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resets per-round stats for all players
+//-----------------------------------------------------------------------------
+void CCSGameStats::ResetRoundStats()
+{
+	for ( int i = 0; i < ARRAYSIZE( m_aPlayerStats ); i++ )
+	{		
+		m_aPlayerStats[i].statsCurrentRound.Reset();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Increments specified stat for specified player by specified amount
+//-----------------------------------------------------------------------------
+void CCSGameStats::IncrementStat( CCSPlayer* pPlayer, CSStatType_t statId, int iDelta, bool bPlayerOnly /* = false */ )
+{
+    if ( pPlayer )
+    {
+	    PlayerStats_t &stats = m_aPlayerStats[pPlayer->entindex()];
+	    stats.statsDelta[statId] += iDelta;
+	    stats.statsCurrentRound[statId] += iDelta;
+	    stats.statsCurrentMatch[statId] += iDelta;
+
+		// increment team stat
+		int teamIndex = pPlayer->GetTeamNumber() - FIRST_GAME_TEAM;
+		if ( !bPlayerOnly && teamIndex >= 0 && teamIndex < ARRAYSIZE(m_aTeamStats) )
+		{
+			m_aTeamStats[teamIndex][statId] += iDelta;
+		}
+
+	    for (int i = 0; i < ARRAYSIZE(ServerStatBasedAchievements); ++i)
+	    {
+		    if (ServerStatBasedAchievements[i].statId == statId)
+		    {
+			    // skip this if there is a map filter and it doesn't match
+			    if (ServerStatBasedAchievements[i].mapFilter != NULL && V_strcmp(gpGlobals->mapname.ToCStr(), ServerStatBasedAchievements[i].mapFilter) != 0)
+				    continue;
+
+			    bool bWasMet = ServerStatBasedAchievements[i].IsMet(stats.statsCurrentRound[statId] - iDelta, stats.statsCurrentMatch[statId] - iDelta);
+			    bool bIsMet = ServerStatBasedAchievements[i].IsMet(stats.statsCurrentRound[statId], stats.statsCurrentMatch[statId]);
+			    if (!bWasMet && bIsMet)
+			    {
+				    pPlayer->AwardAchievement(ServerStatBasedAchievements[i].achievementId);
+                }
+		    }
+	    }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:  Sets the specified stat for specified player to the specified amount
+//-----------------------------------------------------------------------------
+void CCSGameStats::SetStat( CCSPlayer *pPlayer, CSStatType_t statId, int iValue )
+{
+	if (pPlayer)
+	{
+		int oldRoundValue, oldMatchValue;
+		PlayerStats_t &stats = m_aPlayerStats[pPlayer->entindex()];
+
+		oldRoundValue = stats.statsCurrentRound[statId];
+		oldMatchValue = stats.statsCurrentMatch[statId];
+
+		stats.statsDelta[statId] = iValue;
+		stats.statsCurrentRound[statId] = iValue;
+		stats.statsCurrentMatch[statId] = iValue;
+
+		for (int i = 0; i < ARRAYSIZE(ServerStatBasedAchievements); ++i)
+		{
+			if (ServerStatBasedAchievements[i].statId == statId)
+			{
+				// skip this if there is a map filter and it doesn't match
+				if (ServerStatBasedAchievements[i].mapFilter != NULL && V_strcmp(gpGlobals->mapname.ToCStr(), ServerStatBasedAchievements[i].mapFilter) != 0)
+					continue;
+
+				bool bWasMet = ServerStatBasedAchievements[i].IsMet(oldRoundValue, oldMatchValue);
+				bool bIsMet = ServerStatBasedAchievements[i].IsMet(stats.statsCurrentRound[statId], stats.statsCurrentMatch[statId]);
+				if (!bWasMet && bIsMet)
+				{
+					pPlayer->AwardAchievement(ServerStatBasedAchievements[i].achievementId);
+				}
+			}
+		}
+	}
+}
+
+void CCSGameStats::SendStatsToPlayer( CCSPlayer * pPlayer, int iMinStatPriority )
+{
+	ASSERT(CSSTAT_MAX < 255); // if we add more than 255 stats, we'll need to update this protocol
+	if ( pPlayer && pPlayer->IsConnected())
+	{				
+		StatsCollection_t &deltaStats = m_aPlayerStats[pPlayer->entindex()].statsDelta;
+
+		// check to see if we have any stats to actually send
+		byte iStatsToSend = 0;
+		for ( int iStat = CSSTAT_FIRST; iStat < CSSTAT_MAX; ++iStat )
+		{
+			ASSERT(CSStatProperty_Table[iStat].statId == iStat);
+			if ( CSStatProperty_Table[iStat].statId != iStat )
+			{
+				Warning( "CSStatProperty_Table[iStat].statId != iStat, (%d)", CSStatProperty_Table[iStat].statId );
+			}
+			int iPriority = CSStatProperty_Table[iStat].flags & CSSTAT_PRIORITY_MASK;
+			if (deltaStats[iStat] != 0 && iPriority >= iMinStatPriority)
+			{
+				++iStatsToSend;
+			}
+		}
+
+		// nothing changed - bail out
+		if ( !iStatsToSend )
+			return;
+
+		CSingleUserRecipientFilter filter( pPlayer );
+		filter.MakeReliable();
+		UserMessageBegin( filter, "PlayerStatsUpdate" );
+
+		CRC32_t crc;
+		CRC32_Init( &crc );
+
+		// begin the CRC with a trivially hidden key value to discourage packet modification
+		const uint32 key = 0x82DA9F4C;	// this key should match the key in cs_client_gamestats.cpp
+		CRC32_ProcessBuffer( &crc, &key, sizeof(key));
+
+		// if we make any change to the ordering of the stats or this message format, update this value
+		const byte version = 0x01;
+		CRC32_ProcessBuffer( &crc, &version, sizeof(version));
+		WRITE_BYTE(version);
+
+		CRC32_ProcessBuffer( &crc, &iStatsToSend, sizeof(iStatsToSend));
+		WRITE_BYTE(iStatsToSend);
+
+		for ( byte iStat = CSSTAT_FIRST; iStat < CSSTAT_MAX; ++iStat )
+		{
+			int iPriority = CSStatProperty_Table[iStat].flags & CSSTAT_PRIORITY_MASK;
+			if (deltaStats[iStat] != 0 && iPriority >= iMinStatPriority)
+			{
+				CRC32_ProcessBuffer( &crc, &iStat, sizeof(iStat));
+				WRITE_BYTE(iStat);
+				Assert(deltaStats[iStat] <= 0x7FFF && deltaStats[iStat] > 0);	// make sure we aren't truncating bits
+				short delta = deltaStats[iStat];
+				CRC32_ProcessBuffer( &crc, &delta, sizeof(delta));
+				WRITE_SHORT( deltaStats[iStat]);
+				deltaStats[iStat] = 0;
+				--iStatsToSend;
+			}
+		}
+
+		Assert(iStatsToSend == 0);
+
+		CRC32_Final( &crc );
+		WRITE_LONG(crc);
+
+		MessageEnd();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sends intermittent stats updates for stats that need to be updated during a round and/or life
+//-----------------------------------------------------------------------------
+void CCSGameStats::PreClientUpdate()
+{
+	int iMinStatPriority = -1;
+	m_fDisseminationTimerHigh += gpGlobals->frametime;
+	m_fDisseminationTimerLow += gpGlobals->frametime;
+
+	if ( m_fDisseminationTimerHigh > cDisseminationTimeHigh)
+	{
+		iMinStatPriority = CSSTAT_PRIORITY_HIGH;
+		m_fDisseminationTimerHigh = 0.0f;
+
+		if ( m_fDisseminationTimerLow > cDisseminationTimeLow)
+		{
+			iMinStatPriority = CSSTAT_PRIORITY_LOW;
+			m_fDisseminationTimerLow = 0.0f;
+		}
+	}
+	else
+		return;
+
+	//The proper time has elapsed, now send the update to every player
+	for ( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex(iPlayerIndex) );
+		SendStatsToPlayer(pPlayer, iMinStatPriority);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the stats of who has killed whom
+//-----------------------------------------------------------------------------
+void CCSGameStats::TrackKillStats( CCSPlayer *pAttacker, CCSPlayer *pVictim )
+{
+    int iPlayerIndexAttacker = pAttacker->entindex();
+    int iPlayerIndexVictim = pVictim->entindex();
+
+    PlayerStats_t &statsAttacker = m_aPlayerStats[iPlayerIndexAttacker];
+    PlayerStats_t &statsVictim = m_aPlayerStats[iPlayerIndexVictim];
+
+    statsVictim.statsKills.iNumKilledBy[iPlayerIndexAttacker]++;
+    statsVictim.statsKills.iNumKilledByUnanswered[iPlayerIndexAttacker]++;
+    statsAttacker.statsKills.iNumKilled[iPlayerIndexVictim]++;
+    statsAttacker.statsKills.iNumKilledByUnanswered[iPlayerIndexVictim] = 0;    
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines if attacker and victim have gotten domination or revenge
+//-----------------------------------------------------------------------------
+void CCSGameStats::CalcDominationAndRevenge( CCSPlayer *pAttacker, CCSPlayer *pVictim, int *piDeathFlags )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [Forrest] Allow nemesis/revenge to be turned off for a server
+	//=============================================================================
+	if ( sv_nonemesis.GetBool() )
+	{
+		return;
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	//If there is no attacker, there is no domination or revenge
+	if( !pAttacker || !pVictim )
+	{
+		return;
+	}
+	if (pAttacker->GetTeam() == pVictim->GetTeam())
+	{
+		return;
+	}
+	int iPlayerIndexVictim = pVictim->entindex();
+	PlayerStats_t &statsVictim = m_aPlayerStats[iPlayerIndexVictim];	
+	// calculate # of unanswered kills between killer & victim
+	// This is plus 1 as this function gets called before the stat is updated.  That is done so that the domination
+	// and revenge will be calculated prior to the death message being sent to the clients
+	int attackerEntityIndex = pAttacker->entindex();
+	int iKillsUnanswered = statsVictim.statsKills.iNumKilledByUnanswered[attackerEntityIndex] + 1;	
+
+	if ( CS_KILLS_FOR_DOMINATION == iKillsUnanswered )
+	{
+		// this is the Nth unanswered kill between killer and victim, killer is now dominating victim
+		*piDeathFlags |= ( CS_DEATH_DOMINATION );
+	}
+	else if ( pVictim->IsPlayerDominated( pAttacker->entindex() ) )
+	{
+		// the killer killed someone who was dominating him, gains revenge
+		*piDeathFlags |= ( CS_DEATH_REVENGE );
+	}
+
+    //Check the overkill on 1 player achievement
+    if (iKillsUnanswered == CS_KILLS_FOR_DOMINATION + AchievementConsts::ExtendedDomination_AdditionalKills)
+    {
+        pAttacker->AwardAchievement(CSExtendedDomination);
+    }
+
+    if (iKillsUnanswered == CS_KILLS_FOR_DOMINATION)
+    {			
+        //this is the Nth unanswered kill between killer and victim, killer is now dominating victim        
+        //set victim to be dominated by killer
+        pAttacker->SetPlayerDominated( pVictim, true );
+
+        //Check concurrent dominations achievement
+        int numConcurrentDominations = 0;
+        for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
+        {
+            CCSPlayer *pPlayer= ToCSPlayer( UTIL_PlayerByIndex( i ) );
+            if (pPlayer && pAttacker->IsPlayerDominated(pPlayer->entindex()))
+            {
+                numConcurrentDominations++;
+            }
+        }
+        if (numConcurrentDominations >= AchievementConsts::ConcurrentDominations_MinDominations)
+        {
+            pAttacker->AwardAchievement(CSConcurrentDominations);
+        }
+
+        
+        // record stats
+        Event_PlayerDominatedOther( pAttacker, pVictim );
+    }
+    else if ( pVictim->IsPlayerDominated( pAttacker->entindex() ) )
+    {
+        // the killer killed someone who was dominating him, gains revenge        
+        // set victim to no longer be dominating the killer
+
+        pVictim->SetPlayerDominated( pAttacker, false );
+        // record stats
+        Event_PlayerRevenge( pAttacker );
+    }
+}
+
+void CCSGameStats::Event_PlayerDominatedOther( CCSPlayer *pAttacker, CCSPlayer* pVictim )
+{
+    IncrementStat( pAttacker, CSSTAT_DOMINATIONS, 1 );
+}
+
+void CCSGameStats::Event_PlayerRevenge( CCSPlayer *pAttacker )
+{
+    IncrementStat( pAttacker, CSSTAT_REVENGES, 1 );
+}
+
+void CCSGameStats::Event_PlayerAvengedTeammate( CCSPlayer* pAttacker, CCSPlayer* pAvengedPlayer )
+{
+    if (pAttacker && pAvengedPlayer)
+    {
+        IGameEvent *event = gameeventmanager->CreateEvent( "player_avenged_teammate" );
+
+        if ( event )
+        {
+            event->SetInt( "avenger_id", pAttacker->GetUserID() );
+            event->SetInt( "avenged_player_id", pAvengedPlayer->GetUserID() );
+            gameeventmanager->FireEvent( event );
+        }
+    }
+}
+
+void CCSGameStats::Event_LevelInit()
+{
+	ResetAllTeamStats();
+	ResetWeaponStats();
+	CBaseGameStats::Event_LevelInit();
+	GetSteamWorksSGameStatsUploader().StartSession();
+}
+
+void CCSGameStats::Event_LevelShutdown( float fElapsed )
+{
+	DumpMatchWeaponMetrics();
+	CBaseGameStats::Event_LevelShutdown(fElapsed);
+}
+
+// Reset any per match info that resides in the player class
+void CCSGameStats::ResetPlayerClassMatchStats()
+{
+	for ( int i = 1; i <= MAX_PLAYERS; i++ )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( pPlayer )
+		{
+			pPlayer->SetNumMVPs( 0 );
+		}
+	}
+}